Remove RAIDFrame. It hasn't worked since GEOM replaced the old disk

mini-layer.  I don't have time to bing it forward into the GEOM world, and
no one else has stepped forward to claim it.  It'll be in the Attic for safe
keeping for now.

134 files changed, 0 insertions, 42360 deletions

diff --git a/sys/dev/raidframe/rf_acctrace.c b/sys/dev/raidframe/rf_acctrace.c
deleted file mode 100644
index 91c1b6d4..0000000
--- a/sys/dev/raidframe/rf_acctrace.c
+++ /dev/null
@@ -1,174 +0,0 @@
-/*	$NetBSD: rf_acctrace.c,v 1.4 1999/08/13 03:41:52 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * acctrace.c -- code to support collecting information about each access
- *
- *****************************************************************************/
-
-#if defined(__FreeBSD__)
-#include <sys/types.h>
-#include <sys/time.h>
-#endif
-#include <sys/stat.h>
-#if defined(__NetBSD__)
-#include <sys/types.h>
-#endif
-
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_hist.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-static long numTracesSoFar;
-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;
-
-	static void rf_ShutdownAccessTrace(void *);
-
-	static void rf_ShutdownAccessTrace(ignored)
-	void   *ignored;
-{
-	if (rf_accessTraceBufSize) {
-		if (accessTraceBufCount)
-			rf_FlushAccessTraceBuf();
-		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     rc;
-
-	numTracesSoFar = accessTraceBufCount = rf_stopCollectingTraces = 0;
-	if (rf_accessTraceBufSize) {
-		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, __FUNCTION__);
-	if (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);
-		if (rf_accessTraceBufSize) {
-			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.
- */
-void 
-rf_LogTraceRec(raid, rec)
-	RF_Raid_t *raid;
-	RF_AccTraceEntry_t *rec;
-{
-	RF_AccTotals_t *acc = &raid->acc_totals;
-#if 0
-	RF_Etimer_t timer;
-	int     i, n;
-#endif
-
-	if (rf_stopCollectingTraces || ((rf_maxNumTraces >= 0) && (numTracesSoFar >= rf_maxNumTraces)))
-		return;
-
-	/* 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_num_phys_ios += rec->num_phys_ios;
-		acc->recon_phys_io_us += rec->phys_io_us;
-		acc->recon_diskwait_us += rec->diskwait_us;
-		acc->recon_reccount++;
-	} 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 */
-		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;
-		acc->lock_us += rec->specific.user.lock_us;
-		acc->dag_create_us += rec->specific.user.dag_create_us;
-		acc->dag_retry_us += rec->specific.user.dag_retry_us;
-		acc->exec_us += rec->specific.user.exec_us;
-		acc->cleanup_us += rec->specific.user.cleanup_us;
-		acc->exec_engine_us += rec->specific.user.exec_engine_us;
-		acc->xor_us += rec->xor_us;
-		acc->q_us += rec->q_us;
-		acc->plog_us += rec->plog_us;
-		acc->diskqueue_us += rec->diskqueue_us;
-		acc->diskwait_us += rec->diskwait_us;
-		acc->num_phys_ios += rec->num_phys_ios;
-		acc->phys_io_us = rec->phys_io_us;
-		acc->user_reccount++;
-	}
-}
-
-
-/* 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.
- */
-void 
-rf_FlushAccessTraceBuf()
-{
-	accessTraceBufCount = 0;
-}
diff --git a/sys/dev/raidframe/rf_acctrace.h b/sys/dev/raidframe/rf_acctrace.h
deleted file mode 100644
index c211514..0000000
--- a/sys/dev/raidframe/rf_acctrace.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_acctrace.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * acctrace.h -- header file for acctrace.c
- *
- *****************************************************************************/
-
-
-#ifndef _RF__RF_ACCTRACE_H_
-#define _RF__RF_ACCTRACE_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_hist.h>
-#include <dev/raidframe/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;
-
-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;
-
-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;
-
-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 */
-
-	int     rf_ConfigureAccessTrace(RF_ShutdownList_t ** listp);
-	void    rf_LogTraceRec(RF_Raid_t * raid, RF_AccTraceEntry_t * rec);
-	void    rf_FlushAccessTraceBuf(void);
-
-#endif				/* !_RF__RF_ACCTRACE_H_ */
diff --git a/sys/dev/raidframe/rf_alloclist.c b/sys/dev/raidframe/rf_alloclist.c
deleted file mode 100644
index 8c8b837..0000000
--- a/sys/dev/raidframe/rf_alloclist.c
+++ /dev/null
@@ -1,190 +0,0 @@
-/*	$NetBSD: rf_alloclist.c,v 1.4 1999/08/13 03:41:53 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/****************************************************************************
- *
- * 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
- * FreeAList() causes each pointer to be freed.
- *
- ***************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-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;
-
-#define RF_AL_FREELIST_MAX 256
-
-#define DO_FREE(_p,_sz) RF_Free((_p),(_sz))
-
-	static void rf_ShutdownAllocList(void *);
-
-	static void rf_ShutdownAllocList(ignored)
-	void   *ignored;
-{
-	RF_AllocListElem_t *p, *pt;
-
-	for (p = al_free_list; p;) {
-		pt = p;
-		p = p->next;
-		DO_FREE(pt, sizeof(*pt));
-	}
-	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));
-        */
-}
-
-int 
-rf_ConfigureAllocList(listp)
-	RF_ShutdownList_t **listp;
-{
-	int     rc;
-
-	rc = rf_mutex_init(&alist_mutex, __FUNCTION__);
-	if (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_mutex_destroy(&alist_mutex);
-		return (rc);
-	}
-	return (0);
-}
-
-
-/* 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;
-{
-	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 >= 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;
-		l = newelem;
-	}
-	l->pointers[l->numPointers] = p;
-	l->sizes[l->numPointers] = size;
-	l->numPointers++;
-
-}
-
-
-/* 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;
-{
-	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);
-		for (i = 0; i < p->numPointers; i++) {
-			RF_ASSERT(p->pointers[i]);
-			RF_Free(p->pointers[i], p->sizes[i]);
-		}
-	}
-	while (l) {
-		temp = l;
-		l = l->next;
-		if (al_free_list_count > RF_AL_FREELIST_MAX) {
-			DO_FREE(temp, sizeof(*temp));
-		} else {
-			temp->next = al_free_list;
-			al_free_list = temp;
-			al_free_list_count++;
-		}
-	}
-}
-
-RF_AllocListElem_t *
-rf_real_MakeAllocList(lockflag)
-	int     lockflag;
-{
-	RF_AllocListElem_t *p;
-
-	if (al_free_list) {
-		fl_hit_count++;
-		p = al_free_list;
-		al_free_list = p->next;
-		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 */
-	}
-	if (p == NULL) {
-		return (NULL);
-	}
-	bzero((char *) p, sizeof(RF_AllocListElem_t));
-	return (p);
-}
diff --git a/sys/dev/raidframe/rf_alloclist.h b/sys/dev/raidframe/rf_alloclist.h
deleted file mode 100644
index c746452..0000000
--- a/sys/dev/raidframe/rf_alloclist.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_alloclist.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/****************************************************************************
- *
- * alloclist.h -- header file for alloclist.c
- *
- ***************************************************************************/
-
-#ifndef _RF__RF_ALLOCLIST_H_
-#define _RF__RF_ALLOCLIST_H_
-
-#include <dev/raidframe/rf_types.h>
-
-#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;
-};
-#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);
-
-#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 */
-
-#endif				/* !_RF__RF_ALLOCLIST_H_ */
diff --git a/sys/dev/raidframe/rf_archs.h b/sys/dev/raidframe/rf_archs.h
deleted file mode 100644
index faef157..0000000
--- a/sys/dev/raidframe/rf_archs.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_archs.h,v 1.11 2001/01/26 04:43:16 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_archs.h -- defines for which architectures you want to
- * include is 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
- * 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
- * out.
- *
- */
-
-#ifndef _RF__RF_ARCHS_H_
-#define _RF__RF_ARCHS_H_
-
-#define RF_INCLUDE_EVENODD       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_PARITY_DECLUSTERING 1
-#define RF_INCLUDE_PARITY_DECLUSTERING_DS 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_MEMORY_REDZONES 0
-#define RF_RECON_STATS     1
-
-#include <dev/raidframe/rf_options.h>
-
-#endif				/* !_RF__RF_ARCHS_H_ */
diff --git a/sys/dev/raidframe/rf_aselect.c b/sys/dev/raidframe/rf_aselect.c
deleted file mode 100644
index 13cdbbe..0000000
--- a/sys/dev/raidframe/rf_aselect.c
+++ /dev/null
@@ -1,496 +0,0 @@
-/*	$NetBSD: rf_aselect.c,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * aselect.c -- algorithm selection code
- *
- *****************************************************************************/
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_map.h>
-
-#if defined(__NetBSD__) || defined(__FreeBSD__) && defined(_KERNEL)
-/* the function below is not used... so don't define it! */
-#else
-static void 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);
-
-
-/******************************************************************************
- *
- * Create and Initialiaze a dag header and termination node
- *
- *****************************************************************************/
-static int 
-InitHdrNode(hdr, raidPtr, memChunkEnable)
-	RF_DagHeader_t **hdr;
-	RF_Raid_t *raidPtr;
-	int     memChunkEnable;
-{
-	/* create and initialize dag hdr */
-	*hdr = rf_AllocDAGHeader();
-	rf_MakeAllocList((*hdr)->allocList);
-	if ((*hdr)->allocList == NULL) {
-		rf_FreeDAGHeader(*hdr);
-		return (ENOMEM);
-	}
-	(*hdr)->status = rf_enable;
-	(*hdr)->numSuccedents = 0;
-	(*hdr)->raidPtr = raidPtr;
-	(*hdr)->next = NULL;
-	return (0);
-}
-/******************************************************************************
- *
- * Transfer allocation list and mem chunks from one dag to another
- *
- *****************************************************************************/
-#if defined(__NetBSD__) || defined(__FreeBSD__) && defined(_KERNEL)
-/* 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;
-{
-	RF_AccessStripeMapHeader_t *end;
-	RF_AllocListElem_t *p;
-	int     i, memChunksXfrd = 0, xtraChunksXfrd = 0;
-
-	/* 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]);
-			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 */
-		if (memChunksXfrd < dagb->chunkIndex) {
-			daga->memChunk[daga->chunkIndex++] = dagb->memChunk[memChunksXfrd];
-			dagb->memChunk[memChunksXfrd++] = NULL;
-		} else {
-			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) {
-		if (memChunksXfrd < dagb->chunkIndex) {
-			daga->xtraMemChunk[daga->xtraChunkIndex++] = dagb->memChunk[memChunksXfrd];
-			dagb->memChunk[memChunksXfrd++] = NULL;
-		} else {
-			daga->xtraMemChunk[daga->xtraChunkIndex++] = dagb->xtraMemChunk[xtraChunksXfrd];
-			dagb->xtraMemChunk[xtraChunksXfrd++] = NULL;
-		}
-	}
-	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 */
-	if (dagb->asmList) {
-		if (daga->asmList) {
-			end = daga->asmList;
-			while (end->next)
-				end = end->next;
-			end->next = dagb->asmList;
-		} else
-			daga->asmList = dagb->asmList;
-		dagb->asmList = NULL;
-	}
-}
-#endif				/* __NetBSD__ */
-
-/*****************************************************************************************
- *
- * 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.
- *
- ****************************************************************************************/
-static void 
-UpdateNodeHdrPtr(hdr, node)
-	RF_DagHeader_t *hdr;
-	RF_DagNode_t *node;
-{
-	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]);
-	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.
- *
- * Normally, each list contains one dag for the entire stripe.  In some
- * tricky cases, we break this into multiple dags, either one per stripe
- * unit or one per block (sector).  When this occurs, these dags are returned
- * 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
- * independent dagLists (distinct elements in desc->dagArray) and may be
- * executed concurrently.
- *
- * Finally, if the SelectionFunc fails to create a dag for a block, we punt
- * and return 1.
- *
- * The above process is performed in two phases:
- *   1) create an array(s) of creation functions (eg stripeFuncs)
- *   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):
- *   first-pass optimizer to allow max concurrency (need all data dependencies)
- *   second-pass optimizer to eliminate common subexpressions (need true
- *                         data dependencies)
- *   third-pass optimizer to eliminate dead code (need true data dependencies)
- *****************************************************************************/
-
-#define MAXNSTRIPES 5
-
-int 
-rf_SelectAlgorithm(desc, flags)
-	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;
-
-	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;
-	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;
-	RF_StripeNum_t numStripeUnits;
-	RF_SectorNum_t numBlocks;
-	RF_RaidAddr_t address;
-	int     length;
-	RF_PhysDiskAddr_t *physPtr;
-	caddr_t buffer;
-
-	lastdag_h = NULL;
-	asmh_u = asmh_b = NULL;
-	stripeUnitFuncs = NULL;
-	blockFuncs = NULL;
-
-	/* 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 *));
-
-	/* 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 */
-		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 */
-
-			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 **));
-			}
-			/* 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 */
-				address = physPtr->raidAddress;
-				length = physPtr->numSector;
-				buffer = physPtr->bufPtr;
-
-				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 */
-					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 **));
-					}
-					/* create an array of creation funcs
-					 * (called blockFuncs) for this stripe
-					 * 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 */
-					for (k = 0; k < numBlocks; 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
-						 * creation func for this
-						 * stripe unit */
-						if (blockFuncs[numStripeUnitsBailed][k] == NULL)
-							cantCreateDAGs = RF_TRUE;
-					}
-					numStripeUnitsBailed++;
-				} else {
-					numUnitDags++;
-				}
-			}
-			RF_ASSERT(j == numStripeUnits);
-			numStripesBailed++;
-		}
-	}
-
-	if (cantCreateDAGs) {
-		/* free memory and punt */
-		if (asm_h->numStripes > MAXNSTRIPES)
-			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++)
-				if (stripeFuncs[i] == NULL) {
-					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));
-					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 **));
-		}
-		return (1);
-	} else {
-		/* 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);
-
-		for (i = 0, asm_p = asmap; asm_p; asm_p = asm_p->next, i++) {
-			/* 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++) {
-					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++;
-							if (dag_h == NULL) {
-								dag_h = tempdag_h;
-							} else {
-								lastdag_h->next = tempdag_h;
-							}
-							lastdag_h = tempdag_h;
-
-							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);
-						}
-						stripeUnitNum++;
-					} else {
-						/* create a dag for this unit */
-						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 = tempdag_h;
-
-						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 */
-				stripeNum++;
-			} else {
-				/* Create a dag for this parity stripe */
-				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 = tempdag_h;
-
-				(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 */
-		if (asm_h->numStripes > MAXNSTRIPES)
-			RF_Free(stripeFuncs, asm_h->numStripes * sizeof(RF_VoidFuncPtr));
-		if ((numStripesBailed > 0) || (numStripeUnitsBailed > 0)) {
-			stripeNum = 0;
-			stripeUnitNum = 0;
-			if (dag_h->asmList) {
-				endASMList = dag_h->asmList;
-				while (endASMList->next)
-					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++)
-				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
-							 * 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;
-								} else {
-									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));
-							stripeUnitNum++;
-						}
-						if (dag_h->asmList == NULL) {
-							dag_h->asmList = asmh_u[stripeNum][j];
-							endASMList = dag_h->asmList;
-						} else {
-							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));
-					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 **));
-			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 **));
-			}
-		}
-		return (0);
-	}
-}
diff --git a/sys/dev/raidframe/rf_aselect.h b/sys/dev/raidframe/rf_aselect.h
deleted file mode 100644
index de9cd76..0000000
--- a/sys/dev/raidframe/rf_aselect.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_aselect.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * aselect.h -- header file for algorithm selection code
- *
- *****************************************************************************/
-
-#ifndef _RF__RF_ASELECT_H_
-#define _RF__RF_ASELECT_H_
-
-#include <dev/raidframe/rf_desc.h>
-
-int     rf_SelectAlgorithm(RF_RaidAccessDesc_t * desc, RF_RaidAccessFlags_t flags);
-
-#endif				/* !_RF__RF_ASELECT_H_ */
diff --git a/sys/dev/raidframe/rf_bsd.h b/sys/dev/raidframe/rf_bsd.h
deleted file mode 100644
index 14c10f5..0000000
--- a/sys/dev/raidframe/rf_bsd.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*	$FreeBSD$ */
-/*	$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.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Greg Oster; Jason R. Thorpe.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    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.
- * 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef _RF__RF_BSD_H_
-#define _RF__RF_BSD_H_
-
-#ifdef _KERNEL
-#include <sys/fcntl.h>
-#include <sys/systm.h>
-#include <sys/namei.h>
-#include <sys/vnode.h>
-#include "opt_raid.h"
-
-#ifdef RAID_DEBUG
-#define rf_printf(lvl, fmt, args...)				\
-	do {							\
-		if (lvl <= RAID_DEBUG) printf(fmt, ##args);	\
-	} while(0)
-
-#else				/* DEBUG */
-#define rf_printf(lvl, fmt, args...) { }
-#endif				/* DEBUG */
-#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 */
-} 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 */
-} 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
-
-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 */
-#endif
-};
-
-
-
-/* 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. */
-} 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;
-} RF_ConfigSet_t;
-
-#endif /* _KERNEL */
-#endif /* _RF__RF_BSD_H_ */
diff --git a/sys/dev/raidframe/rf_callback.c b/sys/dev/raidframe/rf_callback.c
deleted file mode 100644
index 1739fc6..0000000
--- a/sys/dev/raidframe/rf_callback.c
+++ /dev/null
@@ -1,96 +0,0 @@
-/*	$NetBSD: rf_callback.c,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************************
- *
- * callback.c -- code to manipulate callback descriptor
- *
- ****************************************************************************************/
-
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_callback.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-static RF_FreeList_t *rf_callback_freelist;
-
-#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;
-{
-	RF_FREELIST_DESTROY(rf_callback_freelist, next, (RF_CallbackDesc_t *));
-}
-
-int 
-rf_ConfigureCallback(listp)
-	RF_ShutdownList_t **listp;
-{
-	int     rc;
-
-	RF_FREELIST_CREATE(rf_callback_freelist, RF_MAX_FREE_CALLBACK,
-	    RF_CALLBACK_INC, sizeof(RF_CallbackDesc_t));
-	if (rf_callback_freelist == NULL)
-		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_ShutdownCallback(NULL);
-		return (rc);
-	}
-	RF_FREELIST_PRIME(rf_callback_freelist, RF_CALLBACK_INITIAL, next,
-	    (RF_CallbackDesc_t *));
-	return (0);
-}
-
-RF_CallbackDesc_t *
-rf_AllocCallbackDesc()
-{
-	RF_CallbackDesc_t *p;
-
-	RF_FREELIST_GET(rf_callback_freelist, p, next, (RF_CallbackDesc_t *));
-	return (p);
-}
-
-void 
-rf_FreeCallbackDesc(p)
-	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
deleted file mode 100644
index feda31d..0000000
--- a/sys/dev/raidframe/rf_callback.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_callback.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************************
- *
- * 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
- * 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
- * a function that will restart operation on the indicated disk.
- *
- ****************************************************************************************/
-
-#ifndef _RF__RF_CALLBACK_H_
-#define _RF__RF_CALLBACK_H_
-
-#include <dev/raidframe/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 */
-};
-
-int     rf_ConfigureCallback(RF_ShutdownList_t ** listp);
-RF_CallbackDesc_t *rf_AllocCallbackDesc(void);
-void    rf_FreeCallbackDesc(RF_CallbackDesc_t * p);
-
-#endif				/* !_RF__RF_CALLBACK_H_ */
diff --git a/sys/dev/raidframe/rf_chaindecluster.c b/sys/dev/raidframe/rf_chaindecluster.c
deleted file mode 100644
index 68951a0..0000000
--- a/sys/dev/raidframe/rf_chaindecluster.c
+++ /dev/null
@@ -1,292 +0,0 @@
-/*	$NetBSD: rf_chaindecluster.c,v 1.6 2001/01/26 04:27:16 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Khalil Amiri
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/******************************************************************************
- *
- * rf_chaindecluster.c -- implements chained declustering
- *
- *****************************************************************************/
-
-#include <dev/raidframe/rf_archs.h>
-
-#if (RF_INCLUDE_CHAINDECLUSTER > 0) 
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_chaindecluster.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/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_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);
-	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);
-	if (info->stripeIdentifier == NULL)
-		return (ENOMEM);
-	for (i = 0; i < raidPtr->numCol; i++) {
-		info->stripeIdentifier[i][0] = i % raidPtr->numCol;
-		info->stripeIdentifier[i][1] = (i + 1) % raidPtr->numCol;
-	}
-
-	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;
-	layoutPtr->numDataCol = 1;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numParityCol = 1;
-
-	layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
-
-	raidPtr->sectorsPerDisk =
-	    num_used_stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
-
-	raidPtr->totalSectors =
-	    (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit;
-
-	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
-
-	return (0);
-}
-
-RF_ReconUnitCount_t 
-rf_GetNumSpareRUsChainDecluster(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
-
-	/*
-         * 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)
-{
-	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;
-
-	*row = 0;
-	sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
-	index_within_region = SUID % info->stripeUnitsPerSparingRegion;
-	index_within_disk = index_within_region / raidPtr->numCol;
-	col_before_remap = SUID % raidPtr->numCol;
-
-	if (!remap) {
-		*col = col_before_remap;
-		*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);
-		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;
-			} else
-				*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)
-{
-	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;
-
-	*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);
-	} else {
-		/* 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);
-		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;
-			} else
-				*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)
-{
-	RF_ChaindeclusterConfigInfo_t *info = (RF_ChaindeclusterConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
-	RF_StripeNum_t SUID;
-	RF_RowCol_t col;
-
-	SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
-	col = SUID % raidPtr->numCol;
-	*outRow = 0;
-	*diskids = info->stripeIdentifier[col];
-}
-
-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
- *
- * 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,
-            RF_AllocListElem_t *)
-#endif
-{
-	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");
-		*createFunc = NULL;
-		return;
-	}
-	*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 */
-		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateMirrorPartitionReadDAG;	/* array status not
-											 * degraded, so use
-											 * mirror partition dag */
-	} else
-		*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
-}
-#endif /* (RF_INCLUDE_CHAINDECLUSTER > 0) */
diff --git a/sys/dev/raidframe/rf_chaindecluster.h b/sys/dev/raidframe/rf_chaindecluster.h
deleted file mode 100644
index 6030289..0000000
--- a/sys/dev/raidframe/rf_chaindecluster.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_chaindecluster.h,v 1.4 2001/01/26 04:14:14 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Khalil Amiri
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_chaindecluster.h
- * header file for Chained Declustering
- */
-
-
-#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 *);
-#endif
-
-#endif				/* !_RF__RF_CHAINDECLUSTER_H_ */
diff --git a/sys/dev/raidframe/rf_configure.h b/sys/dev/raidframe/rf_configure.h
deleted file mode 100644
index c51b8a3..0000000
--- a/sys/dev/raidframe/rf_configure.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_configure.h,v 1.4 1999/03/02 03:18:49 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/********************************
- *
- * rf_configure.h
- *
- * 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_
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-
-#include <sys/param.h>
-#include <sys/proc.h>
-
-#if defined(__NetBSD__)
-#include <sys/ioctl.h>
-#elif defined(__FreeBSD__)
-#include <sys/ioccom.h>
-#include <sys/filio.h>
-#endif
-
-/* 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][50];	/* 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
-	 */
-};
-#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_ */
diff --git a/sys/dev/raidframe/rf_copyback.c b/sys/dev/raidframe/rf_copyback.c
deleted file mode 100644
index eb16404..0000000
--- a/sys/dev/raidframe/rf_copyback.c
+++ /dev/null
@@ -1,433 +0,0 @@
-/*	$NetBSD: rf_copyback.c,v 1.15 2001/01/26 02:16:24 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************************
- *
- * 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.
- *
- ****************************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-
-#if defined(__FreeBSD__)
-#include <sys/types.h>
-#include <sys/systm.h>
-#if __FreeBSD_version > 500005
-#include <sys/bio.h>
-#endif
-#endif
-
-#include <sys/time.h>
-#include <sys/buf.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_mcpair.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_copyback.h>
-#include <dev/raidframe/rf_decluster.h>
-#include <dev/raidframe/rf_driver.h>
-#include <dev/raidframe/rf_shutdown.h>
-#include <dev/raidframe/rf_kintf.h>
-
-#define RF_COPYBACK_DATA   0
-#define RF_COPYBACK_PARITY 1
-
-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_ConfigureCopyback(listp)
-	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>
-#if defined(__NetBSD__)
-#include <sys/ioctl.h>
-#elif defined(__FreeBSD__)
-#include <sys/ioccom.h>
-#include <sys/filio.h>
-#endif
-#include <sys/fcntl.h>
-#include <sys/vnode.h>
-
-/* do a complete copyback */
-void 
-rf_CopybackReconstructedData(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	RF_ComponentLabel_t *c_label;
-	int     done, retcode;
-	RF_CopybackDesc_t *desc;
-	RF_RowCol_t frow, fcol;
-	RF_RaidDisk_t *badDisk;
-	struct vnode *vp;
-	char   *databuf;
-	int ac;
-
-	RF_Malloc(c_label, sizeof(RF_ComponentLabel_t), (RF_ComponentLabel_t *));
-	if (c_label == NULL) {
-		printf("rf_CopybackReconstructedData: Out of memory?\n");
-		return;
-	}
-
-	done = 0;
-	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) {
-				done = 1;
-				break;
-			}
-		}
-		if (done)
-			break;
-	}
-
-	if (frow == raidPtr->numRow) {
-		printf("COPYBACK:  no disks need copyback\n");
-		return;
-	}
-	badDisk = &raidPtr->Disks[frow][fcol];
-
-	/* 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",
-		    raidPtr->Disks[frow][fcol].devname);
-		vp = raidPtr->raid_cinfo[frow][fcol].ci_vp;
-		ac = raidPtr->Disks[frow][fcol].auto_configured;
-		rf_close_component(raidPtr, vp, ac);
-		raidPtr->raid_cinfo[frow][fcol].ci_vp = NULL;
-
-	}
-	/* 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",
-	    raidPtr->Disks[frow][fcol].devname);
-
-	retcode = raid_getcomponentsize(raidPtr, frow, fcol);
-
-	if (retcode) {
-		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 :-( */
-		return;
-
-	}
-#if 0
-	/* 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);
-		return;
-	}
-	/* 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");
-		return;
-	}
-	/* get a buffer to hold one SU  */
-	RF_Malloc(databuf, rf_RaidAddressToByte(raidPtr, raidPtr->Layout.sectorsPerStripeUnit), (char *));
-
-	/* create a descriptor */
-	RF_Malloc(desc, sizeof(*desc), (RF_CopybackDesc_t *));
-	desc->raidPtr = raidPtr;
-	desc->status = 0;
-	desc->frow = frow;
-	desc->fcol = fcol;
-	desc->spRow = badDisk->spareRow;
-	desc->spCol = badDisk->spareCol;
-	desc->stripeAddr = 0;
-	desc->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
-	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 */
-	rf_SuspendNewRequestsAndWait(raidPtr);
-
-	/* 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_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 );
-
-	c_label->row = frow;
-	c_label->column = fcol;
-	c_label->partitionSize = raidPtr->Disks[frow][fcol].partitionSize;
-
-	raidwrite_component_label( raidPtr->raid_cinfo[frow][fcol].ci_dev,
-				   raidPtr->raid_cinfo[frow][fcol].ci_vp,
-				   c_label);
-	RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-}
-
-
-/*
- * 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;
-{
-	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;
-	struct timeval t, diff;
-
-	old_pctg = (-1);
-	while (1) {
-		stripeAddr = desc->stripeAddr;
-		desc->raidPtr->copyback_stripes_done = stripeAddr
-			/ desc->sectPerStripe;
-		if (rf_prReconSched) {
-			old_pctg = 100 * desc->stripeAddr / raidPtr->totalSectors;
-		}
-		desc->stripeAddr += desc->sectPerStripe;
-		if (rf_prReconSched) {
-			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);
-			}
-		}
-		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) {
-
-			/* 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);
-				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);
-
-			if (testRow == desc->frow && testCol == desc->fcol) {
-				rf_CopybackOne(desc, RF_COPYBACK_PARITY, stripeAddr, testRow, testCol, testOffs);
-			}
-		}
-		/* 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 */
-	}
-}
-
-
-/* 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;
-{
-	RF_SectorCount_t sectPerSU = desc->sectPerSU;
-	RF_Raid_t *raidPtr = desc->raidPtr;
-	RF_RowCol_t spRow = desc->spRow;
-	RF_RowCol_t spCol = desc->spCol;
-	RF_SectorNum_t spOffs;
-
-	/* find the spare 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);
-		else
-			raidPtr->Layout.map->MapParity(raidPtr, addr, &spRow, &spCol, &spOffs, RF_REMAP);
-	} else {
-		spOffs = testOffs;
-	}
-
-	/* 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);
-	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);
-	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 */
-
-	RF_LOCK_MUTEX(desc->mcpair->mutex);
-	desc->mcpair->flag = 0;
-
-	rf_DiskIOEnqueue(&raidPtr->Queues[spRow][spCol], desc->readreq, RF_IO_NORMAL_PRIORITY);
-
-	while (!desc->mcpair->flag) {
-		RF_WAIT_MCPAIR(desc->mcpair);
-	}
-	RF_UNLOCK_MUTEX(desc->mcpair->mutex);
-	rf_FreeDiskQueueData(desc->readreq);
-	rf_FreeDiskQueueData(desc->writereq);
-
-}
-
-
-/* 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;
-{
-	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);
-	}
-	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.
- */
-static int 
-rf_CopybackWriteDoneProc(desc, status)
-	RF_CopybackDesc_t *desc;
-	int     status;
-{
-	if (status && status != -100) {
-		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;
-{
-	RF_Raid_t *raidPtr = desc->raidPtr;
-	struct timeval t, diff;
-
-	if (!status) {
-		RF_LOCK_MUTEX(raidPtr->mutex);
-		if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
-			RF_ASSERT(raidPtr->Layout.map->parityConfig == 'D');
-			rf_FreeSpareTable(raidPtr);
-		} else {
-			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",
-		    (int) diff.tv_sec, (int) diff.tv_usec);
-	} else
-		printf("COPYBACK: Failure.\n");
-
-	RF_Free(desc->databuf, rf_RaidAddressToByte(raidPtr, desc->sectPerSU));
-	rf_FreeMCPair(desc->mcpair);
-	RF_Free(desc, sizeof(*desc));
-
-	rf_copyback_in_progress = 0;
-	rf_ResumeNewRequests(raidPtr);
-}
diff --git a/sys/dev/raidframe/rf_copyback.h b/sys/dev/raidframe/rf_copyback.h
deleted file mode 100644
index 67da842..0000000
--- a/sys/dev/raidframe/rf_copyback.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_copyback.h,v 1.3 1999/02/05 00:06:06 oster Exp $	*/
-/*
- * rf_copyback.h
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_COPYBACK_H_
-#define _RF__RF_COPYBACK_H_
-
-#include <dev/raidframe/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;
-
-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);
-
-#endif				/* !_RF__RF_COPYBACK_H_ */
diff --git a/sys/dev/raidframe/rf_cvscan.c b/sys/dev/raidframe/rf_cvscan.c
deleted file mode 100644
index b7c1026..0000000
--- a/sys/dev/raidframe/rf_cvscan.c
+++ /dev/null
@@ -1,441 +0,0 @@
-/*	$NetBSD: rf_cvscan.c,v 1.5 1999/08/13 03:41:53 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*******************************************************************************
- *
- * cvscan.c --  prioritized cvscan disk queueing code.
- *
- * Nov 9, 1994, adapted from raidSim version (MCH)
- *
- ******************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_stripelocks.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_cvscan.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_general.h>
-
-#define DO_CHECK_STATE(_hdr_) CheckCvscanState((_hdr_), __FILE__, __LINE__)
-
-#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)
-{
-	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)
-		RF_ASSERT(tmp->sectorOffset <= key
-		    && 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) {
-		RF_ASSERT(key <= tmp->sectorOffset);
-		RF_ASSERT(tmp->priority == hdr->nxt_priority);
-		RF_ASSERT(pri_ok(tmp->priority));
-	}
-	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) {
-		RF_ASSERT(tmp);
-		RF_ASSERT(hdr);
-		RF_ASSERT(pri_ok(tmp->priority));
-		RF_ASSERT(key >= tmp->priority);
-		RF_ASSERT(tmp->priority < hdr->nxt_priority);
-	}
-}
-
-
-
-static void 
-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 */
-
-	for (; (*list_ptr) != (RF_DiskQueueData_t *) NULL &&
-	    (*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)
-{
-	/* * 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 */
-
-	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)) {
-	}
-	req->next = (*list_ptr);
-	(*list_ptr) = req;
-}
-
-
-
-static RF_DiskQueueData_t *
-ReqDequeue(RF_DiskQueueData_t ** list_ptr)
-{
-	RF_DiskQueueData_t *ret = (*list_ptr);
-	if ((*list_ptr) != (RF_DiskQueueData_t *) NULL) {
-		(*list_ptr) = (*list_ptr)->next;
-	}
-	return (ret);
-}
-
-
-
-static void 
-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);
-	}
-	/* DO_CHECK_STATE(hdr); */
-}
-
-
-
-static void 
-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);
-		gp = p;
-	}
-	(*from_list_ptr) = (RF_DiskQueueData_t *) NULL;
-}
-
-
-
-static void 
-RealEnqueue(RF_CvscanHeader_t * hdr, RF_DiskQueueData_t * req)
-{
-	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) {
-		hdr->nxt_priority = req->priority;
-	}
-	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);
-		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);
-	} else {
-		if (req->sectorOffset < hdr->cur_block) {
-			/* this request is to the left of the current arms */
-			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);
-			hdr->right_cnt++;
-		}
-	}
-	DO_CHECK_STATE(hdr);
-}
-
-
-
-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_DiskQueueData_t *
-rf_CvscanDequeue(void *q_in)
-{
-	RF_CvscanHeader_t *hdr = (RF_CvscanHeader_t *) q_in;
-	long    range, i, sum_dist_left, sum_dist_right;
-	RF_DiskQueueData_t *ret;
-	RF_DiskQueueData_t *tmp;
-
-	DO_CHECK_STATE(hdr);
-
-	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));
-	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++) {
-		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++) {
-		sum_dist_right += tmp->sectorOffset - hdr->cur_block;
-	}
-
-	if (hdr->right_cnt == 0 || sum_dist_left < sum_dist_right) {
-		hdr->direction = rf_cvscan_LEFT;
-		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*/ ;
-	} else {
-		hdr->direction = rf_cvscan_RIGHT;
-		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*/ ;
-	}
-	ReBalance(hdr);
-
-	if (hdr->left_cnt == 0 && hdr->right_cnt == 0
-	    && hdr->burner != (RF_DiskQueueData_t *) NULL) {
-		/*
-		** 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) {
-			RF_DiskQueueData_t *next = burner->next;
-			RealEnqueue(hdr, burner);
-			burner = next;
-		}
-		hdr->burner = burner;
-	}
-	DO_CHECK_STATE(hdr);
-	return (ret);
-}
-
-
-
-RF_DiskQueueData_t *
-rf_CvscanPeek(void *q_in)
-{
-	RF_CvscanHeader_t *hdr = (RF_CvscanHeader_t *) q_in;
-	long    range, i, sum_dist_left, sum_dist_right;
-	RF_DiskQueueData_t *tmp, *headElement;
-
-	DO_CHECK_STATE(hdr);
-
-	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));
-		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++) {
-			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++) {
-			sum_dist_right += tmp->sectorOffset - hdr->cur_block;
-		}
-
-		if (hdr->right_cnt == 0 || sum_dist_left < sum_dist_right)
-			headElement = hdr->left;
-		else
-			headElement = hdr->right;
-	}
-	return (headElement);
-}
-
-
-
-/*
-** 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()
-{
-	return (0);
-}
-
-
-
-void   *
-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;
-
-	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);
-	hdr->direction = rf_cvscan_RIGHT;
-	hdr->cur_block = 0;
-	hdr->left_cnt = hdr->right_cnt = 0;
-	hdr->left = hdr->right = (RF_DiskQueueData_t *) NULL;
-	hdr->burner = (RF_DiskQueueData_t *) NULL;
-	DO_CHECK_STATE(hdr);
-
-	return ((void *) hdr);
-}
-
-
-#if defined(__NetBSD__) || defined(__FreeBSD__) && defined(_KERNEL)
-/* PrintCvscanQueue is not used, so we ignore it... */
-#else
-static void 
-PrintCvscanQueue(RF_CvscanHeader_t * hdr)
-{
-	RF_DiskQueueData_t *tmp;
-
-	printf("CVSCAN(%d,%d) at %d going %s\n",
-	    (int) hdr->range_for_avg,
-	    (int) hdr->change_penalty,
-	    (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)
-		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)
-		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)
-		printf("(%d,%ld,%d) ",
-		    (int) tmp->sectorOffset,
-		    (long) (tmp->sectorOffset + tmp->numSector),
-		    tmp->priority);
-	printf("\n");
-}
-#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.
- */
-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;
-
-	DO_CHECK_STATE(hdr);
-	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;
-			tlist = tmp;
-			tmp = hdr->burner;
-		} else
-			break;
-	}
-	if (tmp) {
-		trailer = tmp;
-		tmp = tmp->next;
-	}
-	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 */
-			tmp = trailer->next;
-		} else {
-			trailer = tmp;
-			tmp = tmp->next;
-		}
-	}
-	while (tlist) {
-		retval++;
-		tmp = tlist->next;
-		RealEnqueue(hdr, tlist);
-		tlist = tmp;
-	}
-	RF_ASSERT(retval == 0 || retval == 1);
-	DO_CHECK_STATE((RF_CvscanHeader_t *) q_in);
-	return (retval);
-}
diff --git a/sys/dev/raidframe/rf_cvscan.h b/sys/dev/raidframe/rf_cvscan.h
deleted file mode 100644
index 7f536a8..0000000
--- a/sys/dev/raidframe/rf_cvscan.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_cvscan.h,v 1.3 1999/02/05 00:06:07 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
-**	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_
-
-#include <dev/raidframe/rf_diskqueue.h>
-
-typedef enum RF_CvscanArmDir_e {
-	rf_cvscan_LEFT,
-	rf_cvscan_RIGHT
-}       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;
-
-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);
-
-#endif				/* !_RF__RF_CVSCAN_H_ */
diff --git a/sys/dev/raidframe/rf_dag.h b/sys/dev/raidframe/rf_dag.h
deleted file mode 100644
index 15cd4a8..0000000
--- a/sys/dev/raidframe/rf_dag.h
+++ /dev/null
@@ -1,239 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_dag.h,v 1.3 1999/02/05 00:06:07 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II, Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/****************************************************************************
- *                                                                          *
- * dag.h -- header file for DAG-related data structures                     *
- *                                                                          *
- ****************************************************************************/
-
-#ifndef _RF__RF_DAG_H_
-#define _RF__RF_DAG_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_stripelocks.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_dagflags.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/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 */
-
-#if defined(__FreeBSD__) && __FreeBSD_version > 500005
-#include <sys/bio.h>
-#endif
-#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 */
-};
-
-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;
-/*
- * These were used to control skipping a node.
- * Now, these are only used as comments.
- */
-typedef enum RF_AntecedentType_e {
-	rf_trueData,
-	rf_antiData,
-	rf_outputData,
-	rf_control
-}       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 */
-};
-/*
- * 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 */
-
-/* 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
- */
-typedef enum RF_DagStatus_e {
-	rf_enable,
-	rf_rollForward,
-	rf_rollBackward
-}       RF_DagStatus_t;
-#define RF_MAX_HDR_SUCC 1
-
-#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_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 */
-
-};
-
-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) */
-};
-/* 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;     \
-}
-
-/* convience 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_ */
diff --git a/sys/dev/raidframe/rf_dagdegrd.c b/sys/dev/raidframe/rf_dagdegrd.c
deleted file mode 100644
index 6321db6..0000000
--- a/sys/dev/raidframe/rf_dagdegrd.c
+++ /dev/null
@@ -1,1132 +0,0 @@
-/*	$NetBSD: rf_dagdegrd.c,v 1.7 2001/01/26 14:06:16 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_dagdegrd.c
- *
- * code for creating degraded read DAGs
- */
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_memchunk.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/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
- * is reached, the execution engine will halt forward execution and work
- * 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
- * through the graph, blindly executing nodes until it reaches the end.
- * If a graph reaches the end, it is assumed to have completed successfully.
- *
- * 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 
-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_CreateDegradedReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    &rf_xorRecoveryFuncs);
-}
-
-
-/******************************************************************************
- *
- * DAG creation code begins here
- */
-
-
-/******************************************************************************
- * 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
- *   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
- *****************************************************************************/
-
-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_DagNode_t *nodes, *rdNode, *blockNode, *commitNode, *termNode;
-	RF_StripeNum_t parityStripeID;
-	RF_ReconUnitNum_t which_ru;
-	RF_PhysDiskAddr_t *pda;
-	int     useMirror, i;
-
-	useMirror = 0;
-	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
-	    asmap->raidAddress, &which_ru);
-	if (rf_dagDebug) {
-		printf("[Creating RAID level 1 degraded read DAG]\n");
-	}
-	dag_h->creator = "RaidOneDegradedReadDAG";
-	/* 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);
-	i = 0;
-	rdNode = &nodes[i];
-	i++;
-	blockNode = &nodes[i];
-	i++;
-	commitNode = &nodes[i];
-	i++;
-	termNode = &nodes[i];
-	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 */
-	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);
-
-	pda = asmap->physInfo;
-	RF_ASSERT(pda != NULL);
-	/* parityInfo must describe entire parity unit */
-	RF_ASSERT(asmap->parityInfo->next == NULL);
-
-	/* 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);
-		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);
-	} 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);
-		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);
-	}
-
-	/* 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 */
-	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 */
-	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 */
-	RF_ASSERT(commitNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	commitNode->succedents[0] = termNode;
-	termNode->antecedents[0] = commitNode;
-	termNode->antType[0] = rf_control;
-}
-
-
-
-/******************************************************************************
- *
- * creates 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 -->
- *
- * 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
- * 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
- * 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.
- *
- *****************************************************************************/
-
-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_DagNode_t *nodes, *rudNodes, *rrdNodes, *xorNode, *blockNode;
-	RF_DagNode_t *commitNode, *rpNode, *termNode;
-	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 */
-	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;
-
-	layoutPtr = &(raidPtr->Layout);
-	/* 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);
-	sectorsPerSU = layoutPtr->sectorsPerStripeUnit;
-
-	if (rf_dagDebug) {
-		printf("[Creating degraded read DAG]\n");
-	}
-	RF_ASSERT(asmap->numDataFailed == 1);
-	dag_h->creator = "DegradedReadDAG";
-
-	/*
-         * 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);
-
-	/*
-         * 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 */
-	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *),
-	    allocList);
-	i = 0;
-	blockNode = &nodes[i];
-	i++;
-	commitNode = &nodes[i];
-	i++;
-	xorNode = &nodes[i];
-	i++;
-	rpNode = &nodes[i];
-	i++;
-	termNode = &nodes[i];
-	i++;
-	rudNodes = &nodes[i];
-	i += nRudNodes;
-	rrdNodes = &nodes[i];
-	i += nRrdNodes;
-	RF_ASSERT(i == nNodes);
-
-	/* 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 */
-	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) {
-		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_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);
-	}
-
-	/* 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);
-			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);
-		}
-	}
-	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_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);
-		}
-	}
-	/* 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->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);
-	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);
-
-	/*
-         * 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 */
-		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 */
-		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);
-			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 */
-	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
-         */
-	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.
-         */
-	xorNode->results[0] = failedPDA->bufPtr;
-	RF_BZERO(bp, failedPDA->bufPtr, rf_RaidAddressToByte(raidPtr,
-		failedPDA->numSector));
-
-	/* 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 */
-	RF_ASSERT(blockNode->numSuccedents == (1 + nRrdNodes + nRudNodes));
-	RF_ASSERT(rpNode->numAntecedents == 1);
-	blockNode->succedents[0] = rpNode;
-	rpNode->antecedents[0] = blockNode;
-	rpNode->antType[0] = rf_control;
-	for (i = 0; i < nRrdNodes; i++) {
-		RF_ASSERT(rrdNodes[i].numSuccedents == 1);
-		blockNode->succedents[1 + i] = &rrdNodes[i];
-		rrdNodes[i].antecedents[0] = blockNode;
-		rrdNodes[i].antType[0] = rf_control;
-	}
-	for (i = 0; i < nRudNodes; i++) {
-		RF_ASSERT(rudNodes[i].numSuccedents == 1);
-		blockNode->succedents[1 + nRrdNodes + i] = &rudNodes[i];
-		rudNodes[i].antecedents[0] = blockNode;
-		rudNodes[i].antType[0] = rf_control;
-	}
-
-	/* connect the read nodes to the xor node */
-	RF_ASSERT(xorNode->numAntecedents == (1 + nRrdNodes + nRudNodes));
-	RF_ASSERT(rpNode->numSuccedents == 1);
-	rpNode->succedents[0] = xorNode;
-	xorNode->antecedents[0] = rpNode;
-	xorNode->antType[0] = rf_trueData;
-	for (i = 0; i < nRrdNodes; i++) {
-		RF_ASSERT(rrdNodes[i].numSuccedents == 1);
-		rrdNodes[i].succedents[0] = xorNode;
-		xorNode->antecedents[1 + i] = &rrdNodes[i];
-		xorNode->antType[1 + i] = rf_trueData;
-	}
-	for (i = 0; i < nRudNodes; i++) {
-		RF_ASSERT(rudNodes[i].numSuccedents == 1);
-		rudNodes[i].succedents[0] = xorNode;
-		xorNode->antecedents[1 + nRrdNodes + i] = &rudNodes[i];
-		xorNode->antType[1 + nRrdNodes + i] = rf_trueData;
-	}
-
-	/* 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 */
-	RF_ASSERT(commitNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	commitNode->succedents[0] = termNode;
-	termNode->antType[0] = rf_control;
-	termNode->antecedents[0] = commitNode;
-}
-
-#if (RF_INCLUDE_CHAINDECLUSTER > 0)
-/******************************************************************************
- * Create a degraded read DAG for Chained Declustering
- *
- * Hdr -> Nil -> R(p/s)d -> Cmt -> Trm
- *
- * 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
- *****************************************************************************/
-
-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_DagNode_t *nodes, *rdNode, *blockNode, *commitNode, *termNode;
-	RF_StripeNum_t parityStripeID;
-	int     useMirror, i, shiftable;
-	RF_ReconUnitNum_t which_ru;
-	RF_PhysDiskAddr_t *pda;
-
-	if ((asmap->numDataFailed + asmap->numParityFailed) == 0) {
-		shiftable = RF_TRUE;
-	} else {
-		shiftable = RF_FALSE;
-	}
-	useMirror = 0;
-	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
-	    asmap->raidAddress, &which_ru);
-
-	if (rf_dagDebug) {
-		printf("[Creating RAID C degraded read DAG]\n");
-	}
-	dag_h->creator = "RaidCDegradedReadDAG";
-	/* 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);
-	i = 0;
-	rdNode = &nodes[i];
-	i++;
-	blockNode = &nodes[i];
-	i++;
-	commitNode = &nodes[i];
-	i++;
-	termNode = &nodes[i];
-	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.
-         */
-	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);
-
-	pda = asmap->physInfo;
-	RF_ASSERT(pda != NULL);
-	/* parityInfo must describe entire parity unit */
-	RF_ASSERT(asmap->parityInfo->next == NULL);
-
-	/* 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);
-		if (shiftable && rf_compute_workload_shift(raidPtr, pda)) {
-			/* 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);
-		} else {
-			/* 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);
-		}
-	} 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);
-		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);
-	}
-
-	/* 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 */
-	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 */
-	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 */
-	RF_ASSERT(commitNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	commitNode->succedents[0] = termNode;
-	termNode->antecedents[0] = commitNode;
-	termNode->antType[0] = rf_control;
-}
-#endif /* (RF_INCLUDE_CHAINDECLUSTER > 0) */
-
-#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) || (RF_INCLUDE_EVENODD > 0)
-/*
- * XXX move this elsewhere?
- */
-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_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	int     PDAPerDisk, i;
-	RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
-	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 *pda_p;
-	RF_PhysDiskAddr_t *phys_p;
-	RF_RaidAddr_t sosAddr;
-
-	/* determine how many pda's we will have to generate per unaccess
-	 * stripe. If there is only one failed data unit, it is one; if two,
-	 * 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)
-
-	if (asmap->numDataFailed == 1) {
-		PDAPerDisk = 1;
-		state = 1;
-		RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
-		pda_p = *pqpdap;
-		/* build p */
-		CONS_PDA(parityInfo, fone_start, fone->numSector);
-		pda_p->type = RF_PDA_TYPE_PARITY;
-		pda_p++;
-		/* build q */
-		CONS_PDA(qInfo, fone_start, fone->numSector);
-		pda_p->type = RF_PDA_TYPE_Q;
-	} else {
-		ftwo_start = rf_StripeUnitOffset(layoutPtr, ftwo->startSector);
-		ftwo_end = ftwo_start + ftwo->numSector;
-		if (fone->numSector + ftwo->numSector > secPerSU) {
-			PDAPerDisk = 1;
-			state = 2;
-			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;
-			pda_p++;
-			CONS_PDA(qInfo, 0, secPerSU);
-			pda_p->type = RF_PDA_TYPE_Q;
-		} else {
-			PDAPerDisk = 2;
-			state = 3;
-			/* 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;
-			pda_p++;
-			CONS_PDA(qInfo, fone_start, fone->numSector);
-			pda_p->type = RF_PDA_TYPE_Q;
-			pda_p++;
-			CONS_PDA(parityInfo, ftwo_start, ftwo->numSector);
-			pda_p->type = RF_PDA_TYPE_PARITY;
-			pda_p++;
-			CONS_PDA(qInfo, ftwo_start, ftwo->numSector);
-			pda_p->type = RF_PDA_TYPE_Q;
-		}
-	}
-	/* 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 */
-
-	count = 0;
-	for (pda_p = asmap->physInfo; pda_p; pda_p = pda_p->next) {
-		if ((pda_p == fone) || (pda_p == ftwo))
-			continue;
-		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 */
-			if ((suoff > fone_start) || (suend < fone_end))
-				count++;
-			break;
-		case 2:	/* whole stripe */
-			if (suoff)	/* leak at begining */
-				count++;
-			if (suend < numDataCol)	/* leak at end */
-				count++;
-			break;
-		case 3:	/* two disjoint units */
-			if ((suoff > fone_start) || (suend < fone_end))
-				count++;
-			if ((suoff > ftwo_start) || (suend < ftwo_end))
-				count++;
-			break;
-		default:
-			RF_PANIC();
-		}
-	}
-
-	napdas += count;
-	*nNodep = napdas;
-	if (napdas == 0)
-		return;		/* short circuit */
-
-	/* allocate up our list of pda's */
-
-	RF_CallocAndAdd(pda_p, napdas, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
-	*pdap = pda_p;
-
-	/* linkem 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);
-	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 */
-		if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
-			continue;
-		switch (state) {
-		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);
-			break;
-		case 2:	/* full stripe */
-			pda_p->numSector = secPerSU;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, secPerSU), (char *), allocList);
-			break;
-		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);
-			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);
-			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);
-			break;
-		default:
-			RF_PANIC();
-		}
-		pda_p++;
-	}
-
-	/* 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]))
-			continue;
-		suoff = rf_StripeUnitOffset(layoutPtr, phys_p->startSector);
-		suend = suoff + phys_p->numSector;
-		switch (state) {
-		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 */
-				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++;
-			}
-			if (suend < fone_end) {
-				RF_ASSERT(suoff <= fone_start);
-				/* 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++;
-			}
-			break;
-		case 2:	/* whole stripe unit */
-			RF_ASSERT((suoff == 0) || (suend == secPerSU));
-			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++;
-			} else
-				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++;
-				}
-			break;
-		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
-					 * 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++;
-				}
-				if (suend < fone_end) {
-					RF_ASSERT(suoff <= fone_start);
-					/* 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++;
-				}
-			}
-			if ((suoff > ftwo_start) || (suend < ftwo_end)) {
-				if (suoff > ftwo_start) {
-					RF_ASSERT(suend >= ftwo_end);
-					/* The data read starts after the
-					 * mapped access, snip off the
-					 * 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++;
-				}
-				if (suend < ftwo_end) {
-					RF_ASSERT(suoff <= ftwo_start);
-					/* 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++;
-				}
-			}
-			break;
-		default:
-			RF_PANIC();
-		}
-	}
-
-	/* 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 */
-		if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
-			continue;
-		switch (state) {
-		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);
-			break;
-		case 2:	/* full stripe */
-			pda_p->numSector = secPerSU;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, secPerSU), (char *), allocList);
-			break;
-		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);
-			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);
-			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);
-			break;
-		default:
-			RF_PANIC();
-		}
-		pda_p++;
-	}
-
-	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 
-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_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_DagNode_t *nodes, *rudNodes, *rrdNodes, *recoveryNode, *blockNode,
-	       *unblockNode, *rpNodes, *rqNodes, *termNode;
-	RF_PhysDiskAddr_t *pda, *pqPDAs;
-	RF_PhysDiskAddr_t *npdas;
-	int     nNodes, nRrdNodes, nRudNodes, i;
-	RF_ReconUnitNum_t which_ru;
-	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);
-
-	if (rf_dagDebug)
-		printf("[Creating Double Degraded Read DAG]\n");
-	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;
-
-	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
-	i = 0;
-	blockNode = &nodes[i];
-	i += 1;
-	unblockNode = &nodes[i];
-	i += 1;
-	recoveryNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-	rudNodes = &nodes[i];
-	i += nRudNodes;
-	rrdNodes = &nodes[i];
-	i += nRrdNodes;
-	rpNodes = &nodes[i];
-	i += nPQNodes;
-	rqNodes = &nodes[i];
-	i += nPQNodes;
-	RF_ASSERT(i == nNodes);
-
-	dag_h->numSuccedents = 1;
-	dag_h->succedents[0] = blockNode;
-	dag_h->creator = "DoubleDegRead";
-	dag_h->numCommits = 0;
-	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);
-	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);
-
-	for (i = 0; i < nReadNodes; i++) {
-		blockNode->succedents[i] = rudNodes + i;
-		unblockNode->antecedents[i] = rudNodes + i;
-		unblockNode->antType[i] = rf_control;
-	}
-	unblockNode->succedents[0] = termNode;
-
-	/* 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 */
-	    asmap->numDataFailed,	/* results */
-	    dag_h, recoveryNodeName, allocList);
-
-	recoveryNode->succedents[0] = termNode;
-	for (i = 0; i < nReadNodes; i++) {
-		recoveryNode->antecedents[i] = rudNodes + i;
-		recoveryNode->antType[i] = rf_trueData;
-	}
-
-	/* 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))
-			continue;
-		INIT_DISK_NODE(rudNodes + i, "Rud");
-		RF_ASSERT(pda);
-		DISK_NODE_PARAMS(rudNodes[i], pda);
-		i++;
-	}
-
-	pda = npdas;
-	for (i = 0; i < nRrdNodes; i++, pda = pda->next) {
-		INIT_DISK_NODE(rrdNodes + i, "Rrd");
-		RF_ASSERT(pda);
-		DISK_NODE_PARAMS(rrdNodes[i], pda);
-	}
-
-	/* redundancy pdas */
-	pda = pqPDAs;
-	INIT_DISK_NODE(rpNodes, "Rp");
-	RF_ASSERT(pda);
-	DISK_NODE_PARAMS(rpNodes[0], pda);
-	pda++;
-	INIT_DISK_NODE(rqNodes, redundantReadNodeName);
-	RF_ASSERT(pda);
-	DISK_NODE_PARAMS(rqNodes[0], pda);
-	if (nPQNodes == 2) {
-		pda++;
-		INIT_DISK_NODE(rpNodes + 1, "Rp");
-		RF_ASSERT(pda);
-		DISK_NODE_PARAMS(rpNodes[1], pda);
-		pda++;
-		INIT_DISK_NODE(rqNodes + 1, redundantReadNodeName);
-		RF_ASSERT(pda);
-		DISK_NODE_PARAMS(rqNodes[1], pda);
-	}
-	/* fill in recovery node params */
-	for (i = 0; i < nReadNodes; i++)
-		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? */
-}
-
-#endif /* (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0) || (RF_INCLUDE_EVENODD > 0) */
diff --git a/sys/dev/raidframe/rf_dagdegrd.h b/sys/dev/raidframe/rf_dagdegrd.h
deleted file mode 100644
index 2e899d8..0000000
--- a/sys/dev/raidframe/rf_dagdegrd.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_dagdegrd.h,v 1.3 1999/02/05 00:06:07 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_DAGDEGRD_H_
-#define _RF__RF_DAGDEGRD_H_
-
-#include <dev/raidframe/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 *));
-
-#endif				/* !_RF__RF_DAGDEGRD_H_ */
diff --git a/sys/dev/raidframe/rf_dagdegwr.c b/sys/dev/raidframe/rf_dagdegwr.c
deleted file mode 100644
index 70e0db6..0000000
--- a/sys/dev/raidframe/rf_dagdegwr.c
+++ /dev/null
@@ -1,846 +0,0 @@
-/*	$NetBSD: rf_dagdegwr.c,v 1.6 2001/01/26 04:05:08 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_dagdegwr.c
- *
- * code for creating degraded write DAGs
- *
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_memchunk.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/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
- * is reached, the execution engine will halt forward execution and work
- * 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
- * through the graph, blindly executing nodes until it reaches the end.
- * If a graph reaches the end, it is assumed to have completed successfully.
- *
- * 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.
- */
-
-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;
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_PhysDiskAddr_t *failedPDA = asmap->failedPDAs[0];
-
-	RF_ASSERT(asmap->numDataFailed == 1);
-	dag_h->creator = "DegradedWriteDAG";
-
-	/* 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
-	 * 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);
-}
-
-
-
-/******************************************************************************
- *
- * 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 ---/
- *                                        \ {Wnd} -/
- *
- * commit nodes: Xor, Wnd
- *
- * IMPORTANT:
- * This DAG generator does not work for double-degraded archs since it does not
- * 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.
- *
- * 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.
- * 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;
-{
-	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 */
-	RF_AccessStripeMapHeader_t *new_asm_h[2];
-	RF_PhysDiskAddr_t *pda, *parityPDA;
-	RF_StripeNum_t parityStripeID;
-	RF_PhysDiskAddr_t *failedPDA;
-	RF_RaidLayout_t *layoutPtr;
-
-	layoutPtr = &(raidPtr->Layout);
-	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 = asmap->failedPDAs[0];
-
-	if (rf_dagDebug)
-		printf("[Creating degraded-write DAG]\n");
-
-	RF_ASSERT(asmap->numDataFailed == 1);
-	dag_h->creator = "SimpleDegradedWriteDAG";
-
-	/*
-         * 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
-							 * generated for the
-							 * 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);
-	/*
-         * 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) */
-	nNodes = 5 + nfaults + nWndNodes + nRrdNodes;
-	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t),
-	    (RF_DagNode_t *), allocList);
-	i = 0;
-	blockNode = &nodes[i];
-	i += 1;
-	commitNode = &nodes[i];
-	i += 1;
-	unblockNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-	xorNode = &nodes[i];
-	i += 1;
-	wnpNode = &nodes[i];
-	i += 1;
-	wndNodes = &nodes[i];
-	i += nWndNodes;
-	rrdNodes = &nodes[i];
-	i += nRrdNodes;
-	if (nfaults == 2) {
-		wnqNode = &nodes[i];
-		i += 1;
-	} else {
-		wnqNode = NULL;
-	}
-	RF_ASSERT(i == nNodes);
-
-	/* 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);
-
-	/*
-         * 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_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);
-		}
-	}
-	/* 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_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))
-				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);
-	}
-	/*
-         * 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->numSector = failedPDA->numSector;
-
-	if (!xorTargetBuf) {
-		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);
-	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);
-
-	/* 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->numSector = failedPDA->numSector;
-
-			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);
-			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);
-		}
-	}
-	/* 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_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);
-	}
-
-	/* fill in the results of the xor node */
-	xorNode->results[0] = xorTargetBuf;
-
-	/* 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 */
-			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 */
-		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);
-			xorNode->params[paramNum++].p = pda;
-			xorNode->params[paramNum++].p = pda->bufPtr;
-		}
-	}
-	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.
-         */
-	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.
-         */
-	xorNode->params[paramNum++].p = failedPDA;
-	xorNode->params[paramNum++].p = raidPtr;
-	RF_ASSERT(paramNum == 2 * nXorBufs + 2);
-
-	/*
-         * Code to link nodes begins here
-         */
-
-	/* link header to block node */
-	RF_ASSERT(blockNode->numAntecedents == 0);
-	dag_h->succedents[0] = blockNode;
-
-	/* link block node to rd nodes */
-	RF_ASSERT(blockNode->numSuccedents == nRrdNodes);
-	for (i = 0; i < nRrdNodes; i++) {
-		RF_ASSERT(rrdNodes[i].numAntecedents == 1);
-		blockNode->succedents[i] = &rrdNodes[i];
-		rrdNodes[i].antecedents[0] = blockNode;
-		rrdNodes[i].antType[0] = rf_control;
-	}
-
-	/* link read nodes to xor node */
-	RF_ASSERT(xorNode->numAntecedents == nRrdNodes);
-	for (i = 0; i < nRrdNodes; i++) {
-		RF_ASSERT(rrdNodes[i].numSuccedents == 1);
-		rrdNodes[i].succedents[0] = xorNode;
-		xorNode->antecedents[i] = &rrdNodes[i];
-		xorNode->antType[i] = rf_trueData;
-	}
-
-	/* 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 */
-	RF_ASSERT(commitNode->numSuccedents == nfaults + nWndNodes);
-	for (i = 0; i < nWndNodes; i++) {
-		RF_ASSERT(wndNodes[i].numAntecedents == 1);
-		commitNode->succedents[i] = &wndNodes[i];
-		wndNodes[i].antecedents[0] = commitNode;
-		wndNodes[i].antType[0] = rf_control;
-	}
-
-	/* link the commit node to wnp, wnq nodes */
-	RF_ASSERT(wnpNode->numAntecedents == 1);
-	commitNode->succedents[nWndNodes] = wnpNode;
-	wnpNode->antecedents[0] = commitNode;
-	wnpNode->antType[0] = rf_control;
-	if (nfaults == 2) {
-		RF_ASSERT(wnqNode->numAntecedents == 1);
-		commitNode->succedents[nWndNodes + 1] = wnqNode;
-		wnqNode->antecedents[0] = commitNode;
-		wnqNode->antType[0] = rf_control;
-	}
-	/* 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);
-		wndNodes[i].succedents[0] = unblockNode;
-		unblockNode->antecedents[i] = &wndNodes[i];
-		unblockNode->antType[i] = rf_control;
-	}
-
-	/* 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 */
-	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 */
-	RF_ASSERT(unblockNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	unblockNode->succedents[0] = termNode;
-	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)
-#if (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_EVENODD > 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;
-	RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
-	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 *pda_p;
-	RF_RaidAddr_t sosAddr;
-
-	/* determine how many pda's we will have to generate per unaccess
-	 * stripe. If there is only one failed data unit, it is one; if two,
-	 * possibly two, depending wether they overlap. */
-
-	fone_start = rf_StripeUnitOffset(layoutPtr, fone->startSector);
-	fone_end = fone_start + fone->numSector;
-
-	if (asmap->numDataFailed == 1) {
-		PDAPerDisk = 1;
-		state = 1;
-		RF_MallocAndAdd(*pqpdap, 2 * sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
-		pda_p = *pqpdap;
-		/* build p */
-		CONS_PDA(parityInfo, fone_start, fone->numSector);
-		pda_p->type = RF_PDA_TYPE_PARITY;
-		pda_p++;
-		/* build q */
-		CONS_PDA(qInfo, fone_start, fone->numSector);
-		pda_p->type = RF_PDA_TYPE_Q;
-	} else {
-		ftwo_start = rf_StripeUnitOffset(layoutPtr, ftwo->startSector);
-		ftwo_end = ftwo_start + ftwo->numSector;
-		if (fone->numSector + ftwo->numSector > secPerSU) {
-			PDAPerDisk = 1;
-			state = 2;
-			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;
-			pda_p++;
-			CONS_PDA(qInfo, 0, secPerSU);
-			pda_p->type = RF_PDA_TYPE_Q;
-		} else {
-			PDAPerDisk = 2;
-			state = 3;
-			/* 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;
-			pda_p++;
-			CONS_PDA(qInfo, fone_start, fone->numSector);
-			pda_p->type = RF_PDA_TYPE_Q;
-			pda_p++;
-			CONS_PDA(parityInfo, ftwo_start, ftwo->numSector);
-			pda_p->type = RF_PDA_TYPE_PARITY;
-			pda_p++;
-			CONS_PDA(qInfo, ftwo_start, ftwo->numSector);
-			pda_p->type = RF_PDA_TYPE_Q;
-		}
-	}
-	/* figure out number of nonaccessed pda */
-	napdas = PDAPerDisk * (numDataCol - 2);
-	*nPQNodep = PDAPerDisk;
-
-	*nNodep = napdas;
-	if (napdas == 0)
-		return;		/* short circuit */
-
-	/* allocate up our list of pda's */
-
-	RF_CallocAndAdd(pda_p, napdas, sizeof(RF_PhysDiskAddr_t), (RF_PhysDiskAddr_t *), allocList);
-	*pdap = pda_p;
-
-	/* linkem together */
-	for (i = 0; i < (napdas - 1); i++)
-		pda_p[i].next = pda_p + (i + 1);
-
-	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 */
-		if (RF_DEAD_DISK(raidPtr->Disks[pda_p->row][pda_p->col].status))
-			continue;
-		switch (state) {
-		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);
-			break;
-		case 2:	/* full stripe */
-			pda_p->numSector = secPerSU;
-			RF_MallocAndAdd(pda_p->bufPtr, rf_RaidAddressToByte(raidPtr, secPerSU), (char *), allocList);
-			break;
-		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);
-			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);
-			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);
-			break;
-		default:
-			RF_PANIC();
-		}
-		pda_p++;
-	}
-
-	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,
-    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;
-	RF_PhysDiskAddr_t *pda, *pqPDAs;
-	RF_PhysDiskAddr_t *npdas;
-	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);
-
-	/* 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. */
-
-
-	/* 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)
-	 * 
-	 */
-
-	rf_WriteGenerateFailedAccessASMs(raidPtr, asmap, &npdas, &nRrdNodes, &pqPDAs, &nPQNodes, allocList);
-
-	RF_ASSERT(asmap->numDataFailed == 1);
-
-	nWudNodes = asmap->numStripeUnitsAccessed - (asmap->numDataFailed);
-	nReadNodes = nRrdNodes + 2 * nPQNodes;
-	nWriteNodes = nWudNodes + 2 * nPQNodes;
-	nNodes = 4 + nReadNodes + nWriteNodes;
-
-	RF_CallocAndAdd(nodes, nNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
-	blockNode = nodes;
-	unblockNode = blockNode + 1;
-	termNode = unblockNode + 1;
-	recoveryNode = termNode + 1;
-	rrdNodes = recoveryNode + 1;
-	rpNodes = rrdNodes + nRrdNodes;
-	rqNodes = rpNodes + nPQNodes;
-	wudNodes = rqNodes + nPQNodes;
-	wpNodes = wudNodes + nWudNodes;
-	wqNodes = wpNodes + nPQNodes;
-
-	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);
-	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);
-	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);
-	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;
-
-	/* 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 */
-	pda = pqPDAs;
-	INIT_READ_NODE(rpNodes, "Rp");
-	RF_ASSERT(pda);
-	DISK_NODE_PARAMS(rpNodes[0], pda);
-	pda++;
-	INIT_READ_NODE(rqNodes, redundantReadNodeName);
-	RF_ASSERT(pda);
-	DISK_NODE_PARAMS(rqNodes[0], pda);
-	if (nPQNodes == 2) {
-		pda++;
-		INIT_READ_NODE(rpNodes + 1, "Rp");
-		RF_ASSERT(pda);
-		DISK_NODE_PARAMS(rpNodes[1], pda);
-		pda++;
-		INIT_READ_NODE(rqNodes + 1, redundantReadNodeName);
-		RF_ASSERT(pda);
-		DISK_NODE_PARAMS(rqNodes[1], pda);
-	}
-	/* 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. */
-
-
-	rf_InitNode(recoveryNode, rf_wait, RF_FALSE, recovFunc, rf_NullNodeUndoFunc, NULL,
-	    nWriteNodes,	/* succesors */
-	    nReadNodes,		/* preds */
-	    nReadNodes + nWudNodes + 3,	/* params */
-	    2 * nPQNodes,	/* results */
-	    dag_h, recoveryNodeName, allocList);
-
-
-
-	for (i = 0; i < nReadNodes; i++) {
-		recoveryNode->antecedents[i] = rrdNodes + i;
-		recoveryNode->antType[i] = rf_control;
-		recoveryNode->params[i].p = DISK_NODE_PDA(rrdNodes + i);
-	}
-	for (i = 0; i < nWudNodes; i++) {
-		recoveryNode->succedents[i] = wudNodes + i;
-	}
-	recoveryNode->params[nReadNodes + nWudNodes].p = asmap->failedPDAs[0];
-	recoveryNode->params[nReadNodes + nWudNodes + 1].p = raidPtr;
-	recoveryNode->params[nReadNodes + nWudNodes + 2].p = asmap;
-
-	for (; i < nWriteNodes; i++)
-		recoveryNode->succedents[i] = wudNodes + i;
-
-	pda = pqPDAs;
-	recoveryNode->results[0] = pda;
-	pda++;
-	recoveryNode->results[1] = pda;
-	if (nPQNodes == 2) {
-		pda++;
-		recoveryNode->results[2] = pda;
-		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;
-
-	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);
-		pda = pda->next;
-	}
-	/* write redundancy pdas */
-	pda = pqPDAs;
-	INIT_WRITE_NODE(wpNodes, "Wp");
-	RF_ASSERT(pda);
-	DISK_NODE_PARAMS(wpNodes[0], pda);
-	pda++;
-	INIT_WRITE_NODE(wqNodes, "Wq");
-	RF_ASSERT(pda);
-	DISK_NODE_PARAMS(wqNodes[0], pda);
-	if (nPQNodes == 2) {
-		pda++;
-		INIT_WRITE_NODE(wpNodes + 1, "Wp");
-		RF_ASSERT(pda);
-		DISK_NODE_PARAMS(wpNodes[1], pda);
-		pda++;
-		INIT_WRITE_NODE(wqNodes + 1, "Wq");
-		RF_ASSERT(pda);
-		DISK_NODE_PARAMS(wqNodes[1], pda);
-	}
-}
-#endif   /* (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_EVENODD > 0) */
diff --git a/sys/dev/raidframe/rf_dagdegwr.h b/sys/dev/raidframe/rf_dagdegwr.h
deleted file mode 100644
index 1e4b5e2..0000000
--- a/sys/dev/raidframe/rf_dagdegwr.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_dagdegwr.h,v 1.4 1999/08/15 02:36:03 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-
-#ifndef _RF__RF_DAGDEGWR_H_
-#define _RF__RF_DAGDEGWR_H_
-
-/* 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_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_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_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 *));
-
-#endif				/* !_RF__RF_DAGDEGWR_H_ */
diff --git a/sys/dev/raidframe/rf_dagffrd.c b/sys/dev/raidframe/rf_dagffrd.c
deleted file mode 100644
index 13c0af7..0000000
--- a/sys/dev/raidframe/rf_dagffrd.c
+++ /dev/null
@@ -1,441 +0,0 @@
-/*	$NetBSD: rf_dagffrd.c,v 1.4 2000/01/07 03:40:58 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_dagffrd.c
- *
- * code for creating fault-free read DAGs
- *
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_memchunk.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_dagffrd.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
- * is reached, the execution engine will halt forward execution and work
- * 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
- * through the graph, blindly executing nodes until it reaches the end.
- * If a graph reaches the end, it is assumed to have completed successfully.
- *
- * 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 
-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_CreateNonredundantDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    RF_IO_TYPE_READ);
-}
-
-
-/******************************************************************************
- *
- * DAG creation code begins here
- */
-
-/******************************************************************************
- *
- * creates a DAG to perform a nonredundant read or write of data within one
- * stripe.
- * For reads, this DAG is as follows:
- *
- *                   /---- read ----\
- *    Header -- Block ---- read ---- Commit -- Terminate
- *                   \---- read ----/
- *
- * For writes, this DAG is as follows:
- *
- *                    /---- write ----\
- *    Header -- Commit ---- write ---- Block -- Terminate
- *                    \---- write ----/
- *
- * There is one disk node per stripe unit accessed, and all disk nodes are in
- * parallel.
- *
- * Tricky point here:  The first disk node (read or write) is created
- * normally.  Subsequent disk nodes are created by copying the first one,
- * and modifying a few params.  The "succedents" and "antecedents" fields are
- * _not_ re-created in each node, but rather left pointing to the same array
- * that was malloc'd when the first node was created.  Thus, it's essential
- * that when this DAG is freed, the succedents and antecedents fields be freed
- * in ONLY ONE of the read nodes.  This does not apply to the "params" field
- * because it is recreated for each READ node.
- *
- * Note that normal-priority accesses do not need to be tagged with their
- * parity stripe ID, because they will never be promoted.  Hence, I've
- * commented-out the code to do this, and marked it with UNNEEDED.
- *
- *****************************************************************************/
-
-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_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;
-
-	n = asmap->numStripeUnitsAccessed;
-	dag_h->creator = "NonredundantDAG";
-
-	RF_ASSERT(RF_IO_IS_R_OR_W(type));
-	switch (type) {
-	case RF_IO_TYPE_READ:
-		doFunc = rf_DiskReadFunc;
-		undoFunc = rf_DiskReadUndoFunc;
-		name = "R  ";
-		if (rf_dagDebug)
-			printf("[Creating non-redundant read DAG]\n");
-		break;
-	case RF_IO_TYPE_WRITE:
-		doFunc = rf_DiskWriteFunc;
-		undoFunc = rf_DiskWriteUndoFunc;
-		name = "W  ";
-		if (rf_dagDebug)
-			printf("[Creating non-redundant write DAG]\n");
-		break;
-	default:
-		RF_PANIC();
-	}
-
-	/*
-         * 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
-         */
-	RF_ASSERT(n > 0);
-	totalNumNodes = n + 3;
-	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t),
-	    (RF_DagNode_t *), allocList);
-	i = 0;
-	diskNodes = &nodes[i];
-	i += n;
-	blockNode = &nodes[i];
-	i += 1;
-	commitNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-	RF_ASSERT(i == totalNumNodes);
-
-	/* 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);
-		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);
-		break;
-	default:
-		RF_PANIC();
-	}
-
-	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);
-		diskNodes[i].params[0].p = pda;
-		diskNodes[i].params[1].p = pda->bufPtr;
-		/* 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);
-		pda = pda->next;
-	}
-
-	/*
-         * Connect nodes.
-         */
-
-	/* 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 */
-		RF_ASSERT(blockNode->numSuccedents == n);
-		RF_ASSERT(commitNode->numAntecedents == n);
-		for (i = 0; i < n; i++) {
-			/* 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 */
-			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 */
-		RF_ASSERT(commitNode->numSuccedents == 1);
-		RF_ASSERT(termNode->numAntecedents == 1);
-		RF_ASSERT(termNode->numSuccedents == 0);
-		commitNode->succedents[0] = termNode;
-		termNode->antecedents[0] = commitNode;
-		termNode->antType[0] = rf_control;
-	} else {
-		/* 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;
-		commitNode->antecedents[0] = blockNode;
-		commitNode->antType[0] = rf_control;
-
-		RF_ASSERT(commitNode->numSuccedents == n);
-		RF_ASSERT(termNode->numAntecedents == n);
-		RF_ASSERT(termNode->numSuccedents == 0);
-		for (i = 0; i < n; i++) {
-			/* 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 */
-			RF_ASSERT(diskNodes[i].numSuccedents == 1);
-			diskNodes[i].succedents[0] = termNode;
-			termNode->antecedents[i] = &diskNodes[i];
-			termNode->antType[i] = rf_control;
-		}
-	}
-}
-/******************************************************************************
- * 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
- * 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
- *****************************************************************************/
-
-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))
-{
-	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;
-
-	n = asmap->numStripeUnitsAccessed;
-	dag_h->creator = "RaidOneReadDAG";
-	if (rf_dagDebug) {
-		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.
-         */
-	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
-         */
-	RF_ASSERT(n > 0);
-	totalNumNodes = n + 3;
-	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t),
-	    (RF_DagNode_t *), allocList);
-	i = 0;
-	readNodes = &nodes[i];
-	i += n;
-	blockNode = &nodes[i];
-	i += 1;
-	commitNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-	RF_ASSERT(i == totalNumNodes);
-
-	/* 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,
-	    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);
-
-	for (i = 0; i < n; i++) {
-		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);
-		readNodes[i].params[0].p = data_pda;
-		readNodes[i].params[1].p = data_pda->bufPtr;
-		/* 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[4].p = parity_pda;
-		data_pda = data_pda->next;
-		parity_pda = parity_pda->next;
-	}
-
-	/*
-         * Connect nodes
-         */
-
-	/* connect hdr to block node */
-	RF_ASSERT(blockNode->numAntecedents == 0);
-	dag_h->succedents[0] = blockNode;
-
-	/* connect block node to read nodes */
-	RF_ASSERT(blockNode->numSuccedents == n);
-	for (i = 0; i < n; i++) {
-		RF_ASSERT(readNodes[i].numAntecedents == 1);
-		blockNode->succedents[i] = &readNodes[i];
-		readNodes[i].antecedents[0] = blockNode;
-		readNodes[i].antType[0] = rf_control;
-	}
-
-	/* connect read nodes to commit node */
-	RF_ASSERT(commitNode->numAntecedents == n);
-	for (i = 0; i < n; i++) {
-		RF_ASSERT(readNodes[i].numSuccedents == 1);
-		readNodes[i].succedents[0] = commitNode;
-		commitNode->antecedents[i] = &readNodes[i];
-		commitNode->antType[i] = rf_control;
-	}
-
-	/* connect commit node to term node */
-	RF_ASSERT(commitNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	commitNode->succedents[0] = termNode;
-	termNode->antecedents[0] = commitNode;
-	termNode->antType[0] = rf_control;
-}
-
-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)
-{
-	CreateMirrorReadDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    rf_DiskReadMirrorIdleFunc);
-}
-
-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)
-{
-	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
deleted file mode 100644
index 6862a8d..0000000
--- a/sys/dev/raidframe/rf_dagffrd.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_dagffrd.h,v 1.3 1999/02/05 00:06:07 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_DAGFFRD_H_
-#define _RF__RF_DAGFFRD_H_
-
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_DAGFFRD_H_ */
diff --git a/sys/dev/raidframe/rf_dagffwr.c b/sys/dev/raidframe/rf_dagffwr.c
deleted file mode 100644
index 9216b29..0000000
--- a/sys/dev/raidframe/rf_dagffwr.c
+++ /dev/null
@@ -1,2131 +0,0 @@
-/*	$NetBSD: rf_dagffwr.c,v 1.5 2000/01/07 03:40:58 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_dagff.c
- *
- * code for creating fault-free DAGs
- *
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_memchunk.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_dagffwr.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
- * is reached, the execution engine will halt forward execution and work
- * 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
- * through the graph, blindly executing nodes until it reaches the end.
- * If a graph reaches the end, it is assumed to have completed successfully.
- *
- * 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 
-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)
-{
-	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)
-{
-	/* "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)
-{
-	/* "normal" rollaway */
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    1, rf_RegularXorFunc, RF_TRUE);
-}
-
-
-/******************************************************************************
- *
- * DAG creation code begins here
- */
-
-
-/******************************************************************************
- *
- * creates a DAG to perform a large-write operation:
- *
- *           / Rod \           / Wnd \
- * H -- block- Rod - Xor - Cmt - Wnd --- T
- *           \ Rod /          \  Wnp /
- *                             \[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.
- *
- * 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
- *
- * 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 *),
-    int allowBufferRecycle)
-{
-	RF_DagNode_t *nodes, *wndNodes, *rodNodes, *xorNode, *wnpNode;
-	RF_DagNode_t *wnqNode, *blockNode, *commitNode, *termNode;
-	int     nWndNodes, nRodNodes, i, nodeNum, asmNum;
-	RF_AccessStripeMapHeader_t *new_asm_h[2];
-	RF_StripeNum_t parityStripeID;
-	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);
-
-	if (rf_dagDebug) {
-		printf("[Creating large-write DAG]\n");
-	}
-	dag_h->creator = "LargeWriteDAG";
-
-	dag_h->numCommitNodes = 1;
-	dag_h->numCommits = 0;
-	dag_h->numSuccedents = 1;
-
-	/* 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);
-	i = 0;
-	wndNodes = &nodes[i];
-	i += nWndNodes;
-	xorNode = &nodes[i];
-	i += 1;
-	wnpNode = &nodes[i];
-	i += 1;
-	blockNode = &nodes[i];
-	i += 1;
-	commitNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-	if (nfaults == 2) {
-		wnqNode = &nodes[i];
-		i += 1;
-	} else {
-		wnqNode = NULL;
-	}
-	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);
-	} else {
-		rodNodes = NULL;
-	}
-
-	/* 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);
-	} else {
-		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);
-
-	/* 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);
-				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);
-				nodeNum++;
-				pda = pda->next;
-			}
-		}
-	}
-	RF_ASSERT(nodeNum == nRodNodes);
-
-	/* 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_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);
-		pda = pda->next;
-	}
-
-	/* 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,
-		    "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);
-	}
-	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 */
-	}
-	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 */
-	}
-	/* 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.
-         */
-	if (allowBufferRecycle) {
-		for (i = 0; i < nRodNodes; i++) {
-			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);
-	} 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);
-	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 */
-	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);
-		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 */
-		RF_ASSERT(asmap->parityInfo->next == NULL);
-	}
-	/*
-         * 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 */
-		RF_ASSERT(blockNode->numSuccedents == nRodNodes);
-		RF_ASSERT(xorNode->numAntecedents == nRodNodes);
-		for (i = 0; i < nRodNodes; i++) {
-			RF_ASSERT(rodNodes[i].numAntecedents == 1);
-			blockNode->succedents[i] = &rodNodes[i];
-			rodNodes[i].antecedents[0] = blockNode;
-			rodNodes[i].antType[0] = rf_control;
-
-			/* 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 */
-		RF_ASSERT(blockNode->numSuccedents == 1);
-		RF_ASSERT(xorNode->numAntecedents == 1);
-		blockNode->succedents[0] = xorNode;
-		xorNode->antecedents[0] = blockNode;
-		xorNode->antType[0] = rf_control;
-	}
-
-	/* 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 */
-	RF_ASSERT(commitNode->numSuccedents == nWndNodes + nfaults);
-	for (i = 0; i < nWndNodes; i++) {
-		RF_ASSERT(wndNodes->numAntecedents == 1);
-		commitNode->succedents[i] = &wndNodes[i];
-		wndNodes[i].antecedents[0] = commitNode;
-		wndNodes[i].antType[0] = rf_control;
-	}
-	RF_ASSERT(wnpNode->numAntecedents == 1);
-	commitNode->succedents[nWndNodes] = wnpNode;
-	wnpNode->antecedents[0] = commitNode;
-	wnpNode->antType[0] = rf_trueData;
-	if (nfaults == 2) {
-		RF_ASSERT(wnqNode->numAntecedents == 1);
-		commitNode->succedents[nWndNodes + 1] = wnqNode;
-		wnqNode->antecedents[0] = commitNode;
-		wnqNode->antType[0] = rf_trueData;
-	}
-	/* 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++) {
-		RF_ASSERT(wndNodes->numSuccedents == 1);
-		wndNodes[i].succedents[0] = termNode;
-		termNode->antecedents[i] = &wndNodes[i];
-		termNode->antType[i] = rf_control;
-	}
-	RF_ASSERT(wnpNode->numSuccedents == 1);
-	wnpNode->succedents[0] = termNode;
-	termNode->antecedents[nWndNodes] = wnpNode;
-	termNode->antType[nWndNodes] = rf_control;
-	if (nfaults == 2) {
-		RF_ASSERT(wnqNode->numSuccedents == 1);
-		wnqNode->succedents[0] = termNode;
-		termNode->antecedents[nWndNodes + 1] = wnqNode;
-		termNode->antType[nWndNodes + 1] = rf_control;
-	}
-}
-/******************************************************************************
- *
- * creates 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
- *            \- Rod X      /     \----> Wnd [Und]-/
- *           [\- Rod X     /       \---> Wnd [Und]-/]
- *           [\- Roq -> Q /         \--> Wnq [Unq]-/]
- *
- * Rop = read old parity
- * Rod = read old data
- * Roq = read old "q"
- * Cmt = commit node
- * Und = unlock data disk
- * Unp = unlock parity disk
- * Unq = unlock q disk
- * Wnp = write new parity
- * Wnd = write new data
- * Wnq = write new "q"
- * [ ] 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
- *
- * 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)
-{
-	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;
-	RF_ReconUnitNum_t which_ru;
-	int     (*func) (RF_DagNode_t *), (*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;
-
-	nfaults = qfuncs ? 2 : 1;
-	lu_flag = (rf_enableAtomicRMW) ? 1 : 0;	/* lock/unlock flag */
-
-	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
-	    asmap->raidAddress, &which_ru);
-	pda = asmap->physInfo;
-	numDataNodes = asmap->numStripeUnitsAccessed;
-	numParityNodes = (asmap->parityInfo->next) ? 2 : 1;
-
-	if (rf_dagDebug) {
-		printf("[Creating small-write DAG]\n");
-	}
-	RF_ASSERT(numDataNodes > 0);
-	dag_h->creator = "SmallWriteDAG";
-
-	dag_h->numCommitNodes = 1;
-	dag_h->numCommits = 0;
-	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
-         */
-
-	/*
-         * 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 */
-	totalNumNodes = (2 * numDataNodes) + (nfaults * numParityNodes)
-	    + (nfaults * 2 * numParityNodes) + 3;
-	if (lu_flag) {
-		totalNumNodes += (numDataNodes + (nfaults * numParityNodes));
-	}
-	/*
-         * Step 2. create the nodes
-         */
-	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t),
-	    (RF_DagNode_t *), allocList);
-	i = 0;
-	blockNode = &nodes[i];
-	i += 1;
-	commitNode = &nodes[i];
-	i += 1;
-	readDataNodes = &nodes[i];
-	i += numDataNodes;
-	readParityNodes = &nodes[i];
-	i += numParityNodes;
-	writeDataNodes = &nodes[i];
-	i += numDataNodes;
-	writeParityNodes = &nodes[i];
-	i += numParityNodes;
-	xorNodes = &nodes[i];
-	i += numParityNodes;
-	termNode = &nodes[i];
-	i += 1;
-	if (lu_flag) {
-		unlockDataNodes = &nodes[i];
-		i += numDataNodes;
-		unlockParityNodes = &nodes[i];
-		i += numParityNodes;
-	} else {
-		unlockDataNodes = unlockParityNodes = NULL;
-	}
-	if (nfaults == 2) {
-		readQNodes = &nodes[i];
-		i += numParityNodes;
-		writeQNodes = &nodes[i];
-		i += numParityNodes;
-		qNodes = &nodes[i];
-		i += numParityNodes;
-		if (lu_flag) {
-			unlockQNodes = &nodes[i];
-			i += numParityNodes;
-		} else {
-			unlockQNodes = NULL;
-		}
-	} else {
-		readQNodes = writeQNodes = qNodes = unlockQNodes = NULL;
-	}
-	RF_ASSERT(i == totalNumNodes);
-
-	/*
-         * 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);
-
-	/* 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 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_ASSERT(pda != NULL);
-		/* 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);
-		pda = pda->next;
-		for (j = 0; j < readDataNodes[i].numSuccedents; j++) {
-			readDataNodes[i].propList[j] = NULL;
-		}
-	}
-
-	/* 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);
-		readParityNodes[i].params[0].p = pda;
-		/* 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);
-		pda = pda->next;
-		for (j = 0; j < readParityNodes[i].numSuccedents; j++) {
-			readParityNodes[i].propList[0] = NULL;
-		}
-	}
-
-	/* 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);
-			readQNodes[i].params[0].p = pda;
-			/* 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);
-			pda = pda->next;
-			for (j = 0; j < readQNodes[i].numSuccedents; j++) {
-				readQNodes[i].propList[0] = NULL;
-			}
-		}
-	}
-	/* 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);
-		/* 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);
-		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);
-			/* 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
-         * 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;
-		if (qfuncs) {
-			qfunc = qfuncs->simple;
-			qname = qfuncs->SimpleName;
-		} else {
-			qfunc = NULL;
-			qname = NULL;
-		}
-	} else {
-		func = pfuncs->regular;
-		undoFunc = rf_NullNodeUndoFunc;
-		name = pfuncs->RegularName;
-		if (qfuncs) {
-			qfunc = qfuncs->regular;
-			qname = qfuncs->RegularName;
-		} else {
-			qfunc = NULL;
-			qname = NULL;
-		}
-	}
-	/*
-         * 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++) {
-			/* 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];
-			xorNodes[i].params[2] = readParityNodes[i].params[0];
-			xorNodes[i].params[3] = readParityNodes[i].params[1];
-			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 */
-			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];
-				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[6].p = raidPtr;
-				/* 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);
-		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 */
-		}
-		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];
-		}
-		/* 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);
-			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 */
-			}
-			/* 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];
-			for (i = 0; i < numDataNodes; i++) {
-				/* 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 */
-				    writeDataNodes[i].params[1];
-			}
-			/* 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) */
-	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,
-		    "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 */
-		writeParityNodes[i].params[2].v = parityStripeID;
-		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);
-		}
-		pda = pda->next;
-	}
-
-	/* 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,
-			    "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 */
-			writeQNodes[i].params[2].v = parityStripeID;
-			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);
-			}
-			pda = pda->next;
-		}
-	}
-	/*
-         * Step 4. connect the nodes.
-         */
-
-	/* 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)));
-	for (i = 0; i < numDataNodes; i++) {
-		blockNode->succedents[i] = &readDataNodes[i];
-		RF_ASSERT(readDataNodes[i].numAntecedents == 1);
-		readDataNodes[i].antecedents[0] = blockNode;
-		readDataNodes[i].antType[0] = rf_control;
-	}
-
-	/* 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);
-		readParityNodes[i].antecedents[0] = blockNode;
-		readParityNodes[i].antType[0] = rf_control;
-	}
-
-	/* connect block node to read old Q nodes */
-	if (nfaults == 2) {
-		for (i = 0; i < numParityNodes; 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 */
-	for (i = 0; i < numDataNodes; i++) {
-		RF_ASSERT(readDataNodes[i].numSuccedents == (nfaults * numParityNodes));
-		for (j = 0; j < numParityNodes; j++) {
-			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 */
-	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];
-				qNodes[j].antecedents[i] = &readDataNodes[i];
-				qNodes[j].antType[i] = rf_trueData;
-			}
-		}
-	}
-	/* 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].antType[numDataNodes + i] = rf_trueData;
-		}
-	}
-
-	/* connect read old q nodes to q nodes */
-	if (nfaults == 2) {
-		for (i = 0; i < numParityNodes; i++) {
-			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;
-			}
-		}
-	}
-	/* connect xor nodes to commit node */
-	RF_ASSERT(commitNode->numAntecedents == (nfaults * numParityNodes));
-	for (i = 0; i < numParityNodes; i++) {
-		RF_ASSERT(xorNodes[i].numSuccedents == 1);
-		xorNodes[i].succedents[0] = commitNode;
-		commitNode->antecedents[i] = &xorNodes[i];
-		commitNode->antType[i] = rf_control;
-	}
-
-	/* 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->antType[i + numParityNodes] = rf_control;
-		}
-	}
-	/* 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];
-		writeDataNodes[i].antecedents[0] = commitNode;
-		writeDataNodes[i].antType[0] = rf_trueData;
-	}
-	for (i = 0; i < numParityNodes; i++) {
-		RF_ASSERT(writeParityNodes[i].numAntecedents == 1);
-		commitNode->succedents[i + numDataNodes] = &writeParityNodes[i];
-		writeParityNodes[i].antecedents[0] = commitNode;
-		writeParityNodes[i].antType[0] = rf_trueData;
-	}
-	if (nfaults == 2) {
-		for (i = 0; i < numParityNodes; i++) {
-			RF_ASSERT(writeQNodes[i].numAntecedents == 1);
-			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->numSuccedents == 0);
-	for (i = 0; i < numDataNodes; i++) {
-		if (lu_flag) {
-			/* 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 */
-			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 */
-			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
-			RF_ASSERT(termNode->numAntecedents == (numDataNodes + (nfaults * numParityNodes)));
-			writeDataNodes[i].succedents[0] = termNode;
-			termNode->antecedents[i] = &writeDataNodes[i];
-			termNode->antType[i] = rf_control;
-		}
-	}
-
-	for (i = 0; i < numParityNodes; i++) {
-		if (lu_flag) {
-			/* 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];
-			unlockParityNodes[i].antType[0] = rf_control;
-
-			/* connect unlock nodes to term node */
-			RF_ASSERT(unlockParityNodes[i].numSuccedents == 1);
-			unlockParityNodes[i].succedents[0] = termNode;
-			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->antType[numDataNodes + i] = rf_control;
-		}
-	}
-
-	if (nfaults == 2) {
-		for (i = 0; i < numParityNodes; i++) {
-			if (lu_flag) {
-				/* 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].antType[0] = rf_control;
-
-				/* 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;
-			} 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;
-			}
-		}
-	}
-}
-
-
-/******************************************************************************
- * create a write graph (fault-free or degraded) for RAID level 1
- *
- * Hdr -> Commit -> Wpd -> Nil -> Trm
- *               -> 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
- *
- * 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)
-{
-	RF_DagNode_t *unblockNode, *termNode, *commitNode;
-	RF_DagNode_t *nodes, *wndNode, *wmirNode;
-	int     nWndNodes, nWmirNodes, i;
-	RF_ReconUnitNum_t which_ru;
-	RF_PhysDiskAddr_t *pda, *pdaP;
-	RF_StripeNum_t parityStripeID;
-
-	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
-	    asmap->raidAddress, &which_ru);
-	if (rf_dagDebug) {
-		printf("[Creating RAID level 1 write DAG]\n");
-	}
-	dag_h->creator = "RaidOneWriteDAG";
-
-	/* 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 */
-	if (asmap->numDataFailed == 1)
-		nWndNodes--;
-	if (asmap->numParityFailed == 1)
-		nWmirNodes--;
-
-	/* 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;
-	wndNode = &nodes[i];
-	i += nWndNodes;
-	wmirNode = &nodes[i];
-	i += nWmirNodes;
-	commitNode = &nodes[i];
-	i += 1;
-	unblockNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-	RF_ASSERT(i == (nWndNodes + nWmirNodes + 3));
-
-	/* 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 */
-	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_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);
-			pda = pda->next;
-		}
-		RF_ASSERT(pda == NULL);
-	}
-	/* 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_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);
-			pda = pda->next;
-			pdaP = pdaP->next;
-		}
-		RF_ASSERT(pda == NULL);
-		RF_ASSERT(pdaP == NULL);
-	}
-	/* 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 */
-	RF_ASSERT(commitNode->numSuccedents == (nWndNodes + nWmirNodes));
-	for (i = 0; i < nWndNodes; i++) {
-		RF_ASSERT(wndNode[i].numAntecedents == 1);
-		commitNode->succedents[i] = &wndNode[i];
-		wndNode[i].antecedents[0] = commitNode;
-		wndNode[i].antType[0] = rf_control;
-	}
-	for (i = 0; i < nWmirNodes; i++) {
-		RF_ASSERT(wmirNode[i].numAntecedents == 1);
-		commitNode->succedents[i + nWndNodes] = &wmirNode[i];
-		wmirNode[i].antecedents[0] = commitNode;
-		wmirNode[i].antType[0] = rf_control;
-	}
-
-	/* 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);
-		wndNode[i].succedents[0] = unblockNode;
-		unblockNode->antecedents[i] = &wndNode[i];
-		unblockNode->antType[i] = rf_control;
-	}
-	for (i = 0; i < nWmirNodes; i++) {
-		RF_ASSERT(wmirNode[i].numSuccedents == 1);
-		wmirNode[i].succedents[0] = unblockNode;
-		unblockNode->antecedents[i + nWndNodes] = &wmirNode[i];
-		unblockNode->antType[i + nWndNodes] = rf_control;
-	}
-
-	/* link the unblock node to the term node */
-	RF_ASSERT(unblockNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	unblockNode->succedents[0] = termNode;
-	termNode->antecedents[0] = unblockNode;
-	termNode->antType[0] = rf_control;
-}
-
-
-
-/* DAGs which 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 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 *),
-    int allowBufferRecycle)
-{
-	RF_DagNode_t *nodes, *wndNodes, *rodNodes, *xorNode, *wnpNode;
-	RF_DagNode_t *wnqNode, *blockNode, *syncNode, *termNode;
-	int     nWndNodes, nRodNodes, i, nodeNum, asmNum;
-	RF_AccessStripeMapHeader_t *new_asm_h[2];
-	RF_StripeNum_t parityStripeID;
-	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);
-
-	if (rf_dagDebug)
-		printf("[Creating large-write DAG]\n");
-	dag_h->creator = "LargeWriteDAGFwd";
-
-	dag_h->numCommitNodes = 0;
-	dag_h->numCommits = 0;
-	dag_h->numSuccedents = 1;
-
-	/* 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);
-	i = 0;
-	wndNodes = &nodes[i];
-	i += nWndNodes;
-	xorNode = &nodes[i];
-	i += 1;
-	wnpNode = &nodes[i];
-	i += 1;
-	blockNode = &nodes[i];
-	i += 1;
-	syncNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-	if (nfaults == 2) {
-		wnqNode = &nodes[i];
-		i += 1;
-	} else {
-		wnqNode = NULL;
-	}
-	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);
-	} else {
-		rodNodes = NULL;
-	}
-
-	/* 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);
-	} 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(termNode, rf_wait, RF_FALSE, rf_TerminateFunc, rf_TerminateUndoFunc, NULL, 0, nWndNodes + nfaults, 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);
-				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);
-				nodeNum++;
-				pda = pda->next;
-			}
-		}
-	}
-	RF_ASSERT(nodeNum == nRodNodes);
-
-	/* 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_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);
-		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);
-	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 */
-	}
-	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 + nRodNodes)].p = raidPtr;	/* xor node needs to get
-									 * at RAID information */
-
-	/* 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)
-				break;
-	}
-	if ((!allowBufferRecycle) || (i == nRodNodes)) {
-		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);
-	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 */
-
-	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);
-		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 */
-	}
-	/* 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 */
-		RF_ASSERT(blockNode->numSuccedents == nRodNodes);
-		RF_ASSERT(syncNode->numAntecedents == nRodNodes);
-		for (i = 0; i < nRodNodes; i++) {
-			RF_ASSERT(rodNodes[i].numAntecedents == 1);
-			blockNode->succedents[i] = &rodNodes[i];
-			rodNodes[i].antecedents[0] = blockNode;
-			rodNodes[i].antType[0] = rf_control;
-
-			/* 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 */
-		RF_ASSERT(blockNode->numSuccedents == 1);
-		RF_ASSERT(syncNode->numAntecedents == 1);
-		blockNode->succedents[0] = syncNode;
-		syncNode->antecedents[0] = blockNode;
-		syncNode->antType[0] = rf_control;
-	}
-
-	/* 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);
-		syncNode->succedents[i] = &wndNodes[i];
-		wndNodes[i].antecedents[0] = syncNode;
-		wndNodes[i].antType[0] = rf_control;
-	}
-
-	/* 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 */
-	RF_ASSERT(xorNode->numSuccedents == nfaults);
-	RF_ASSERT(wnpNode->numAntecedents == 1);
-	xorNode->succedents[0] = wnpNode;
-	wnpNode->antecedents[0] = xorNode;
-	wnpNode->antType[0] = rf_trueData;
-	if (nfaults == 2) {
-		RF_ASSERT(wnqNode->numAntecedents == 1);
-		xorNode->succedents[1] = wnqNode;
-		wnqNode->antecedents[0] = xorNode;
-		wnqNode->antType[0] = rf_trueData;
-	}
-	/* 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++) {
-		RF_ASSERT(wndNodes->numSuccedents == 1);
-		wndNodes[i].succedents[0] = termNode;
-		termNode->antecedents[i] = &wndNodes[i];
-		termNode->antType[i] = rf_control;
-	}
-	RF_ASSERT(wnpNode->numSuccedents == 1);
-	wnpNode->succedents[0] = termNode;
-	termNode->antecedents[nWndNodes] = wnpNode;
-	termNode->antType[nWndNodes] = rf_control;
-	if (nfaults == 2) {
-		RF_ASSERT(wnqNode->numSuccedents == 1);
-		wnqNode->succedents[0] = termNode;
-		termNode->antecedents[nWndNodes + 1] = wnqNode;
-		termNode->antType[nWndNodes + 1] = rf_control;
-	}
-}
-
-
-/******************************************************************************
- *
- * creates a DAG to perform a small-write operation (either raid 5 or pq),
- * which is as follows:
- *
- * Hdr -> Nil -> Rop - Xor - Wnp [Unp] -- Trm
- *            \- Rod X- Wnd [Und] -------/
- *           [\- Rod X- Wnd [Und] ------/]
- *           [\- Roq - Q --> Wnq [Unq]-/]
- *
- * Rop = read old parity
- * Rod = read old data
- * Roq = read old "q"
- * Cmt = commit node
- * Und = unlock data disk
- * Unp = unlock parity disk
- * Unq = unlock q disk
- * Wnp = write new parity
- * Wnd = write new data
- * Wnq = write new "q"
- * [ ] 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
- *
- * 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)
-{
-	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;
-	RF_ReconUnitNum_t which_ru;
-	int     (*func) (RF_DagNode_t *), (*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;
-
-	nfaults = qfuncs ? 2 : 1;
-	lu_flag = (rf_enableAtomicRMW) ? 1 : 0;	/* lock/unlock flag */
-
-	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout), asmap->raidAddress, &which_ru);
-	pda = asmap->physInfo;
-	numDataNodes = asmap->numStripeUnitsAccessed;
-	numParityNodes = (asmap->parityInfo->next) ? 2 : 1;
-
-	if (rf_dagDebug)
-		printf("[Creating small-write DAG]\n");
-	RF_ASSERT(numDataNodes > 0);
-	dag_h->creator = "SmallWriteDAGFwd";
-
-	dag_h->numCommitNodes = 0;
-	dag_h->numCommits = 0;
-	dag_h->numSuccedents = 1;
-
-	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 */
-
-	/* 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;
-	if (lu_flag)
-		totalNumNodes += (numDataNodes + (nfaults * numParityNodes));
-
-
-	/* Step 2. create the nodes */
-	RF_CallocAndAdd(nodes, totalNumNodes, sizeof(RF_DagNode_t), (RF_DagNode_t *), allocList);
-	i = 0;
-	blockNode = &nodes[i];
-	i += 1;
-	readDataNodes = &nodes[i];
-	i += numDataNodes;
-	readParityNodes = &nodes[i];
-	i += numParityNodes;
-	writeDataNodes = &nodes[i];
-	i += numDataNodes;
-	writeParityNodes = &nodes[i];
-	i += numParityNodes;
-	xorNodes = &nodes[i];
-	i += numParityNodes;
-	termNode = &nodes[i];
-	i += 1;
-	if (lu_flag) {
-		unlockDataNodes = &nodes[i];
-		i += numDataNodes;
-		unlockParityNodes = &nodes[i];
-		i += numParityNodes;
-	} else {
-		unlockDataNodes = unlockParityNodes = NULL;
-	}
-	if (nfaults == 2) {
-		readQNodes = &nodes[i];
-		i += numParityNodes;
-		writeQNodes = &nodes[i];
-		i += numParityNodes;
-		qNodes = &nodes[i];
-		i += numParityNodes;
-		if (lu_flag) {
-			unlockQNodes = &nodes[i];
-			i += numParityNodes;
-		} else {
-			unlockQNodes = NULL;
-		}
-	} else {
-		readQNodes = writeQNodes = qNodes = unlockQNodes = NULL;
-	}
-	RF_ASSERT(i == totalNumNodes);
-
-	/* 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);
-
-	/* 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) */
-	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_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 */
-		readDataNodes[i].params[2].v = parityStripeID;
-		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) */
-	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);
-		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[2].v = parityStripeID;
-		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) */
-	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);
-			readQNodes[i].params[0].p = pda;
-			readQNodes[i].params[1].p = rf_AllocBuffer(raidPtr, dag_h, pda, allocList);	/* buffer to hold old Q */
-			readQNodes[i].params[2].v = parityStripeID;
-			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) */
-	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 */
-		writeDataNodes[i].params[2].v = parityStripeID;
-		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);
-		}
-		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
-	 * 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;
-		if (qfuncs) {
-			qfunc = qfuncs->simple;
-			qname = qfuncs->SimpleName;
-		}
-	} else {
-		func = pfuncs->regular;
-		undoFunc = rf_NullNodeUndoFunc;
-		name = pfuncs->RegularName;
-		if (qfuncs) {
-			qfunc = qfuncs->regular;
-			qname = qfuncs->RegularName;
-		}
-	}
-	/* 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 */
-			xorNodes[i].flags |= RF_DAGNODE_FLAG_YIELD;
-			xorNodes[i].params[0] = readDataNodes[i].params[0];
-			xorNodes[i].params[1] = readDataNodes[i].params[1];
-			xorNodes[i].params[2] = readParityNodes[i].params[0];
-			xorNodes[i].params[3] = readParityNodes[i].params[1];
-			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 */
-			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];
-				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[6].p = raidPtr;
-				qNodes[i].results[0] = readQNodes[i].params[1].p;	/* use old Q buf as
-											 * target buf */
-			}
-		}
-	} 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);
-		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 */
-		}
-		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 */
-		}
-		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);
-			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 */
-			}
-			/* 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 */
-			}
-			qNodes[0].params[2 * (numDataNodes + numDataNodes + 1)].p = raidPtr;	/* xor node needs to get
-												 * at RAID information */
-			qNodes[0].results[0] = readQNodes[0].params[1].p;
-		}
-	}
-
-	/* 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_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 */
-		writeParityNodes[i].params[2].v = parityStripeID;
-		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);
-		}
-		pda = pda->next;
-	}
-
-	/* 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_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 */
-			writeQNodes[i].params[2].v = parityStripeID;
-			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);
-			}
-			pda = pda->next;
-		}
-	}
-	/* Step 4. connect the nodes */
-
-	/* 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)));
-	for (i = 0; i < numDataNodes; i++) {
-		blockNode->succedents[i] = &readDataNodes[i];
-		RF_ASSERT(readDataNodes[i].numAntecedents == 1);
-		readDataNodes[i].antecedents[0] = blockNode;
-		readDataNodes[i].antType[0] = rf_control;
-	}
-
-	/* 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);
-		readParityNodes[i].antecedents[0] = blockNode;
-		readParityNodes[i].antType[0] = rf_control;
-	}
-
-	/* connect block node to read old Q nodes */
-	if (nfaults == 2)
-		for (i = 0; i < numParityNodes; 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 */
-	for (i = 0; i < numDataNodes; i++) {
-		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 */
-	for (i = 0; i < numDataNodes; i++) {
-		for (j = 0; j < numParityNodes; j++) {
-			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 */
-	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];
-				qNodes[j].antecedents[i] = &readDataNodes[i];
-				qNodes[j].antType[i] = rf_trueData;
-			}
-
-	/* 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);
-			readParityNodes[i].succedents[j] = &xorNodes[j];
-			xorNodes[j].antecedents[numDataNodes + i] = &readParityNodes[i];
-			xorNodes[j].antType[numDataNodes + i] = rf_trueData;
-		}
-	}
-
-	/* 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);
-				readQNodes[i].succedents[j] = &qNodes[j];
-				qNodes[j].antecedents[numDataNodes + i] = &readQNodes[i];
-				qNodes[j].antType[numDataNodes + i] = rf_trueData;
-			}
-		}
-
-	/* 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++) {
-			RF_ASSERT(xorNodes[j].numSuccedents == numParityNodes);
-			xorNodes[i].succedents[j] = &writeParityNodes[j];
-			writeParityNodes[j].antecedents[i] = &xorNodes[i];
-			writeParityNodes[j].antType[i] = rf_trueData;
-		}
-	}
-
-	/* connect q nodes to the write new q nodes */
-	if (nfaults == 2)
-		for (i = 0; i < numParityNodes; i++) {
-			RF_ASSERT(writeQNodes[i].numAntecedents == numParityNodes);
-			for (j = 0; j < numParityNodes; j++) {
-				RF_ASSERT(qNodes[j].numSuccedents == 1);
-				qNodes[i].succedents[j] = &writeQNodes[j];
-				writeQNodes[j].antecedents[i] = &qNodes[i];
-				writeQNodes[j].antType[i] = rf_trueData;
-			}
-		}
-
-	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 */
-			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 */
-			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 */
-			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
-			RF_ASSERT(termNode->numAntecedents == (numDataNodes + (nfaults * numParityNodes)));
-			writeDataNodes[i].succedents[0] = termNode;
-			termNode->antecedents[i] = &writeDataNodes[i];
-			termNode->antType[i] = rf_control;
-		}
-	}
-
-	for (i = 0; i < numParityNodes; i++) {
-		if (lu_flag) {
-			/* 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];
-			unlockParityNodes[i].antType[0] = rf_control;
-
-			/* connect unlock nodes to term node */
-			RF_ASSERT(unlockParityNodes[i].numSuccedents == 1);
-			unlockParityNodes[i].succedents[0] = termNode;
-			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->antType[numDataNodes + i] = rf_control;
-		}
-	}
-
-	if (nfaults == 2)
-		for (i = 0; i < numParityNodes; i++) {
-			if (lu_flag) {
-				/* 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].antType[0] = rf_control;
-
-				/* 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;
-			} 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;
-			}
-		}
-}
-
-
-
-/******************************************************************************
- * create a write graph (fault-free or degraded) for RAID level 1
- *
- * Hdr  Nil -> Wpd -> Nil -> Trm
- *      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
- *
- * 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)
-{
-	RF_DagNode_t *blockNode, *unblockNode, *termNode;
-	RF_DagNode_t *nodes, *wndNode, *wmirNode;
-	int     nWndNodes, nWmirNodes, i;
-	RF_ReconUnitNum_t which_ru;
-	RF_PhysDiskAddr_t *pda, *pdaP;
-	RF_StripeNum_t parityStripeID;
-
-	parityStripeID = rf_RaidAddressToParityStripeID(&(raidPtr->Layout),
-	    asmap->raidAddress, &which_ru);
-	if (rf_dagDebug) {
-		printf("[Creating RAID level 1 write DAG]\n");
-	}
-	nWmirNodes = (asmap->parityInfo->next) ? 2 : 1;	/* 2 implies access not
-							 * SU aligned */
-	nWndNodes = (asmap->physInfo->next) ? 2 : 1;
-
-	/* 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);
-	i = 0;
-	wndNode = &nodes[i];
-	i += nWndNodes;
-	wmirNode = &nodes[i];
-	i += nWmirNodes;
-	blockNode = &nodes[i];
-	i += 1;
-	unblockNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-	RF_ASSERT(i == (nWndNodes + nWmirNodes + 3));
-
-	/* 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 */
-	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_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);
-			pda = pda->next;
-		}
-		RF_ASSERT(pda == NULL);
-	}
-	/* 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_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);
-			pda = pda->next;
-			pdaP = pdaP->next;
-		}
-		RF_ASSERT(pda == NULL);
-		RF_ASSERT(pdaP == NULL);
-	}
-	/* 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 */
-	RF_ASSERT(blockNode->numSuccedents == (nWndNodes + nWmirNodes));
-	for (i = 0; i < nWndNodes; i++) {
-		RF_ASSERT(wndNode[i].numAntecedents == 1);
-		blockNode->succedents[i] = &wndNode[i];
-		wndNode[i].antecedents[0] = blockNode;
-		wndNode[i].antType[0] = rf_control;
-	}
-	for (i = 0; i < nWmirNodes; i++) {
-		RF_ASSERT(wmirNode[i].numAntecedents == 1);
-		blockNode->succedents[i + nWndNodes] = &wmirNode[i];
-		wmirNode[i].antecedents[0] = blockNode;
-		wmirNode[i].antType[0] = rf_control;
-	}
-
-	/* 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);
-		wndNode[i].succedents[0] = unblockNode;
-		unblockNode->antecedents[i] = &wndNode[i];
-		unblockNode->antType[i] = rf_control;
-	}
-	for (i = 0; i < nWmirNodes; i++) {
-		RF_ASSERT(wmirNode[i].numSuccedents == 1);
-		wmirNode[i].succedents[0] = unblockNode;
-		unblockNode->antecedents[i + nWndNodes] = &wmirNode[i];
-		unblockNode->antType[i + nWndNodes] = rf_control;
-	}
-
-	/* link the unblock node to the term node */
-	RF_ASSERT(unblockNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	unblockNode->succedents[0] = termNode;
-	termNode->antecedents[0] = unblockNode;
-	termNode->antType[0] = rf_control;
-
-	return;
-}
diff --git a/sys/dev/raidframe/rf_dagffwr.h b/sys/dev/raidframe/rf_dagffwr.h
deleted file mode 100644
index f65875e..0000000
--- a/sys/dev/raidframe/rf_dagffwr.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_dagffwr.h,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_DAGFFWR_H_
-#define _RF__RF_DAGFFWR_H_
-
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_DAGFFWR_H_ */
diff --git a/sys/dev/raidframe/rf_dagflags.h b/sys/dev/raidframe/rf_dagflags.h
deleted file mode 100644
index b0777bd..0000000
--- a/sys/dev/raidframe/rf_dagflags.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_dagflags.h,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/**************************************************************************************
- *
- * 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_
-
-/*
- * Bitmasks for the "flags" parameter (RF_RaidAccessFlags_t) used
- * by DoAccess, SelectAlgorithm, and the DAG creation routines.
- *
- * If USE_DAG or USE_ASM is specified, neither the DAG nor the ASM
- * will be modified, which means that you can't SUPRESS if you
- * 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
-						 * where the dag invokes no
-						 * I/O */
-#define RF_DAG_TEST_ACCESS        (1<<6)	/* this access came through
-						 * rf_ioctl instead of
-						 * rf_strategy */
-
-#endif				/* !_RF__RF_DAGFLAGS_H_ */
diff --git a/sys/dev/raidframe/rf_dagfuncs.c b/sys/dev/raidframe/rf_dagfuncs.c
deleted file mode 100644
index a1ba8150..0000000
--- a/sys/dev/raidframe/rf_dagfuncs.c
+++ /dev/null
@@ -1,906 +0,0 @@
-/*	$NetBSD: rf_dagfuncs.c,v 1.7 2001/02/03 12:51:10 mrg Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * dagfuncs.c -- DAG node execution routines
- *
- * Rules:
- * 1. Every DAG execution function must eventually cause node->status to
- *    get set to "good" or "bad", and "FinishNode" to be called. In the
- *    case of nodes that complete immediately (xor, NullNodeFunc, etc),
- *    the node execution function can do these two things directly. In
- *    the case of nodes that have to wait for some event (a disk read to
- *    complete, a lock to be released, etc) to occur before they can
- *    complete, this is typically achieved by having whatever module
- *    is doing the operation call GenericWakeupFunc upon completion.
- * 2. DAG execution functions should check the status in the DAG header
- *    and NOP out their operations if the status is not "enable". However,
- *    execution functions that release resources must be sure to release
- *    them even when they NOP out the function that would use them.
- *    Functions that acquire resources should go ahead and acquire them
- *    even when they NOP, so that a downstream release node will not have
- *    to check to find out whether or not the acquire was suppressed.
- */
-
-#include <sys/param.h>
-#if defined(__NetBSD__)
-#include <sys/ioctl.h>
-#elif defined(__FreeBSD__)
-#include <sys/ioccom.h>
-#include <sys/filio.h>
-#endif
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_engine.h>
-#include <dev/raidframe/rf_dagutils.h>
-
-#include <dev/raidframe/rf_kintf.h>
-
-#if RF_INCLUDE_PARITYLOGGING > 0
-#include <dev/raidframe/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;
-{
-	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;
-	rf_DiskWriteUndoFunc = rf_DiskUndoFunc;
-	rf_DiskUnlockFunc = rf_DiskUnlockFuncForThreads;
-	rf_DiskUnlockUndoFunc = rf_NullNodeUndoFunc;
-	rf_RegularXorUndoFunc = rf_NullNodeUndoFunc;
-	rf_SimpleXorUndoFunc = rf_NullNodeUndoFunc;
-	rf_RecoveryXorUndoFunc = rf_NullNodeUndoFunc;
-	return (0);
-}
-
-
-
-/*****************************************************************************************
- * the execution function associated with a terminate node
- ****************************************************************************************/
-int 
-rf_TerminateFunc(node)
-	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;
-{
-	return (0);
-}
-
-
-/*****************************************************************************************
- * 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)
- *
- ****************************************************************************************/
-
-int 
-rf_DiskReadMirrorIdleFunc(node)
-	RF_DagNode_t *node;
-{
-	/* 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;
-{
-	/* 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;
-{
-	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;
-{
-	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-	caddr_t buf = (caddr_t) node->params[1].p;
-	RF_ParityLogData_t *logData;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	RF_Etimer_t timer;
-
-	if (node->dagHdr->status == rf_enable) {
-		RF_ETIMER_START(timer);
-		logData = rf_CreateParityLogData(RF_UPDATE, 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 {
-			RF_ETIMER_STOP(timer);
-			RF_ETIMER_EVAL(timer);
-			tracerec->plog_us += RF_ETIMER_VAL_US(timer);
-			(node->wakeFunc) (node, ENOMEM);
-		}
-	}
-	return (0);
-}
-
-
-/*****************************************************************************************
- * the execution function associated with a parity log overwrite node
- ****************************************************************************************/
-int 
-rf_ParityLogOverwriteFunc(node)
-	RF_DagNode_t *node;
-{
-	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-	caddr_t buf = (caddr_t) node->params[1].p;
-	RF_ParityLogData_t *logData;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	RF_Etimer_t timer;
-
-	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);
-		if (logData)
-			rf_ParityLogAppend(logData, RF_FALSE, NULL, RF_FALSE);
-		else {
-			RF_ETIMER_STOP(timer);
-			RF_ETIMER_EVAL(timer);
-			tracerec->plog_us += RF_ETIMER_VAL_US(timer);
-			(node->wakeFunc) (node, ENOMEM);
-		}
-	}
-	return (0);
-}
-#else				/* RF_INCLUDE_PARITYLOGGING > 0 */
-
-int 
-rf_ParityLogUpdateFunc(node)
-	RF_DagNode_t *node;
-{
-	return (0);
-}
-int 
-rf_ParityLogOverwriteFunc(node)
-	RF_DagNode_t *node;
-{
-	return (0);
-}
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
-
-int 
-rf_ParityLogUpdateUndoFunc(node)
-	RF_DagNode_t *node;
-{
-	return (0);
-}
-
-int 
-rf_ParityLogOverwriteUndoFunc(node)
-	RF_DagNode_t *node;
-{
-	return (0);
-}
-/*****************************************************************************************
- * the execution function associated with a NOP node
- ****************************************************************************************/
-int 
-rf_NullNodeFunc(node)
-	RF_DagNode_t *node;
-{
-	node->status = rf_good;
-	return (rf_FinishNode(node, RF_THREAD_CONTEXT));
-}
-
-int 
-rf_NullNodeUndoFunc(node)
-	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;
-{
-	RF_DiskQueueData_t *req;
-	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-	caddr_t buf = (caddr_t) node->params[1].p;
-	RF_StripeNum_t parityStripeID = (RF_StripeNum_t) node->params[2].v;
-	unsigned priority = RF_EXTRACT_PRIORITY(node->params[3].v);
-	unsigned lock = RF_EXTRACT_LOCK_FLAG(node->params[3].v);
-	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_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
-	void   *b_proc = NULL;
-
-#if defined(__NetBSD__)
-	if (node->dagHdr->bp)
-		b_proc = (void *) ((RF_Buf_t) node->dagHdr->bp)->b_proc;
-#endif
-
-	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,
-	    node, NULL, node->dagHdr->tracerec,
-	    (void *) (node->dagHdr->raidPtr), flags, b_proc);
-	if (!req) {
-		(node->wakeFunc) (node, ENOMEM);
-	} else {
-		node->dagFuncData = (void *) req;
-		rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req, priority);
-	}
-	return (0);
-}
-
-
-/*****************************************************************************************
- * the execution function associated with a disk-write node
- ****************************************************************************************/
-int 
-rf_DiskWriteFuncForThreads(node)
-	RF_DagNode_t *node;
-{
-	RF_DiskQueueData_t *req;
-	RF_PhysDiskAddr_t *pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-	caddr_t buf = (caddr_t) node->params[1].p;
-	RF_StripeNum_t parityStripeID = (RF_StripeNum_t) node->params[2].v;
-	unsigned priority = RF_EXTRACT_PRIORITY(node->params[3].v);
-	unsigned lock = RF_EXTRACT_LOCK_FLAG(node->params[3].v);
-	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_DiskQueue_t **dqs = ((RF_Raid_t *) (node->dagHdr->raidPtr))->Queues;
-	void   *b_proc = NULL;
-
-#if defined(__NetBSD__)
-	if (node->dagHdr->bp)
-		b_proc = (void *) ((RF_Buf_t) node->dagHdr->bp)->b_proc;
-#endif
-
-	/* 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),
-	    flags, b_proc);
-
-	if (!req) {
-		(node->wakeFunc) (node, ENOMEM);
-	} else {
-		node->dagFuncData = (void *) req;
-		rf_DiskIOEnqueue(&(dqs[pda->row][pda->col]), req, priority);
-	}
-
-	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;
-{
-	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),
-	    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);
-	}
-
-	return (0);
-}
-/*****************************************************************************************
- * the execution function associated with an "unlock disk queue" node
- ****************************************************************************************/
-int 
-rf_DiskUnlockFuncForThreads(node)
-	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),
-	    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);
-	}
-
-	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;
-{
-	switch (node->status) {
-	case rf_bwd1:
-		node->status = rf_bwd2;
-		if (node->dagFuncData)
-			rf_FreeDiskQueueData((RF_DiskQueueData_t *) node->dagFuncData);
-		return (rf_DiskWriteFuncForThreads(node));
-		break;
-	case rf_fired:
-		if (status)
-			node->status = rf_bad;
-		else
-			node->status = rf_good;
-		break;
-	case rf_recover:
-		/* probably should never reach this case */
-		if (status)
-			node->status = rf_panic;
-		else
-			node->status = rf_undone;
-		break;
-	default:
-		printf("rf_GenericWakeupFunc:");
-		printf("node->status is %d,", node->status);
-		printf("status is %d \n", status);
-		RF_PANIC();
-		break;
-	}
-	if (node->dagFuncData)
-		rf_FreeDiskQueueData((RF_DiskQueueData_t *) node->dagFuncData);
-	return (rf_FinishNode(node, RF_INTR_CONTEXT));
-}
-
-
-/*****************************************************************************************
- * 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 "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;
-{
-	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;
-
-	retcode = 0;
-	if (node->dagHdr->status == rf_enable) {
-		/* 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);
-			}
-		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 */
-}
-/* xor the inputs into the result buffer, ignoring placement issues */
-int 
-rf_SimpleXorFunc(node)
-	RF_DagNode_t *node;
-{
-	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[node->numParams - 1].p;
-	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 */
-		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), (RF_Buf_t)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 */
-}
-/* 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;
-{
-	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 *pda;
-	int     suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
-	char   *srcbuf, *destbuf;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	RF_Etimer_t timer;
-
-	if (node->dagHdr->status == rf_enable) {
-		RF_ETIMER_START(timer);
-		for (i = 0; i < node->numParams - 2; i += 2)
-			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);
-			}
-		RF_ETIMER_STOP(timer);
-		RF_ETIMER_EVAL(timer);
-		tracerec->xor_us += RF_ETIMER_VAL_US(timer);
-	}
-	return (rf_GenericWakeupFunc(node, retcode));
-}
-/*****************************************************************************************
- * 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.
- */
-
-int 
-rf_XorIntoBuffer(raidPtr, pda, srcbuf, targbuf, bp)
-	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;
-
-	RF_ASSERT(pda->numSector <= sectPerSU);
-
-	targptr = targbuf + rf_RaidAddressToByte(raidPtr, SUOffset);
-	length = rf_RaidAddressToByte(raidPtr, pda->numSector);
-	retcode = rf_bxor(srcbuf, targptr, length, bp);
-	return (retcode);
-}
-/* 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
- * 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;
-{
-	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);
-	} 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.
- */
-int 
-rf_longword_bxor(src, dest, len, bp)
-	unsigned long *src;
-	unsigned long *dest;
-	int     len;		/* longwords */
-	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 */
-
-	REMAP_VA(bp, src, pg_src);
-	REMAP_VA(bp, dest, pg_dest);
-	if (!pg_src || !pg_dest)
-		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 */
-		src += longs_this_time;
-		dest += longs_this_time;
-		len -= longs_this_time;
-		while (longs_this_time >= 4) {
-			d0 = pg_dest[0];
-			d1 = pg_dest[1];
-			d2 = pg_dest[2];
-			d3 = pg_dest[3];
-			s0 = pg_src[0];
-			s1 = pg_src[1];
-			s2 = pg_src[2];
-			s3 = pg_src[3];
-			pg_dest[0] = d0 ^ s0;
-			pg_dest[1] = d1 ^ s1;
-			pg_dest[2] = d2 ^ s2;
-			pg_dest[3] = d3 ^ s3;
-			pg_src += 4;
-			pg_dest += 4;
-			longs_this_time -= 4;
-		}
-		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 */
-		if (len) {
-			if (RF_PAGE_ALIGNED(src))
-				REMAP_VA(bp, src, pg_src);
-			if (RF_PAGE_ALIGNED(dest))
-				REMAP_VA(bp, dest, pg_dest);
-			if (!pg_src || !pg_dest)
-				return (EFAULT);
-		}
-	}
-	while (src < end) {
-		*pg_dest++ ^= *pg_src++;
-		src++;
-		dest++;
-		len--;
-		if (RF_PAGE_ALIGNED(src))
-			REMAP_VA(bp, src, pg_src);
-		if (RF_PAGE_ALIGNED(dest))
-			REMAP_VA(bp, dest, pg_dest);
-	}
-	RF_ASSERT(len == 0);
-	return (0);
-}
-
-
-/*
-   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;
-{
-	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;
-
-	REMAP_VA(bp, a, pg_a);
-	REMAP_VA(bp, b, pg_b);
-	REMAP_VA(bp, c, pg_c);
-	if (a == dst) {
-		pg_dst = pg_a;
-		dst_is_a = 1;
-	} else {
-		REMAP_VA(bp, dst, pg_dst);
-	}
-
-	/* 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++;
-		a++;
-		b++;
-		c++;
-		if (RF_PAGE_ALIGNED(a)) {
-			REMAP_VA(bp, a, pg_a);
-			if (!pg_a)
-				return (EFAULT);
-		}
-		if (RF_PAGE_ALIGNED(b)) {
-			REMAP_VA(bp, a, pg_b);
-			if (!pg_b)
-				return (EFAULT);
-		}
-		if (RF_PAGE_ALIGNED(c)) {
-			REMAP_VA(bp, a, pg_c);
-			if (!pg_c)
-				return (EFAULT);
-		}
-		len--;
-	}
-
-	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);
-		a += longs_this_time;
-		b += longs_this_time;
-		c += longs_this_time;
-		dst += longs_this_time;
-		len -= longs_this_time;
-		while (longs_this_time >= 4) {
-			a0 = pg_a[0];
-			longs_this_time -= 4;
-
-			a1 = pg_a[1];
-			a2 = pg_a[2];
-
-			a3 = pg_a[3];
-			pg_a += 4;
-
-			b0 = pg_b[0];
-			b1 = pg_b[1];
-
-			b2 = pg_b[2];
-			b3 = pg_b[3];
-			/* start dual issue */
-			a0 ^= b0;
-			b0 = pg_c[0];
-
-			pg_b += 4;
-			a1 ^= b1;
-
-			a2 ^= b2;
-			a3 ^= b3;
-
-			b1 = pg_c[1];
-			a0 ^= b0;
-
-			b2 = pg_c[2];
-			a1 ^= b1;
-
-			b3 = pg_c[3];
-			a2 ^= b2;
-
-			pg_dst[0] = a0;
-			a3 ^= b3;
-			pg_dst[1] = a1;
-			pg_c += 4;
-			pg_dst[2] = a2;
-			pg_dst[3] = a3;
-			pg_dst += 4;
-		}
-		while (longs_this_time > 0) {	/* cannot cross any page
-						 * boundaries here */
-			*pg_dst++ = *pg_a++ ^ *pg_b++ ^ *pg_c++;
-			longs_this_time--;
-		}
-
-		if (len) {
-			if (RF_PAGE_ALIGNED(a)) {
-				REMAP_VA(bp, a, pg_a);
-				if (!pg_a)
-					return (EFAULT);
-				if (dst_is_a)
-					pg_dst = pg_a;
-			}
-			if (RF_PAGE_ALIGNED(b)) {
-				REMAP_VA(bp, b, pg_b);
-				if (!pg_b)
-					return (EFAULT);
-			}
-			if (RF_PAGE_ALIGNED(c)) {
-				REMAP_VA(bp, c, pg_c);
-				if (!pg_c)
-					return (EFAULT);
-			}
-			if (!dst_is_a)
-				if (RF_PAGE_ALIGNED(dst)) {
-					REMAP_VA(bp, dst, pg_dst);
-					if (!pg_dst)
-						return (EFAULT);
-				}
-		}
-	}
-	while (len) {
-		*pg_dst++ = *pg_a++ ^ *pg_b++ ^ *pg_c++;
-		dst++;
-		a++;
-		b++;
-		c++;
-		if (RF_PAGE_ALIGNED(a)) {
-			REMAP_VA(bp, a, pg_a);
-			if (!pg_a)
-				return (EFAULT);
-			if (dst_is_a)
-				pg_dst = pg_a;
-		}
-		if (RF_PAGE_ALIGNED(b)) {
-			REMAP_VA(bp, b, pg_b);
-			if (!pg_b)
-				return (EFAULT);
-		}
-		if (RF_PAGE_ALIGNED(c)) {
-			REMAP_VA(bp, c, pg_c);
-			if (!pg_c)
-				return (EFAULT);
-		}
-		if (!dst_is_a)
-			if (RF_PAGE_ALIGNED(dst)) {
-				REMAP_VA(bp, dst, pg_dst);
-				if (!pg_dst)
-					return (EFAULT);
-			}
-		len--;
-	}
-	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;
-{
-	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));
-}
diff --git a/sys/dev/raidframe/rf_dagfuncs.h b/sys/dev/raidframe/rf_dagfuncs.h
deleted file mode 100644
index da7e8b2..0000000
--- a/sys/dev/raidframe/rf_dagfuncs.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_dagfuncs.h,v 1.4 2000/03/30 13:39:07 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, William V. Courtright II, Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************************
- *
- * dagfuncs.h -- header file for DAG node execution routines
- *
- ****************************************************************************************/
-
-#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);
-
-/* 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 *);
-extern int (*rf_DiskWriteUndoFunc) (RF_DagNode_t *);
-extern int (*rf_DiskUnlockFunc) (RF_DagNode_t *);
-extern int (*rf_DiskUnlockUndoFunc) (RF_DagNode_t *);
-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)
-
-#endif				/* !_RF__RF_DAGFUNCS_H_ */
diff --git a/sys/dev/raidframe/rf_dagutils.c b/sys/dev/raidframe/rf_dagutils.c
deleted file mode 100644
index c961870..0000000
--- a/sys/dev/raidframe/rf_dagutils.c
+++ /dev/null
@@ -1,1299 +0,0 @@
-/*	$NetBSD: rf_dagutils.c,v 1.6 1999/12/09 02:26:09 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Authors: Mark Holland, William V. Courtright II, Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/******************************************************************************
- *
- * rf_dagutils.c -- utility routines for manipulating dags
- *
- *****************************************************************************/
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-#define SNUM_DIFF(_a_,_b_) (((_a_)>(_b_))?((_a_)-(_b_)):((_b_)-(_a_)))
-
-RF_RedFuncs_t rf_xorFuncs = {
-	rf_RegularXorFunc, "Reg Xr",
-rf_SimpleXorFunc, "Simple Xr"};
-
-RF_RedFuncs_t rf_xorRecoveryFuncs = {
-	rf_RecoveryXorFunc, "Recovery Xr",
-rf_RecoveryXorFunc, "Recovery Xr"};
-
-static void rf_RecurPrintDAG(RF_DagNode_t *, int, int);
-static void rf_PrintDAG(RF_DagHeader_t *);
-static int 
-rf_ValidateBranch(RF_DagNode_t *, int *, int *,
-    RF_DagNode_t **, int);
-static void rf_ValidateBranchVisitedBits(RF_DagNode_t *, int, int);
-static void rf_ValidateVisitedBits(RF_DagHeader_t *);
-
-/******************************************************************************
- *
- * InitNode - initialize a dag node
- *
- * the size of the propList array is always the same as that of the
- * successors array.
- *
- *****************************************************************************/
-void 
-rf_InitNode(
-    RF_DagNode_t * node,
-    RF_NodeStatus_t initstatus,
-    int commit,
-    int (*doFunc) (RF_DagNode_t * node),
-    int (*undoFunc) (RF_DagNode_t * node),
-    int (*wakeFunc) (RF_DagNode_t * node, int status),
-    int nSucc,
-    int nAnte,
-    int nParam,
-    int nResult,
-    RF_DagHeader_t * hdr,
-    char *name,
-    RF_AllocListElem_t * alist)
-{
-	void  **ptrs;
-	int     nptrs;
-
-	if (nAnte > RF_MAX_ANTECEDENTS)
-		RF_PANIC();
-	node->status = initstatus;
-	node->commitNode = commit;
-	node->doFunc = doFunc;
-	node->undoFunc = undoFunc;
-	node->wakeFunc = wakeFunc;
-	node->numParams = nParam;
-	node->numResults = nResult;
-	node->numAntecedents = nAnte;
-	node->numAntDone = 0;
-	node->next = NULL;
-	node->numSuccedents = nSucc;
-	node->name = name;
-	node->dagHdr = hdr;
-	node->visited = 0;
-
-	/* allocate all the pointers with one call to malloc */
-	nptrs = nSucc + nAnte + nResult + nSucc;
-
-	if (nptrs <= RF_DAG_PTRCACHESIZE) {
-		/*
-	         * The dag_ptrs field of the node is basically some scribble
-	         * space to be used here. We could get rid of it, and always
-	         * allocate the range of pointers, but that's expensive. So,
-	         * we pick a "common case" size for the pointer cache. Hopefully,
-	         * we'll find that:
-	         * (1) Generally, nptrs doesn't exceed RF_DAG_PTRCACHESIZE by
-	         *     only a little bit (least efficient case)
-	         * (2) Generally, ntprs isn't a lot less than RF_DAG_PTRCACHESIZE
-	         *     (wasted memory)
-	         */
-		ptrs = (void **) node->dag_ptrs;
-	} else {
-		RF_CallocAndAdd(ptrs, nptrs, sizeof(void *), (void **), alist);
-	}
-	node->succedents = (nSucc) ? (RF_DagNode_t **) ptrs : NULL;
-	node->antecedents = (nAnte) ? (RF_DagNode_t **) (ptrs + nSucc) : NULL;
-	node->results = (nResult) ? (void **) (ptrs + nSucc + nAnte) : NULL;
-	node->propList = (nSucc) ? (RF_PropHeader_t **) (ptrs + nSucc + nAnte + nResult) : NULL;
-
-	if (nParam) {
-		if (nParam <= RF_DAG_PARAMCACHESIZE) {
-			node->params = (RF_DagParam_t *) node->dag_params;
-		} else {
-			RF_CallocAndAdd(node->params, nParam, sizeof(RF_DagParam_t), (RF_DagParam_t *), alist);
-		}
-	} else {
-		node->params = NULL;
-	}
-}
-
-
-
-/******************************************************************************
- *
- * allocation and deallocation routines
- *
- *****************************************************************************/
-
-void 
-rf_FreeDAG(dag_h)
-	RF_DagHeader_t *dag_h;
-{
-	RF_AccessStripeMapHeader_t *asmap, *t_asmap;
-	RF_DagHeader_t *nextDag;
-	int     i;
-
-	while (dag_h) {
-		nextDag = dag_h->next;
-		for (i = 0; dag_h->memChunk[i] && i < RF_MAXCHUNKS; i++) {
-			/* release mem chunks */
-			rf_ReleaseMemChunk(dag_h->memChunk[i]);
-			dag_h->memChunk[i] = NULL;
-		}
-
-		RF_ASSERT(i == dag_h->chunkIndex);
-		if (dag_h->xtraChunkCnt > 0) {
-			/* free xtraMemChunks */
-			for (i = 0; dag_h->xtraMemChunk[i] && i < dag_h->xtraChunkIndex; i++) {
-				rf_ReleaseMemChunk(dag_h->xtraMemChunk[i]);
-				dag_h->xtraMemChunk[i] = NULL;
-			}
-			RF_ASSERT(i == dag_h->xtraChunkIndex);
-			/* free ptrs to xtraMemChunks */
-			RF_Free(dag_h->xtraMemChunk, dag_h->xtraChunkCnt * sizeof(RF_ChunkDesc_t *));
-		}
-		rf_FreeAllocList(dag_h->allocList);
-		for (asmap = dag_h->asmList; asmap;) {
-			t_asmap = asmap;
-			asmap = asmap->next;
-			rf_FreeAccessStripeMap(t_asmap);
-		}
-		rf_FreeDAGHeader(dag_h);
-		dag_h = nextDag;
-	}
-}
-
-RF_PropHeader_t *
-rf_MakePropListEntry(
-    RF_DagHeader_t * dag_h,
-    int resultNum,
-    int paramNum,
-    RF_PropHeader_t * next,
-    RF_AllocListElem_t * allocList)
-{
-	RF_PropHeader_t *p;
-
-	RF_CallocAndAdd(p, 1, sizeof(RF_PropHeader_t),
-	    (RF_PropHeader_t *), allocList);
-	p->resultNum = resultNum;
-	p->paramNum = paramNum;
-	p->next = next;
-	return (p);
-}
-
-static RF_FreeList_t *rf_dagh_freelist;
-
-#define RF_MAX_FREE_DAGH 128
-#define RF_DAGH_INC       16
-#define RF_DAGH_INITIAL   32
-
-static void rf_ShutdownDAGs(void *);
-static void 
-rf_ShutdownDAGs(ignored)
-	void   *ignored;
-{
-	RF_FREELIST_DESTROY(rf_dagh_freelist, next, (RF_DagHeader_t *));
-}
-
-int 
-rf_ConfigureDAGs(listp)
-	RF_ShutdownList_t **listp;
-{
-	int     rc;
-
-	RF_FREELIST_CREATE(rf_dagh_freelist, RF_MAX_FREE_DAGH,
-	    RF_DAGH_INC, sizeof(RF_DagHeader_t));
-	if (rf_dagh_freelist == NULL)
-		return (ENOMEM);
-	rc = rf_ShutdownCreate(listp, rf_ShutdownDAGs, NULL);
-	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n",
-		    __FILE__, __LINE__, rc);
-		rf_ShutdownDAGs(NULL);
-		return (rc);
-	}
-	RF_FREELIST_PRIME(rf_dagh_freelist, RF_DAGH_INITIAL, next,
-	    (RF_DagHeader_t *));
-	return (0);
-}
-
-RF_DagHeader_t *
-rf_AllocDAGHeader()
-{
-	RF_DagHeader_t *dh;
-
-	RF_FREELIST_GET(rf_dagh_freelist, dh, next, (RF_DagHeader_t *));
-	if (dh) {
-		bzero((char *) dh, sizeof(RF_DagHeader_t));
-	}
-	return (dh);
-}
-
-void 
-rf_FreeDAGHeader(RF_DagHeader_t * dh)
-{
-	RF_FREELIST_FREE(rf_dagh_freelist, dh, next);
-}
-/* allocates a buffer big enough to hold the data described by pda */
-void   *
-rf_AllocBuffer(
-    RF_Raid_t * raidPtr,
-    RF_DagHeader_t * dag_h,
-    RF_PhysDiskAddr_t * pda,
-    RF_AllocListElem_t * allocList)
-{
-	char   *p;
-
-	RF_MallocAndAdd(p, pda->numSector << raidPtr->logBytesPerSector,
-	    (char *), allocList);
-	return ((void *) p);
-}
-/******************************************************************************
- *
- * debug routines
- *
- *****************************************************************************/
-
-char   *
-rf_NodeStatusString(RF_DagNode_t * node)
-{
-	switch (node->status) {
-		case rf_wait:return ("wait");
-	case rf_fired:
-		return ("fired");
-	case rf_good:
-		return ("good");
-	case rf_bad:
-		return ("bad");
-	default:
-		return ("?");
-	}
-}
-
-void 
-rf_PrintNodeInfoString(RF_DagNode_t * node)
-{
-	RF_PhysDiskAddr_t *pda;
-	int     (*df) (RF_DagNode_t *) = node->doFunc;
-	int     i, lk, unlk;
-	void   *bufPtr;
-
-	if ((df == rf_DiskReadFunc) || (df == rf_DiskWriteFunc)
-	    || (df == rf_DiskReadMirrorIdleFunc)
-	    || (df == rf_DiskReadMirrorPartitionFunc)) {
-		pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-		bufPtr = (void *) node->params[1].p;
-		lk = RF_EXTRACT_LOCK_FLAG(node->params[3].v);
-		unlk = RF_EXTRACT_UNLOCK_FLAG(node->params[3].v);
-		RF_ASSERT(!(lk && unlk));
-		printf("r %d c %d offs %ld nsect %d buf 0x%lx %s\n", pda->row, pda->col,
-		    (long) pda->startSector, (int) pda->numSector, (long) bufPtr,
-		    (lk) ? "LOCK" : ((unlk) ? "UNLK" : " "));
-		return;
-	}
-	if (df == rf_DiskUnlockFunc) {
-		pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-		lk = RF_EXTRACT_LOCK_FLAG(node->params[3].v);
-		unlk = RF_EXTRACT_UNLOCK_FLAG(node->params[3].v);
-		RF_ASSERT(!(lk && unlk));
-		printf("r %d c %d %s\n", pda->row, pda->col,
-		    (lk) ? "LOCK" : ((unlk) ? "UNLK" : "nop"));
-		return;
-	}
-	if ((df == rf_SimpleXorFunc) || (df == rf_RegularXorFunc)
-	    || (df == rf_RecoveryXorFunc)) {
-		printf("result buf 0x%lx\n", (long) node->results[0]);
-		for (i = 0; i < node->numParams - 1; i += 2) {
-			pda = (RF_PhysDiskAddr_t *) node->params[i].p;
-			bufPtr = (RF_PhysDiskAddr_t *) node->params[i + 1].p;
-			printf("    buf 0x%lx r%d c%d offs %ld nsect %d\n",
-			    (long) bufPtr, pda->row, pda->col,
-			    (long) pda->startSector, (int) pda->numSector);
-		}
-		return;
-	}
-#if RF_INCLUDE_PARITYLOGGING > 0
-	if (df == rf_ParityLogOverwriteFunc || df == rf_ParityLogUpdateFunc) {
-		for (i = 0; i < node->numParams - 1; i += 2) {
-			pda = (RF_PhysDiskAddr_t *) node->params[i].p;
-			bufPtr = (RF_PhysDiskAddr_t *) node->params[i + 1].p;
-			printf(" r%d c%d offs %ld nsect %d buf 0x%lx\n",
-			    pda->row, pda->col, (long) pda->startSector,
-			    (int) pda->numSector, (long) bufPtr);
-		}
-		return;
-	}
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
-
-	if ((df == rf_TerminateFunc) || (df == rf_NullNodeFunc)) {
-		printf("\n");
-		return;
-	}
-	printf("?\n");
-}
-
-static void 
-rf_RecurPrintDAG(node, depth, unvisited)
-	RF_DagNode_t *node;
-	int     depth;
-	int     unvisited;
-{
-	char   *anttype;
-	int     i;
-
-	node->visited = (unvisited) ? 0 : 1;
-	printf("(%d) %d C%d %s: %s,s%d %d/%d,a%d/%d,p%d,r%d S{", depth,
-	    node->nodeNum, node->commitNode, node->name, rf_NodeStatusString(node),
-	    node->numSuccedents, node->numSuccFired, node->numSuccDone,
-	    node->numAntecedents, node->numAntDone, node->numParams, node->numResults);
-	for (i = 0; i < node->numSuccedents; i++) {
-		printf("%d%s", node->succedents[i]->nodeNum,
-		    ((i == node->numSuccedents - 1) ? "\0" : " "));
-	}
-	printf("} A{");
-	for (i = 0; i < node->numAntecedents; i++) {
-		switch (node->antType[i]) {
-		case rf_trueData:
-			anttype = "T";
-			break;
-		case rf_antiData:
-			anttype = "A";
-			break;
-		case rf_outputData:
-			anttype = "O";
-			break;
-		case rf_control:
-			anttype = "C";
-			break;
-		default:
-			anttype = "?";
-			break;
-		}
-		printf("%d(%s)%s", node->antecedents[i]->nodeNum, anttype, (i == node->numAntecedents - 1) ? "\0" : " ");
-	}
-	printf("}; ");
-	rf_PrintNodeInfoString(node);
-	for (i = 0; i < node->numSuccedents; i++) {
-		if (node->succedents[i]->visited == unvisited)
-			rf_RecurPrintDAG(node->succedents[i], depth + 1, unvisited);
-	}
-}
-
-static void 
-rf_PrintDAG(dag_h)
-	RF_DagHeader_t *dag_h;
-{
-	int     unvisited, i;
-	char   *status;
-
-	/* set dag status */
-	switch (dag_h->status) {
-	case rf_enable:
-		status = "enable";
-		break;
-	case rf_rollForward:
-		status = "rollForward";
-		break;
-	case rf_rollBackward:
-		status = "rollBackward";
-		break;
-	default:
-		status = "illegal!";
-		break;
-	}
-	/* find out if visited bits are currently set or clear */
-	unvisited = dag_h->succedents[0]->visited;
-
-	printf("DAG type:  %s\n", dag_h->creator);
-	printf("format is (depth) num commit type: status,nSucc nSuccFired/nSuccDone,nAnte/nAnteDone,nParam,nResult S{x} A{x(type)};  info\n");
-	printf("(0) %d Hdr: %s, s%d, (commit %d/%d) S{", dag_h->nodeNum,
-	    status, dag_h->numSuccedents, dag_h->numCommitNodes, dag_h->numCommits);
-	for (i = 0; i < dag_h->numSuccedents; i++) {
-		printf("%d%s", dag_h->succedents[i]->nodeNum,
-		    ((i == dag_h->numSuccedents - 1) ? "\0" : " "));
-	}
-	printf("};\n");
-	for (i = 0; i < dag_h->numSuccedents; i++) {
-		if (dag_h->succedents[i]->visited == unvisited)
-			rf_RecurPrintDAG(dag_h->succedents[i], 1, unvisited);
-	}
-}
-/* assigns node numbers */
-int 
-rf_AssignNodeNums(RF_DagHeader_t * dag_h)
-{
-	int     unvisited, i, nnum;
-	RF_DagNode_t *node;
-
-	nnum = 0;
-	unvisited = dag_h->succedents[0]->visited;
-
-	dag_h->nodeNum = nnum++;
-	for (i = 0; i < dag_h->numSuccedents; i++) {
-		node = dag_h->succedents[i];
-		if (node->visited == unvisited) {
-			nnum = rf_RecurAssignNodeNums(dag_h->succedents[i], nnum, unvisited);
-		}
-	}
-	return (nnum);
-}
-
-int 
-rf_RecurAssignNodeNums(node, num, unvisited)
-	RF_DagNode_t *node;
-	int     num;
-	int     unvisited;
-{
-	int     i;
-
-	node->visited = (unvisited) ? 0 : 1;
-
-	node->nodeNum = num++;
-	for (i = 0; i < node->numSuccedents; i++) {
-		if (node->succedents[i]->visited == unvisited) {
-			num = rf_RecurAssignNodeNums(node->succedents[i], num, unvisited);
-		}
-	}
-	return (num);
-}
-/* set the header pointers in each node to "newptr" */
-void 
-rf_ResetDAGHeaderPointers(dag_h, newptr)
-	RF_DagHeader_t *dag_h;
-	RF_DagHeader_t *newptr;
-{
-	int     i;
-	for (i = 0; i < dag_h->numSuccedents; i++)
-		if (dag_h->succedents[i]->dagHdr != newptr)
-			rf_RecurResetDAGHeaderPointers(dag_h->succedents[i], newptr);
-}
-
-void 
-rf_RecurResetDAGHeaderPointers(node, newptr)
-	RF_DagNode_t *node;
-	RF_DagHeader_t *newptr;
-{
-	int     i;
-	node->dagHdr = newptr;
-	for (i = 0; i < node->numSuccedents; i++)
-		if (node->succedents[i]->dagHdr != newptr)
-			rf_RecurResetDAGHeaderPointers(node->succedents[i], newptr);
-}
-
-
-void 
-rf_PrintDAGList(RF_DagHeader_t * dag_h)
-{
-	int     i = 0;
-
-	for (; dag_h; dag_h = dag_h->next) {
-		rf_AssignNodeNums(dag_h);
-		printf("\n\nDAG %d IN LIST:\n", i++);
-		rf_PrintDAG(dag_h);
-	}
-}
-
-static int 
-rf_ValidateBranch(node, scount, acount, nodes, unvisited)
-	RF_DagNode_t *node;
-	int    *scount;
-	int    *acount;
-	RF_DagNode_t **nodes;
-	int     unvisited;
-{
-	int     i, retcode = 0;
-
-	/* construct an array of node pointers indexed by node num */
-	node->visited = (unvisited) ? 0 : 1;
-	nodes[node->nodeNum] = node;
-
-	if (node->next != NULL) {
-		printf("INVALID DAG: next pointer in node is not NULL\n");
-		retcode = 1;
-	}
-	if (node->status != rf_wait) {
-		printf("INVALID DAG: Node status is not wait\n");
-		retcode = 1;
-	}
-	if (node->numAntDone != 0) {
-		printf("INVALID DAG: numAntDone is not zero\n");
-		retcode = 1;
-	}
-	if (node->doFunc == rf_TerminateFunc) {
-		if (node->numSuccedents != 0) {
-			printf("INVALID DAG: Terminator node has succedents\n");
-			retcode = 1;
-		}
-	} else {
-		if (node->numSuccedents == 0) {
-			printf("INVALID DAG: Non-terminator node has no succedents\n");
-			retcode = 1;
-		}
-	}
-	for (i = 0; i < node->numSuccedents; i++) {
-		if (!node->succedents[i]) {
-			printf("INVALID DAG: succedent %d of node %s is NULL\n", i, node->name);
-			retcode = 1;
-		}
-		scount[node->succedents[i]->nodeNum]++;
-	}
-	for (i = 0; i < node->numAntecedents; i++) {
-		if (!node->antecedents[i]) {
-			printf("INVALID DAG: antecedent %d of node %s is NULL\n", i, node->name);
-			retcode = 1;
-		}
-		acount[node->antecedents[i]->nodeNum]++;
-	}
-	for (i = 0; i < node->numSuccedents; i++) {
-		if (node->succedents[i]->visited == unvisited) {
-			if (rf_ValidateBranch(node->succedents[i], scount,
-				acount, nodes, unvisited)) {
-				retcode = 1;
-			}
-		}
-	}
-	return (retcode);
-}
-
-static void 
-rf_ValidateBranchVisitedBits(node, unvisited, rl)
-	RF_DagNode_t *node;
-	int     unvisited;
-	int     rl;
-{
-	int     i;
-
-	RF_ASSERT(node->visited == unvisited);
-	for (i = 0; i < node->numSuccedents; i++) {
-		if (node->succedents[i] == NULL) {
-			printf("node=%lx node->succedents[%d] is NULL\n", (long) node, i);
-			RF_ASSERT(0);
-		}
-		rf_ValidateBranchVisitedBits(node->succedents[i], unvisited, rl + 1);
-	}
-}
-/* NOTE:  never call this on a big dag, because it is exponential
- * in execution time
- */
-static void 
-rf_ValidateVisitedBits(dag)
-	RF_DagHeader_t *dag;
-{
-	int     i, unvisited;
-
-	unvisited = dag->succedents[0]->visited;
-
-	for (i = 0; i < dag->numSuccedents; i++) {
-		if (dag->succedents[i] == NULL) {
-			printf("dag=%lx dag->succedents[%d] is NULL\n", (long) dag, i);
-			RF_ASSERT(0);
-		}
-		rf_ValidateBranchVisitedBits(dag->succedents[i], unvisited, 0);
-	}
-}
-/* validate a DAG.  _at entry_ verify that:
- *   -- numNodesCompleted is zero
- *   -- node queue is null
- *   -- dag status is rf_enable
- *   -- next pointer is null on every node
- *   -- all nodes have status wait
- *   -- numAntDone is zero in all nodes
- *   -- terminator node has zero successors
- *   -- no other node besides terminator has zero successors
- *   -- no successor or antecedent pointer in a node is NULL
- *   -- number of times that each node appears as a successor of another node
- *      is equal to the antecedent count on that node
- *   -- number of times that each node appears as an antecedent of another node
- *      is equal to the succedent count on that node
- *   -- what else?
- */
-int 
-rf_ValidateDAG(dag_h)
-	RF_DagHeader_t *dag_h;
-{
-	int     i, nodecount;
-	int    *scount, *acount;/* per-node successor and antecedent counts */
-	RF_DagNode_t **nodes;	/* array of ptrs to nodes in dag */
-	int     retcode = 0;
-	int     unvisited;
-	int     commitNodeCount = 0;
-
-	if (rf_validateVisitedDebug)
-		rf_ValidateVisitedBits(dag_h);
-
-	if (dag_h->numNodesCompleted != 0) {
-		printf("INVALID DAG: num nodes completed is %d, should be 0\n", dag_h->numNodesCompleted);
-		retcode = 1;
-		goto validate_dag_bad;
-	}
-	if (dag_h->status != rf_enable) {
-		printf("INVALID DAG: not enabled\n");
-		retcode = 1;
-		goto validate_dag_bad;
-	}
-	if (dag_h->numCommits != 0) {
-		printf("INVALID DAG: numCommits != 0 (%d)\n", dag_h->numCommits);
-		retcode = 1;
-		goto validate_dag_bad;
-	}
-	if (dag_h->numSuccedents != 1) {
-		/* currently, all dags must have only one succedent */
-		printf("INVALID DAG: numSuccedents !1 (%d)\n", dag_h->numSuccedents);
-		retcode = 1;
-		goto validate_dag_bad;
-	}
-	nodecount = rf_AssignNodeNums(dag_h);
-
-	unvisited = dag_h->succedents[0]->visited;
-
-	RF_Calloc(scount, nodecount, sizeof(int), (int *));
-	RF_Calloc(acount, nodecount, sizeof(int), (int *));
-	RF_Calloc(nodes, nodecount, sizeof(RF_DagNode_t *), (RF_DagNode_t **));
-	for (i = 0; i < dag_h->numSuccedents; i++) {
-		if ((dag_h->succedents[i]->visited == unvisited)
-		    && rf_ValidateBranch(dag_h->succedents[i], scount,
-			acount, nodes, unvisited)) {
-			retcode = 1;
-		}
-	}
-	/* start at 1 to skip the header node */
-	for (i = 1; 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);
-			retcode = 1;
-			goto validate_dag_out;
-		}
-		if (nodes[i]->undoFunc == NULL) {
-			printf("INVALID DAG: node %s has an undefined doFunc\n", nodes[i]->name);
-			retcode = 1;
-			goto validate_dag_out;
-		}
-		if (nodes[i]->numAntecedents != scount[nodes[i]->nodeNum]) {
-			printf("INVALID DAG: node %s has %d antecedents but appears as a succedent %d times\n",
-			    nodes[i]->name, nodes[i]->numAntecedents, scount[nodes[i]->nodeNum]);
-			retcode = 1;
-			goto validate_dag_out;
-		}
-		if (nodes[i]->numSuccedents != acount[nodes[i]->nodeNum]) {
-			printf("INVALID DAG: node %s has %d succedents but appears as an antecedent %d times\n",
-			    nodes[i]->name, nodes[i]->numSuccedents, acount[nodes[i]->nodeNum]);
-			retcode = 1;
-			goto validate_dag_out;
-		}
-	}
-
-	if (dag_h->numCommitNodes != commitNodeCount) {
-		printf("INVALID DAG: incorrect commit node count.  hdr->numCommitNodes (%d) found (%d) commit nodes in graph\n",
-		    dag_h->numCommitNodes, commitNodeCount);
-		retcode = 1;
-		goto validate_dag_out;
-	}
-validate_dag_out:
-	RF_Free(scount, nodecount * sizeof(int));
-	RF_Free(acount, nodecount * sizeof(int));
-	RF_Free(nodes, nodecount * sizeof(RF_DagNode_t *));
-	if (retcode)
-		rf_PrintDAGList(dag_h);
-
-	if (rf_validateVisitedDebug)
-		rf_ValidateVisitedBits(dag_h);
-
-	return (retcode);
-
-validate_dag_bad:
-	rf_PrintDAGList(dag_h);
-	return (retcode);
-}
-
-
-/******************************************************************************
- *
- * misc construction routines
- *
- *****************************************************************************/
-
-void 
-rf_redirect_asm(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap)
-{
-	int     ds = (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) ? 1 : 0;
-	int     row = asmap->physInfo->row;
-	int     fcol = raidPtr->reconControl[row]->fcol;
-	int     srow = raidPtr->reconControl[row]->spareRow;
-	int     scol = raidPtr->reconControl[row]->spareCol;
-	RF_PhysDiskAddr_t *pda;
-
-	RF_ASSERT(raidPtr->status[row] == rf_rs_reconstructing);
-	for (pda = asmap->physInfo; pda; pda = pda->next) {
-		if (pda->col == fcol) {
-			if (rf_dagDebug) {
-				if (!rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap,
-					pda->startSector)) {
-					RF_PANIC();
-				}
-			}
-			/* printf("Remapped data for large write\n"); */
-			if (ds) {
-				raidPtr->Layout.map->MapSector(raidPtr, pda->raidAddress,
-				    &pda->row, &pda->col, &pda->startSector, RF_REMAP);
-			} else {
-				pda->row = srow;
-				pda->col = scol;
-			}
-		}
-	}
-	for (pda = asmap->parityInfo; pda; pda = pda->next) {
-		if (pda->col == fcol) {
-			if (rf_dagDebug) {
-				if (!rf_CheckRUReconstructed(raidPtr->reconControl[row]->reconMap, pda->startSector)) {
-					RF_PANIC();
-				}
-			}
-		}
-		if (ds) {
-			(raidPtr->Layout.map->MapParity) (raidPtr, pda->raidAddress, &pda->row, &pda->col, &pda->startSector, RF_REMAP);
-		} else {
-			pda->row = srow;
-			pda->col = scol;
-		}
-	}
-}
-
-
-/* this routine allocates read buffers and generates stripe maps for the
- * regions of the array from the start of the stripe to the start of the
- * access, and from the end of the access to the end of the stripe.  It also
- * computes and returns the number of DAG nodes needed to read all this data.
- * Note that this routine does the wrong thing if the access is fully
- * contained within one stripe unit, so we RF_ASSERT against this case at the
- * start.
- */
-void 
-rf_MapUnaccessedPortionOfStripe(
-    RF_Raid_t * raidPtr,
-    RF_RaidLayout_t * layoutPtr,/* in: layout information */
-    RF_AccessStripeMap_t * asmap,	/* in: access stripe map */
-    RF_DagHeader_t * dag_h,	/* in: header of the dag to create */
-    RF_AccessStripeMapHeader_t ** new_asm_h,	/* in: ptr to array of 2
-						 * headers, to be filled in */
-    int *nRodNodes,		/* out: num nodes to be generated to read
-				 * unaccessed data */
-    char **sosBuffer,		/* out: pointers to newly allocated buffer */
-    char **eosBuffer,
-    RF_AllocListElem_t * allocList)
-{
-	RF_RaidAddr_t sosRaidAddress, eosRaidAddress;
-	RF_SectorNum_t sosNumSector, eosNumSector;
-
-	RF_ASSERT(asmap->numStripeUnitsAccessed > (layoutPtr->numDataCol / 2));
-	/* generate an access map for the region of the array from start of
-	 * stripe to start of access */
-	new_asm_h[0] = new_asm_h[1] = NULL;
-	*nRodNodes = 0;
-	if (!rf_RaidAddressStripeAligned(layoutPtr, asmap->raidAddress)) {
-		sosRaidAddress = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
-		sosNumSector = asmap->raidAddress - sosRaidAddress;
-		RF_MallocAndAdd(*sosBuffer, rf_RaidAddressToByte(raidPtr, sosNumSector), (char *), allocList);
-		new_asm_h[0] = rf_MapAccess(raidPtr, sosRaidAddress, sosNumSector, *sosBuffer, RF_DONT_REMAP);
-		new_asm_h[0]->next = dag_h->asmList;
-		dag_h->asmList = new_asm_h[0];
-		*nRodNodes += new_asm_h[0]->stripeMap->numStripeUnitsAccessed;
-
-		RF_ASSERT(new_asm_h[0]->stripeMap->next == NULL);
-		/* we're totally within one stripe here */
-		if (asmap->flags & RF_ASM_REDIR_LARGE_WRITE)
-			rf_redirect_asm(raidPtr, new_asm_h[0]->stripeMap);
-	}
-	/* generate an access map for the region of the array from end of
-	 * access to end of stripe */
-	if (!rf_RaidAddressStripeAligned(layoutPtr, asmap->endRaidAddress)) {
-		eosRaidAddress = asmap->endRaidAddress;
-		eosNumSector = rf_RaidAddressOfNextStripeBoundary(layoutPtr, eosRaidAddress) - eosRaidAddress;
-		RF_MallocAndAdd(*eosBuffer, rf_RaidAddressToByte(raidPtr, eosNumSector), (char *), allocList);
-		new_asm_h[1] = rf_MapAccess(raidPtr, eosRaidAddress, eosNumSector, *eosBuffer, RF_DONT_REMAP);
-		new_asm_h[1]->next = dag_h->asmList;
-		dag_h->asmList = new_asm_h[1];
-		*nRodNodes += new_asm_h[1]->stripeMap->numStripeUnitsAccessed;
-
-		RF_ASSERT(new_asm_h[1]->stripeMap->next == NULL);
-		/* we're totally within one stripe here */
-		if (asmap->flags & RF_ASM_REDIR_LARGE_WRITE)
-			rf_redirect_asm(raidPtr, new_asm_h[1]->stripeMap);
-	}
-}
-
-
-
-/* returns non-zero if the indicated ranges of stripe unit offsets overlap */
-int 
-rf_PDAOverlap(
-    RF_RaidLayout_t * layoutPtr,
-    RF_PhysDiskAddr_t * src,
-    RF_PhysDiskAddr_t * dest)
-{
-	RF_SectorNum_t soffs = rf_StripeUnitOffset(layoutPtr, src->startSector);
-	RF_SectorNum_t doffs = rf_StripeUnitOffset(layoutPtr, dest->startSector);
-	/* use -1 to be sure we stay within SU */
-	RF_SectorNum_t send = rf_StripeUnitOffset(layoutPtr, src->startSector + src->numSector - 1);
-	RF_SectorNum_t dend = rf_StripeUnitOffset(layoutPtr, dest->startSector + dest->numSector - 1);
-	return ((RF_MAX(soffs, doffs) <= RF_MIN(send, dend)) ? 1 : 0);
-}
-
-
-/* GenerateFailedAccessASMs
- *
- * this routine figures out what portion of the stripe needs to be read
- * to effect the degraded read or write operation.  It's primary function
- * is to identify everything required to recover the data, and then
- * eliminate anything that is already being accessed by the user.
- *
- * The main result is two new ASMs, one for the region from the start of the
- * stripe to the start of the access, and one for the region from the end of
- * the access to the end of the stripe.  These ASMs describe everything that
- * needs to be read to effect the degraded access.  Other results are:
- *    nXorBufs -- the total number of buffers that need to be XORed together to
- *                recover the lost data,
- *    rpBufPtr -- ptr to a newly-allocated buffer to hold the parity.  If NULL
- *                at entry, not allocated.
- *    overlappingPDAs --
- *                describes which of the non-failed PDAs in the user access
- *                overlap data that needs to be read to effect recovery.
- *                overlappingPDAs[i]==1 if and only if, neglecting the failed
- *                PDA, the ith pda in the input asm overlaps data that needs
- *                to be read for recovery.
- */
- /* in: asm - ASM for the actual access, one stripe only */
- /* in: faildPDA - which component of the access has failed */
- /* in: dag_h - header of the DAG we're going to create */
- /* out: new_asm_h - the two new ASMs */
- /* out: nXorBufs - the total number of xor bufs required */
- /* out: rpBufPtr - a buffer for the parity read */
-void 
-rf_GenerateFailedAccessASMs(
-    RF_Raid_t * raidPtr,
-    RF_AccessStripeMap_t * asmap,
-    RF_PhysDiskAddr_t * failedPDA,
-    RF_DagHeader_t * dag_h,
-    RF_AccessStripeMapHeader_t ** new_asm_h,
-    int *nXorBufs,
-    char **rpBufPtr,
-    char *overlappingPDAs,
-    RF_AllocListElem_t * allocList)
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-
-	/* s=start, e=end, s=stripe, a=access, f=failed, su=stripe unit */
-	RF_RaidAddr_t sosAddr, sosEndAddr, eosStartAddr, eosAddr;
-
-	RF_SectorCount_t numSect[2], numParitySect;
-	RF_PhysDiskAddr_t *pda;
-	char   *rdBuf, *bufP;
-	int     foundit, i;
-
-	bufP = NULL;
-	foundit = 0;
-	/* first compute the following raid addresses: start of stripe,
-	 * (sosAddr) MIN(start of access, start of failed SU),   (sosEndAddr)
-	 * MAX(end of access, end of failed SU),       (eosStartAddr) end of
-	 * stripe (i.e. start of next stripe)   (eosAddr) */
-	sosAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, asmap->raidAddress);
-	sosEndAddr = RF_MIN(asmap->raidAddress, rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, failedPDA->raidAddress));
-	eosStartAddr = RF_MAX(asmap->endRaidAddress, rf_RaidAddressOfNextStripeUnitBoundary(layoutPtr, failedPDA->raidAddress));
-	eosAddr = rf_RaidAddressOfNextStripeBoundary(layoutPtr, asmap->raidAddress);
-
-	/* now generate access stripe maps for each of the above regions of
-	 * the stripe.  Use a dummy (NULL) buf ptr for now */
-
-	new_asm_h[0] = (sosAddr != sosEndAddr) ? rf_MapAccess(raidPtr, sosAddr, sosEndAddr - sosAddr, NULL, RF_DONT_REMAP) : NULL;
-	new_asm_h[1] = (eosStartAddr != eosAddr) ? rf_MapAccess(raidPtr, eosStartAddr, eosAddr - eosStartAddr, NULL, RF_DONT_REMAP) : NULL;
-
-	/* walk through the PDAs and range-restrict each SU to the region of
-	 * the SU touched on the failed PDA.  also compute total data buffer
-	 * space requirements in this step.  Ignore the parity for now. */
-
-	numSect[0] = numSect[1] = 0;
-	if (new_asm_h[0]) {
-		new_asm_h[0]->next = dag_h->asmList;
-		dag_h->asmList = new_asm_h[0];
-		for (pda = new_asm_h[0]->stripeMap->physInfo; pda; pda = pda->next) {
-			rf_RangeRestrictPDA(raidPtr, failedPDA, pda, RF_RESTRICT_NOBUFFER, 0);
-			numSect[0] += pda->numSector;
-		}
-	}
-	if (new_asm_h[1]) {
-		new_asm_h[1]->next = dag_h->asmList;
-		dag_h->asmList = new_asm_h[1];
-		for (pda = new_asm_h[1]->stripeMap->physInfo; pda; pda = pda->next) {
-			rf_RangeRestrictPDA(raidPtr, failedPDA, pda, RF_RESTRICT_NOBUFFER, 0);
-			numSect[1] += pda->numSector;
-		}
-	}
-	numParitySect = failedPDA->numSector;
-
-	/* allocate buffer space for the data & parity we have to read to
-	 * recover from the failure */
-
-	if (numSect[0] + numSect[1] + ((rpBufPtr) ? numParitySect : 0)) {	/* don't allocate parity
-										 * buf if not needed */
-		RF_MallocAndAdd(rdBuf, rf_RaidAddressToByte(raidPtr, numSect[0] + numSect[1] + numParitySect), (char *), allocList);
-		bufP = rdBuf;
-		if (rf_degDagDebug)
-			printf("Newly allocated buffer (%d bytes) is 0x%lx\n",
-			    (int) rf_RaidAddressToByte(raidPtr, numSect[0] + numSect[1] + numParitySect), (unsigned long) bufP);
-	}
-	/* now walk through the pdas one last time and assign buffer pointers
-	 * (ugh!).  Again, ignore the parity.  also, count nodes to find out
-	 * how many bufs need to be xored together */
-	(*nXorBufs) = 1;	/* in read case, 1 is for parity.  In write
-				 * case, 1 is for failed data */
-	if (new_asm_h[0]) {
-		for (pda = new_asm_h[0]->stripeMap->physInfo; pda; pda = pda->next) {
-			pda->bufPtr = bufP;
-			bufP += rf_RaidAddressToByte(raidPtr, pda->numSector);
-		}
-		*nXorBufs += new_asm_h[0]->stripeMap->numStripeUnitsAccessed;
-	}
-	if (new_asm_h[1]) {
-		for (pda = new_asm_h[1]->stripeMap->physInfo; pda; pda = pda->next) {
-			pda->bufPtr = bufP;
-			bufP += rf_RaidAddressToByte(raidPtr, pda->numSector);
-		}
-		(*nXorBufs) += new_asm_h[1]->stripeMap->numStripeUnitsAccessed;
-	}
-	if (rpBufPtr)
-		*rpBufPtr = bufP;	/* the rest of the buffer is for
-					 * parity */
-
-	/* the last step is to figure out how many more distinct buffers need
-	 * to get xor'd to produce the missing unit.  there's one for each
-	 * user-data read node that overlaps the portion of the failed unit
-	 * being accessed */
-
-	for (foundit = i = 0, pda = asmap->physInfo; pda; i++, pda = pda->next) {
-		if (pda == failedPDA) {
-			i--;
-			foundit = 1;
-			continue;
-		}
-		if (rf_PDAOverlap(layoutPtr, pda, failedPDA)) {
-			overlappingPDAs[i] = 1;
-			(*nXorBufs)++;
-		}
-	}
-	if (!foundit) {
-		RF_ERRORMSG("GenerateFailedAccessASMs: did not find failedPDA in asm list\n");
-		RF_ASSERT(0);
-	}
-	if (rf_degDagDebug) {
-		if (new_asm_h[0]) {
-			printf("First asm:\n");
-			rf_PrintFullAccessStripeMap(new_asm_h[0], 1);
-		}
-		if (new_asm_h[1]) {
-			printf("Second asm:\n");
-			rf_PrintFullAccessStripeMap(new_asm_h[1], 1);
-		}
-	}
-}
-
-
-/* adjusts the offset and number of sectors in the destination pda so that
- * it covers at most the region of the SU covered by the source PDA.  This
- * is exclusively a restriction:  the number of sectors indicated by the
- * target PDA can only shrink.
- *
- * For example:  s = sectors within SU indicated by source PDA
- *               d = sectors within SU indicated by dest PDA
- *               r = results, stored in dest PDA
- *
- * |--------------- one stripe unit ---------------------|
- * |           sssssssssssssssssssssssssssssssss         |
- * |    ddddddddddddddddddddddddddddddddddddddddddddd    |
- * |           rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr         |
- *
- * Another example:
- *
- * |--------------- one stripe unit ---------------------|
- * |           sssssssssssssssssssssssssssssssss         |
- * |    ddddddddddddddddddddddd                          |
- * |           rrrrrrrrrrrrrrrr                          |
- *
- */
-void 
-rf_RangeRestrictPDA(
-    RF_Raid_t * raidPtr,
-    RF_PhysDiskAddr_t * src,
-    RF_PhysDiskAddr_t * dest,
-    int dobuffer,
-    int doraidaddr)
-{
-	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_SectorNum_t soffs = rf_StripeUnitOffset(layoutPtr, src->startSector);
-	RF_SectorNum_t doffs = rf_StripeUnitOffset(layoutPtr, dest->startSector);
-	RF_SectorNum_t send = rf_StripeUnitOffset(layoutPtr, src->startSector + src->numSector - 1);	/* use -1 to be sure we
-													 * stay within SU */
-	RF_SectorNum_t dend = rf_StripeUnitOffset(layoutPtr, dest->startSector + dest->numSector - 1);
-	RF_SectorNum_t subAddr = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, dest->startSector);	/* stripe unit boundary */
-
-	dest->startSector = subAddr + RF_MAX(soffs, doffs);
-	dest->numSector = subAddr + RF_MIN(send, dend) + 1 - dest->startSector;
-
-	if (dobuffer)
-		dest->bufPtr += (soffs > doffs) ? rf_RaidAddressToByte(raidPtr, soffs - doffs) : 0;
-	if (doraidaddr) {
-		dest->raidAddress = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, dest->raidAddress) +
-		    rf_StripeUnitOffset(layoutPtr, dest->startSector);
-	}
-}
-/*
- * Want the highest of these primes to be the largest one
- * less than the max expected number of columns (won't hurt
- * to be too small or too large, but won't be optimal, either)
- * --jimz
- */
-#define NLOWPRIMES 8
-static int lowprimes[NLOWPRIMES] = {2, 3, 5, 7, 11, 13, 17, 19};
-/*****************************************************************************
- * compute the workload shift factor.  (chained declustering)
- *
- * return nonzero if access should shift to secondary, otherwise,
- * access is to primary
- *****************************************************************************/
-int 
-rf_compute_workload_shift(
-    RF_Raid_t * raidPtr,
-    RF_PhysDiskAddr_t * pda)
-{
-	/*
-         * variables:
-         *  d   = column of disk containing primary
-         *  f   = column of failed disk
-         *  n   = number of disks in array
-         *  sd  = "shift distance" (number of columns that d is to the right of f)
-         *  row = row of array the access is in
-         *  v   = numerator of redirection ratio
-         *  k   = denominator of redirection ratio
-         */
-	RF_RowCol_t d, f, sd, row, n;
-	int     k, v, ret, i;
-
-	row = pda->row;
-	n = raidPtr->numCol;
-
-	/* assign column of primary copy to d */
-	d = pda->col;
-
-	/* assign column of dead disk to f */
-	for (f = 0; ((!RF_DEAD_DISK(raidPtr->Disks[row][f].status)) && (f < n)); f++);
-
-	RF_ASSERT(f < n);
-	RF_ASSERT(f != d);
-
-	sd = (f > d) ? (n + d - f) : (d - f);
-	RF_ASSERT(sd < n);
-
-	/*
-         * v of every k accesses should be redirected
-         *
-         * v/k := (n-1-sd)/(n-1)
-         */
-	v = (n - 1 - sd);
-	k = (n - 1);
-
-#if 1
-	/*
-         * XXX
-         * Is this worth it?
-         *
-         * Now reduce the fraction, by repeatedly factoring
-         * out primes (just like they teach in elementary school!)
-         */
-	for (i = 0; i < NLOWPRIMES; i++) {
-		if (lowprimes[i] > v)
-			break;
-		while (((v % lowprimes[i]) == 0) && ((k % lowprimes[i]) == 0)) {
-			v /= lowprimes[i];
-			k /= lowprimes[i];
-		}
-	}
-#endif
-
-	raidPtr->hist_diskreq[row][d]++;
-	if (raidPtr->hist_diskreq[row][d] > v) {
-		ret = 0;	/* do not redirect */
-	} else {
-		ret = 1;	/* redirect */
-	}
-
-#if 0
-	printf("d=%d f=%d sd=%d v=%d k=%d ret=%d h=%d\n", d, f, sd, v, k, ret,
-	    raidPtr->hist_diskreq[row][d]);
-#endif
-
-	if (raidPtr->hist_diskreq[row][d] >= k) {
-		/* reset counter */
-		raidPtr->hist_diskreq[row][d] = 0;
-	}
-	return (ret);
-}
-/*
- * Disk selection routines
- */
-
-/*
- * Selects the disk with the shortest queue from a mirror pair.
- * Both the disk I/Os queued in RAIDframe as well as those at the physical
- * disk are counted as members of the "queue"
- */
-void 
-rf_SelectMirrorDiskIdle(RF_DagNode_t * node)
-{
-	RF_Raid_t *raidPtr = (RF_Raid_t *) node->dagHdr->raidPtr;
-	RF_RowCol_t rowData, colData, rowMirror, colMirror;
-	int     dataQueueLength, mirrorQueueLength, usemirror;
-	RF_PhysDiskAddr_t *data_pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-	RF_PhysDiskAddr_t *mirror_pda = (RF_PhysDiskAddr_t *) node->params[4].p;
-	RF_PhysDiskAddr_t *tmp_pda;
-	RF_RaidDisk_t **disks = raidPtr->Disks;
-	RF_DiskQueue_t **dqs = raidPtr->Queues, *dataQueue, *mirrorQueue;
-
-	/* return the [row col] of the disk with the shortest queue */
-	rowData = data_pda->row;
-	colData = data_pda->col;
-	rowMirror = mirror_pda->row;
-	colMirror = mirror_pda->col;
-	dataQueue = &(dqs[rowData][colData]);
-	mirrorQueue = &(dqs[rowMirror][colMirror]);
-
-#ifdef RF_LOCK_QUEUES_TO_READ_LEN
-	RF_LOCK_QUEUE_MUTEX(dataQueue, "SelectMirrorDiskIdle");
-#endif				/* RF_LOCK_QUEUES_TO_READ_LEN */
-	dataQueueLength = dataQueue->queueLength + dataQueue->numOutstanding;
-#ifdef RF_LOCK_QUEUES_TO_READ_LEN
-	RF_UNLOCK_QUEUE_MUTEX(dataQueue, "SelectMirrorDiskIdle");
-	RF_LOCK_QUEUE_MUTEX(mirrorQueue, "SelectMirrorDiskIdle");
-#endif				/* RF_LOCK_QUEUES_TO_READ_LEN */
-	mirrorQueueLength = mirrorQueue->queueLength + mirrorQueue->numOutstanding;
-#ifdef RF_LOCK_QUEUES_TO_READ_LEN
-	RF_UNLOCK_QUEUE_MUTEX(mirrorQueue, "SelectMirrorDiskIdle");
-#endif				/* RF_LOCK_QUEUES_TO_READ_LEN */
-
-	usemirror = 0;
-	if (RF_DEAD_DISK(disks[rowMirror][colMirror].status)) {
-		usemirror = 0;
-	} else
-		if (RF_DEAD_DISK(disks[rowData][colData].status)) {
-			usemirror = 1;
-		} else
-			if (raidPtr->parity_good == RF_RAID_DIRTY) {
-				/* Trust only the main disk */
-				usemirror = 0;
-			} else
-				if (dataQueueLength < mirrorQueueLength) {
-					usemirror = 0;
-				} else
-					if (mirrorQueueLength < dataQueueLength) {
-						usemirror = 1;
-					} else {
-						/* queues are equal length. attempt
-						 * cleverness. */
-						if (SNUM_DIFF(dataQueue->last_deq_sector, data_pda->startSector)
-						    <= SNUM_DIFF(mirrorQueue->last_deq_sector, mirror_pda->startSector)) {
-							usemirror = 0;
-						} else {
-							usemirror = 1;
-						}
-					}
-
-	if (usemirror) {
-		/* use mirror (parity) disk, swap params 0 & 4 */
-		tmp_pda = data_pda;
-		node->params[0].p = mirror_pda;
-		node->params[4].p = tmp_pda;
-	} else {
-		/* use data disk, leave param 0 unchanged */
-	}
-	/* printf("dataQueueLength %d, mirrorQueueLength
-	 * %d\n",dataQueueLength, mirrorQueueLength); */
-}
-/*
- * Do simple partitioning. This assumes that
- * the data and parity disks are laid out identically.
- */
-void 
-rf_SelectMirrorDiskPartition(RF_DagNode_t * node)
-{
-	RF_Raid_t *raidPtr = (RF_Raid_t *) node->dagHdr->raidPtr;
-	RF_RowCol_t rowData, colData, rowMirror, colMirror;
-	RF_PhysDiskAddr_t *data_pda = (RF_PhysDiskAddr_t *) node->params[0].p;
-	RF_PhysDiskAddr_t *mirror_pda = (RF_PhysDiskAddr_t *) node->params[4].p;
-	RF_PhysDiskAddr_t *tmp_pda;
-	RF_RaidDisk_t **disks = raidPtr->Disks;
-	RF_DiskQueue_t **dqs = raidPtr->Queues, *dataQueue, *mirrorQueue;
-	int     usemirror;
-
-	/* return the [row col] of the disk with the shortest queue */
-	rowData = data_pda->row;
-	colData = data_pda->col;
-	rowMirror = mirror_pda->row;
-	colMirror = mirror_pda->col;
-	dataQueue = &(dqs[rowData][colData]);
-	mirrorQueue = &(dqs[rowMirror][colMirror]);
-
-	usemirror = 0;
-	if (RF_DEAD_DISK(disks[rowMirror][colMirror].status)) {
-		usemirror = 0;
-	} else
-		if (RF_DEAD_DISK(disks[rowData][colData].status)) {
-			usemirror = 1;
-		} else 
-			if (raidPtr->parity_good == RF_RAID_DIRTY) {
-				/* Trust only the main disk */
-				usemirror = 0;
-			} else
-				if (data_pda->startSector < 
-				    (disks[rowData][colData].numBlocks / 2)) {
-					usemirror = 0;
-				} else {
-					usemirror = 1;
-				}
-
-	if (usemirror) {
-		/* use mirror (parity) disk, swap params 0 & 4 */
-		tmp_pda = data_pda;
-		node->params[0].p = mirror_pda;
-		node->params[4].p = tmp_pda;
-	} else {
-		/* use data disk, leave param 0 unchanged */
-	}
-}
diff --git a/sys/dev/raidframe/rf_dagutils.h b/sys/dev/raidframe/rf_dagutils.h
deleted file mode 100644
index bad2c76..0000000
--- a/sys/dev/raidframe/rf_dagutils.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_dagutils.h,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*************************************************************************
- *
- * rf_dagutils.h -- header file for utility routines for manipulating DAGs
- *
- *************************************************************************/
-
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_general.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;
-};
-
-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_FreeDAG(RF_DagHeader_t * dag_h);
-
-	RF_PropHeader_t *rf_MakePropListEntry(RF_DagHeader_t * dag_h, int resultNum,
-            int paramNum, RF_PropHeader_t * next, RF_AllocListElem_t * allocList);
-
-	int     rf_ConfigureDAGs(RF_ShutdownList_t ** listp);
-
-	RF_DagHeader_t *rf_AllocDAGHeader(void);
-
-	void    rf_FreeDAGHeader(RF_DagHeader_t * dh);
-
-	void   *rf_AllocBuffer(RF_Raid_t * raidPtr, RF_DagHeader_t * dag_h,
-            RF_PhysDiskAddr_t * pda, RF_AllocListElem_t * allocList);
-
-	char   *rf_NodeStatusString(RF_DagNode_t * node);
-
-	void    rf_PrintNodeInfoString(RF_DagNode_t * node);
-
-	int     rf_AssignNodeNums(RF_DagHeader_t * dag_h);
-
-	int     rf_RecurAssignNodeNums(RF_DagNode_t * node, int num, int unvisited);
-
-	void    rf_ResetDAGHeaderPointers(RF_DagHeader_t * dag_h, RF_DagHeader_t * newptr);
-
-	void    rf_RecurResetDAGHeaderPointers(RF_DagNode_t * node, RF_DagHeader_t * newptr);
-
-	void    rf_PrintDAGList(RF_DagHeader_t * dag_h);
-
-	int     rf_ValidateDAG(RF_DagHeader_t * dag_h);
-
-	void    rf_redirect_asm(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap);
-
-	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);
-
-	int     rf_PDAOverlap(RF_RaidLayout_t * layoutPtr, RF_PhysDiskAddr_t * src,
-            RF_PhysDiskAddr_t * dest);
-
-	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);
-
-/* 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);
-
-	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);
-
-#endif				/* !_RF__RF_DAGUTILS_H_ */
diff --git a/sys/dev/raidframe/rf_debugMem.c b/sys/dev/raidframe/rf_debugMem.c
deleted file mode 100644
index a138021..0000000
--- a/sys/dev/raidframe/rf_debugMem.c
+++ /dev/null
@@ -1,208 +0,0 @@
-/*	$NetBSD: rf_debugMem.c,v 1.7 2000/01/07 03:40:59 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky, Mark Holland, Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* 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
- * case, we eliminate all references to the threads package
- * and to the allocation list stuff.
- */
-
-#include <dev/raidframe/rf_types.h>
-
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_options.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_general.h>
-
-#if defined(__FreeBSD__)
-#include <sys/kernel.h>
-MALLOC_DEFINE(M_RAIDFRAME, "rfbuf", "Buffers for RAIDframe operation");
-#endif
-
-static long tot_mem_in_use = 0;
-
-/* 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;
-	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);
-
-void 
-rf_record_malloc(p, size, line, filen)
-	void   *p;
-	int     size, line;
-	char   *filen;
-{
-	RF_ASSERT(size != 0);
-
-	/* RF_LOCK_MUTEX(rf_debug_mem_mutex); */
-	memory_hash_insert(p, size, line, filen);
-	tot_mem_in_use += size;
-	/* 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);
-	}
-}
-
-void 
-rf_unrecord_malloc(p, sz)
-	void   *p;
-	int     sz;
-{
-	int     size;
-
-	/* RF_LOCK_MUTEX(rf_debug_mem_mutex); */
-	size = memory_hash_remove(p, sz);
-	tot_mem_in_use -= size;
-	/* 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 */
-	}
-}
-
-void 
-rf_print_unfreed()
-{
-	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");
-				foundone = 1;
-				printf("Addr 0x%lx Size %d line %d file %s\n",
-				    (long) p->address, p->size, p->line, p->filen);
-			}
-	}
-	if (tot_mem_in_use) {
-		printf("%ld total bytes in use\n", tot_mem_in_use);
-	}
-}
-
-int 
-rf_ConfigureDebugMem(listp)
-	RF_ShutdownList_t **listp;
-{
-	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);
-		return (rc);
-	}
-	if (rf_memDebug) {
-		for (i = 0; i < RF_MH_TABLESIZE; i++)
-			mh_table[i] = NULL;
-		mh_table_initialized = 1;
-	}
-	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;
-{
-	unsigned long bucket = HASHADDR(addr);
-	struct mh_struct *p;
-
-	RF_ASSERT(mh_table_initialized);
-
-	/* 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 *));
-		RF_ASSERT(p);
-		p->next = mh_table[bucket];
-		mh_table[bucket] = p;
-		p->address = addr;
-		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);
-		RF_ASSERT(0);
-	}
-	p->size = size;
-	p->line = line;
-	p->filen = filen;
-	p->allocated = 1;
-}
-
-static int 
-memory_hash_remove(addr, sz)
-	void   *addr;
-	int     sz;
-{
-	unsigned long bucket = HASHADDR(addr);
-	struct mh_struct *p;
-
-	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);
-		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);
-		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);
-		RF_PANIC();
-	}
-	p->allocated = 0;
-	return (p->size);
-}
diff --git a/sys/dev/raidframe/rf_debugMem.h b/sys/dev/raidframe/rf_debugMem.h
deleted file mode 100644
index e6d8c60..0000000
--- a/sys/dev/raidframe/rf_debugMem.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_debugMem.h,v 1.7 1999/09/05 01:58:11 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky, Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_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
- *
- */
-
-#ifndef _RF__RF_DEBUGMEM_H_
-#define _RF__RF_DEBUGMEM_H_
-
-#include <dev/raidframe/rf_alloclist.h>
-
-#ifdef _KERNEL
-#include <sys/types.h>
-#include <sys/malloc.h>
-
-#if defined(__FreeBSD__)
-MALLOC_DECLARE(M_RAIDFRAME);
-#endif
-
-#define RF_Malloc(_p_, _size_, _cast_)                                      \
-  {                                                                         \
-     _p_ = _cast_ malloc((u_long)_size_, M_RAIDFRAME, M_NOWAIT | M_ZERO);   \
-     if (_p_ == NULL) panic("out of memory\n");				    \
-     if (rf_memDebug) rf_record_malloc(_p_, _size_, __LINE__, __FILE__);    \
-  }
-
-#define RF_MallocAndAdd(__p_, __size_, __cast_, __alist_)                   \
-  {                                                                         \
-     RF_Malloc(__p_, __size_, __cast_);                                     \
-     if (__alist_) rf_AddToAllocList(__alist_, __p_, __size_);              \
-  }
-
-#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_Free(_p_, _sz_)                                                  \
-  {                                                                         \
-     free((void *)(_p_), M_RAIDFRAME);                                      \
-     if (rf_memDebug) rf_unrecord_malloc(_p_, (u_int32_t) (_sz_));          \
-  }
-
-#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);
-
-#endif				/* !_RF__RF_DEBUGMEM_H_ */
diff --git a/sys/dev/raidframe/rf_debugprint.c b/sys/dev/raidframe/rf_debugprint.c
deleted file mode 100644
index 02adee7..0000000
--- a/sys/dev/raidframe/rf_debugprint.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/*	$NetBSD: rf_debugprint.c,v 1.3 1999/02/05 00:06:08 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * Code to do debug printfs. Calls to rf_debug_printf cause the corresponding
- * information to be printed to a circular buffer rather than the screen.
- * The point is to try and minimize the timing variations induced by the
- * printfs, and to capture only the printf's immediately preceding a failure.
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_debugprint.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_options.h>
-
-#include <sys/param.h>
-
-struct RF_Entry_s {
-	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)
-
-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;
-{
-	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);
-		return (rc);
-	}
-	rf_clear_debug_print_buffer();
-	return (0);
-}
-
-void 
-rf_clear_debug_print_buffer()
-{
-	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;
-{
-	int     idx;
-
-	if (rf_debugPrintUseBuffer) {
-
-		RF_LOCK_MUTEX(rf_debug_print_mutex);
-		idx = rf_debugprint_index;
-		rf_debugprint_index = (rf_debugprint_index + 1) & BUFMASK;
-		RF_UNLOCK_MUTEX(rf_debug_print_mutex);
-
-		rf_debugprint_buf[idx].cstring = s;
-		rf_debugprint_buf[idx].a1 = a1;
-		rf_debugprint_buf[idx].a2 = a2;
-		rf_debugprint_buf[idx].a3 = a3;
-		rf_debugprint_buf[idx].a4 = a4;
-		rf_debugprint_buf[idx].a5 = a5;
-		rf_debugprint_buf[idx].a6 = a6;
-		rf_debugprint_buf[idx].a7 = a7;
-		rf_debugprint_buf[idx].a8 = a8;
-	} else {
-		printf(s, a1, a2, a3, a4, a5, a6, a7, a8);
-	}
-}
-
-void 
-rf_print_debug_buffer()
-{
-	rf_spill_debug_buffer(NULL);
-}
-
-void 
-rf_spill_debug_buffer(fname)
-	char   *fname;
-{
-	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)
-		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);
-	RF_UNLOCK_MUTEX(rf_debug_print_mutex);
-}
diff --git a/sys/dev/raidframe/rf_debugprint.h b/sys/dev/raidframe/rf_debugprint.h
deleted file mode 100644
index 318f620..0000000
--- a/sys/dev/raidframe/rf_debugprint.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*	$FreeBSD$ */
-/*	$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.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#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);
-
-#endif				/* !_RF__RF_DEBUGPRINT_H_ */
diff --git a/sys/dev/raidframe/rf_decluster.c b/sys/dev/raidframe/rf_decluster.c
deleted file mode 100644
index 646a5ad..0000000
--- a/sys/dev/raidframe/rf_decluster.c
+++ /dev/null
@@ -1,747 +0,0 @@
-/*	$NetBSD: rf_decluster.c,v 1.6 2001/01/26 04:40:03 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*----------------------------------------------------------------------
- *
- * rf_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           |
- *                   |            ...               |
- *                   +------------------------------+
- *
- *--------------------------------------------------------------------*/
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_raidframe.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_decluster.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-
-extern int rf_copyback_in_progress;	/* debug only */
-
-/* found in rf_kintf.c */
-extern int     rf_GetSpareTableFromDaemon(RF_SparetWait_t * req);
-
-#if (RF_INCLUDE_PARITY_DECLUSTERING > 0) || (RF_INCLUDE_PARITY_DECLUSTERING_PQ > 0)
-
-/* configuration code */
-
-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;
-	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 totSparePUsPerDisk;
-	RF_SectorNum_t diskOffsetOfLastFullTableInSUs;
-	RF_SectorCount_t SpareSpaceInSUs;
-	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);
-	if (info == NULL)
-		return (ENOMEM);
-	layoutPtr->layoutSpecificInfo = (void *) info;
-	info->SpareTable = NULL;
-
-	/* 2. extract parameters from the config structure */
-	if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) {
-		(void) bcopy(cfgBuf, info->sparemap_fname, RF_SPAREMAP_NAME_LEN);
-	}
-	cfgBuf += RF_SPAREMAP_NAME_LEN;
-
-	b = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	v = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	k = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	r = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	lambda = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	raidPtr->noRotate = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-
-	/* 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");
-	}
-	if (raidPtr->numCol != v) {
-		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 */
-	info->BlocksPerTable = b;
-	info->Lambda = lambda;
-	info->NumParityReps = info->groupSize = k;
-	info->SUsPerTable = b * (k - 1) * layoutPtr->SUsPerPU;	/* b blks, k-1 SUs each */
-	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 */
-
-	/* 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;
-
-	/* 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);
-			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), \
-			    (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) */
-	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;
-		info->NumCompleteSRs = numCompleteSpareRegionsPerDisk;
-		extraPUsPerDisk = PUsPerDisk % spareRegionDepthInPUs;
-
-		/* 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);
-		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;
-		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);
-		info->TotSparePUsPerDisk = totSparePUsPerDisk;
-
-		layoutPtr->stripeUnitsPerDisk =
-		    ((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)
-		    * 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;
-	}
-
-	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
-
-	/* 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;
-	if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
-		SpareSpaceInSUs = numCompleteSpareRegionsPerDisk * info->SpareSpaceDepthPerRegionInSUs;
-		diskOffsetOfLastFullTableInSUs += SpareSpaceInSUs;
-		info->DiskOffsetOfLastSpareSpaceChunkInSUs =
-		    diskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk * info->TableDepthInPUs * layoutPtr->SUsPerPU;
-	}
-	info->DiskOffsetOfLastFullTableInSUs = diskOffsetOfLastFullTableInSUs;
-	info->numCompleteFullTablesPerDisk = numCompleteFullTablesPerDisk;
-
-	/* 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);
-	if (info->BlockTable == NULL)
-		return (ENOMEM);
-
-	first_avail_slot = rf_make_1d_array(v, NULL);
-	if (first_avail_slot == NULL)
-		return (ENOMEM);
-
-	for (i = 0; i < b; i++)
-		for (j = 0; j < k; j++)
-			info->LayoutTable[i][j] = *cfgBuf++;
-
-	/* 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]];
-			first_avail_slot[info->LayoutTable[i][j]]++;
-		}
-
-	/* 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->LayoutTable[i][j]] = SUID;
-			}
-			SUID++;
-		}
-	}
-
-	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 - 1);
-
-	/* 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;
-{
-	RF_DeclusteredConfigInfo_t *info;
-	RF_Raid_t *raidPtr;
-
-	raidPtr = (RF_Raid_t *) arg;
-	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     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_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;
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	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_StripeNum_t base_suid = 0, outSU, SpareRegion = 0, SpareSpace = 0;
-
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-
-	FullTableID = SUID / sus_per_fulltable;	/* fulltable ID within array
-						 * (across rows) */
-	if (raidPtr->numRow == 1)
-		*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 */
-	}
-	if (raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE) {
-		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
-		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
-	}
-	FullTableOffset = SUID % sus_per_fulltable;
-	TableID = FullTableOffset / info->SUsPerTable;
-	TableOffset = FullTableOffset - TableID * info->SUsPerTable;
-	BlockID = TableOffset / info->PUsPerBlock;
-	BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
-	BlockID %= info->BlocksPerTable;
-	RepIndex = info->PUsPerBlock - TableID;
-	if (!raidPtr->noRotate)
-		BlockOffset += ((BlockOffset >= RepIndex) ? 1 : 0);
-	*col = info->LayoutTable[BlockID][BlockOffset];
-
-	/* 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);
-	} 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 += 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);
-
-	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)
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	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_StripeNum_t base_suid = 0, outSU, SpareRegion = 0, SpareSpace = 0;
-
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-
-	/* 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 */
-	else {
-		*row = FullTableID % raidPtr->numRow;
-		FullTableID /= raidPtr->numRow;	/* convert to fulltable ID on
-						 * this disk */
-	}
-	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
-		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
-	}
-	/* 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; */
-	BlockID = 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;
-	*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);
-	} else {
-
-		/* 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 += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
-	*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.
- */
-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_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	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;
-
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-	FullTableID = SUID / sus_per_fulltable;	/* fulltable ID within array
-						 * (across rows) */
-	*outRow = FullTableID % raidPtr->numRow;
-	stripeID = rf_StripeUnitIDToStripeID(layoutPtr, SUID);	/* find stripe offset
-								 * into array */
-	tableOffset = (stripeID % info->BlocksPerTable);	/* find offset into
-								 * block design table */
-	*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
- * 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
- * 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
- * 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.
- *
- * 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
- * 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 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_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
-
-	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.
- */
-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
- * changes the values of certain params to handle this.
- *
- * 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
- * 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)
-{
-	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 depth is corresponding depth */
-		*fulltable_depth = info->ExtraTablesPerDisk * info->TableDepthInPUs * layoutPtr->SUsPerPU;
-
-		/* set up the new base offset */
-		*base_suid = info->DiskOffsetOfLastFullTableInSUs;
-
-		/* convert users array address to an offset into the last
-		 * fulltable */
-		*SUID -= info->FullTableLimitSUID;
-	}
-}
-/*
- * 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)
-{
-	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;
-	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)
-{
-	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.
-         */
-	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;
-		SpareRegion = info->NumCompleteSRs;
-	}
-	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;
-	if (*outSU >= layoutPtr->stripeUnitsPerDisk) {
-		printf("rf_remap_to_spare_space: invalid remapped disk SU offset %ld\n", (long) *outSU);
-	}
-}
-
-#endif /* (RF_INCLUDE_PARITY_DECLUSTERING > 0)  || (RF_INCLUDE_PARITY_DECLUSTERING_PQ > 0) */
-
-
-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_SparetWait_t *req;
-	int     retcode;
-
-	RF_Malloc(req, sizeof(*req), (RF_SparetWait_t *));
-	req->C = raidPtr->numCol;
-	req->G = raidPtr->Layout.numDataCol + raidPtr->Layout.numParityCol;
-	req->fcol = fcol;
-	req->SUsPerPU = raidPtr->Layout.SUsPerPU;
-	req->TablesPerSpareRegion = info->TablesPerSpareRegion;
-	req->BlocksPerTable = info->BlocksPerTable;
-	req->TableDepthInPUs = info->TableDepthInPUs;
-	req->SpareSpaceDepthPerRegionInSUs = info->SpareSpaceDepthPerRegionInSUs;
-
-	retcode = rf_GetSpareTableFromDaemon(req);
-	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;
-{
-	RF_DeclusteredConfigInfo_t *info = (RF_DeclusteredConfigInfo_t *) raidPtr->Layout.layoutSpecificInfo;
-	RF_SpareTableEntry_t **ptrs;
-	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 *));
-
-	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 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));
-		if (retcode) {
-			info->SpareTable = NULL;	/* blow off the memory
-							 * we've allocated */
-			return (retcode);
-		}
-	}
-
-	/* 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_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-
-	return (((RF_DeclusteredConfigInfo_t *) layoutPtr->layoutSpecificInfo)->TotSparePUsPerDisk);
-}
-
-void 
-rf_FreeSpareTable(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	long    i;
-	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	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, 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
deleted file mode 100644
index a630298..0000000
--- a/sys/dev/raidframe/rf_decluster.h
+++ /dev/null
@@ -1,141 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_decluster.h,v 1.3 1999/02/05 00:06:09 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*----------------------------------------------------------------------
- *
- * 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_
-
-#include <dev/raidframe/rf_types.h>
-
-/*
- * These structures define the tables used to locate the spare unit
- * associated with a particular data or parity unit, and to perform
- * 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 */
-};
-#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 */
-
-	/* 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 */
-};
-
-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);
-
-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);
-
-RF_HeadSepLimit_t rf_GetDefaultHeadSepLimitDeclustered(RF_Raid_t * raidPtr);
-int     rf_GetDefaultNumFloatingReconBuffersDeclustered(RF_Raid_t * raidPtr);
-
-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);
-
-#endif				/* !_RF__RF_DECLUSTER_H_ */
diff --git a/sys/dev/raidframe/rf_declusterPQ.c b/sys/dev/raidframe/rf_declusterPQ.c
deleted file mode 100644
index dc539a3..0000000
--- a/sys/dev/raidframe/rf_declusterPQ.c
+++ /dev/null
@@ -1,493 +0,0 @@
-/*	$NetBSD: rf_declusterPQ.c,v 1.5 2001/01/26 14:06:17 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Authors: Daniel Stodolsky, Mark Holland, Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*--------------------------------------------------
- * rf_declusterPQ.c
- *
- * mapping code for declustered P & Q or declustered EvenOdd
- * much code borrowed from rf_decluster.c
- *
- *--------------------------------------------------*/
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_decluster.h>
-#include <dev/raidframe/rf_declusterPQ.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_general.h>
-
-#if (RF_INCLUDE_PARITY_DECLUSTERING_PQ > 0) || (RF_INCLUDE_EVENODD > 0)
-/* configuration code */
-
-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;
-	RF_DeclusteredConfigInfo_t *info;
-	int     numCompleteFullTablesPerDisk;
-	int     PUsPerDisk, spareRegionDepthInPUs, numCompleteSpareRegionsPerDisk = 0,
-	        extraPUsPerDisk;
-	int     totSparePUsPerDisk;
-	int     diskOffsetOfLastFullTableInSUs, SpareSpaceInSUs;
-	char   *cfgBuf = (char *) (cfgPtr->layoutSpecific);
-
-	cfgBuf += RF_SPAREMAP_NAME_LEN;
-
-	b = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	v = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	k = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	r = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	lambda = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-	raidPtr->noRotate = *((int *) cfgBuf);
-	cfgBuf += sizeof(int);
-
-	if (k <= 2) {
-		printf("RAIDFRAME: k=%d, minimum value 2\n", k);
-		return (EINVAL);
-	}
-	/* 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");
-	}
-	if (raidPtr->numCol != v) {
-		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 */
-	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->SUsPerBlock = info->PUsPerBlock * layoutPtr->SUsPerPU;
-	info->TableDepthInPUs = (b * k) / v;
-	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 */
-	info->TablesPerSpareRegion = k * info->FullTablesPerSpareRegion;
-	info->SpareSpaceDepthPerRegionInSUs = (r * info->TablesPerSpareRegion / (v - 1)) * layoutPtr->SUsPerPU;
-
-	/* 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);
-			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),
-			    (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) */
-	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;
-		info->NumCompleteSRs = numCompleteSpareRegionsPerDisk;
-		extraPUsPerDisk = PUsPerDisk % spareRegionDepthInPUs;
-
-		/* 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);
-		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;
-		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);
-		info->TotSparePUsPerDisk = totSparePUsPerDisk;
-
-		layoutPtr->stripeUnitsPerDisk =
-		    ((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)
-		    * 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;
-	}
-
-	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
-
-	/* 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;
-	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		SpareSpaceInSUs = numCompleteSpareRegionsPerDisk * info->SpareSpaceDepthPerRegionInSUs;
-		diskOffsetOfLastFullTableInSUs += SpareSpaceInSUs;
-		info->DiskOffsetOfLastSpareSpaceChunkInSUs =
-		    diskOffsetOfLastFullTableInSUs + info->ExtraTablesPerDisk * info->TableDepthInPUs * layoutPtr->SUsPerPU;
-	}
-	info->DiskOffsetOfLastFullTableInSUs = diskOffsetOfLastFullTableInSUs;
-	info->numCompleteFullTablesPerDisk = numCompleteFullTablesPerDisk;
-
-	/* 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);
-	if (info->BlockTable == NULL)
-		return (ENOMEM);
-
-	first_avail_slot = (int *) rf_make_1d_array(v, NULL);
-	if (first_avail_slot == NULL)
-		return (ENOMEM);
-
-	for (i = 0; i < b; i++)
-		for (j = 0; j < k; j++)
-			info->LayoutTable[i][j] = *cfgBuf++;
-
-	/* 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]];
-			first_avail_slot[info->LayoutTable[i][j]]++;
-		}
-
-	/* 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->LayoutTable[i][j]] = SUID;
-			}
-			SUID++;
-		}
-	}
-
-	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);
-
-	/* 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     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)
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	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_StripeNum_t base_suid = 0, outSU, SpareRegion = 0, SpareSpace = 0;
-
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-
-	FullTableID = SUID / sus_per_fulltable;	/* fulltable ID within array
-						 * (across rows) */
-	*row = FullTableID % raidPtr->numRow;
-	FullTableID /= raidPtr->numRow;	/* convert to fulltable ID on this
-					 * disk */
-	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
-		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
-	}
-	FullTableOffset = SUID % sus_per_fulltable;
-	TableID = FullTableOffset / info->SUsPerTable;
-	TableOffset = FullTableOffset - TableID * info->SUsPerTable;
-	BlockID = TableOffset / info->PUsPerBlock;
-	BlockOffset = TableOffset - BlockID * info->PUsPerBlock;
-	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
-           */
-	RepIndex = info->groupSize - 1 - TableID;
-	RF_ASSERT(RepIndex >= 0);
-	if (!raidPtr->noRotate) {
-		if (TableID == 0)
-			BlockOffset++;	/* P on last drive, Q on first */
-		else
-			BlockOffset += ((BlockOffset >= RepIndex) ? 2 : 0);	/* skip over PQ */
-		RF_ASSERT(BlockOffset < info->groupSize);
-		*col = info->LayoutTable[BlockID][BlockOffset];
-	}
-	/* 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);
-	} 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 += 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);
-}
-
-
-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_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_StripeNum_t base_suid = 0, outSU, SpareRegion, SpareSpace = 0;
-
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-
-	/* 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 */
-	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
-		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
-	}
-	/* compute BlockID and RepIndex exactly as before */
-	FullTableOffset = SUID % sus_per_fulltable;
-	TableID = FullTableOffset / info->SUsPerTable;
-	TableOffset = FullTableOffset - TableID * info->SUsPerTable;
-	BlockID = 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->groupSize - 1 - TableID;
-	*col = info->LayoutTable[BlockID][RepIndex];
-
-	if (remap)
-		RF_PANIC();
-
-	/* 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 += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
-
-	*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)
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	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_StripeNum_t base_suid = 0, outSU, SpareRegion, SpareSpace = 0;
-
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-
-	/* 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 */
-	if ((raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		SpareRegion = FullTableID / info->FullTablesPerSpareRegion;
-		SpareSpace = SpareRegion * info->SpareSpaceDepthPerRegionInSUs;
-	}
-	/* compute BlockID and RepIndex exactly as before */
-	FullTableOffset = SUID % sus_per_fulltable;
-	TableID = FullTableOffset / info->SUsPerTable;
-	TableOffset = FullTableOffset - TableID * info->SUsPerTable;
-	BlockID = TableOffset / info->PUsPerBlock;
-	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;
-	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 */
-	outSU = base_suid;
-	outSU += FullTableID * fulltable_depth;
-	outSU += SpareSpace;	/* skip rsvd spare space */
-	outSU += TableID * info->TableDepthInPUs * layoutPtr->SUsPerPU;
-	outSU += TableOffset / (info->BlocksPerTable * info->PUsPerBlock);
-
-	outSU += info->OffsetTable[BlockID][RepIndexQ] * layoutPtr->SUsPerPU;
-	*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.
- */
-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_StripeCount_t sus_per_fulltable = info->SUsPerFullTable;
-	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;
-
-	rf_decluster_adjust_params(layoutPtr, &SUID, &sus_per_fulltable, &fulltable_depth, &base_suid);
-	FullTableID = SUID / sus_per_fulltable;	/* fulltable ID within array
-						 * (across rows) */
-	*outRow = FullTableID % raidPtr->numRow;
-	stripeID = rf_StripeUnitIDToStripeID(layoutPtr, SUID);	/* find stripe offset
-								 * into array */
-	tableOffset = (stripeID % info->BlocksPerTable);	/* find offset into
-								 * block design table */
-	*diskids = info->LayoutTable[tableOffset];
-}
-#endif /* (RF_INCLUDE_PARITY_DECLUSTERING_PQ > 0) || (RF_INCLUDE_EVENODD > 0) */
diff --git a/sys/dev/raidframe/rf_declusterPQ.h b/sys/dev/raidframe/rf_declusterPQ.h
deleted file mode 100644
index 6edef0b..0000000
--- a/sys/dev/raidframe/rf_declusterPQ.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_declusterPQ.h,v 1.3 1999/02/05 00:06:09 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky, Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_DECLUSTERPQ_H_
-#define _RF__RF_DECLUSTERPQ_H_
-
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_DECLUSTERPQ_H_ */
diff --git a/sys/dev/raidframe/rf_desc.h b/sys/dev/raidframe/rf_desc.h
deleted file mode 100644
index 8a6951b..0000000
--- a/sys/dev/raidframe/rf_desc.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_desc.h,v 1.5 2000/01/09 00:00:18 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_DESC_H_
-#define _RF__RF_DESC_H_
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/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) */
-	/*
-         * Prevent recon from hogging CPU
-         */
-	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 */
-	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
-						 * 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 */
-
-	RF_AllocListElem_t *cleanupList;	/* memory to be freed at the
-						 * end of the access */
-
-	RF_RaidAccessDesc_t *next;
-	RF_RaidAccessDesc_t *head;
-
-	int     numPending;
-
-	        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 */
-};
-#endif				/* !_RF__RF_DESC_H_ */
diff --git a/sys/dev/raidframe/rf_diskqueue.c b/sys/dev/raidframe/rf_diskqueue.c
deleted file mode 100644
index c03e6cd..0000000
--- a/sys/dev/raidframe/rf_diskqueue.c
+++ /dev/null
@@ -1,593 +0,0 @@
-/*	$NetBSD: rf_diskqueue.c,v 1.13 2000/03/04 04:22:34 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/****************************************************************************
- *
- * rf_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,
- * and locking ops (see below) on top of the lower-level queueing code.
- *
- * 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
- * code relies on the higher layers to guarantee that a locking op
- * 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
- * check to see that an unlocking op "corresponds" to the op that
- * 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
- * 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
- * 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
- * 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
- * and wake up the disk thread to do the dispatch.
- *
- ****************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_debugprint.h>
-#include <dev/raidframe/rf_shutdown.h>
-#include <dev/raidframe/rf_cvscan.h>
-#include <dev/raidframe/rf_sstf.h>
-#include <dev/raidframe/rf_fifo.h>
-#include <dev/raidframe/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)
-
-/*****************************************************************************
- *
- * the disk queue switch defines all the functions used in the
- * different queueing disciplines queue ID, init routine, enqueue
- * routine, dequeue routine
- *
- ****************************************************************************/
-
-static RF_DiskQueueSW_t diskqueuesw[] = {
-	{"fifo",		/* FIFO */
-		rf_FifoCreate,
-		rf_FifoEnqueue,
-		rf_FifoDequeue,
-		rf_FifoPeek,
-	rf_FifoPromote},
-
-	{"cvscan",		/* cvscan */
-		rf_CvscanCreate,
-		rf_CvscanEnqueue,
-		rf_CvscanDequeue,
-		rf_CvscanPeek,
-	rf_CvscanPromote},
-
-	{"sstf",		/* shortest seek time first */
-		rf_SstfCreate,
-		rf_SstfEnqueue,
-		rf_SstfDequeue,
-		rf_SstfPeek,
-	rf_SstfPromote},
-
-	{"scan",		/* SCAN (two-way elevator) */
-		rf_ScanCreate,
-		rf_SstfEnqueue,
-		rf_ScanDequeue,
-		rf_ScanPeek,
-	rf_SstfPromote},
-
-	{"cscan",		/* CSCAN (one-way elevator) */
-		rf_CscanCreate,
-		rf_SstfEnqueue,
-		rf_CscanDequeue,
-		rf_CscanPeek,
-	rf_SstfPromote},
-
-};
-#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
-
-#if defined(__FreeBSD__) && __FreeBSD_version > 500005
-#include <sys/bio.h>
-#endif
-
-#include <sys/buf.h>
-
-static int 
-init_dqd(dqd)
-	RF_DiskQueueData_t *dqd;
-{
-
-	dqd->bp = (RF_Buf_t) malloc(sizeof(*dqd->bp), M_RAIDFRAME, M_NOWAIT);
-	if (dqd->bp == NULL) {
-		return (ENOMEM);
-	}
-	memset(dqd->bp, 0, sizeof(*dqd->bp));	/* if you don't do it, nobody
-						 * else will.. */
-	return (0);
-}
-
-static void 
-clean_dqd(dqd)
-	RF_DiskQueueData_t *dqd;
-{
-	free(dqd->bp, M_RAIDFRAME);
-}
-/* configures 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)
-{
-	int     rc;
-
-	diskqueue->row = r;
-	diskqueue->col = c;
-	diskqueue->qPtr = p;
-	diskqueue->qHdr = (p->Create) (sectPerDisk, clList, listp);
-	diskqueue->dev = dev;
-	diskqueue->numOutstanding = 0;
-	diskqueue->queueLength = 0;
-	diskqueue->maxOutstanding = maxOutstanding;
-	diskqueue->curPriority = RF_IO_NORMAL_PRIORITY;
-	diskqueue->nextLockingOp = NULL;
-	diskqueue->unlockingOp = NULL;
-	diskqueue->numWaiting = 0;
-	diskqueue->flags = 0;
-	diskqueue->raidPtr = raidPtr;
-	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);
-		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);
-		return (rc);
-	}
-	return (0);
-}
-
-static void 
-rf_ShutdownDiskQueueSystem(ignored)
-	void   *ignored;
-{
-	RF_FREELIST_DESTROY_CLEAN(rf_dqd_freelist, next, (RF_DiskQueueData_t *), clean_dqd);
-}
-
-int 
-rf_ConfigureDiskQueueSystem(listp)
-	RF_ShutdownList_t **listp;
-{
-	int     rc;
-
-	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_ShutdownDiskQueueSystem(NULL);
-		return (rc);
-	}
-	RF_FREELIST_PRIME_INIT(rf_dqd_freelist, RF_DQD_INITIAL, next,
-	    (RF_DiskQueueData_t *), init_dqd);
-	return (0);
-}
-
-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;
-
-	raidPtr->maxQueueDepth = cfgPtr->maxOutstandingDiskReqs;
-
-	for (p = NULL, i = 0; i < NUM_DISK_QUEUE_TYPES; i++) {
-		if (!strcmp(diskqueuesw[i].queueType, cfgPtr->diskQueueType)) {
-			p = &diskqueuesw[i];
-			break;
-		}
-	}
-	if (p == NULL) {
-		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);
-	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 *), 
-				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);
-			if (rc)
-				return (rc);
-		}
-	}
-
-	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,
-		    raidPtr->Disks[0][raidPtr->numCol + r].dev,
-		    cfgPtr->maxOutstandingDiskReqs, listp,
-		    raidPtr->cleanupList);
-		if (rc)
-			return (rc);
-	}
-	return (0);
-}
-/* Enqueue a disk I/O
- *
- * Unfortunately, we have to do things differently in the different
- * environments (simulator, user-level, kernel).
- * At user level, all I/O is blocking, so we have 1 or more threads/disk
- * and the thread that enqueues is different from the thread that dequeues.
- * 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:
- *    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
- *
- * 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:
- *    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;
-{
-	RF_ETIMER_START(req->qtime);
-	RF_ASSERT(req->type == RF_IO_TYPE_NOP || req->numSector);
-	req->priority = pri;
-
-	if (rf_queueDebug && (req->numSector == 0)) {
-		printf("Warning: Enqueueing zero-sector access\n");
-	}
-	/*
-         * kernel
-         */
-	RF_LOCK_QUEUE_MUTEX(queue, "DiskIOEnqueue");
-	/* 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);
-			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);
-			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);
-			RF_ASSERT(RF_QUEUE_LOCKED(queue));
-			rf_DispatchKernelIO(queue, req);
-		}
-	/* normal request */
-		else
-			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);
-				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);
-				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;
-{
-	int     done = 0;
-
-	RF_LOCK_QUEUE_MUTEX(queue, "DiskIOComplete");
-
-	/* 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));
-		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 */
-
-	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);
-		} 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);
-			} else {
-				Dprintf1("DiskIOComplete: no more requests to extract.\n", "");
-			}
-		}
-		if (req) {
-			queue->queueLength--;	/* decrement count of number
-						 * of requests waiting in this
-						 * queue */
-			RF_ASSERT(queue->queueLength >= 0);
-		}
-		if (!req)
-			done = 1;
-		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);
-					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);
-					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);
-					rf_DispatchKernelIO(queue, req);
-					done = 1;
-				} 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);
-						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);
-						queue->queueLength++;
-						(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
- * 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     retval;
-
-	if (!queue->qPtr->Promote)
-		return (-1);
-	RF_LOCK_QUEUE_MUTEX(queue, "DiskIOPromote");
-	retval = (queue->qPtr->Promote) (queue->qHdr, parityStripeID, which_ru);
-	RF_UNLOCK_QUEUE_MUTEX(queue, "DiskIOPromote");
-	return (retval);
-}
-
-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 *p;
-
-	RF_FREELIST_GET_INIT(rf_dqd_freelist, p, next, (RF_DiskQueueData_t *), init_dqd);
-
-	p->sectorOffset = ssect + rf_protectedSectors;
-	p->numSector = nsect;
-	p->type = typ;
-	p->buf = buf;
-	p->parityStripeID = parityStripeID;
-	p->which_ru = which_ru;
-	p->CompleteFunc = wakeF;
-	p->argument = arg;
-	p->next = next;
-	p->tracerec = tracerec;
-	p->priority = RF_IO_NORMAL_PRIORITY;
-	p->AuxFunc = NULL;
-	p->buf2 = NULL;
-	p->raidPtr = raidPtr;
-	p->flags = flags;
-	p->b_proc = kb_proc;
-	return (p);
-}
-
-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_DiskQueueData_t *p;
-
-	RF_FREELIST_GET_INIT(rf_dqd_freelist, p, next, (RF_DiskQueueData_t *), init_dqd);
-
-	p->sectorOffset = ssect + rf_protectedSectors;
-	p->numSector = nsect;
-	p->type = typ;
-	p->buf = buf;
-	p->parityStripeID = parityStripeID;
-	p->which_ru = which_ru;
-	p->CompleteFunc = wakeF;
-	p->argument = arg;
-	p->next = next;
-	p->tracerec = tracerec;
-	p->priority = priority;
-	p->AuxFunc = AuxFunc;
-	p->buf2 = buf2;
-	p->raidPtr = raidPtr;
-	p->flags = flags;
-	p->b_proc = kb_proc;
-	return (p);
-}
-
-void 
-rf_FreeDiskQueueData(p)
-	RF_DiskQueueData_t *p;
-{
-	RF_FREELIST_FREE_CLEAN(rf_dqd_freelist, p, next, clean_dqd);
-}
diff --git a/sys/dev/raidframe/rf_diskqueue.h b/sys/dev/raidframe/rf_diskqueue.h
deleted file mode 100644
index 7b162b0..0000000
--- a/sys/dev/raidframe/rf_diskqueue.h
+++ /dev/null
@@ -1,208 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_diskqueue.h,v 1.5 2000/02/13 04:53:57 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************************
- *
- * rf_diskqueue.h -- header file for disk queues
- *
- * see comments in rf_diskqueue.c
- *
- ****************************************************************************************/
-
-
-#ifndef _RF__RF_DISKQUEUE_H_
-#define _RF__RF_DISKQUEUE_H_
-
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_etimer.h>
-
-#include <dev/raidframe/rf_bsd.h>
-
-#define RF_IO_NORMAL_PRIORITY 1
-#define RF_IO_LOW_PRIORITY    0
-
-/* 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_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 */
-				/* XXX Should this be changed to the opaque
-				 * RF_Thread_t ? */
-	RF_Buf_t bp;		/* a bp to use to get this I/O done */
-};
-#define RF_LOCK_DISK_QUEUE   0x01
-#define RF_UNLOCK_DISK_QUEUE 0x02
-
-/* 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 */
-};
-
-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.. */
-};
-#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_ */
diff --git a/sys/dev/raidframe/rf_disks.c b/sys/dev/raidframe/rf_disks.c
deleted file mode 100644
index 14f72c2..0000000
--- a/sys/dev/raidframe/rf_disks.c
+++ /dev/null
@@ -1,1140 +0,0 @@
-/*	$NetBSD: rf_disks.c,v 1.34 2000/12/05 01:35:56 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*-
- * Copyright (c) 1999 The NetBSD Foundation, Inc.
- * All rights reserved.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Greg Oster
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    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.
- * 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/***************************************************************
- * rf_disks.c -- code to perform operations on the actual disks
- ***************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_options.h>
-#include <dev/raidframe/rf_kintf.h>
-#include <dev/raidframe/rf_bsd.h>
-
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/proc.h>
-#if defined(__NetBSD__)
-#include <sys/ioctl.h>
-#elif defined(__FreeBSD__)
-#include <sys/ioccom.h>
-#include <sys/filio.h>
-#endif
-#include <sys/fcntl.h>
-#include <sys/vnode.h>
-
-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 );
-
-#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
- *
- * 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;
-{
-	RF_RaidDisk_t **disks;
-	RF_SectorCount_t min_numblks = (RF_SectorCount_t) 0x7FFFFFFFFFFFLL;
-	RF_RowCol_t r, c;
-	int bs, ret;
-	unsigned i, count, foundone = 0, numFailuresThisRow;
-	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);
-			
-			if (ret)
-				goto fail;
-
-			if (disks[r][c].status == rf_ds_optimal) {
-				raidread_component_label(
-					 raidPtr->raid_cinfo[r][c].ci_dev,
-					 raidPtr->raid_cinfo[r][c].ci_vp,
-					 &raidPtr->raid_cinfo[r][c].ci_label);
-			}
-
-			if (disks[r][c].status != rf_ds_optimal) {
-				numFailuresThisRow++;
-			} 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",
-				    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);
-			}
-		}
-		/* 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 */
-	bs = 0;
-	for (foundone = r = 0; !foundone && r < raidPtr->numRow; r++) {
-		for (c = 0; !foundone && c < raidPtr->numCol; c++) {
-			if (disks[r][c].status == rf_ds_optimal) {
-				bs = disks[r][c].blockSize;
-				foundone = 1;
-			}
-		}
-	}
-	if (!foundone) {
-		RF_ERRORMSG("RAIDFRAME: Did not find any live disks in the array.\n");
-		ret = EINVAL;
-		goto fail;
-	}
-	for (count = 0, i = 1; i; i <<= 1)
-		if (bs & i)
-			count++;
-	if (count != 1) {
-		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 )) {
-		printf("raid%d: There were fatal errors\n", raidPtr->raidid);
-		if (force != 0) {
-			printf("raid%d: Fatal errors being ignored.\n",
-			       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);
-					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",
-					    r, c, (int) min_numblks);
-					disks[r][c].numBlocks = min_numblks;
-				}
-			}
-		}
-	}
-
-	raidPtr->sectorsPerDisk = min_numblks;
-	raidPtr->logBytesPerSector = ffs(bs) - 1;
-	raidPtr->bytesPerSector = bs;
-	raidPtr->sectorMask = bs - 1;
-	return (0);
-
-fail:
-	
-	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
- * 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     i, ret;
-	unsigned int bs;
-	RF_RaidDisk_t *disks;
-	int     num_spares_done;
-
-	num_spares_done = 0;
-
-	/* 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);
-		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]);
-		} 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,
-			    (long int) disks[i].numBlocks, disks[i].blockSize,
-			    (long int) disks[i].numBlocks * 
-				 disks[i].blockSize / 1024 / 1024);
-		}
-		num_spares_done++;
-	}
-
-	/* 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);
-			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);
-			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);
-
-				disks[i].numBlocks = raidPtr->sectorsPerDisk;
-			}
-	}
-
-	return (0);
-
-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"... 
-
-	 */
-
-	rf_UnconfigureVnodes( raidPtr );
-	
-	return (ret);
-}
-
-static int
-rf_AllocDiskStructures(raidPtr, cfgPtr)
-	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);
-	if (disks == NULL) {
-		ret = ENOMEM;
-		goto fail;
-	}
-	raidPtr->Disks = disks;
-	/* get space for the device-specific stuff... */
-	RF_CallocAndAdd(raidPtr->raid_cinfo, raidPtr->numRow,
-	    sizeof(struct raidcinfo *), (struct raidcinfo **),
-	    raidPtr->cleanupList);
-	if (raidPtr->raid_cinfo == NULL) {
-		ret = ENOMEM;
-		goto fail;
-	}
-
-	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);
-		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),
-		    sizeof(struct raidcinfo), (struct raidcinfo *),
-		    raidPtr->cleanupList);
-		if (raidPtr->raid_cinfo[r] == NULL) {
-			ret = ENOMEM;
-			goto fail;
-		}
-	}
-	return(0);
-fail:	
-	rf_UnconfigureVnodes( raidPtr );
-
-	return(ret);
-}
-
-
-/* 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_RaidDisk_t **disks;
-	RF_RaidDisk_t *diskPtr;
-	RF_RowCol_t r, c;	
-	RF_SectorCount_t min_numblks = (RF_SectorCount_t) 0x7FFFFFFFFFFFLL;
-	int bs, ret;
-	int numFailuresThisRow;
-	int force;
-	RF_AutoConfig_t *ac;
-	int parity_good;
-	int mod_counter;
-	int mod_counter_found;
-
-	rf_printf(0, "Starting autoconfiguration of RAID set...\n");
-	force = cfgPtr->force;
-
-	ret = rf_AllocDiskStructures(raidPtr, cfgPtr);
-	if (ret)
-		goto fail;
-
-	disks = raidPtr->Disks;
-
-	/* assume the parity will be fine.. */
-	parity_good = RF_RAID_CLEAN;
-
-	/* Check for mod_counters that are too low */
-	mod_counter_found = 0;
-	mod_counter = 0;
-	ac = auto_config;
-	while(ac!=NULL) {
-		if (mod_counter_found==0) {
-			mod_counter = ac->clabel->mod_counter;
-			mod_counter_found = 1;
-		} else {
-			if (ac->clabel->mod_counter > mod_counter) {
-				mod_counter = ac->clabel->mod_counter;
-			}
-		}
-		ac->flag = 0; /* clear the general purpose flag */
-		ac = ac->next;
-	}
-
-	bs = 0;
-	for (r = 0; r < raidPtr->numRow; r++) {
-		numFailuresThisRow = 0;
-		for (c = 0; c < raidPtr->numCol; c++) {
-			diskPtr = &disks[r][c];
-
-			/* find this row/col in the autoconfig */
-			rf_printf(1, "Looking for %d,%d in autoconfig\n",r,c);
-			ac = auto_config;
-			while(ac!=NULL) {
-				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. */
-					ac->flag = 1;
-					rf_printf(1, "Found: %s at %d,%d\n",
-					    ac->devname, r, c);
-					break;
-				}
-				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) 
-				*/
-
-				ac = auto_config;
-				while(ac!=NULL) {
-					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. */
-						ac->flag = 1;
-						rf_printf(1, "Found(low mod_counter): %s at %d,%d\n",
-						       ac->devname,r,c);
-						
-						break;
-					}
-					ac=ac->next;
-				}
-			}
-
-
-
-			if (ac!=NULL) {
-				/* Found it.  Configure it.. */
-				diskPtr->blockSize = ac->clabel->blockSize;
-				diskPtr->numBlocks = ac->clabel->numBlocks;
-				/* 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 :) */
-				diskPtr->auto_configured = 1;
-				diskPtr->dev = ac->dev;
-			
-				/* 
-				 * 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;
-
-				/* 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.  */
-					disks[r][c].status = rf_ds_failed;
-					numFailuresThisRow++;
-				} else {
-					if (ac->clabel->clean != 
-					    RF_RAID_CLEAN) {
-						parity_good = RF_RAID_DIRTY;
-					}
-				}
-			} else {
-				/* 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);
-				numFailuresThisRow++;
-			}
-		}
-		/* 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 */
-
-	ac = auto_config;
-	while(ac!=NULL) {
-		if (ac->flag == 0) {
-#if defined(__NetBSD__)
-			vn_lock(ac->vp, LK_EXCLUSIVE | LK_RETRY);
-#elif defined(__FreeBSD__)
-			vn_lock(ac->vp, LK_EXCLUSIVE | LK_RETRY,
-				raidPtr->engine_thread);
-#endif
-			VOP_CLOSE(ac->vp, FREAD | FWRITE, NOCRED, 0);
-			vput(ac->vp);
-			ac->vp = NULL;
-			rf_printf(1, "Released %s from auto-config set.\n",
-			       ac->devname);
-		}
-		ac = ac->next;
-	}
-
-	raidPtr->mod_counter = mod_counter;
-
-	/* note the state of the parity, if any */
-	raidPtr->parity_good = parity_good;
-	raidPtr->sectorsPerDisk = min_numblks;
-	raidPtr->logBytesPerSector = ffs(bs) - 1;
-	raidPtr->bytesPerSector = bs;
-	raidPtr->sectorMask = bs - 1;
-	return (0);
-
-fail:
-	
-	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;
-{
-	char   *p;
-	int     retcode;
-
-	int     error;
-
-	retcode = 0;
-	p = rf_find_non_white(buf);
-	if (p[strlen(p) - 1] == '\n') {
-		/* strip off the newline */
-		p[strlen(p) - 1] = '\0';
-	}
-	(void) strcpy(diskPtr->devname, p);
-
-	/* Let's start by claiming the component is fine and well... */
-	diskPtr->status = rf_ds_optimal;
-
-	raidPtr->raid_cinfo[row][col].ci_vp = NULL;
-	raidPtr->raid_cinfo[row][col].ci_dev = NULL;
-
-	error = raid_getcomponentsize(raidPtr, row, col);
-	if (error) {
-		printf("raidlookup on device: %s failed!\n", diskPtr->devname);
-		if (error == ENXIO) {
-			/* the component isn't there... must be dead :-( */
-			diskPtr->status = rf_ds_failed;
-			return (error);
-		}
-	}
-	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;
-{
-
-	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);
-	printf("         Version: %d Serial Number: %d Mod Counter: %d\n",
-	       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 );
-}
-
-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 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);
-		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);
-	}
-	
-	if (row != ci_label->row) {
-		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);
-		fatal_error = 1;
-	}
-	if (raidPtr->numRow != ci_label->num_rows) {
-		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);
-		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);
-	}
-	return(fatal_error);
-}
-
-
-/* 
-
-   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 r,c;
-	char *dev_name;
-	RF_ComponentLabel_t *ci_label;
-	int serial_number = 0;
-	int mod_number = 0;
-	int fatal_error = 0;
-	int mod_values[4];
-	int mod_count[4];
-	int ser_values[4];
-	int ser_count[4];
-	int num_ser;
-	int num_mod;
-	int i;
-	int found;
-	int hosed_row;
-	int hosed_column;
-	int too_fatal;
-	int parity_good;
-	int force;
-
-	hosed_row = -1;
-	hosed_column = -1;
-	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".
-
-	 */
-
-	num_ser = 0;
-	num_mod = 0;
-	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++) {
-				if (ser_values[i] == ci_label->serial_number) {
-					ser_count[i]++;
-					found=1;
-					break;
-				}
-			}
-			if (!found) {
-				ser_values[num_ser] = ci_label->serial_number;
-				ser_count[num_ser] = 1;
-				num_ser++;
-				if (num_ser>2) {
-					fatal_error = 1;
-					break;
-				}
-			}
-			found=0;
-			for(i=0;i<num_mod;i++) {
-				if (mod_values[i] == ci_label->mod_counter) {
-					mod_count[i]++;
-					found=1;
-					break;
-				}
-			}
-			if (!found) {
-			        mod_values[num_mod] = ci_label->mod_counter;
-				mod_count[num_mod] = 1;
-				num_mod++;
-				if (num_mod>2) {
-					fatal_error = 1;
-					break;
-				}
-			}
-		}
-	}
-	rf_printf(1, "raid%d: Summary of serial numbers:\n", raidPtr->raidid);
-	for(i=0;i<num_ser;i++) {
-		rf_printf(1, "%d %d\n", ser_values[i], ser_count[i]);
-	}
-	rf_printf(1, "raid%d: Summary of mod counters:\n", raidPtr->raidid);
-	for(i=0;i<num_mod;i++) {
-		rf_printf(1, "%d %d\n", mod_values[i], mod_count[i]);
-	}
-	serial_number = ser_values[0];
-	if (num_ser == 2) {
-		if ((ser_count[0] == 1) || (ser_count[1] == 1)) {
-			/* 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->serial_number) {
-						hosed_row = r;
-						hosed_column = c;
-						break;
-					}
-				}
-			}
-			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 */
-				raidPtr->Disks[hosed_row][hosed_column].status
-					= rf_ds_failed;
-				raidPtr->numFailures++;
-				raidPtr->status[hosed_row] = rf_rs_degraded;
-			}
-		} else {
-			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 */
-			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 */
-	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 */
-			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 */
-				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 (c = 0; c < raidPtr->numCol; c++) {
-					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.  */
-						} else {
-							hosed_row = r;
-							hosed_column = c;
-							if (num_ser != 1) {
-								too_fatal = 1;
-								break;
-							}
-						}
-					}
-				}
-			}
-			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;
-					raidPtr->numFailures++;
-					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 */
-			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... */
-		hosed_row = -1;
-		hosed_column = -1;
-	}
-
-	if (num_ser > 2) {
-		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);
-	}
-
-	/* 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++) {
-		for (c = 0; c < raidPtr->numCol; c++) {
-			dev_name = &cfgPtr->devnames[r][c][0];
-			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 )) {
-					fatal_error = 1;
-				}
-				if (ci_label->clean != RF_RAID_CLEAN) {
-					parity_good = RF_RAID_DIRTY;
-				}
-			}
-		}
-	}
-	if (fatal_error) {
-		parity_good = RF_RAID_DIRTY;
-	}
-
-	/* we note the state of the parity */
-	raidPtr->parity_good = parity_good;
-
-	return(fatal_error);	
-}
-
-int
-rf_add_hot_spare(raidPtr, sparePtr)
-	RF_Raid_t *raidPtr;
-	RF_SingleComponent_t *sparePtr;
-{
-	RF_RaidDisk_t *disks;
-	RF_DiskQueue_t *spareQueues;
-	int ret;
-	unsigned int bs;
-	int spare_number;
-
-#if 0
-	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);
-		return(EINVAL);
-	}
-
-	RF_LOCK_MUTEX(raidPtr->mutex);
-
-	/* 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);
-
-	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;
-		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);
-	}
-	
-
-	/* 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);
-		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);
-		ret = EINVAL;
-		goto fail;
-	} else {
-		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);
-			
-			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);
-				 
-
-	raidPtr->numSpare++;
-	RF_UNLOCK_MUTEX(raidPtr->mutex);
-	return (0);
-
-fail:
-	RF_UNLOCK_MUTEX(raidPtr->mutex);
-	return(ret);
-}
-
-int
-rf_remove_hot_spare(raidPtr,sparePtr)
-	RF_Raid_t *raidPtr;
-	RF_SingleComponent_t *sparePtr;
-{
-	int spare_number;
-
-
-	if (raidPtr->numSpare==0) {
-		printf("No spares to remove!\n");
-		return(EINVAL);
-	}
-
-	spare_number = sparePtr->column;
-
-	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... */
-
-
-
-
-	/* it's gone.. */
-
-	raidPtr->numSpare--;
-
-	return(0);
-#endif
-}
-
-
-int
-rf_delete_component(raidPtr,component)
-	RF_Raid_t *raidPtr;
-	RF_SingleComponent_t *component;
-{
-	RF_RaidDisk_t *disks;
-
-	if ((component->row < 0) || 
-	    (component->row >= raidPtr->numRow) ||
-	    (component->column < 0) || 
-	    (component->column >= raidPtr->numCol)) {
-		return(EINVAL);
-	}
-
-	disks = &raidPtr->Disks[component->row][component->column];
-
-	/* 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;
-{
-
-	/* 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
deleted file mode 100644
index b57c4f8..0000000
--- a/sys/dev/raidframe/rf_disks.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_disks.h,v 1.8 2000/03/27 03:25:17 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_disks.h -- header file for code related to physical disks
- */
-
-#ifndef _RF__RF_DISKS_H_
-#define _RF__RF_DISKS_H_
-
-#include <sys/types.h>
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_bsd.h>
-
-/*
- * A physical disk can be in one of several states:
- * 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 */
-};
-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;
-};
-/*
- * 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
- * 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))
-
-#ifdef _KERNEL
-#include <dev/raidframe/rf_bsd.h>
-
-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 */
-#endif				/* !_RF__RF_DISKS_H_ */
diff --git a/sys/dev/raidframe/rf_driver.c b/sys/dev/raidframe/rf_driver.c
deleted file mode 100644
index 9534132..0000000
--- a/sys/dev/raidframe/rf_driver.c
+++ /dev/null
@@ -1,1050 +0,0 @@
-/*	$NetBSD: rf_driver.c,v 1.39 2000/12/15 02:12:58 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*-
- * Copyright (c) 1999 The NetBSD Foundation, Inc.
- * All rights reserved.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Greg Oster
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    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.
- * 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * 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
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/******************************************************************************
- *
- * rf_driver.c -- main setup, teardown, and access routines for the RAID driver
- *
- * all routines are prefixed with rf_ (raidframe), to avoid conficts.
- *
- ******************************************************************************/
-
-
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/systm.h>
-#if defined(__NetBSD__)
-#include <sys/ioctl.h>
-#elif defined(__FreeBSD__)
-#include <sys/ioccom.h>
-#include <sys/filio.h>
-#endif
-#include <sys/fcntl.h>
-#include <sys/vnode.h>
-
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_threadstuff.h>
-
-#include <sys/errno.h>
-
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_aselect.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_parityscan.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_states.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_decluster.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_revent.h>
-#include <dev/raidframe/rf_callback.h>
-#include <dev/raidframe/rf_engine.h>
-#include <dev/raidframe/rf_memchunk.h>
-#include <dev/raidframe/rf_mcpair.h>
-#include <dev/raidframe/rf_nwayxor.h>
-#include <dev/raidframe/rf_debugprint.h>
-#include <dev/raidframe/rf_copyback.h>
-#include <dev/raidframe/rf_driver.h>
-#include <dev/raidframe/rf_options.h>
-#include <dev/raidframe/rf_shutdown.h>
-#include <dev/raidframe/rf_kintf.h>
-
-#if defined(__FreeBSD__) && __FreeBSD_version > 500005
-#include <sys/bio.h>
-#endif
-
-#include <sys/buf.h>
-
-/* 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
-
-/* debug variables */
-char    rf_panicbuf[2048];	/* a buffer to hold an error msg when we panic */
-
-/* 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_) \
-	RF_LTSLEEP(&((_raid_)->accesses_suspended), PRIBIO, \
-		"raidframe quiesce", 0, &((_raid_)->access_suspend_mutex))
-
-#if defined(__FreeBSD__) && __FreeBSD_version > 500005
-#define IO_BUF_ERR(bp, err) { \
-	bp->bio_flags |= BIO_ERROR; \
-	bp->bio_resid = bp->bio_bcount; \
-	bp->bio_error = err; \
-	biodone(bp); \
-};
-#else
-#define IO_BUF_ERR(bp, err) { \
-	bp->b_flags |= B_ERROR; \
-	bp->b_resid = bp->b_bcount; \
-	bp->b_error = err; \
-	biodone(bp); \
-}
-#endif
-
-static int configureCount = 0;	/* number of active configurations */
-static int configInProgress = 0; /* configuration is in progress and code
-				  * needs to be serialized. */
-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 */
-
-/* called at system boot time */
-int     
-rf_BootRaidframe()
-{
-	int     rc;
-
-	if (raidframe_booted)
-		return (EBUSY);
-	raidframe_booted = 1;
-
-	rc = rf_mutex_init(&configureMutex, __FUNCTION__);
-	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
-		RF_PANIC();
-	}
-	configureCount = 0;
-	isconfigged = 0;
-	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
- * be kept around. This is used with systems like "sentinel" to detect
- * memory leaks.
- */
-int 
-rf_UnbootRaidframe()
-{
-	int     rc;
-
-	RF_LOCK_MUTEX(configureMutex);
-	if (configureCount) {
-		RF_UNLOCK_MUTEX(configureMutex);
-		return (EBUSY);
-	}
-	raidframe_booted = 0;
-	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_PANIC();
-	}
-	return (0);
-}
-/*
- * Called whenever an array is shutdown
- */
-static void 
-rf_UnconfigureArray()
-{
-	int     rc;
-
-	RF_LOCK_MUTEX(configureMutex);
-	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);
-		}
-
-		/*
-	         * 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;
-{
-
-	if (!raidPtr->valid) {
-		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.
-         */
-	RF_FREELIST_DO_LOCK(rf_rad_freelist);
-	if (raidPtr->waitShutdown) {
-		RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
-		return (EBUSY);
-	}
-	raidPtr->waitShutdown = 1;
-	while (raidPtr->nAccOutstanding) {
-		RF_WAIT_COND(raidPtr->outstandingCond, RF_FREELIST_MUTEX_OF(rf_rad_freelist));
-	}
-	RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
-
-	/* Wait for any parity re-writes to stop... */
-	while (raidPtr->parity_rewrite_in_progress) {
-		printf("Waiting for parity re-write to exit...\n");
-		tsleep(&raidPtr->parity_rewrite_in_progress, PRIBIO,
-		       "rfprwshutdown", 0);
-	}
-
-	raidPtr->valid = 0;
-
-	rf_update_component_labels(raidPtr, RF_FINAL_COMPONENT_UPDATE);
-
-	rf_UnconfigureVnodes(raidPtr);
-
-	rf_ShutdownList(&raidPtr->shutdownList);
-
-	rf_UnconfigureArray();
-
-	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); \
-		RF_LOCK_MUTEX(configureMutex); \
-		configInProgress = 0; \
-		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); \
-	} \
-}
-
-int 
-rf_Configure(raidPtr, cfgPtr, ac)
-	RF_Raid_t *raidPtr;
-	RF_Config_t *cfgPtr;
-	RF_AutoConfig_t *ac;
-{
-	RF_RowCol_t row, col;
-	int     i, rc;
-
-	/* 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");
-		return (EINVAL);
-	}
-	RF_LOCK_MUTEX(configureMutex);
-	if (configInProgress == 1) {
-		RF_UNLOCK_MUTEX(configureMutex);
-		return (EBUSY);
-	}
-	configureCount++;
-	if (isconfigged == 0) {
-		configInProgress = 1;
-		RF_UNLOCK_MUTEX(configureMutex);
-		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_ShutdownList(&globalShutdown);
-			return (rc);
-		}
-		/* initialize globals */
-		printf("RAIDFRAME: protectedSectors is %ld\n", 
-		       rf_protectedSectors);
-
-		rf_clear_debug_print_buffer();
-
-		DO_INIT_CONFIGURE(rf_ConfigureAllocList);
-
-		/*
-	         * 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);
-		DO_INIT_CONFIGURE(rf_ConfigureAccessTrace);
-		DO_INIT_CONFIGURE(rf_ConfigureMapModule);
-		DO_INIT_CONFIGURE(rf_ConfigureReconEvent);
-		DO_INIT_CONFIGURE(rf_ConfigureCallback);
-		DO_INIT_CONFIGURE(rf_ConfigureMemChunk);
-		DO_INIT_CONFIGURE(rf_ConfigureRDFreeList);
-		DO_INIT_CONFIGURE(rf_ConfigureNWayXor);
-		DO_INIT_CONFIGURE(rf_ConfigureStripeLockFreeList);
-		DO_INIT_CONFIGURE(rf_ConfigureMCPair);
-		DO_INIT_CONFIGURE(rf_ConfigureDAGs);
-		DO_INIT_CONFIGURE(rf_ConfigureDAGFuncs);
-		DO_INIT_CONFIGURE(rf_ConfigureDebugPrint);
-		DO_INIT_CONFIGURE(rf_ConfigureReconstruction);
-		DO_INIT_CONFIGURE(rf_ConfigureCopyback);
-		DO_INIT_CONFIGURE(rf_ConfigureDiskQueueSystem);
-
-		RF_LOCK_MUTEX(configureMutex);
-		isconfigged = 1;
-		configInProgress = 0;
-	}
-	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 */
-
-	rf_MakeAllocList(raidPtr->cleanupList);
-	if (raidPtr->cleanupList == NULL) {
-		DO_RAID_FAIL();
-		return (ENOMEM);
-	}
-	rc = rf_ShutdownCreate(&raidPtr->shutdownList,
-	    (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);
-		DO_RAID_FAIL();
-		return (rc);
-	}
-	raidPtr->numRow = cfgPtr->numRow;
-	raidPtr->numCol = cfgPtr->numCol;
-	raidPtr->numSpare = cfgPtr->numSpare;
-
-	/* 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);
-	if (raidPtr->status == NULL) {
-		DO_RAID_FAIL();
-		return (ENOMEM);
-	}
-	RF_CallocAndAdd(raidPtr->reconControl, raidPtr->numRow,
-	    sizeof(RF_ReconCtrl_t *), (RF_ReconCtrl_t **), raidPtr->cleanupList);
-	if (raidPtr->reconControl == NULL) {
-		DO_RAID_FAIL();
-		return (ENOMEM);
-	}
-	for (i = 0; i < raidPtr->numRow; i++) {
-		raidPtr->status[i] = rf_rs_optimal;
-		raidPtr->reconControl[i] = NULL;
-	}
-
-	DO_RAID_INIT_CONFIGURE(rf_ConfigureEngine);
-	DO_RAID_INIT_CONFIGURE(rf_ConfigureStripeLocks);
-
-	DO_RAID_COND(&raidPtr->outstandingCond);
-
-	raidPtr->nAccOutstanding = 0;
-	raidPtr->waitShutdown = 0;
-
-	DO_RAID_MUTEX(&raidPtr->access_suspend_mutex);
-	DO_RAID_COND(&raidPtr->quiescent_cond);
-
-	DO_RAID_COND(&raidPtr->waitForReconCond);
-
-	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 */
-		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_RAID_INIT_CONFIGURE(rf_ConfigureDiskQueues);
-
-	DO_RAID_INIT_CONFIGURE(rf_ConfigureLayout);
-
-	DO_RAID_INIT_CONFIGURE(rf_ConfigurePSStatus);
-
-	for (row = 0; row < raidPtr->numRow; row++) {
-		for (col = 0; col < raidPtr->numCol; col++) {
-			/*
-		         * XXX better distribution
-		         */
-			raidPtr->hist_diskreq[row][col] = 0;
-		}
-	}
-
-	raidPtr->numNewFailures = 0;
-	raidPtr->copyback_in_progress = 0;
-	raidPtr->parity_rewrite_in_progress = 0;
-	raidPtr->recon_in_progress = 0;
-	raidPtr->maxOutstanding = cfgPtr->maxOutstandingDiskReqs;
-
-	/* 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;
-	raidPtr->config_order = 0;
-
-	if (rf_keepAccTotals) {
-		raidPtr->keep_acc_totals = 1;
-	}
-	rf_StartUserStats(raidPtr);
-
-	raidPtr->valid = 1;
-	return (0);
-}
-
-static int 
-init_rad(desc)
-	RF_RaidAccessDesc_t *desc;
-{
-	int     rc;
-
-	rc = rf_mutex_init(&desc->mutex, __FUNCTION__);
-	if (rc) {
-		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__,
-		    __LINE__, rc);
-		rf_mutex_destroy(&desc->mutex);
-		return (rc);
-	}
-	return (0);
-}
-
-static void 
-clean_rad(desc)
-	RF_RaidAccessDesc_t *desc;
-{
-	rf_mutex_destroy(&desc->mutex);
-	rf_cond_destroy(&desc->cond);
-}
-
-static void 
-rf_ShutdownRDFreeList(ignored)
-	void   *ignored;
-{
-	RF_FREELIST_DESTROY_CLEAN(rf_rad_freelist, next, (RF_RaidAccessDesc_t *), clean_rad);
-}
-
-static int 
-rf_ConfigureRDFreeList(listp)
-	RF_ShutdownList_t **listp;
-{
-	int     rc;
-
-	RF_FREELIST_CREATE(rf_rad_freelist, RF_MAX_FREE_RAD,
-	    RF_RAD_INC, sizeof(RF_RaidAccessDesc_t));
-	if (rf_rad_freelist == NULL) {
-		return (ENOMEM);
-	}
-	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__,
-		    __LINE__, rc);
-		rf_ShutdownRDFreeList(NULL);
-		return (rc);
-	}
-	RF_FREELIST_PRIME_INIT(rf_rad_freelist, RF_RAD_INITIAL, next,
-	    (RF_RaidAccessDesc_t *), 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) (RF_Buf_t),
-    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);
-	if (raidPtr->waitShutdown) {
-		/*
-	         * 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);
-		return (NULL);
-	}
-	raidPtr->nAccOutstanding++;
-	RF_FREELIST_DO_UNLOCK(rf_rad_freelist);
-
-	desc->raidPtr = (void *) raidPtr;
-	desc->type = type;
-	desc->raidAddress = raidAddress;
-	desc->numBlocks = numBlocks;
-	desc->bufPtr = bufPtr;
-	desc->bp = bp;
-	desc->paramDAG = paramDAG;
-	desc->paramASM = paramASM;
-	desc->flags = flags;
-	desc->states = states;
-	desc->state = 0;
-
-	desc->status = 0;
-	bzero((char *) &desc->tracerec, sizeof(RF_AccTraceEntry_t));
-	desc->callbackFunc = (void (*) (RF_CBParam_t)) cbF;	/* XXX */
-	desc->callbackArg = cbA;
-	desc->next = NULL;
-	desc->head = desc;
-	desc->numPending = 0;
-	desc->cleanupList = NULL;
-	rf_MakeAllocList(desc->cleanupList);
-	return (desc);
-}
-
-void 
-rf_FreeRaidAccDesc(RF_RaidAccessDesc_t * desc)
-{
-	RF_Raid_t *raidPtr = desc->raidPtr;
-
-	RF_ASSERT(desc);
-
-	rf_FreeAllocList(desc->cleanupList);
-	RF_FREELIST_FREE_CLEAN_NOUNLOCK(rf_rad_freelist, desc, next, 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
- * when either the DAG library is incomplete or there are too many
- * failures in a parity group.
- ********************************************************************/
-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) (RF_Buf_t),
-    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_RaidAccessDesc_t *desc;
-	caddr_t lbufPtr = bufPtr;
-	RF_Buf_t bp = (RF_Buf_t) bp_in;
-
-	raidAddress += rf_raidSectorOffset;
-
-	if (!raidPtr->valid) {
-		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,
-		    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,
-		    (type == RF_IO_TYPE_READ) ? "READ" : "WRITE", (int) raidAddress,
-		    (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress),
-		    (int) rf_RaidAddressToStripeID(&raidPtr->Layout, raidAddress + numBlocks - 1),
-		    (int) numBlocks,
-		    (int) rf_RaidAddressToByte(raidPtr, numBlocks),
-		    (long) bufPtr);
-	}
-	if (raidAddress + numBlocks > raidPtr->totalSectors) {
-
-		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);
-		return (ENOSPC);
-	}
-	desc = rf_AllocRaidAccDesc(raidPtr, type, raidAddress,
-	    numBlocks, lbufPtr, bp, paramDAG, paramASM,
-	    flags, cbF, cbA, raidPtr->Layout.map->states);
-
-	if (desc == NULL) {
-		return (ENOMEM);
-	}
-	RF_ETIMER_START(desc->tracerec.tot_timer);
-
-	desc->async_flag = async_flag;
-
-	rf_ContinueRaidAccess(desc);
-
-	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;
-{
-	if (!(raidPtr->Layout.map->flags & RF_DISTRIBUTE_SPARE)) {
-		printf("Can't set reconfigured mode in dedicated-spare array\n");
-		RF_PANIC();
-	}
-	RF_LOCK_MUTEX(raidPtr->mutex);
-	raidPtr->numFailures++;
-	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. */
-	if (raidPtr->Layout.map->flags & RF_BD_DECLUSTERED)
-		rf_InstallSpareTable(raidPtr, row, col);
-	RF_UNLOCK_MUTEX(raidPtr->mutex);
-	return (0);
-}
-
-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)
-{
-	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;
-	raidPtr->status[frow] = rf_rs_degraded;
-	rf_update_component_labels(raidPtr, RF_NORMAL_COMPONENT_UPDATE);
-	RF_UNLOCK_MUTEX(raidPtr->mutex);
-	if (initRecon)
-		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
- */
-void 
-rf_SignalQuiescenceLock(raidPtr, reconDesc)
-	RF_Raid_t *raidPtr;
-	RF_RaidReconDesc_t *reconDesc;
-{
-	if (rf_quiesceDebug) {
-		printf("raid%d: Signalling quiescence lock\n", 
-		       raidPtr->raidid);
-	}
-	raidPtr->access_suspend_release = 1;
-
-	if (raidPtr->waiting_for_quiescence) {
-		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;
-{
-	if (rf_quiesceDebug)
-		printf("Suspending new reqs\n");
-
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
-	raidPtr->accesses_suspended++;
-	raidPtr->waiting_for_quiescence = (raidPtr->accs_in_flight == 0) ? 0 : 1;
-
-	if (raidPtr->waiting_for_quiescence) {
-		raidPtr->access_suspend_release = 0;
-		while (!raidPtr->access_suspend_release) {
-			printf("Suspending: Waiting for Quiescence\n");
-			WAIT_FOR_QUIESCENCE(raidPtr);
-			raidPtr->waiting_for_quiescence = 0;
-		}
-	}
-	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;
-{
-	RF_CallbackDesc_t *t, *cb;
-
-	if (rf_quiesceDebug)
-		printf("Resuming new reqs\n");
-
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
-	raidPtr->accesses_suspended--;
-	if (raidPtr->accesses_suspended == 0)
-		cb = raidPtr->quiesce_wait_list;
-	else
-		cb = NULL;
-	raidPtr->quiesce_wait_list = NULL;
-	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
-
-	while (cb) {
-		t = cb;
-		cb = cb->next;
-		(t->callbackFunc) (t->callbackArg);
-		rf_FreeCallbackDesc(t);
-	}
-}
-/*****************************************************************************************
- *
- * debug routines
- *
- ****************************************************************************************/
-
-static void 
-set_debug_option(name, val)
-	char   *name;
-	long    val;
-{
-	RF_DebugName_t *p;
-
-	for (p = rf_debugNames; p->name; p++) {
-		if (!strcmp(p->name, name)) {
-			*(p->ptr) = val;
-			printf("[Set debug variable %s to %ld]\n", name, val);
-			return;
-		}
-	}
-	RF_ERRORMSG1("Unknown debug string \"%s\"\n", name);
-}
-
-
-/* would like to use sscanf here, but apparently not available in kernel */
-/*ARGSUSED*/
-static void 
-rf_ConfigureDebug(cfgPtr)
-	RF_Config_t *cfgPtr;
-{
-	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 */
-		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);
-	}
-}
-/* performance monitoring stuff */
-
-#define TIMEVAL_TO_US(t) (((long) t.tv_sec) * 1000000L + (long) t.tv_usec)
-
-#if !defined(_KERNEL) && !defined(SIMULATE)
-
-/*
- * 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     rc;
-
-	/* 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);
-		return (rc);
-	}
-	raidPtr->throughputstats.sum_io_us = 0;
-	raidPtr->throughputstats.num_ios = 0;
-	raidPtr->throughputstats.num_out_ios = 0;
-	return (0);
-}
-
-void 
-rf_StartThroughputStats(RF_Raid_t * raidPtr)
-{
-	RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
-	raidPtr->throughputstats.num_ios++;
-	raidPtr->throughputstats.num_out_ios++;
-	if (raidPtr->throughputstats.num_out_ios == 1)
-		RF_GETTIME(raidPtr->throughputstats.start);
-	RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
-}
-
-static void 
-rf_StopThroughputStats(RF_Raid_t * raidPtr)
-{
-	struct timeval diff;
-
-	RF_LOCK_MUTEX(raidPtr->throughputstats.mutex);
-	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);
-		raidPtr->throughputstats.sum_io_us += TIMEVAL_TO_US(diff);
-	}
-	RF_UNLOCK_MUTEX(raidPtr->throughputstats.mutex);
-}
-
-static 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));
-	}
-}
-#endif				/* !KERNEL && !SIMULATE */
-
-void 
-rf_StartUserStats(RF_Raid_t * raidPtr)
-{
-	RF_GETTIME(raidPtr->userstats.start);
-	raidPtr->userstats.sum_io_us = 0;
-	raidPtr->userstats.num_ios = 0;
-	raidPtr->userstats.num_sect_moved = 0;
-}
-
-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 */
-{
-	raidPtr->userstats.sum_io_us += rt;
-	raidPtr->userstats.num_ios++;
-	raidPtr->userstats.num_sect_moved += numsect;
-}
-
-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);
-	elapsed_us = TIMEVAL_TO_US(diff);
-
-	/* 2000 sectors per megabyte, 10000000 microseconds per second */
-	if (elapsed_us)
-		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 */
-	if (elapsed_us) {
-		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);
-}
-
-
-void
-rf_print_panic_message(line,file)
-	int line;
-	char *file;
-{
-	sprintf(rf_panicbuf,"raidframe error at line %d file %s",
-		line, file);
-}
-
-void
-rf_print_assert_panic_message(line,file,condition)
-	int line;
-	char *file;
-	char *condition;
-{
-	sprintf(rf_panicbuf,
-		"raidframe error at line %d file %s (failed asserting %s)\n",
-		line, file, condition);
-}
diff --git a/sys/dev/raidframe/rf_driver.h b/sys/dev/raidframe/rf_driver.h
deleted file mode 100644
index 8b156c5..0000000
--- a/sys/dev/raidframe/rf_driver.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_driver.h,v 1.4 2000/02/13 04:53:57 oster Exp $	*/
-/*
- * rf_driver.h
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_DRIVER_H_
-#define _RF__RF_DRIVER_H_
-
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_bsd.h>
-
-#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) (RF_Buf_t), 
-					 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) (RF_Buf_t), 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_ */
diff --git a/sys/dev/raidframe/rf_engine.c b/sys/dev/raidframe/rf_engine.c
deleted file mode 100644
index d49ec20..0000000
--- a/sys/dev/raidframe/rf_engine.c
+++ /dev/null
@@ -1,812 +0,0 @@
-/*	$NetBSD: rf_engine.c,v 1.10 2000/08/20 16:51:03 thorpej Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II, Mark Holland, Rachad Youssef
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/****************************************************************************
- *                                                                          *
- * 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 *
- *   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       *
- *   queue and fires them.                                                  *
- *                                                                          *
- *   NULL nodes are never fired.                                            *
- *                                                                          *
- *   Terminator nodes are never fired, but rather cause the callback        *
- *   associated with the DAG to be invoked.                                 *
- *                                                                          *
- *   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 occured before the commit node in   *
- *   the graph, backward recovery is used.  Otherwise, forward recovery is  *
- *   used.                                                                  *
- *                                                                          *
- ****************************************************************************/
-
-#include <dev/raidframe/rf_threadstuff.h>
-
-#include <sys/errno.h>
-
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_engine.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_shutdown.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_kintf.h>
-
-static void DAGExecutionThread(RF_ThreadArg_t arg);
-
-#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); \
-  } \
-}
-
-/* synchronization primitives for this file.  DO_WAIT should be enclosed in a while loop. */
-
-/*
- * XXX Is this spl-ing really necessary?
- */
-#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); \
-} while (0)
-
-#define	DO_WAIT(_r_) \
-	RF_WAIT_COND((_r_)->node_queue, (_r_)->node_queue_mutex)
-
-#define	DO_SIGNAL(_r_) \
-	RF_BROADCAST_COND((_r_)->node_queue)	/* XXX RF_SIGNAL_COND? */
-
-static void rf_ShutdownEngine(void *);
-
-static void 
-rf_ShutdownEngine(arg)
-	void   *arg;
-{
-	RF_Raid_t *raidPtr;
-
-	raidPtr = (RF_Raid_t *) arg;
-	raidPtr->shutdown_engine = 1;
-	DO_SIGNAL(raidPtr);
-}
-
-int 
-rf_ConfigureEngine(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
-{
-	int     rc;
-
-	DO_INIT(listp, raidPtr);
-
-	raidPtr->node_queue = NULL;
-	raidPtr->dags_in_flight = 0;
-
-	rc = rf_init_managed_threadgroup(listp, &raidPtr->engine_tg);
-	if (rc)
-		return (rc);
-
-	/* 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. */
-	if (rf_engineDebug) {
-		printf("raid%d: Creating engine thread\n", raidPtr->raidid);
-	}
-	if (RF_CREATE_THREAD(raidPtr->engine_thread, DAGExecutionThread, raidPtr,"raid")) {
-		RF_ERRORMSG("RAIDFRAME: Unable to create engine thread\n");
-		return (ENOMEM);
-	}
-	if (rf_engineDebug) {
-		printf("raid%d: Created engine thread\n", raidPtr->raidid);
-	}
-	RF_THREADGROUP_STARTED(&raidPtr->engine_tg);
-	/* XXX something is missing here... */
-#ifdef debug
-	printf("Skipping the WAIT_START!!\n");
-#endif
-#if 1
-	printf("Waiting for DAG engine to start\n");
-	RF_THREADGROUP_WAIT_START(&raidPtr->engine_tg);
-#endif
-	/* 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);
-	}
-	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_ShutdownEngine(NULL);
-	}
-	return (rc);
-}
-
-static int 
-BranchDone(RF_DagNode_t * node)
-{
-	int     i;
-
-	/* 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 */
-		RF_PANIC();
-		break;
-	case rf_fired:
-		/* 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 */
-				return RF_FALSE;
-		return RF_TRUE;	/* node and all succedent branches aren't in
-				 * fired state */
-		break;
-	case rf_bad:
-		/* succedents can't fire */
-		return (RF_TRUE);
-	case rf_recover:
-		/* 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 */
-		return (RF_TRUE);
-		break;
-	default:
-		/* illegal node status */
-		RF_PANIC();
-		break;
-	}
-}
-
-static int 
-NodeReady(RF_DagNode_t * node)
-{
-	int     ready;
-
-	switch (node->dagHdr->status) {
-	case rf_enable:
-	case rf_rollForward:
-		if ((node->status == rf_wait) && (node->numAntecedents == node->numAntDone))
-			ready = RF_TRUE;
-		else
-			ready = RF_FALSE;
-		break;
-	case rf_rollBackward:
-		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))
-			ready = RF_TRUE;
-		else
-			ready = RF_FALSE;
-		break;
-	default:
-		printf("Execution engine found illegal DAG status in NodeReady\n");
-		RF_PANIC();
-		break;
-	}
-
-	return (ready);
-}
-
-
-
-/* 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)
-{
-	switch (node->status) {
-	case rf_fired:
-		/* 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);
-		}
-		if (node->flags & RF_DAGNODE_FLAG_YIELD) {
-#if defined(__NetBSD__) || defined(__FreeBSD__) && 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 */
-#else
-			thread_block();
-#endif
-		}
-		(*(node->doFunc)) (node);
-		break;
-	case rf_recover:
-		/* 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);
-		}
-		if (node->flags & RF_DAGNODE_FLAG_YIELD)
-#if defined(__NetBSD__) || defined(__FreeBSD__) && 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 */
-#else
-			thread_block();
-#endif
-		(*(node->undoFunc)) (node);
-		break;
-	default:
-		RF_PANIC();
-		break;
-	}
-}
-
-
-
-/* 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)
-{
-	RF_DagStatus_t dstat;
-	RF_DagNode_t *node;
-	int     i, j;
-
-	/* 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)) {
-			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++;
-			} else {
-				RF_ASSERT(dstat == rf_rollBackward);
-				RF_ASSERT(node->status == rf_good);
-				RF_ASSERT(node->commitNode == RF_FALSE);	/* only one commit node
-										 * per graph */
-				node->status = rf_recover;
-			}
-		}
-	}
-	/* now, fire the nodes */
-	for (i = 0; i < numNodes; i++) {
-		if ((nodeList[i]->status == rf_fired) || (nodeList[i]->status == rf_recover))
-			FireNode(nodeList[i]);
-	}
-}
-
-
-/* user context:
- * Attempt to fire each node in a linked list.
- * The entire list is fired atomically.
- */
-static void 
-FireNodeList(RF_DagNode_t * nodeList)
-{
-	RF_DagNode_t *node, *next;
-	RF_DagStatus_t dstat;
-	int     j;
-
-	if (nodeList) {
-		/* 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);
-					if (node->commitNode)
-						node->dagHdr->numCommits++;
-					node->status = rf_fired;
-					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 */
-					node->status = rf_recover;
-				}
-			}
-		}
-		/* now, fire the nodes */
-		for (node = nodeList; node; node = next) {
-			next = node->next;
-			if ((node->status == rf_fired) || (node->status == rf_recover))
-				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
- *
- * 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
- * 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
- * entire function, but this is certainly overkill.
- */
-static void 
-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 */
-	RF_DagNode_t *q = NULL, *qh = NULL, *next;
-	int     j, skipNode;
-
-	raidPtr = node->dagHdr->raidPtr;
-
-	DO_LOCK(raidPtr);
-
-	/* debug - validate fire counts */
-	for (i = 0; i < node->numAntecedents; i++) {
-		a = *(node->antecedents + i);
-		RF_ASSERT(a->numSuccFired >= a->numSuccDone);
-		RF_ASSERT(a->numSuccFired <= a->numSuccedents);
-		a->numSuccDone++;
-	}
-
-	switch (node->dagHdr->status) {
-	case rf_enable:
-	case rf_rollForward:
-		for (i = 0; i < node->numSuccedents; i++) {
-			s = *(node->succedents + i);
-			RF_ASSERT(s->status == rf_wait);
-			(s->numAntDone)++;
-			if (s->numAntDone == s->numAntecedents) {
-				/* look for NIL nodes */
-				if (s->doFunc == rf_NullNodeFunc) {
-					/* don't fire NIL nodes, just process
-					 * them */
-					s->next = finishlist;
-					finishlist = s;
-				} else {
-					/* 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))
-							skipNode = RF_TRUE;
-					if (skipNode) {
-						/* this node has one or more
-						 * failed true data
-						 * 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
-							 * enqueue if we're at
-							 * intr context */
-							s->next = firelist;	/* put node on a list to
-										 * be fired after we
-										 * unlock */
-							firelist = s;
-						} else {	/* enqueue the node for
-								 * the dag exec thread
-								 * to fire */
-							RF_ASSERT(NodeReady(s));
-							if (q) {
-								q->next = s;
-								q = s;
-							} else {
-								qh = q = s;
-								qh->next = NULL;
-							}
-						}
-				}
-			}
-		}
-
-		if (q) {
-			/* xfer 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 (; skiplist; skiplist = next) {
-			next = skiplist->next;
-			skiplist->status = rf_skipped;
-			for (i = 0; i < skiplist->numAntecedents; i++) {
-				skiplist->antecedents[i]->numSuccFired++;
-			}
-			if (skiplist->commitNode) {
-				skiplist->dagHdr->numCommits++;
-			}
-			rf_FinishNode(skiplist, context);
-		}
-		for (; finishlist; finishlist = next) {
-			/* NIL nodes: no need to fire them */
-			next = finishlist->next;
-			finishlist->status = rf_good;
-			for (i = 0; i < finishlist->numAntecedents; i++) {
-				finishlist->antecedents[i]->numSuccFired++;
-			}
-			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 */
-		}
-		/* fire all nodes in firelist */
-		FireNodeList(firelist);
-		break;
-
-	case rf_rollBackward:
-		for (i = 0; i < node->numAntecedents; i++) {
-			a = *(node->antecedents + i);
-			RF_ASSERT(a->status == rf_good);
-			RF_ASSERT(a->numSuccDone <= a->numSuccedents);
-			RF_ASSERT(a->numSuccDone <= a->numSuccFired);
-
-			if (a->numSuccDone == a->numSuccFired) {
-				if (a->undoFunc == rf_NullNodeFunc) {
-					/* 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 */
-						firelist = a;
-					} else {	/* enqueue the node for
-							 * the dag exec thread
-							 * to fire */
-						RF_ASSERT(NodeReady(a));
-						if (q) {
-							q->next = a;
-							q = a;
-						} else {
-							qh = q = a;
-							qh->next = NULL;
-						}
-					}
-				}
-			}
-		}
-		if (q) {
-			/* xfer 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 */
-			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 */
-		}
-		/* fire all nodes in firelist */
-		FireNodeList(firelist);
-
-		break;
-	default:
-		printf("Engine found illegal DAG status in PropagateResults()\n");
-		RF_PANIC();
-		break;
-	}
-}
-
-
-
-/*
- * Process a fired node which has completed
- */
-static void 
-ProcessNode(
-    RF_DagNode_t * node,
-    int context)
-{
-	RF_Raid_t *raidPtr;
-
-	raidPtr = node->dagHdr->raidPtr;
-
-	switch (node->status) {
-	case rf_good:
-		/* 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 (rf_engineDebug || 1) {
-				printf("raid%d: node (%s) returned fail, rolling forward\n", raidPtr->raidid, node->name);
-			}
-		} else {
-			node->dagHdr->status = rf_rollBackward;	/* never reached commit
-								 * barrier */
-			if (rf_engineDebug || 1) {
-				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 */
-		break;
-	case rf_panic:
-		/* an undo node failed!!! */
-		printf("UNDO of a node failed!!!/n");
-		break;
-	default:
-		printf("node finished execution with an illegal status!!!\n");
-		RF_PANIC();
-		break;
-	}
-
-	/* enqueue node's succedents (antecedents if rollBackward) for
-	 * execution */
-	PropagateResults(node, 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)
-{
-	/* as far as I can tell, retcode is not used -wvcii */
-	int     retcode = RF_FALSE;
-	node->dagHdr->numNodesCompleted++;
-	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
- * 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.
- *
- * 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)
-{
-	RF_Raid_t *raidPtr;
-
-	raidPtr = dag->raidPtr;
-	if (dag->tracerec) {
-		RF_ETIMER_START(dag->tracerec->timer);
-	}
-	if (rf_engineDebug || rf_validateDAGDebug) {
-		if (rf_ValidateDAG(dag))
-			RF_PANIC();
-	}
-	if (rf_engineDebug) {
-		printf("raid%d: Entering DispatchDAG\n", raidPtr->raidid);
-	}
-	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);
-	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.
- *
- * In the kernel, this thread runs at spl0 and is not swappable.  I copied these
- * characteristics from the aio_completion_thread.
- */
-
-static void 
-DAGExecutionThread(RF_ThreadArg_t arg)
-{
-	RF_DagNode_t *nd, *local_nq, *term_nq, *fire_nq;
-	RF_Raid_t *raidPtr;
-	int     ks;
-
-	raidPtr = (RF_Raid_t *) arg;
-
-	if (rf_engineDebug) {
-		printf("raid%d: Engine thread is running\n", raidPtr->raidid);
-	}
-
-	mtx_lock(&Giant);
-
-	RF_THREADGROUP_RUNNING(&raidPtr->engine_tg);
-
-	DO_LOCK(raidPtr);
-	while (!raidPtr->shutdown_engine) {
-
-		while (raidPtr->node_queue != NULL) {
-			local_nq = raidPtr->node_queue;
-			fire_nq = NULL;
-			term_nq = NULL;
-			raidPtr->node_queue = NULL;
-			DO_UNLOCK(raidPtr);
-
-			/* first, strip out the terminal nodes */
-			while (local_nq) {
-				nd = local_nq;
-				local_nq = local_nq->next;
-				switch (nd->dagHdr->status) {
-				case rf_enable:
-				case rf_rollForward:
-					if (nd->numSuccedents == 0) {
-						/* end of the dag, add to
-						 * callback list */
-						nd->next = term_nq;
-						term_nq = nd;
-					} else {
-						/* 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 */
-						nd->next = term_nq;
-						term_nq = nd;
-					} else {
-						/* not the end, add to the
-						 * fire queue */
-						nd->next = fire_nq;
-						fire_nq = nd;
-					}
-					break;
-				default:
-					RF_PANIC();
-					break;
-				}
-			}
-
-			/* 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 */
-			}
-
-			/* fire remaining nodes */
-			FireNodeList(fire_nq);
-
-			DO_LOCK(raidPtr);
-		}
-		while (!raidPtr->shutdown_engine && raidPtr->node_queue == NULL)
-			DO_WAIT(raidPtr);
-	}
-	DO_UNLOCK(raidPtr);
-
-	RF_THREADGROUP_DONE(&raidPtr->engine_tg);
-
-	RF_THREAD_EXIT(0);
-}
diff --git a/sys/dev/raidframe/rf_engine.h b/sys/dev/raidframe/rf_engine.h
deleted file mode 100644
index c758c05..0000000
--- a/sys/dev/raidframe/rf_engine.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_engine.h,v 1.3 1999/02/05 00:06:11 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II, Mark Holland, Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/**********************************************************
- *                                                        *
- * engine.h -- header file for execution engine functions *
- *                                                        *
- **********************************************************/
-
-#ifndef _RF__RF_ENGINE_H_
-#define _RF__RF_ENGINE_H_
-
-int 
-rf_ConfigureEngine(RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr, RF_Config_t * cfgPtr);
-
-int     rf_FinishNode(RF_DagNode_t * node, int context);	/* return finished node
-								 * to engine */
-
-int     rf_DispatchDAG(RF_DagHeader_t * dag, void (*cbFunc) (void *), void *cbArg);	/* execute dag */
-
-#endif				/* !_RF__RF_ENGINE_H_ */
diff --git a/sys/dev/raidframe/rf_etimer.h b/sys/dev/raidframe/rf_etimer.h
deleted file mode 100644
index e66e01b..0000000
--- a/sys/dev/raidframe/rf_etimer.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_etimer.h,v 1.4 1999/08/13 03:26:55 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_TIMER_H_
-#define _RF__RF_TIMER_H_
-
-#include <dev/raidframe/rf_options.h>
-#include <dev/raidframe/rf_utils.h>
-
-#include <sys/time.h>
-
-struct RF_Etimer_s {
-        struct timeval st;
-        struct timeval et;
-        struct timeval diff;
-};
-
-#if defined(_KERNEL)
-#include <sys/kernel.h>
-
-#if defined(__NetBSD__)
-#define RF_ETIMER_START(_t_)                                    \
-                {                                               \
-                        int s;                                  \
-                        bzero(&(_t_), sizeof (_t_));            \
-                        s = splclock();                         \
-                        (_t_).st = mono_time;                   \
-                        splx(s);                                \
-                }
-#elif defined(__FreeBSD__)
-#define RF_ETIMER_START(_t_)                                    \
-                {                                               \
-                        int s;                                  \
-                        bzero(&(_t_), sizeof (_t_));            \
-                        s = splclock();                         \
-                        getmicrouptime(&(_t_).st);              \
-                        splx(s);                                \
-                }
-#endif
-
-#if defined(__NetBSD__)
-#define RF_ETIMER_STOP(_t_)                                     \
-                {                                               \
-                        int s;                                  \
-                        s = splclock();                         \
-                        (_t_).et = mono_time;                   \
-                        splx(s);                                \
-                }
-#elif defined(__FreeBSD__)
-#define RF_ETIMER_STOP(_t_)                                     \
-                {                                               \
-                        int s;                                  \
-                        s = splclock();                         \
-                        getmicrouptime(&(_t_).et);              \
-                        splx(s);                                \
-                }
-#endif
-
-#define RF_ETIMER_EVAL(_t_)                                     \
-        {                                                       \
-                RF_TIMEVAL_DIFF(&(_t_).st, &(_t_).et, &(_t_).diff) \
-        }
-
-#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				/* !_RF__RF_TIMER_H_ */
diff --git a/sys/dev/raidframe/rf_evenodd.c b/sys/dev/raidframe/rf_evenodd.c
deleted file mode 100644
index 334ba0b..0000000
--- a/sys/dev/raidframe/rf_evenodd.c
+++ /dev/null
@@ -1,559 +0,0 @@
-/*	$NetBSD: rf_evenodd.c,v 1.4 2000/01/07 03:40:59 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Chang-Ming Wu
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************************
- *
- * rf_evenodd.c -- implements EVENODD array architecture
- *
- ****************************************************************************************/
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_EVENODD > 0
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_evenodd.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_parityscan.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_pq.h>
-#include <dev/raidframe/rf_mcpair.h>
-#include <dev/raidframe/rf_evenodd.h>
-#include <dev/raidframe/rf_evenodd_dagfuncs.h>
-#include <dev/raidframe/rf_evenodd_dags.h>
-#include <dev/raidframe/rf_engine.h>
-#include <dev/raidframe/rf_kintf.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_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);
-	layoutPtr->layoutSpecificInfo = (void *) info;
-
-	RF_ASSERT(raidPtr->numRow == 1);
-
-	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;
-		}
-		if ((startdisk -= 2) < 0)
-			startdisk += raidPtr->numCol;
-	}
-
-	/* fill in the remaining layout parameters */
-	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
-	layoutPtr->numDataCol = raidPtr->numCol - 2;	/* ORIG:
-							 * layoutPtr->numDataCol
-							 * = 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");
-		return (EINVAL);
-	}
-#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");
-		return (EINVAL);
-	}
-#endif
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numParityCol = 2;
-	layoutPtr->dataStripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk;
-	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
-
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-
-	return (0);
-}
-
-int 
-rf_GetDefaultNumFloatingReconBuffersEvenOdd(RF_Raid_t * raidPtr)
-{
-	return (20);
-}
-
-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)
-{
-	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.
-*/
-
-
-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_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	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 +
-	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
-}
-
-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_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	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 +
-	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
-}
-
-void 
-rf_EODagSelect(
-    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;
-	unsigned npfail = asmap->numParityFailed + asmap->numQFailed;
-	unsigned ntfail = npfail + ndfail;
-
-	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");
-		 /* *infoFunc = */ *createFunc = NULL;
-		return;
-	}
-	/* 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 */
-			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;
-				else
-					*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;
-				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_100_CreateReadDAG;
-			}
-			break;
-		case 2:
-			/* *createFunc = rf_EO_200_CreateReadDAG; */
-			*createFunc = NULL;
-			break;
-		}
-		return;
-	}
-	/* a write */
-	switch (ntfail) {
-	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))) {
-
-			*createFunc = (RF_VoidFuncPtr) rf_EOCreateSmallWriteDAG;
-		} else {
-			*createFunc = (RF_VoidFuncPtr) rf_EOCreateLargeWriteDAG;
-		}
-		break;
-
-	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;
-				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;
-				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_010_CreateLargeWriteDAG;
-			}
-		} 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) {
-				if (asmap->numStripeUnitsAccessed == 1)
-					*createFunc = (RF_VoidFuncPtr) rf_EO_200_CreateWriteDAG;
-				else
-					*createFunc = NULL;	/* No direct support for
-								 * this case now, like
-								 * that in Raid-5  */
-			} 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  */
-				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_100_CreateWriteDAG;
-			}
-		}
-		break;
-
-	case 2:		/* two disk faults */
-		switch (npfail) {
-		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));
-			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  */
-				else
-					*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  */
-				else
-					*createFunc = (RF_VoidFuncPtr) rf_EO_110_CreateWriteDAG;
-			}
-			break;
-		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
-						 * support for simultaneous
-						 * access of both failed SUs */
-			break;
-		}
-		break;
-
-	default:		/* more than 2 disk faults */
-		*createFunc = NULL;
-		RF_PANIC();
-	}
-	return;
-}
-
-
-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;
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	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 */
-	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;
-	RF_ReconUnitNum_t which_ru;
-	RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr, raidAddr, &which_ru);
-	int     stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
-	RF_AccTraceEntry_t tracerec;
-	RF_MCPair_t *mcpair;
-
-	retcode = RF_PARITY_OKAY;
-
-	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 */
-	end_p = buf + bytesPerStripe;
-	RF_CallocAndAdd(redundantbuf2, 1, numbytes, (char *), alloclist);	/* use calloc to make
-										 * sure buffer is zeroed */
-
-	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);
-	asmap = asm_h->stripeMap;
-
-	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 */
-		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);
-	}
-
-	RF_ASSERT(!asmap->parityInfo->next);
-	rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->parityInfo, 0, 1);
-	RF_ASSERT(asmap->parityInfo->numSector != 0);
-	if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
-		goto out;
-	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 */
-	bzero((char *) &tracerec, sizeof(tracerec));
-	rd_dag_h->tracerec = &tracerec;
-
-	if (rf_verifyParityDebug) {
-		printf("Parity verify read dag:\n");
-		rf_PrintDAGList(rd_dag_h);
-	}
-	RF_LOCK_MUTEX(mcpair->mutex);
-	mcpair->flag = 0;
-	rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
-	    (void *) mcpair);
-	while (!mcpair->flag)
-		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");
-		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_bxor(p, pbuf, numbytes, NULL);
-	}
-	RF_ASSERT(i == layoutPtr->numDataCol);
-
-	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]);
-			}
-		}
-		redundantOneErr = 1;
-		break;
-	}
-
-	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]);
-			}
-			redundantTwoErr = 1;
-			break;
-		}
-	}
-	if (redundantOneErr || redundantTwoErr)
-		retcode = RF_PARITY_BAD;
-
-	/* 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);
-		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);
-		bzero((char *) &tracerec, sizeof(tracerec));
-		wr_dag_h->tracerec = &tracerec;
-		if (rf_verifyParityDebug) {
-			printf("Parity verify write dag:\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);
-		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");
-			parity_cant_correct = RF_TRUE;
-		} else {
-			parity_corrected = RF_TRUE;
-		}
-		rf_FreeDAG(wr_dag_h);
-	}
-	if (redundantTwoErr && correct_it) {
-		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);
-		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");
-			rf_PrintDAGList(wr_dag_h);
-		}
-		RF_LOCK_MUTEX(mcpair->mutex);
-		mcpair->flag = 0;
-		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");
-			red2_cant_correct = RF_TRUE;
-		} else {
-			red2_corrected = RF_TRUE;
-		}
-		rf_FreeDAG(wr_dag_h);
-	}
-	if ((redundantOneErr && parity_cant_correct) ||
-	    (redundantTwoErr && red2_cant_correct))
-		retcode = RF_PARITY_COULD_NOT_CORRECT;
-	if ((retcode = RF_PARITY_BAD) && parity_corrected && red2_corrected)
-		retcode = RF_PARITY_CORRECTED;
-
-
-out:
-	rf_FreeAccessStripeMap(asm_h);
-	rf_FreeAllocList(alloclist);
-	rf_FreeDAG(rd_dag_h);
-	rf_FreeMCPair(mcpair);
-	return (retcode);
-}
-#endif				/* RF_INCLUDE_EVENODD > 0 */
diff --git a/sys/dev/raidframe/rf_evenodd.h b/sys/dev/raidframe/rf_evenodd.h
deleted file mode 100644
index 4babdec..0000000
--- a/sys/dev/raidframe/rf_evenodd.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*	$FreeBSD$ */
-/*	$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.
- *
- * Author: Chang-Ming Wu
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#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);
-
-#endif				/* !_RF__RF_EVENODD_H_ */
diff --git a/sys/dev/raidframe/rf_evenodd_dagfuncs.c b/sys/dev/raidframe/rf_evenodd_dagfuncs.c
deleted file mode 100644
index 2e39a53..0000000
--- a/sys/dev/raidframe/rf_evenodd_dagfuncs.c
+++ /dev/null
@@ -1,977 +0,0 @@
-/*	$NetBSD: rf_evenodd_dagfuncs.c,v 1.7 2001/01/26 03:50:53 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: ChangMing Wu
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * Code for RAID-EVENODD  architecture.
- */
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_EVENODD > 0
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_parityscan.h>
-#include <dev/raidframe/rf_evenodd.h>
-#include <dev/raidframe/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;
-{
-	rf_RegularESubroutine(node, node->results[1]);
-	rf_RegularXorFunc(node);/* does 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;
-{
-	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;
-	RF_RowCol_t scol;
-	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_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 */
-	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);
-	}
-	/* Start to encoding 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 */
-			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);
-		}
-	/* 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);
-	}
-	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 */
-#endif
-}
-
-int 
-rf_SimpleONEFunc(node)
-	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;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	int     length;
-	RF_RowCol_t scol;
-	RF_Etimer_t timer;
-
-	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' */
-		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);
-		RF_ETIMER_STOP(timer);
-		RF_ETIMER_EVAL(timer);
-		tracerec->q_us += RF_ETIMER_VAL_US(timer);
-
-	}
-	return (rf_GenericWakeupFunc(node, retcode));	/* call wake func
-							 * explicitly since no
-							 * 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;
-{
-	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;
-	RF_RowCol_t scol;
-	char   *srcbuf, *destbuf;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	RF_Etimer_t timer;
-
-	RF_ETIMER_START(timer);
-	for (i = 0; i < node->numParams - 2; i += 2) {
-		RF_ASSERT(node->params[i + 1].p != ebuf);
-		pda = (RF_PhysDiskAddr_t *) node->params[i].p;
-		suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
-		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_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->xor_us += RF_ETIMER_VAL_US(timer);
-}
-
-
-/*******************************************************************************************
- *			 Used in  EO_001_CreateLargeWriteDAG
- ******************************************************************************************/
-int 
-rf_RegularEFunc(node)
-	RF_DagNode_t *node;
-{
-	rf_RegularESubroutine(node, node->results[0]);
-	rf_GenericWakeupFunc(node, 0);
-#if 1
-	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;
-{
-	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);
-	RF_RowCol_t scol;
-	char   *srcbuf, *destbuf;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	RF_Etimer_t timer;
-
-	RF_ETIMER_START(timer);
-	for (i = 0; i < node->numParams - 2; i += 2) {
-		RF_ASSERT(node->params[i + 1].p != ebuf);
-		pda = (RF_PhysDiskAddr_t *) node->params[i].p;
-		suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
-		scol = rf_EUCol(layoutPtr, pda->raidAddress);
-		srcbuf = (char *) node->params[i + 1].p;
-		destbuf = ebuf + rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
-		rf_e_encToBuf(raidPtr, scol, srcbuf, RF_EO_MATRIX_DIM - 2, destbuf, pda->numSector);
-	}
-
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->q_us += RF_ETIMER_VAL_US(timer);
-}
-
-
-/**************************************************************************************
- * 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;
-{
-	rf_DegrESubroutine(node, node->results[1]);
-	rf_RecoveryXorFunc(node);	/* does the wakeup here! */
-#if 1
-	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)
-{
-	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);
-	short  *destShortBuf, *srcShortBuf1, *srcShortBuf2;
-	short temp1;
-#elif RF_EO_MATRIX_DIM == 17
-	int     longsPerEU = bytesPerEU / sizeof(long);
-	long   *destLongBuf, *srcLongBuf1, *srcLongBuf2;
-	long temp1;
-#endif
-
-#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
-	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
-	srcShortBuf1 = (short *) (srcSecbuf + S_index * bytesPerEU);
-#elif RF_EO_MATRIX_DIM == 17
-	srcLongBuf1 = (long *) (srcSecbuf + S_index * bytesPerEU);
-#endif
-
-	for (indexInDest = 0; indexInDest < numRowInEncMatix; indexInDest++) {
-		indexInSrc = rf_EO_Mod((indexInDest + destLogicCol - srcLogicCol), RF_EO_MATRIX_DIM);
-
-#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! */
-			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! */
-			else
-				destShortBuf[j] = temp1;
-		}
-
-#elif RF_EO_MATRIX_DIM == 17
-		destLongBuf = (long *) (destSecbuf + indexInDest * bytesPerEU);
-		srcLongBuf2 = (long *) (srcSecbuf + indexInSrc * bytesPerEU);
-		for (j = 0; j < longsPerEU; j++) {
-			temp1 = destLongBuf[j] ^ srcLongBuf1[j];
-			if (indexInSrc != RF_EO_MATRIX_DIM - 1)
-				destLongBuf[j] = (srcLongBuf2[j]) ^ temp1;
-			else
-				destLongBuf[j] = temp1;
-		}
-#endif
-	}
-}
-
-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);
-
-	for (i = 0; i < numSector; i++) {
-		rf_e_EncOneSect(srcLogicCol, srcbuf, destLogicCol, destbuf, bytesPerSector);
-		srcbuf += bytesPerSector;
-		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;
-{
-	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
-									 * failed SU */
-	int     i;
-	RF_PhysDiskAddr_t *pda;
-	int     suoffset, failedSUOffset = rf_StripeUnitOffset(layoutPtr, failedPDA->startSector);
-	char   *srcbuf, *destbuf;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	RF_Etimer_t timer;
-
-	bzero((char *) node->results[0], rf_RaidAddressToByte(raidPtr, failedPDA->numSector));
-	if (node->dagHdr->status == rf_enable) {
-		RF_ETIMER_START(timer);
-		for (i = 0; i < node->numParams - 2; i += 2)
-			if (node->params[i + 1].p != node->results[0]) {
-				pda = (RF_PhysDiskAddr_t *) node->params[i].p;
-				if (i == node->numParams - 4)
-					scol = RF_EO_MATRIX_DIM - 2;	/* the colume of
-									 * redundant E */
-				else
-					scol = rf_EUCol(layoutPtr, pda->raidAddress);
-				srcbuf = (char *) node->params[i + 1].p;
-				suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
-				destbuf = ((char *) node->results[0]) + rf_RaidAddressToByte(raidPtr, suoffset - failedSUOffset);
-				rf_e_encToBuf(raidPtr, scol, srcbuf, fcol, destbuf, pda->numSector);
-			}
-		RF_ETIMER_STOP(timer);
-		RF_ETIMER_EVAL(timer);
-		tracerec->xor_us += RF_ETIMER_VAL_US(timer);
-	}
-	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)
-{
-	rf_DegrESubroutine(node, node->results[0]);
-	rf_GenericWakeupFunc(node, 0);
-#if 1
-	return (0);		/* XXX Yet another one!! GO */
-#endif
-}
-
-
-
-/**************************************************************************************
- *  		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)
-{
-	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;
-#if 0
-	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;
-	short *temp;
-	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;
-	long *temp;
-	long   *P;
-
-	RF_ASSERT(bytesPerEU % sizeof(long) == 0);
-	RF_Malloc(P, bytesPerEU, (long *));
-	RF_Malloc(temp, bytesPerEU, (long *));
-#endif
-	RF_ASSERT(*((long *) dest[0]) == 0);
-	RF_ASSERT(*((long *) dest[1]) == 0);
-	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++)
-		for (k = 0; k < longsPerEU; k++) {
-#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
-			ebuf_current = ((long *) ebuf) + i * longsPerEU + k;
-			pbuf_current = ((long *) pbuf) + i * longsPerEU + k;
-#endif
-			P[k] ^= *ebuf_current;
-			P[k] ^= *pbuf_current;
-		}
-	RF_ASSERT(fcol[0] != fcol[1]);
-	if (fcol[0] < fcol[1]) {
-#if RF_EO_MATRIX_DIM > 17
-		dest_smaller = (short *) (dest[0]);
-		dest_larger = (short *) (dest[1]);
-#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
-		dest_smaller = (short *) (dest[1]);
-		dest_larger = (short *) (dest[0]);
-#elif RF_EO_MATRIX_DIM == 17
-		dest_smaller = (long *) (dest[1]);
-		dest_larger = (long *) (dest[0]);
-#endif
-		f1 = fcol[1];
-		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
-		dest_larger_current = dest_larger + row * shortsPerEU;
-		dest_smaller_current = dest_smaller + row * shortsPerEU;
-#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))         */
-		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;
-				for (k = 0; k < shortsPerEU; k++)
-					temp[k] ^= *(rrdbuf_current + k);
-#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)       */
-
-		erow = rf_EO_Mod((row + f2 - ecol), (RF_EO_MATRIX_DIM));
-		if (erow != (RF_EO_MATRIX_DIM) - 1) {
-#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
-			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
-		for (k = 0; k < shortsPerEU; k++)
-			temp[k] ^= P[k];
-		/* Put the data to the destination buffer                              */
-		for (k = 0; k < shortsPerEU; k++)
-			dest_larger_current[k] = temp[k];
-#elif RF_EO_MATRIX_DIM == 17
-		for (k = 0; k < longsPerEU; k++)
-			temp[k] ^= P[k];
-		/* Put the data to 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    */
-		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;
-			for (k = 0; k < shortsPerEU; k++)
-				temp[k] ^= *(rrdbuf_current + k);
-#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
-		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
-		pbuf_current = (long *) pbuf + longsPerEU * row;
-		for (k = 0; k < longsPerEU; k++)
-			temp[k] ^= *(pbuf_current + k);
-		for (k = 0; k < longsPerEU; k++)
-			dest_smaller_current[k] = temp[k];
-#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);
-	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;
-{
-	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;
-	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);
-	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;
-	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 */
-	for (i = 0; i <= np; i++)
-		if (((RF_PhysDiskAddr_t *) node->params[i].p)->type != RF_PDA_TYPE_DATA) {
-			ndataParam = i;
-			break;
-		}
-	RF_Malloc(buf, numDataCol * sizeof(char *), (char **));
-	if (ndataParam != 0) {
-		RF_Malloc(suoff, ndataParam * sizeof(long), (long *));
-		RF_Malloc(suend, ndataParam * sizeof(long), (long *));
-		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 */
-		ppda = node->params[np - 6].p;
-		ppda2 = node->params[np - 5].p;
-		RF_ASSERT(ppda2->type == RF_PDA_TYPE_PARITY);
-		epda = node->params[np - 4].p;
-		epda2 = node->params[np - 3].p;
-		RF_ASSERT(epda2->type == RF_PDA_TYPE_Q);
-		two = 1;
-	} else {
-		ppda = node->params[np - 4].p;
-		epda = node->params[np - 3].p;
-		psuoff = rf_StripeUnitOffset(layoutPtr, ppda->startSector);
-		esuoff = rf_StripeUnitOffset(layoutPtr, epda->startSector);
-		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.
-         */
-	if (nresults == 1) {
-		/* find the startSector to begin decoding */
-		pda = node->results[0];
-		bzero(pda->bufPtr, bytesPerSector * pda->numSector);
-		fsuoff[0] = rf_StripeUnitOffset(layoutPtr, pda->startSector);
-		fsuend[0] = fsuoff[0] + pda->numSector;
-		startSector = fsuoff[0];
-		endSector = fsuend[0];
-
-		/* 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);
-		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))
-				if (i != fcol[0])
-					break;
-		}
-		RF_ASSERT(i < numDataCol);
-		fcol[1] = i;
-	} else {
-		RF_ASSERT(nresults == 2);
-		pda0 = node->results[0];
-		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. */
-		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. */
-		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 */
-		startSector = RF_MIN(pda0->startSector, pda1->startSector);
-		/* 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
-        */
-	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. */
-	for (sector = startSector; sector < endSector; sector++) {
-		if (nresults == 2)
-			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
-		 * SU. If yes, assign dest[0], dest[1] to point at suitable
-		 * position of the buffer corresponding to failed SUs. if no,
-		 * malloc a temporary space of a sector in size for
-		 * 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]  */
-			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]);
-			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]);
-			else {
-				RF_Malloc(dest[1], bytesPerSector, (char *));
-				bzero(dest[1], bytesPerSector);
-				mallc_two = 1;
-			}
-			RF_ASSERT(mallc_one == 0 || mallc_two == 0);
-		}
-		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.
-	         */
-		rf_doubleEOdecode(raidPtr, buf, dest, fcol, pbuf, ebuf);
-		/* 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)
-			RF_Free(dest[1], bytesPerSector);
-		mallc_one = mallc_two = 0;
-	}
-	RF_Free(buf, numDataCol * sizeof(char *));
-	if (ndataParam != 0) {
-		RF_Free(suoff, ndataParam * sizeof(long));
-		RF_Free(suend, ndataParam * sizeof(long));
-		RF_Free(prmToCol, ndataParam * sizeof(long));
-	}
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	if (tracerec) {
-		tracerec->q_us += RF_ETIMER_VAL_US(timer);
-	}
-	rf_GenericWakeupFunc(node, 0);
-#if 1
-	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.
- */
-
-int 
-rf_EOWriteDoubleRecoveryFunc(node)
-	RF_DagNode_t *node;
-{
-	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_SectorNum_t sector;
-	RF_RowCol_t col, scol;
-	int     prm, i, j;
-	RF_SectorCount_t secPerSU = layoutPtr->sectorsPerStripeUnit;
-	unsigned sosAddr;
-	unsigned bytesPerSector = rf_RaidAddressToByte(raidPtr, 1);
-	RF_int64 numbytes;
-	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
-				 * buffer storing data read from col0, col1,
-				 * 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
-						 * case, the other failed SU
-						 * 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  */
-	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 */
-	startSector = rf_StripeUnitOffset(layoutPtr, fpda->startSector);
-	endSector = startSector + fpda->numSector;
-	/* Assign buf[col] pointers to point to each non-failed colume  and
-	 * initialize the pbuf and ebuf to point at the beginning of each
-	 * 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 = ppda->bufPtr;
-	ebuf = epda->bufPtr;
-	/* find out the logical colume numbers in the encoding matrix of the
-	 * two failed columes */
-	fcol[0] = rf_EUCol(layoutPtr, fpda->raidAddress);
-
-	/* find out the other failed colume 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 */
-		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 */
-	numbytes = fpda->numSector * bytesPerSector;
-	RF_Malloc(olddata[0], numbytes, (char *));
-	RF_Malloc(olddata[1], numbytes, (char *));
-	dest[0] = olddata[0];
-	dest[1] = olddata[1];
-	bzero(olddata[0], numbytes);
-	bzero(olddata[1], numbytes);
-	/* Begin the recovery decoding, initially buf[j],  ebuf, pbuf, dest[j]
-	 * have already pointed at the beginning of each source buffers and
-	 * 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++)
-			if ((j != fcol[0]) && (j != fcol[1]))
-				buf[j] += bytesPerSector;
-		dest[0] += bytesPerSector;
-		dest[1] += bytesPerSector;
-		ebuf += bytesPerSector;
-		pbuf += bytesPerSector;
-	}
-	/* 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
-	 * Rrd; params[ PDAPerDisk*(numDataCol - 2), ... PDAPerDisk*numDataCol
-	 * -1 ] are Pdas of Rp, ( Rp2 ), Re, ( Re2 ) ; params[
-	 * PDAPerDisk*numDataCol, ... PDAPerDisk*numDataCol
-	 * +asmap->numStripeUnitsAccessed -asmap->numDataFailed-1] are Pdas of
-	 * wudNodes; For current implementation, we assume the simplest case:
-	 * asmap->numStripeUnitsAccessed == 1 and asmap->numDataFailed == 1
-	 * ie. PDAPerDisk = 1 then node->params[numDataCol] must be the new
-	 * data to be writen to the failed disk. We first bxor the new data
-	 * into the old recovered data, then do the same things as small
-	 * 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' */
-	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);
-
-	/* do new 'P' calculation  */
-	rf_bxor(olddata[0], ppda->bufPtr, numbytes, node->dagHdr->bp);
-	/* Free the allocated buffer  */
-	RF_Free(olddata[0], numbytes);
-	RF_Free(olddata[1], numbytes);
-	RF_Free(buf, numDataCol * sizeof(char *));
-
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	if (tracerec) {
-		tracerec->q_us += RF_ETIMER_VAL_US(timer);
-	}
-	rf_GenericWakeupFunc(node, 0);
-	return (0);
-}
-#endif				/* RF_INCLUDE_EVENODD > 0 */
diff --git a/sys/dev/raidframe/rf_evenodd_dagfuncs.h b/sys/dev/raidframe/rf_evenodd_dagfuncs.h
deleted file mode 100644
index cf5028b..0000000
--- a/sys/dev/raidframe/rf_evenodd_dagfuncs.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_evenodd_dagfuncs.h,v 1.2 1999/02/05 00:06:11 oster Exp $	*/
-/*
- * rf_evenodd_dagfuncs.h
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Chang-Ming Wu
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_EVENODD_DAGFUNCS_H_
-#define _RF__RF_EVENODD_DAGFUNCS_H_
-
-extern RF_RedFuncs_t rf_EOSmallWriteEFuncs;
-extern RF_RedFuncs_t rf_EOSmallWritePFuncs;
-extern RF_RedFuncs_t rf_eoERecoveryFuncs;
-extern RF_RedFuncs_t rf_eoPRecoveryFuncs;
-
-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);
-
-#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_OffsetOfNextEUBoundary(_offset_, sec_per_eu) ((_offset_)/(sec_per_eu) + 1)*(sec_per_eu)
-
-#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
- * for disk array larger than 17 columns totally.
- */
-
-#endif				/* !_RF__RF_EVENODD_DAGFUNCS_H_ */
diff --git a/sys/dev/raidframe/rf_evenodd_dags.c b/sys/dev/raidframe/rf_evenodd_dags.c
deleted file mode 100644
index cef32c2..0000000
--- a/sys/dev/raidframe/rf_evenodd_dags.c
+++ /dev/null
@@ -1,191 +0,0 @@
-/*	$NetBSD: rf_evenodd_dags.c,v 1.2 1999/02/05 00:06:11 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * rf_evenodd_dags.c
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Chang-Ming Wu
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_EVENODD > 0
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_evenodd_dags.h>
-#include <dev/raidframe/rf_evenodd.h>
-#include <dev/raidframe/rf_evenodd_dagfuncs.h>
-#include <dev/raidframe/rf_pq.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_dagffwr.h>
-
-
-/*
- * Lost one data.
- * Use P to reconstruct missing data.
- */
-RF_CREATE_DAG_FUNC_DECL(rf_EO_100_CreateReadDAG)
-{
-	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);
-}
-/*
- * Lost data + P.
- * Make E look like P, and use Eor for Xor, and we can
- * use degraded read DAG.
- */
-RF_CREATE_DAG_FUNC_DECL(rf_EO_110_CreateReadDAG)
-{
-	RF_PhysDiskAddr_t *temp;
-	/* 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);
-}
-/*
- * Lost two data.
- */
-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_CREATE_DAG_FUNC_DECL(rf_EO_100_CreateWriteDAG)
-{
-	if (asmap->numStripeUnitsAccessed != 1 &&
-	    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);
-}
-/*
- * 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);
-}
-/*
- * 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);
-}
-/*
- * P is dead. Small write.
- * Swap E + P, use single-degraded stuff.
- */
-RF_CREATE_DAG_FUNC_DECL(rf_EO_010_CreateSmallWriteDAG)
-{
-	RF_PhysDiskAddr_t *temp;
-	/* 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);
-}
-/*
- * P is dead. Large write.
- * Swap E + P, use single-degraded stuff.
- */
-RF_CREATE_DAG_FUNC_DECL(rf_EO_010_CreateLargeWriteDAG)
-{
-	RF_PhysDiskAddr_t *temp;
-	/* 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_CREATE_DAG_FUNC_DECL(rf_EO_011_CreateWriteDAG)
-{
-	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) {
-		RF_PANIC();
-	}
-	/* 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_CREATE_DAG_FUNC_DECL(rf_EO_101_CreateWriteDAG)
-{
-	if (asmap->numStripeUnitsAccessed != 1 &&
-	    asmap->failedPDAs[0]->numSector != raidPtr->Layout.sectorsPerStripeUnit)
-		RF_PANIC();
-	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_CREATE_DAG_FUNC_DECL(rf_EOCreateLargeWriteDAG)
-{
-	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);
-}
-#endif				/* RF_INCLUDE_EVENODD > 0 */
diff --git a/sys/dev/raidframe/rf_evenodd_dags.h b/sys/dev/raidframe/rf_evenodd_dags.h
deleted file mode 100644
index c4218a4..0000000
--- a/sys/dev/raidframe/rf_evenodd_dags.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_evenodd_dags.h,v 1.2 1999/02/05 00:06:11 oster Exp $	*/
-/*
- * rf_evenodd_dags.h
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Chang-Ming Wu
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_EVENODD_DAGS_H_
-#define _RF__RF_EVENODD_DAGS_H_
-
-#include <dev/raidframe/rf_types.h>
-
-#if RF_UTILITY == 0
-#include <dev/raidframe/rf_dag.h>
-
-/* extern decl's of the failure mode EO functions.
- * swiped from rf_pqdeg.h
- */
-
-RF_CREATE_DAG_FUNC_DECL(rf_EO_100_CreateReadDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_101_CreateReadDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_110_CreateReadDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_200_CreateReadDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EOCreateDoubleDegradedReadDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_100_CreateWriteDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_010_CreateSmallWriteDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_001_CreateSmallWriteDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_010_CreateLargeWriteDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_001_CreateLargeWriteDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_011_CreateWriteDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_110_CreateWriteDAG);
-RF_CREATE_DAG_FUNC_DECL(rf_EO_101_CreateWriteDAG);
-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__RF_EVENODD_DAGS_H_ */
diff --git a/sys/dev/raidframe/rf_fifo.c b/sys/dev/raidframe/rf_fifo.c
deleted file mode 100644
index d5ce0d0..0000000
--- a/sys/dev/raidframe/rf_fifo.c
+++ /dev/null
@@ -1,238 +0,0 @@
-/*	$NetBSD: rf_fifo.c,v 1.5 2000/03/04 03:27:13 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/***************************************************
- *
- * rf_fifo.c --  prioritized fifo queue code.
- * There are only two priority levels: hi and lo.
- *
- * Aug 4, 1994, adapted from raidSim version (MCH)
- *
- ***************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_stripelocks.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_fifo.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_options.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_types.h>
-
-/* 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;
-{
-	RF_FifoHeader_t *q;
-
-	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;
-{
-	RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
-
-	RF_ASSERT(priority == RF_IO_NORMAL_PRIORITY || priority == RF_IO_LOW_PRIORITY);
-
-	elem->next = NULL;
-	if (priority == RF_IO_NORMAL_PRIORITY) {
-		if (!q->hq_tail) {
-			RF_ASSERT(q->hq_count == 0 && q->hq_head == NULL);
-			q->hq_head = q->hq_tail = elem;
-		} else {
-			RF_ASSERT(q->hq_count != 0 && q->hq_head != NULL);
-			q->hq_tail->next = elem;
-			q->hq_tail = elem;
-		}
-		q->hq_count++;
-	} else {
-		RF_ASSERT(elem->next == NULL);
-		if (rf_fifoDebug) {
-			printf("raid%d: fifo: ENQ lopri\n", 
-			       elem->raidPtr->raidid);
-		}
-		if (!q->lq_tail) {
-			RF_ASSERT(q->lq_count == 0 && q->lq_head == NULL);
-			q->lq_head = q->lq_tail = elem;
-		} else {
-			RF_ASSERT(q->lq_count != 0 && q->lq_head != NULL);
-			q->lq_tail->next = elem;
-			q->lq_tail = elem;
-		}
-		q->lq_count++;
-	}
-	if ((q->hq_count + q->lq_count) != elem->queue->queueLength) {
-		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,
-		    (int) elem->queue->maxOutstanding,
-		    (int) elem->queue->row,
-		    (int) elem->queue->col);
-	}
-	RF_ASSERT((q->hq_count + q->lq_count) == elem->queue->queueLength);
-}
-
-RF_DiskQueueData_t *
-rf_FifoDequeue(q_in)
-	void   *q_in;
-{
-	RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
-	RF_DiskQueueData_t *nd;
-
-	RF_ASSERT(q);
-	if (q->hq_head) {
-		RF_ASSERT(q->hq_count != 0 && q->hq_tail != NULL);
-		nd = q->hq_head;
-		q->hq_head = q->hq_head->next;
-		if (!q->hq_head)
-			q->hq_tail = NULL;
-		nd->next = NULL;
-		q->hq_count--;
-	} else
-		if (q->lq_head) {
-			RF_ASSERT(q->lq_count != 0 && q->lq_tail != NULL);
-			nd = q->lq_head;
-			q->lq_head = q->lq_head->next;
-			if (!q->lq_head)
-				q->lq_tail = NULL;
-			nd->next = NULL;
-			q->lq_count--;
-			if (rf_fifoDebug) {
-				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);
-			nd = NULL;
-		}
-	return (nd);
-}
-
-/* Return ptr to item at head of queue.  Used to examine request
- * info without actually dequeueing the request.
- */
-RF_DiskQueueData_t *
-rf_FifoPeek(void *q_in)
-{
-	RF_DiskQueueData_t *headElement = NULL;
-	RF_FifoHeader_t *q = (RF_FifoHeader_t *) q_in;
-
-	RF_ASSERT(q);
-	if (q->hq_head)
-		headElement = q->hq_head;
-	else
-		if (q->lq_head)
-			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 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;
-{
-	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;
-
-	while (lp) {
-
-		/* 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); */
-			if (pt)
-				pt->next = lp->next;	/* delete an entry other
-							 * than the first */
-			else
-				q->lq_head = lp->next;	/* delete the head entry */
-
-			if (!q->lq_head)
-				q->lq_tail = NULL;	/* we deleted the only
-							 * entry */
-			else
-				if (lp == q->lq_tail)
-					q->lq_tail = pt;	/* we deleted the tail
-								 * entry */
-
-			lp->next = NULL;
-			q->lq_count--;
-
-			if (q->hq_tail) {
-				q->hq_tail->next = lp;
-				q->hq_tail = lp;
-			}
-			 /* append to hi-priority queue */ 
-			else {
-				q->hq_head = q->hq_tail = lp;
-			}
-			q->hq_count++;
-
-			/* UpdateShortestSeekFinishTimeForced(lp->requestPtr,
-			 * lp->diskState); *//* deal with this later, if ever */
-
-			lp = (pt) ? pt->next : q->lq_head;	/* reset low-pri pointer
-								 * and continue */
-			retval++;
-
-		} else {
-			pt = lp;
-			lp = lp->next;
-		}
-	}
-
-	/* 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
deleted file mode 100644
index 9392f08..0000000
--- a/sys/dev/raidframe/rf_fifo.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_fifo.h,v 1.3 1999/02/05 00:06:11 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_fifo.h --  prioritized FIFO queue code.
- *
- * 4-9-93 Created (MCH)
- */
-
-
-#ifndef _RF__RF_FIFO_H_
-#define _RF__RF_FIFO_H_
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_diskqueue.h>
-
-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_ */
diff --git a/sys/dev/raidframe/rf_freebsdkintf.c b/sys/dev/raidframe/rf_freebsdkintf.c
deleted file mode 100644
index 13f5abb..0000000
--- a/sys/dev/raidframe/rf_freebsdkintf.c
+++ /dev/null
@@ -1,3192 +0,0 @@
-/*-
- * Copyright (c) 2002 Scott Long <scottl@freebsd.org>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * $FreeBSD$
- */
-
-/*	$NetBSD: rf_netbsdkintf.c,v 1.105 2001/04/05 02:48:51 oster Exp $	*/
-/*-
- * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
- * All rights reserved.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Greg Oster; Jason R. Thorpe.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    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.
- * 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.
- *
- * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * Copyright (c) 1988 University of Utah.
- * Copyright (c) 1990, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * the Systems Programming Group of the University of Utah Computer
- * Science Department.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    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 University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * from: Utah $Hdr: cd.c 1.6 90/11/28$
- *
- *      @(#)cd.c        8.2 (Berkeley) 11/16/93
- */
-
-
-
-
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Authors: Mark Holland, Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/***********************************************************
- *
- * rf_kintf.c -- the kernel interface routines for RAIDframe
- *
- ***********************************************************/
-
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/errno.h>
-#include <sys/param.h>
-#include <sys/queue.h>
-#include <sys/stat.h>
-#include <sys/ioccom.h>
-#include <sys/filio.h>
-#include <sys/filedesc.h>
-#include <sys/fcntl.h>
-#include <sys/systm.h>
-#include <sys/namei.h>
-#include <sys/vnode.h>
-#include <sys/bio.h>
-#include <sys/buf.h>
-#include <sys/conf.h>
-#include <sys/disk.h>
-#include <sys/lock.h>
-#include <sys/reboot.h>
-#include <sys/module.h>
-#include <vm/uma.h>
-#include <geom/geom_disk.h>
-
-#include "opt_raid.h"
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_raidframe.h>
-#include <dev/raidframe/rf_copyback.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagflags.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_kintf.h>
-#include <dev/raidframe/rf_options.h>
-#include <dev/raidframe/rf_driver.h>
-#include <dev/raidframe/rf_parityscan.h>
-#include <dev/raidframe/rf_debugprint.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_configure.h>
-
-RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex)
-
-static RF_SparetWait_t *rf_sparet_wait_queue;	/* requests to install a
-						 * spare table */
-static RF_SparetWait_t *rf_sparet_resp_queue;	/* responses from
-						 * installation process */
-
-/* prototypes */
-static void KernelWakeupFunc(struct bio *);
-static void InitBP(struct bio *, struct vnode *, unsigned rw_flag, 
-		   dev_t dev, RF_SectorNum_t startSect, 
-		   RF_SectorCount_t numSect, caddr_t buf,
-		   void (*cbFunc) (struct bio *), void *cbArg, 
-		   int logBytesPerSector, struct proc * b_proc);
-static struct raid_softc *raidinit(RF_Raid_t *);
-static void rf_search_label(dev_t, struct disklabel *,
-			    RF_AutoConfig_t **) __unused;
-
-static int	raid_modevent(module_t, int, void*);
-void		raidattach(void);
-
-disk_open_t	raidopen;
-disk_close_t	raidclose;
-disk_ioctl_t	raidioctl;
-disk_strategy_t	raidstrategy;
-
-d_open_t	raidctlopen;
-d_close_t	raidctlclose;
-d_ioctl_t	raidctlioctl;
-
-static struct cdevsw raidctl_cdevsw = {
-	.d_version =	D_VERSION,
-	.d_flags =	D_NEEDGIANT,
-	.d_open =	raidctlopen,
-	.d_close =	raidctlclose,
-	.d_ioctl =	raidctlioctl,
-	.d_name =	"raidctl",
-};
-
-/*
- * Pilfered from ccd.c
- */
-
-struct raidbuf {
-	struct bio rf_buf;	/* new I/O buf.  MUST BE FIRST!!! */
-	struct bio *rf_obp;	/* ptr. to original I/O buf */
-	int     rf_flags;	/* misc. flags */
-	RF_DiskQueueData_t *req;/* the request that this was part of.. */
-};
-
-
-#define RAIDGETBUF(sc) uma_zalloc((sc)->sc_cbufpool, M_NOWAIT)
-#define	RAIDPUTBUF(sc, cbp) uma_zfree((sc)->sc_cbufpool, cbp)
-
-#define RF_MAX_ARRAYS	32
-
-/* Raid control device */
-struct raidctl_softc {
-	dev_t	sc_dev;		/* Device node */
-	int	sc_flags;	/* flags */
-	int	sc_numraid;	/* Number of configured raid devices */
-	struct raid_softc *sc_raiddevs[RF_MAX_ARRAYS];
-};
-
-struct raid_softc {
-	dev_t	sc_parent_dev;
-	int     sc_flags;	/* flags */
-	int	sc_busycount;	/* How many times are we opened? */
-	size_t  sc_size;	/* size of the raid device */
-	dev_t	sc_parent;	/* Parent device */
-	struct disk		*sc_disk;	/* generic disk device info */
- 	uma_zone_t		sc_cbufpool;	/* component buffer pool */
-	RF_Raid_t		*raidPtr;	/* Raid information struct */
-	struct bio_queue_head	bio_queue;	/* used for the device queue */
-};
-/* sc_flags */
-#define RAIDF_OPEN	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 */
-
-/* 
- * 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 
- * 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 
- * disks to participate -- 4 * 32K/disk == 128K again.
- */
-
-#ifndef RAIDOUTSTANDING
-#define RAIDOUTSTANDING   10
-#endif
-
-static void raidgetdefaultlabel(RF_Raid_t *, struct raid_softc *, struct disk*);
-static int raidlock(struct raid_softc *);
-static void raidunlock(struct raid_softc *);
-
-static void rf_markalldirty(RF_Raid_t *);
-
-static dev_t raidctl_dev;
-
-void rf_ReconThread(struct rf_recon_req *);
-/* XXX what I want is: */
-/*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 *);
-void rf_buildroothack(void *, struct raidctl_softc *);
-
-RF_AutoConfig_t *rf_find_raid_components(void);
-RF_ConfigSet_t *rf_create_auto_sets(RF_AutoConfig_t *);
-static int rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *);
-static int rf_reasonable_label(RF_ComponentLabel_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);
-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 *, struct raidctl_softc *);
-static int raidgetunit(struct raidctl_softc *, int);
-static int raidshutdown(void);
-
-void
-raidattach(void)
-{
-	struct raidctl_softc *parent_sc = NULL;
-	RF_AutoConfig_t *ac_list; /* autoconfig list */
-	RF_ConfigSet_t *config_sets;
-	int autoconfig = 0;
-
-	/* This is where all the initialization stuff gets done. */
-
-	if(rf_mutex_init(&rf_sparet_wait_mutex, __FUNCTION__)) {
-		rf_printf(0, "RAIDframe: failed to initialize mutexes\n");
-		return;
-	}
-
-	rf_sparet_wait_queue = rf_sparet_resp_queue = NULL;
-
-	if (rf_BootRaidframe() != 0) {
-		rf_printf(0, "Serious error booting RAIDframe!!\n");
-		return;
-	}
-
-	rf_printf(0, "Kernelized RAIDframe activated\n");
-	MALLOC(parent_sc, struct raidctl_softc *, sizeof(*parent_sc),
-	    M_RAIDFRAME, M_NOWAIT|M_ZERO);
-	if (parent_sc == NULL) {
-		RF_PANIC();
-		return;
-	}
-
-	parent_sc->sc_dev= make_dev(&raidctl_cdevsw, 0, UID_ROOT, GID_WHEEL,
-	    0600, "raidctl");
-	parent_sc->sc_dev->si_drv1 = parent_sc;
-	raidctl_dev = parent_sc->sc_dev;
-
-#if RAID_AUTOCONFIG
-	autoconfig = 1;
-#endif
-
-	if (autoconfig) {
-		/* 1. locate all RAID components on the system */
-
-		rf_printf(0, "Searching for raid components...\n");
-		ac_list = rf_find_raid_components();
-		if (ac_list == NULL)
-			return;
-
-		/* 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() */
-
-		/* schedule the creation of the thread to do the 
-		   "/ on RAID" stuff */
-
-		rf_buildroothack(config_sets, parent_sc);
-#if 0
-		kthread_create(rf_buildroothack,config_sets);
-
-#endif /* RAID_AUTOCONFIG */
-	}
-}
-
-void
-rf_buildroothack(arg, parent_sc)
-	void *arg;
-	struct raidctl_softc *parent_sc;
-{
-	RF_ConfigSet_t *config_sets = arg;
-	RF_ConfigSet_t *cset;
-	RF_ConfigSet_t *next_cset;
-	int retcode;
-	int raidID;
-	int rootID;
-	int num_root;
-
-	rootID = 0;
-	num_root = 0;
-	cset = config_sets;
-	while(cset != NULL ) {
-		next_cset = cset->next;
-		if (rf_have_enough_components(cset) && 
-		    cset->ac->clabel->autoconfigure==1) {
-			retcode = rf_auto_config_set(cset, &raidID, parent_sc);
-			if (!retcode) {
-				if (cset->rootable) {
-					rootID = raidID;
-					num_root++;
-				}
-			} else {
-				/* The autoconfig didn't work :( */
-				rf_printf(1, "Autoconfig failed with code %d"
-				    "for raid%d\n", retcode, raidID);
-				rf_release_all_vps(cset);
-			}
-		} else {
-			/* we're not autoconfiguring this set...  
-			   release the associated resources */
-			rf_release_all_vps(cset);
-		}
-		/* cleanup */
-		rf_cleanup_config_set(cset);
-		cset = next_cset;
-	}
-	if (boothowto & RB_ASKNAME) {
-		/* We don't auto-config... */
-	} else {
-		/* They didn't ask, and we found something bootable... */
-
-#if 0
-		if (num_root == 1) {
-			booted_device = &raidrootdev[rootID]; 
-		} else if (num_root > 1) {
-			/* we can't guess.. require the user to answer... */
-			boothowto |= RB_ASKNAME;
-		}
-#endif
-	}
-}
-
-int
-raidctlopen(dev_t dev, int flags, int fmt, struct thread *td)
-{
-	struct raidctl_softc *parent_sc;
-
-	parent_sc = dev->si_drv1;
-
-	if ((parent_sc->sc_flags & RAIDF_OPEN) != 0)
-		return (EBUSY);
-
-	parent_sc->sc_flags |= RAIDF_OPEN;
-	return (0);
-}
-
-int
-raidctlclose(dev_t dev, int flags, int fmt, struct thread *td)
-{
-	struct raidctl_softc *parent_sc;
-
-	parent_sc = dev->si_drv1;
-
-	parent_sc->sc_flags &= ~RAIDF_OPEN;
-	return (0);
-}
-
-int
-raidctlioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct thread *td)
-{
-	struct raidctl_softc *parent_sc;
-	struct raid_softc *sc;
-	RF_Config_t *u_cfg, *k_cfg;
-	RF_Raid_t *raidPtr;
-	u_char *specific_buf;
-	u_int unit;
-	int retcode = 0;
-
-	parent_sc = dev->si_drv1;
-
-	switch (cmd) {
-		/* configure the system */
-	case RAIDFRAME_CONFIGURE:
-
-		/* copy-in the configuration information */
-		/* data points to a pointer to the configuration structure */
-
-		u_cfg = *((RF_Config_t **) data);
-		RF_Malloc(k_cfg, sizeof(RF_Config_t), (RF_Config_t *));
-		if (k_cfg == NULL) {
-			return (ENOMEM);
-		}
-		retcode = copyin((caddr_t) u_cfg, (caddr_t) k_cfg,
-		    sizeof(RF_Config_t));
-		if (retcode) {
-			RF_Free(k_cfg, sizeof(RF_Config_t));
-			rf_printf(2, "raidctlioctl: retcode=%d copyin.1\n",
-				retcode);
-			return (retcode);
-		}
-		/* allocate a buffer for the layout-specific data, and copy it
-		 * in */
-		if (k_cfg->layoutSpecificSize) {
-			if (k_cfg->layoutSpecificSize > 10000) {
-				/* sanity check */
-				RF_Free(k_cfg, sizeof(RF_Config_t));
-				return (EINVAL);
-			}
-			RF_Malloc(specific_buf, k_cfg->layoutSpecificSize,
-			    (u_char *));
-			if (specific_buf == NULL) {
-				RF_Free(k_cfg, sizeof(RF_Config_t));
-				return (ENOMEM);
-			}
-			retcode = copyin(k_cfg->layoutSpecific,
-			    (caddr_t) specific_buf,
-			    k_cfg->layoutSpecificSize);
-			if (retcode) {
-				RF_Free(specific_buf, 
-					k_cfg->layoutSpecificSize);
-				RF_Free(k_cfg, sizeof(RF_Config_t));
-				rf_printf(2, "raidctlioctl: retcode=%d "
-					"copyin.2\n", retcode);
-				return (retcode);
-			}
-		} else
-			specific_buf = NULL;
-		k_cfg->layoutSpecific = specific_buf;
-
-		/* should do some kind of sanity check on the configuration.
-		 * Store the sum of all the bytes in the last byte? */
-
-		/* configure the system */
-
-		RF_Malloc(raidPtr, sizeof(*raidPtr), (RF_Raid_t *));
-		if (raidPtr == NULL) {
-			rf_printf(0, "No memory for raid device\n");
-			RF_Free(k_cfg, sizeof(RF_Config_t));
-			retcode = ENOMEM;
-		}
-		bzero((char *) raidPtr, sizeof(RF_Raid_t));
-
-		/* Request a unit number for this soon-to-be device. */
-		unit = raidgetunit(parent_sc, 0);
-		if (unit == -1) {
-			rf_printf(0, "Cannot allocate raid unit\n");
-			RF_Free(raidPtr, sizeof(*raidPtr));
-			goto out;
-		}
-		raidPtr->raidid = unit;
-
-		if ((retcode = rf_Configure(raidPtr, k_cfg, NULL)) == 0) {
-
-			/* allow this many simultaneous IO's to 
-			   this RAID device */
-			raidPtr->openings = RAIDOUTSTANDING;
-
-			parent_sc->sc_raiddevs[unit] = raidinit(raidPtr);
-			if (parent_sc->sc_raiddevs[unit] == NULL) {
-				rf_printf(0, "Could not create raid device\n");
-				RF_Free(raidPtr, sizeof(*raidPtr));
-				goto out;
-			}
-			parent_sc->sc_numraid++;
-			((struct raid_softc *)raidPtr->sc)->sc_parent_dev = dev;
-			rf_markalldirty(raidPtr);
-		} else {
-			parent_sc->sc_raiddevs[unit] = NULL;
-			RF_Free(raidPtr, sizeof(*raidPtr));
-		}
-
-out:
-		/* free the buffers.  No return code here. */
-		if (k_cfg->layoutSpecificSize) {
-			RF_Free(specific_buf, k_cfg->layoutSpecificSize);
-		}
-		RF_Free(k_cfg, sizeof(RF_Config_t));
-		break;
-
-	case RAIDFRAME_SHUTDOWN:
-
-		unit = *(u_int *)data;
-		if ((unit >= RF_MAX_ARRAYS) ||
-		    (parent_sc->sc_raiddevs[unit] == NULL))
-			return (EINVAL);
-
-		sc = parent_sc->sc_raiddevs[unit];
-		if ((retcode = raidlock(sc)) != 0)
-			return (retcode);
-
-		/*
-		 * If somebody has a partition mounted, we shouldn't
-		 * shutdown.
-		 */
-
-		if ((sc->sc_flags & RAIDF_OPEN) != 0) {
-			raidunlock(sc);
-			return (EBUSY);
-		}
-
-		rf_printf(0, "Shutting down RAIDframe engine\n");
-		retcode = rf_Shutdown(sc->raidPtr);
-		RF_THREADGROUP_WAIT_STOP(&sc->raidPtr->engine_tg);
-
-		disk_destroy(sc->sc_disk);
-		raidunlock(sc);
-
-		/* XXX Need to be able to destroy the zone */
-		uma_zdestroy(sc->sc_cbufpool);
-
-		parent_sc->sc_numraid--;
-		parent_sc->sc_raiddevs[unit] = NULL;
-
-		RF_Free(sc->raidPtr, sizeof(*raidPtr));
-		RF_Free(sc, sizeof(*sc));
-
-		break;
-
-	default:
-		retcode = ENOIOCTL;
-	}
-
-	return (retcode);
-}
-
-/* ARGSUSED */
-int
-raidopen(struct disk *dp)
-{
-	struct raid_softc *sc;
-	int     error = 0;
-
-	sc = dp->d_drv1;
-
-	if ((error = raidlock(sc)) != 0)
-		return (error);
-	dp = sc->sc_disk;
-
-	rf_printf(1, "Opening raid device %s%d\n", dp->d_name, dp->d_unit);
-
-	/* Generate overall disklabel */
-	raidgetdefaultlabel(sc->raidPtr, sc, dp);
-
-	if (sc->sc_busycount == 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.. */
-
-		rf_markalldirty( sc->raidPtr );
-		sc->sc_flags |= RAIDF_OPEN;
-	}
-
-	/* Prevent this unit from being unconfigured while open. */
-	sc->sc_busycount++;
-
-	raidunlock(sc);
-
-	return (error);
-
-
-}
-/* ARGSUSED */
-int
-raidclose(struct disk *dp)
-{
-	struct raid_softc *sc;
-	int     error = 0;
-
-	sc = dp->d_drv1;
-
-	if ((error = raidlock(sc)) != 0)
-		return (error);
-
-	sc->sc_busycount--;
-	if (sc->sc_busycount == 0) {
-		sc->sc_flags &= ~RAIDF_OPEN;
-		rf_update_component_labels(sc->raidPtr,
-		    RF_FINAL_COMPONENT_UPDATE);
-	}
-
-	raidunlock(sc);
-	return (0);
-
-}
-
-void
-raidstrategy(bp)
-	struct bio *bp;
-{
-	RF_Raid_t *raidPtr;
-	struct raid_softc *sc = bp->bio_disk->d_drv1;
-	int     s;
-
-	raidPtr = sc->raidPtr;
-	if (raidPtr == NULL) {
-		bp->bio_error = ENODEV;
-		bp->bio_flags |= BIO_ERROR;
-		bp->bio_resid = bp->bio_bcount;
-		biodone(bp);
-		return;
-	}
-	if (!raidPtr->valid) {
-		bp->bio_error = ENODEV;
-		bp->bio_flags |= BIO_ERROR;
-		bp->bio_resid = bp->bio_bcount;
-		biodone(bp);
-		return;
-	}
-	if (bp->bio_bcount == 0) {
-		rf_printf(2, "b_bcount is zero..\n");
-		biodone(bp);
-		return;
-	}
-
-	s = splbio();
-
-	bp->bio_resid = 0;
-
-	/* stuff it onto our queue. XXX locking? */
-	bioq_insert_tail(&sc->bio_queue, bp);
-
-	raidstart(raidPtr);
-
-	splx(s);
-}
-
-int
-raidioctl(dp, cmd, data, flag, td)
-	struct disk *dp;
-	u_long  cmd;
-	void	*data;
-	int     flag;
-	struct thread *td;
-{
-	struct raid_softc *sc;
-	RF_Raid_t *raidPtr;
-	RF_RaidDisk_t *diskPtr;
-	RF_AccTotals_t *totals;
-	RF_DeviceConfig_t *d_cfg, **ucfgp;
-	struct rf_recon_req *rrcopy, *rr;
-	RF_ComponentLabel_t *clabel;
-	RF_ComponentLabel_t *ci_label;
-	RF_SingleComponent_t *sparePtr,*componentPtr;
-	RF_SingleComponent_t *hot_spare, *component;
-	RF_ProgressInfo_t progressInfo;
-	int retcode = 0;
-	int row, column;
-	int unit;
-	int i, j, d;
-
-	sc = dp->d_drv1;
-	raidPtr = sc->raidPtr;
-
-	rf_printf(2, "raidioctl: %s%d %ld\n", dp->d_name, dp->d_unit, cmd);
-
-	switch (cmd) {
-
-	case RAIDFRAME_GET_COMPONENT_LABEL:
-		/* 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 */
-		RF_Malloc( clabel, sizeof( RF_ComponentLabel_t ),
-			   (RF_ComponentLabel_t *));
-		if (clabel == NULL)
-			return (ENOMEM);
-
-		bzero((char *) clabel, sizeof(RF_ComponentLabel_t));
-		
-		bcopy(data, clabel, sizeof(RF_ComponentLabel_t));
-
-		row = clabel->row;
-		column = clabel->column;
-
-		if ((row < 0) || (row >= raidPtr->numRow) ||
-		    (column < 0) || (column >= raidPtr->numCol +
-				     raidPtr->numSpare)) {
-			RF_Free( clabel, sizeof(RF_ComponentLabel_t));
-			return(EINVAL);
-		}
-
-		raidread_component_label(raidPtr->Disks[row][column].dev, 
-				raidPtr->raid_cinfo[row][column].ci_vp, 
-				clabel );
-
-		bcopy(clabel, data, sizeof(RF_ComponentLabel_t));
-		RF_Free( clabel, sizeof(RF_ComponentLabel_t));
-		return (retcode);
-
-	case RAIDFRAME_SET_COMPONENT_LABEL:
-		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.
-		   */
-
-		rf_printf(1, "Got component label:\n");
-		rf_printf(1, "Version: %d\n",clabel->version);
-		rf_printf(1, "Serial Number: %d\n",clabel->serial_number);
-		rf_printf(1, "Mod counter: %d\n",clabel->mod_counter);
-		rf_printf(1, "Row: %d\n", clabel->row);
-		rf_printf(1, "Column: %d\n", clabel->column);
-		rf_printf(1, "Num Rows: %d\n", clabel->num_rows);
-		rf_printf(1, "Num Columns: %d\n", clabel->num_columns);
-		rf_printf(1, "Clean: %d\n", clabel->clean);
-		rf_printf(1, "Status: %d\n", clabel->status);
-
-		row = clabel->row;
-		column = clabel->column;
-
-		if ((row < 0) || (row >= raidPtr->numRow) ||
-		    (column < 0) || (column >= raidPtr->numCol)) {
-			return(EINVAL);
-		}
-
-		/* XXX this isn't allowed to do anything for now :-) */
-
-		/* XXX and before it is, we need to fill in the rest
-		   of the fields!?!?!?! */
-#if 0
-		raidwrite_component_label( 
-                            raidPtr->Disks[row][column].dev, 
-			    raidPtr->raid_cinfo[row][column].ci_vp, 
-			    clabel );
-#endif
-		return (0);
-
-	case RAIDFRAME_INIT_LABELS:
-		MALLOC(ci_label, RF_ComponentLabel_t *,
-		    sizeof(RF_ComponentLabel_t), M_RAIDFRAME,
-		    M_WAITOK | M_ZERO);
-		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. 
-		   */
-
-		raidPtr->serial_number = clabel->serial_number;
-		
-		raid_init_component_label(raidPtr, ci_label);
-		ci_label->serial_number = clabel->serial_number;
-
-		for(row=0;row<raidPtr->numRow;row++) {
-			ci_label->row = row;
-			for(column=0;column<raidPtr->numCol;column++) {
-				diskPtr = &raidPtr->Disks[row][column];
-				if (!RF_DEAD_DISK(diskPtr->status)) {
-					ci_label->partitionSize =
-					    diskPtr->partitionSize;
-					ci_label->column = column;
-					raidwrite_component_label( 
-					    raidPtr->Disks[row][column].dev, 
-					    raidPtr->raid_cinfo[row][column].ci_vp, 
-					  ci_label );
-				}
-			}
-		}
-
-		FREE(ci_label, M_RAIDFRAME);
-		return (retcode);
-	case RAIDFRAME_SET_AUTOCONFIG:
-		d = rf_set_autoconfig(raidPtr, *(int *) data);
-		rf_printf(1, "New autoconfig value is: %d\n", d);
-		*(int *) data = d;
-		return (retcode);
-
-	case RAIDFRAME_SET_ROOT:
-		d = rf_set_rootpartition(raidPtr, *(int *) data);
-		rf_printf(1, "New rootpartition value is: %d\n", d);
-		*(int *) data = d;
-		return (retcode);
-
-		/* initialize all parity */
-	case RAIDFRAME_REWRITEPARITY:
-
-		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* 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! */
-			return(EINVAL);
-		}
-
-		retcode = RF_CREATE_THREAD(raidPtr->parity_rewrite_thread,
-					   rf_RewriteParityThread,
-					   raidPtr,"raid_parity");
-		return (retcode);
-
-
-	case RAIDFRAME_ADD_HOT_SPARE:
-		MALLOC(hot_spare, RF_SingleComponent_t *,
-		    sizeof(RF_SingleComponent_t), M_RAIDFRAME,
-		     M_WAITOK | M_ZERO);
-		sparePtr = (RF_SingleComponent_t *) data;
-		memcpy( hot_spare, sparePtr, sizeof(RF_SingleComponent_t));
-		retcode = rf_add_hot_spare(raidPtr, hot_spare);
-		FREE(hot_spare, M_RAIDFRAME);
-		return(retcode);
-
-	case RAIDFRAME_REMOVE_HOT_SPARE:
-		return(retcode);
-
-	case RAIDFRAME_DELETE_COMPONENT:
-		MALLOC(component, RF_SingleComponent_t *,
-		    sizeof(RF_SingleComponent_t), M_RAIDFRAME,
-		     M_WAITOK | M_ZERO);
-		componentPtr = (RF_SingleComponent_t *)data;
-		memcpy( component, componentPtr, 
-			sizeof(RF_SingleComponent_t));
-		retcode = rf_delete_component(raidPtr, component);
-		FREE(component, M_RAIDFRAME);
-		return(retcode);
-
-	case RAIDFRAME_INCORPORATE_HOT_SPARE:
-		MALLOC(component, RF_SingleComponent_t *,
-		    sizeof(RF_SingleComponent_t), M_RAIDFRAME,
-		     M_WAITOK | M_ZERO);
-		componentPtr = (RF_SingleComponent_t *)data;
-		memcpy( component, componentPtr, 
-			sizeof(RF_SingleComponent_t));
-		retcode = rf_incorporate_hot_spare(raidPtr, component);
-		FREE(component, M_RAIDFRAME);
-		return(retcode);
-
-	case RAIDFRAME_REBUILD_IN_PLACE:
-
-		MALLOC(component, RF_SingleComponent_t *,
-		    sizeof(RF_SingleComponent_t), M_RAIDFRAME,
-		     M_WAITOK | M_ZERO);
-		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* Can't do this on a RAID 0!! */
-			FREE(component, M_RAIDFRAME);
-			return(EINVAL);
-		}
-
-		if (raidPtr->recon_in_progress == 1) {
-			/* a reconstruct is already in progress! */
-			FREE(component, M_RAIDFRAME);
-			return(EINVAL);
-		}
-
-		componentPtr = (RF_SingleComponent_t *) data;
-		memcpy( component, componentPtr, 
-			sizeof(RF_SingleComponent_t));
-		row = component->row;
-		column = component->column;
-		unit = raidPtr->raidid;
-		rf_printf(0, "raid%d Rebuild: %d %d\n", unit, row, column);
-		if ((row < 0) || (row >= raidPtr->numRow) ||
-		    (column < 0) || (column >= raidPtr->numCol)) {
-			FREE(component, M_RAIDFRAME);
-			return(EINVAL);
-		}
-
-		RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *));
-		if (rrcopy == NULL) {
-			FREE(component, M_RAIDFRAME);
-			return(ENOMEM);
-		}
-
-		rrcopy->raidPtr = (void *) raidPtr;
-		rrcopy->row = row;
-		rrcopy->col = column;
-
-		retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
-					   rf_ReconstructInPlaceThread,
-					   rrcopy,"raid_reconip");
-		FREE(component, M_RAIDFRAME);
-		return(retcode);
-
-	case RAIDFRAME_GET_UNIT:
-
-		*(int *)data = raidPtr->raidid;
-		return (0);
-
-	case RAIDFRAME_GET_INFO:
-		if (!raidPtr->valid)
-			return (ENODEV);
-		ucfgp = (RF_DeviceConfig_t **) data;
-		RF_Malloc(d_cfg, sizeof(RF_DeviceConfig_t),
-			  (RF_DeviceConfig_t *));
-		if (d_cfg == NULL)
-			return (ENOMEM);
-		bzero((char *) d_cfg, sizeof(RF_DeviceConfig_t));
-		d_cfg->rows = raidPtr->numRow;
-		d_cfg->cols = raidPtr->numCol;
-		d_cfg->ndevs = raidPtr->numRow * raidPtr->numCol;
-		if (d_cfg->ndevs >= RF_MAX_DISKS) {
-			RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
-			return (ENOMEM);
-		}
-		d_cfg->nspares = raidPtr->numSpare;
-		if (d_cfg->nspares >= RF_MAX_DISKS) {
-			RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
-			return (ENOMEM);
-		}
-		d_cfg->maxqdepth = raidPtr->maxQueueDepth;
-		d = 0;
-		for (i = 0; i < d_cfg->rows; i++) {
-			for (j = 0; j < d_cfg->cols; j++) {
-				d_cfg->devs[d] = raidPtr->Disks[i][j];
-				d++;
-			}
-		}
-		for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++) {
-			d_cfg->spares[i] = raidPtr->Disks[0][j];
-		}
-
-		retcode = copyout(d_cfg, *ucfgp, sizeof(RF_DeviceConfig_t));
-
-		RF_Free(d_cfg, sizeof(RF_DeviceConfig_t));
-
-		return (retcode);
-
-	case RAIDFRAME_CHECK_PARITY:
-		*(int *) data = raidPtr->parity_good;
-		return (0);
-
-	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;
-		return (0);
-
-	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 */
-	case RAIDFRAME_FAIL_DISK:
-
-		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* Can't do this on a RAID 0!! */
-			return(EINVAL);
-		}
-
-		rr = (struct rf_recon_req *) data;
-
-		if (rr->row < 0 || rr->row >= raidPtr->numRow
-		    || rr->col < 0 || rr->col >= raidPtr->numCol)
-			return (EINVAL);
-
-		rf_printf(0, "%s%d: Failing the disk: row: %d col: %d\n",
-		       dp->d_name, dp->d_unit, rr->row, rr->col);
-
-		/* make a copy of the recon request so that we don't rely on
-		 * the user's buffer */
-		RF_Malloc(rrcopy, sizeof(*rrcopy), (struct rf_recon_req *));
-		if (rrcopy == NULL)
-			return(ENOMEM);
-		bcopy(rr, rrcopy, sizeof(*rr));
-		rrcopy->raidPtr = (void *) raidPtr;
-
-		retcode = RF_CREATE_THREAD(raidPtr->recon_thread,
-					   rf_ReconThread,
-					   rrcopy,"raid_recon");
-		return (0);
-
-		/* invoke a copyback operation after recon on whatever disk
-		 * needs it, if any */
-	case RAIDFRAME_COPYBACK:
-
-		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* This makes no sense on a RAID 0!! */
-			return(EINVAL);
-		}
-
-		if (raidPtr->copyback_in_progress == 1) {
-			/* 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 */
-	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. */
-			*(int *) data = 100;
-			return(0);
-		}
-		row = 0; /* XXX we only consider a single row... */
-		if (raidPtr->status[row] != rf_rs_reconstructing)
-			*(int *) data = 100;
-		else
-			*(int *) data = raidPtr->reconControl[row]->percentComplete;
-		return (0);
-	case RAIDFRAME_CHECK_RECON_STATUS_EXT:
-		row = 0; /* XXX we only consider a single row... */
-		if (raidPtr->status[row] != rf_rs_reconstructing) {
-			progressInfo.remaining = 0;
-			progressInfo.completed = 100;
-			progressInfo.total = 100;
-		} else {
-			progressInfo.total = 
-				raidPtr->reconControl[row]->numRUsTotal;
-			progressInfo.completed = 
-				raidPtr->reconControl[row]->numRUsComplete;
-			progressInfo.remaining = progressInfo.total -
-				progressInfo.completed;
-		}
-		bcopy((caddr_t) &progressInfo, data, sizeof(RF_ProgressInfo_t));
-		return (retcode);
-
-	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. */
-			*(int *) data = 100;
-			return(0);
-		}
-		if (raidPtr->parity_rewrite_in_progress == 1) {
-			*(int *) data = 100 * 
-				raidPtr->parity_rewrite_stripes_done / 
-				raidPtr->Layout.numStripe;
-		} else {
-			*(int *) data = 100;
-		}
-		return (0);
-
-	case RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT:
-		if (raidPtr->parity_rewrite_in_progress == 1) {
-			progressInfo.total = raidPtr->Layout.numStripe;
-			progressInfo.completed = 
-				raidPtr->parity_rewrite_stripes_done;
-			progressInfo.remaining = progressInfo.total -
-				progressInfo.completed;
-		} else {
-			progressInfo.remaining = 0;
-			progressInfo.completed = 100;
-			progressInfo.total = 100;
-		}
-		bcopy((caddr_t) &progressInfo, data, sizeof(RF_ProgressInfo_t));
-		return (retcode);
-
-	case RAIDFRAME_CHECK_COPYBACK_STATUS:
-		if (raidPtr->Layout.map->faultsTolerated == 0) {
-			/* This makes no sense on a RAID 0 */
-			*(int *) data = 100;
-			return(0);
-		}
-		if (raidPtr->copyback_in_progress == 1) {
-			*(int *) data = 100 * raidPtr->copyback_stripes_done /
-				raidPtr->Layout.numStripe;
-		} else {
-			*(int *) data = 100;
-		}
-		return (0);
-
-	case RAIDFRAME_CHECK_COPYBACK_STATUS_EXT:
-		if (raidPtr->copyback_in_progress == 1) {
-			progressInfo.total = raidPtr->Layout.numStripe;
-			progressInfo.completed = 
-				raidPtr->copyback_stripes_done;
-			progressInfo.remaining = progressInfo.total -
-				progressInfo.completed;
-		} else {
-			progressInfo.remaining = 0;
-			progressInfo.completed = 100;
-			progressInfo.total = 100;
-		}
-		bcopy((caddr_t) &progressInfo, data, sizeof(RF_ProgressInfo_t));
-		return (retcode);
-
-		/* the sparetable daemon calls this to wait for the kernel to
-		 * need a spare table. this ioctl does not return until a
-		 * spare table is needed. XXX -- calling mpsleep here in the
-		 * ioctl code is almost certainly wrong and evil. -- XXX XXX
-		 * -- I should either compute the spare table in the kernel,
-		 * or have a different -- XXX XXX -- interface (a different
-		 * character device) for delivering the table     -- XXX */
-#if 0
-	case RAIDFRAME_SPARET_WAIT:
-		RF_LOCK_MUTEX(rf_sparet_wait_mutex);
-		while (!rf_sparet_wait_queue)
-			mpsleep(&rf_sparet_wait_queue, (PZERO + 1) | PCATCH, "sparet wait", 0, (void *) simple_lock_addr(rf_sparet_wait_mutex), MS_LOCK_SIMPLE);
-		waitreq = rf_sparet_wait_queue;
-		rf_sparet_wait_queue = rf_sparet_wait_queue->next;
-		RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
-
-		/* structure assignment */
-		*((RF_SparetWait_t *) data) = *waitreq;	
-
-		RF_Free(waitreq, sizeof(*waitreq));
-		return (0);
-
-		/* wakes up a process waiting on SPARET_WAIT and puts an error
-		 * code in it that will cause the dameon to exit */
-	case RAIDFRAME_ABORT_SPARET_WAIT:
-		RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *));
-		waitreq->fcol = -1;
-		RF_LOCK_MUTEX(rf_sparet_wait_mutex);
-		waitreq->next = rf_sparet_wait_queue;
-		rf_sparet_wait_queue = waitreq;
-		RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
-		wakeup(&rf_sparet_wait_queue);
-		return (0);
-
-		/* used by the spare table daemon to deliver a spare table
-		 * into the kernel */
-	case RAIDFRAME_SEND_SPARET:
-
-		/* 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 */
-		RF_Malloc(waitreq, sizeof(*waitreq), (RF_SparetWait_t *));
-		waitreq->fcol = retcode;
-		RF_LOCK_MUTEX(rf_sparet_wait_mutex);
-		waitreq->next = rf_sparet_resp_queue;
-		rf_sparet_resp_queue = waitreq;
-		wakeup(&rf_sparet_resp_queue);
-		RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
-
-		return (retcode);
-#endif
-
-	default:
-		retcode = ENOIOCTL;
-		break; /* fall through to the os-specific code below */
-
-	}
-
-	return (retcode);
-
-}
-
-
-/* raidinit -- complete the rest of the initialization for the
-   RAIDframe device.  */
-
-
-static struct raid_softc *
-raidinit(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	struct raid_softc *sc;
-
-	RF_Malloc(sc, sizeof(struct raid_softc), (struct raid_softc *));
-	if (sc == NULL) {
-		rf_printf(1, "No memory for raid device\n");
-		return(NULL);
-	}
-
-	sc->raidPtr = raidPtr;
-
-	/* XXX Should check return code here */
-	bioq_init(&sc->bio_queue);
-	sc->sc_cbufpool = uma_zcreate("raidpl", sizeof(struct raidbuf), NULL,
-	    NULL, NULL, NULL, 0, 0); 
-
-	/* XXX There may be a weird interaction here between this, and
-	 * protectedSectors, as used in RAIDframe.  */
-
-	sc->sc_size = raidPtr->totalSectors;
-
-	/* Create the disk device */
-	sc->sc_disk = disk_alloc();
-	sc->sc_disk->d_open = raidopen;
-	sc->sc_disk->d_close = raidclose;
-	sc->sc_disk->d_ioctl = raidioctl;
-	sc->sc_disk->d_strategy = raidstrategy;
-	sc->sc_disk->d_drv1 = sc;
-	sc->sc_disk->d_maxsize = DFLTPHYS;
-	sc->sc_disk->d_name = "raid";
-	sc->sc_disk->d_unit = raidPtr->raidid;
-	sc->sc_disk->d_flags = DISKFLAG_NEEDSGIANT;
-	disk_create(sc->sc_disk, DISK_VERSION);
-	raidPtr->sc = sc;
-
-	return (sc);
-}
-
-/* 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
- * XXX
- * 
- * XXX This code is not currently used. GO
- */
-int 
-rf_GetSpareTableFromDaemon(req)
-	RF_SparetWait_t *req;
-{
-	int     retcode;
-
-	RF_LOCK_MUTEX(rf_sparet_wait_mutex);
-	req->next = rf_sparet_wait_queue;
-	rf_sparet_wait_queue = req;
-	wakeup(&rf_sparet_wait_queue);
-
-	/* mpsleep unlocks the mutex */
-	while (!rf_sparet_resp_queue) {
-		tsleep(&rf_sparet_resp_queue, PRIBIO,
-		    "raidframe getsparetable", 0);
-	}
-	req = rf_sparet_resp_queue;
-	rf_sparet_resp_queue = req->next;
-	RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
-
-	retcode = req->fcol;
-	RF_Free(req, sizeof(*req));	/* this is not the same req as we
-					 * alloc'd */
-	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)
- * 
- * Formerly known as: rf_DoAccessKernel
- */
-void
-raidstart(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	RF_SectorCount_t num_blocks, pb, sum;
-	RF_RaidAddr_t raid_addr;
-	struct raid_softc *sc;
-	struct bio *bp;
-	daddr_t blocknum;
-	int     unit, retcode, do_async;
-
-	unit = raidPtr->raidid;
-	sc = raidPtr->sc;
-	
-	/* quick check to see if anything has died recently */
-	RF_LOCK_MUTEX(raidPtr->mutex);
-	if (raidPtr->numNewFailures > 0) {
-		raidPtr->numNewFailures--;
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-		rf_update_component_labels(raidPtr, 
-					   RF_NORMAL_COMPONENT_UPDATE);
-	} else
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-
-	/* Check to see if we're at the limit... */
-	RF_LOCK_MUTEX(raidPtr->mutex);
-	while (raidPtr->openings > 0) {
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-
-		/* get the next item, if any, from the queue */
-		if ((bp = bioq_first(&sc->bio_queue)) == NULL) {
-			/* nothing more to do */
-			return;
-		}
-		bioq_remove(&sc->bio_queue, bp);
-
-		/* Ok, for the bp we have here, bp->b_blkno is relative to the
-		 * partition.. Need to make it absolute to the underlying 
-		 * device.. */
-
-		blocknum = bp->bio_pblkno =
-		    bp->bio_offset >> raidPtr->logBytesPerSector;
-
-		rf_printf(3, "Blocks: %ld, %ld\n", (long)bp->bio_pblkno, (long)blocknum);
-		
-		rf_printf(3, "bp->bio_bcount = %d\n", (int) bp->bio_bcount);
-		rf_printf(3, "bp->bio_resid = %d\n", (int) bp->bio_resid);
-		
-		/* *THIS* is where we adjust what block we're going to... 
-		 * but DO NOT TOUCH bp->bio_pblkno!!! */
-		raid_addr = blocknum;
-		
-		num_blocks = bp->bio_bcount >> raidPtr->logBytesPerSector;
-		pb = (bp->bio_bcount & raidPtr->sectorMask) ? 1 : 0;
-		sum = raid_addr + num_blocks + pb;
-		if (rf_debugKernelAccess) {
-			rf_printf(0, "raid_addr=0x%x sum=%d num_blocks=%d(+%d) "
-				    "(%d)\n", (int)raid_addr, (int)sum, 
-				    (int)num_blocks, (int)pb,
-				    (int)bp->bio_resid);
-		}
-		if ((sum > raidPtr->totalSectors) || (sum < raid_addr)
-		    || (sum < num_blocks) || (sum < pb)) {
-			bp->bio_error = ENOSPC;
-			bp->bio_flags |= BIO_ERROR;
-			bp->bio_resid = bp->bio_bcount;
-			biodone(bp);
-			RF_LOCK_MUTEX(raidPtr->mutex);
-			continue;
-		}
-		/*
-		 * XXX rf_DoAccess() should do this, not just DoAccessKernel()
-		 */
-		
-		if (bp->bio_bcount & raidPtr->sectorMask) {
-			bp->bio_error = EINVAL;
-			bp->bio_flags |= BIO_ERROR;
-			bp->bio_resid = bp->bio_bcount;
-			biodone(bp);
-			RF_LOCK_MUTEX(raidPtr->mutex);
-			continue;
-			
-		}
-		rf_printf(3, "Calling DoAccess..\n");
-		
-
-		RF_LOCK_MUTEX(raidPtr->mutex);
-		raidPtr->openings--;
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-
-		/*
-		 * Everything is async.
-		 */
-		do_async = 1;
-
-		/* XXX we're still at splbio() here... do we *really* 
-		   need to be? */
-
-		/* don't ever condition on bp->bio_cmd & BIO_WRITE.  
-		 * always condition on BIO_READ instead */
-		
-		retcode = rf_DoAccess(raidPtr, (bp->bio_cmd & BIO_READ) ?
-				      RF_IO_TYPE_READ : RF_IO_TYPE_WRITE,
-				      do_async, raid_addr, num_blocks,
-				      bp->bio_data, bp, NULL, NULL, 
-				      RF_DAG_NONBLOCKING_IO, NULL, NULL, NULL);
-
-
-		RF_LOCK_MUTEX(raidPtr->mutex);
-	}
-	RF_UNLOCK_MUTEX(raidPtr->mutex);
-}
-
-
-
-
-/* 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;
-{
-	int     op = (req->type == RF_IO_TYPE_READ) ? BIO_READ : BIO_WRITE;
-	struct bio *bp;
-	struct raidbuf *raidbp = NULL;
-	struct raid_softc *sc;
-
-	/* XXX along with the vnode, we also need the softc associated with
-	 * this device.. */
-
-	req->queue = queue;
-
-	sc = queue->raidPtr->sc;
-
-	rf_printf(3, "DispatchKernelIO %s\n", sc->sc_disk->d_name);
-
-	bp = req->bp;
-#if 1
-	/* XXX when there is a physical disk failure, someone is passing 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 ) */
-
-	if (bp->bio_flags & BIO_ERROR) {
-		bp->bio_flags &= ~BIO_ERROR;
-	}
-	if (bp->bio_error != 0) {
-		bp->bio_error = 0;
-	}
-#endif
-	raidbp = RAIDGETBUF(sc);
-
-	raidbp->rf_flags = 0;	/* XXX not really used anywhere... */
-
-	/*
-	 * context for raidiodone
-	 */
-	raidbp->rf_obp = bp;
-	raidbp->req = req;
-
-#if 0	/* XXX */
-	LIST_INIT(&raidbp->rf_buf.b_dep);
-#endif
-
-	switch (req->type) {
-	case RF_IO_TYPE_NOP:	/* used primarily to unlock a locked queue */
-		/* XXX need to do something extra here.. */
-		/* I'm leaving this in, as I've never actually seen it used,
-		 * and I'd like folks to report it... GO */
-		rf_printf(2, "WAKEUP CALLED\n");
-		queue->numOutstanding++;
-
-		/* XXX need to glue the original buffer into this?  */
-
-		KernelWakeupFunc(&raidbp->rf_buf);
-		break;
-
-	case RF_IO_TYPE_READ:
-	case RF_IO_TYPE_WRITE:
-
-		if (req->tracerec) {
-			RF_ETIMER_START(req->tracerec->timer);
-		}
-		InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp,
-		    op | bp->bio_cmd, queue->rf_cinfo->ci_dev,
-		    req->sectorOffset, req->numSector,
-		    req->buf, KernelWakeupFunc, (void *) req,
-		    queue->raidPtr->logBytesPerSector, req->b_proc);
-
-		if (rf_debugKernelAccess) {
-			rf_printf(0, "dispatch: bp->bio_pblkno = %ld\n",
-				(long) bp->bio_pblkno);
-		}
-		queue->numOutstanding++;
-		queue->last_deq_sector = req->sectorOffset;
-		/* acc wouldn't have been let in if there were any pending
-		 * reqs at any other priority */
-		queue->curPriority = req->priority;
-
-		rf_printf(3, "Going for %c to %s%d row %d col %d\n",
-			req->type, sc->sc_disk->d_name, 
-			sc->sc_disk->d_unit, queue->row, queue->col);
-		rf_printf(3, "sector %d count %d (%d bytes) %d\n",
-			(int) req->sectorOffset, (int) req->numSector,
-			(int) (req->numSector <<
-			    queue->raidPtr->logBytesPerSector),
-			(int) queue->raidPtr->logBytesPerSector);
-#if 0	/* XXX */
-		if ((raidbp->rf_buf.bio_cmd & BIO_READ) == 0) {
-			raidbp->rf_buf.b_vp->v_numoutput++;
-		}
-#endif
-		(*devsw(raidbp->rf_buf.bio_dev)->d_strategy)(&raidbp->rf_buf);
-
-		break;
-
-	default:
-		panic("bad req->type in rf_DispatchKernelIO");
-	}
-	rf_printf(3, "Exiting from DispatchKernelIO\n");
-	/* splx(s); */ /* want to test this */
-	return (0);
-}
-/* This is the callback function associated with an I/O invoked from
-   kernel code.
- */
-static void 
-KernelWakeupFunc(vbp)
-	struct bio *vbp;
-{
-	RF_DiskQueueData_t *req = NULL;
-	RF_DiskQueue_t *queue;
-	struct raidbuf *raidbp = (struct raidbuf *) vbp;
-	struct bio *bp;
-	struct raid_softc *sc;
-	int s;
-
-	s = splbio();
-	rf_printf(2, "recovering the request queue:\n");
-	req = raidbp->req;
-
-	bp = raidbp->rf_obp;
-	queue = (RF_DiskQueue_t *) req->queue;
-	sc = queue->raidPtr->sc;
-
-	if (raidbp->rf_buf.bio_flags & BIO_ERROR) {
-		bp->bio_flags |= BIO_ERROR;
-		bp->bio_error = raidbp->rf_buf.bio_error ?
-		    raidbp->rf_buf.bio_error : EIO;
-	}
-
-	/* XXX methinks this could be wrong... */
-#if 1
-	bp->bio_resid = raidbp->rf_buf.bio_resid;
-#endif
-
-	if (req->tracerec) {
-		RF_ETIMER_STOP(req->tracerec->timer);
-		RF_ETIMER_EVAL(req->tracerec->timer);
-		RF_LOCK_MUTEX(rf_tracing_mutex);
-		req->tracerec->diskwait_us += RF_ETIMER_VAL_US(req->tracerec->timer);
-		req->tracerec->phys_io_us += RF_ETIMER_VAL_US(req->tracerec->timer);
-		req->tracerec->num_phys_ios++;
-		RF_UNLOCK_MUTEX(rf_tracing_mutex);
-	}
-	bp->bio_bcount = raidbp->rf_buf.bio_bcount;	/* XXXX ? */
-
-	/* XXX Ok, let's get aggressive... If BIO_ERROR is set, let's go
-	 * ballistic, and mark the component as hosed... */
-
-	if (bp->bio_flags & BIO_ERROR) {
-		/* Mark the disk as dead */
-		/* but only mark it once... */
-		if (queue->raidPtr->Disks[queue->row][queue->col].status ==
-		    rf_ds_optimal) {
-			rf_printf(0, "%s%d: IO Error.  Marking %s as "
-			    "failed.\n", sc->sc_disk->d_name, sc->sc_disk->d_unit,
-			    queue->raidPtr->Disks[queue->row][queue->col].devname);
-			queue->raidPtr->Disks[queue->row][queue->col].status =
-			    rf_ds_failed;
-			queue->raidPtr->status[queue->row] = rf_rs_degraded;
-			queue->raidPtr->numFailures++;
-			queue->raidPtr->numNewFailures++;
-		} else {	/* Disk is already dead... */
-			/* printf("Disk already marked as dead!\n"); */
-		}
-
-	}
-
-	RAIDPUTBUF(sc, raidbp);
-
-	rf_DiskIOComplete(queue, req, (bp->bio_flags & BIO_ERROR) ? 1 : 0);
-	(req->CompleteFunc)(req->argument, (bp->bio_flags & BIO_ERROR) ? 1 : 0);
-
-	splx(s);
-}
-
-
-
-/*
- * initialize a buf structure for doing an I/O in the kernel.
- */
-static void 
-InitBP(bp, b_vp, rw_flag, dev, startSect, numSect, buf, cbFunc, cbArg,
-       logBytesPerSector, b_proc)
-	struct bio *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 bio *);
-	void *cbArg;
-	int logBytesPerSector;
-	struct proc *b_proc;
-{
-	bp->bio_cmd = rw_flag;
-	bp->bio_bcount = numSect << logBytesPerSector;
-#if 0	/* XXX */
-	bp->bio_bufsize = bp->bio_bcount;
-#endif
-	bp->bio_error = 0;
-	bp->bio_dev = dev;
-	bp->bio_data = buf;
-	bp->bio_resid = bp->bio_bcount;	/* XXX is this right!?!?!! */
-	bp->bio_offset = startSect << logBytesPerSector;
-	if (bp->bio_bcount == 0) {
-		panic("bp->bio_bcount is zero in InitBP!!\n");
-	}
-/*
-	bp->b_proc = b_proc;
-	bp->b_vp = b_vp;
-*/
-	bp->bio_done = cbFunc;
-
-}
-
-static void
-raidgetdefaultlabel(raidPtr, sc, dp)
-	RF_Raid_t *raidPtr;
-	struct raid_softc *sc;
-	struct disk *dp;
-{
-	rf_printf(1, "Building a default label...\n");
-	if (dp == NULL)
-		panic("raidgetdefaultlabel(): dp is NULL\n");
-
-	/* fabricate a label... */
-	dp->d_mediasize = raidPtr->totalSectors * raidPtr->bytesPerSector;
-	dp->d_sectorsize = raidPtr->bytesPerSector;
-	dp->d_fwsectors = raidPtr->Layout.dataSectorsPerStripe;
-	dp->d_fwheads = 4 * raidPtr->numCol;
-
-}
-/*
- * Lookup the provided name in the filesystem.  If the file exists,
- * is a valid block device, and isn't being used by anyone else,
- * set *vpp to the file's vnode.
- * You'll find the original of this in ccd.c
- */
-int
-raidlookup(path, td, vpp)
-	char   *path;
-	struct thread *td;
-	struct vnode **vpp;	/* result */
-{
-	struct nameidata *nd;
-	struct vnode *vp;
-	struct vattr *va;
-	struct proc *p;
-	int     error = 0, flags;
-
-	MALLOC(nd, struct nameidata *, sizeof(struct nameidata), M_TEMP, M_NOWAIT | M_ZERO);
-	MALLOC(va, struct vattr *, sizeof(struct vattr), M_TEMP, M_NOWAIT | M_ZERO);
-	if ((nd == NULL) || (va == NULL)) {
-		printf("Out of memory?\n");
-		return (ENOMEM);
-	}
-
-	/* Sanity check the p_fd fields.  This is really just a hack */
-	p = td->td_proc;
-	if (!p->p_fd->fd_rdir || !p->p_fd->fd_cdir)
-		printf("Warning: p_fd fields not set\n");
-
-	if (!td->td_proc->p_fd->fd_rdir)
-		p->p_fd->fd_rdir = rootvnode;
-
-	if (!p->p_fd->fd_cdir)
-		p->p_fd->fd_cdir = rootvnode;
-
-	NDINIT(nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, curthread);
-	flags = FREAD | FWRITE;
-	if ((error = vn_open(nd, &flags, 0, -1)) != 0) {
-		rf_printf(2, "RAIDframe: vn_open returned %d\n", error);
-		goto end1;
-	}
-	vp = nd->ni_vp;
-	if (vp->v_usecount > 1) {
-		rf_printf(1, "raidlookup() vp->v_usecount= %d\n", vp->v_usecount);
-		error = EBUSY;
-		goto end;
-	}
-	if ((error = VOP_GETATTR(vp, va, td->td_ucred, td)) != 0) {
-		rf_printf(1, "raidlookup() VOP_GETATTR returned %d", error);
-		goto end;
-	}
-	/* XXX: eventually we should handle VREG, too. */
-	if (va->va_type != VCHR) {
-		rf_printf(1, "Returning ENOTBLK\n");
-		error = ENOTBLK;
-	}
-	*vpp = vp;
-
-end:
-	VOP_UNLOCK(vp, 0, td);
-	NDFREE(nd, NDF_ONLY_PNBUF);
-end1:
-	FREE(nd, M_TEMP);
-	FREE(va, M_TEMP);
-	return (error);
-}
-/*
- * Wait interruptibly for an exclusive lock.
- *
- * XXX
- * Several drivers do this; it should be abstracted and made MP-safe.
- * (Hmm... where have we seen this warning before :->  GO )
- */
-static int
-raidlock(sc)
-	struct raid_softc *sc;
-{
-	int     error;
-
-	while ((sc->sc_flags & RAIDF_LOCKED) != 0) {
-		sc->sc_flags |= RAIDF_WANTED;
-		if ((error =
-			tsleep(sc, PRIBIO | PCATCH, "raidlck", 0)) != 0)
-			return (error);
-	}
-	sc->sc_flags |= RAIDF_LOCKED;
-	return (0);
-}
-/*
- * Unlock and wake up any waiters.
- */
-static void
-raidunlock(sc)
-	struct raid_softc *sc;
-{
-
-	sc->sc_flags &= ~RAIDF_LOCKED;
-	if ((sc->sc_flags & RAIDF_WANTED) != 0) {
-		sc->sc_flags &= ~RAIDF_WANTED;
-		wakeup(sc);
-	}
-}
- 
-
-#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;
-
-	MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t),
-	    M_RAIDFRAME, M_NOWAIT | M_ZERO);
-	if (clabel == NULL) {
-		printf("raidmarkclean: Out of memory?\n");
-		return (ENOMEM);
-	}
-
-	raidread_component_label(dev, b_vp, clabel);
-	clabel->mod_counter = mod_counter;
-	clabel->clean = RF_RAID_CLEAN;
-	raidwrite_component_label(dev, b_vp, clabel);
-	FREE(clabel, M_RAIDFRAME);
-	return(0);
-}
-
-
-int 
-raidmarkdirty(dev_t dev, struct vnode *b_vp, int mod_counter)
-{
-	RF_ComponentLabel_t *clabel;
-
-	MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t),
-	    M_RAIDFRAME, M_NOWAIT | M_ZERO);
-	if (clabel == NULL) {
-		printf("raidmarkclean: Out of memory?\n");
-		return (ENOMEM);
-	}
-
-	raidread_component_label(dev, b_vp, clabel);
-	clabel->mod_counter = mod_counter;
-	clabel->clean = RF_RAID_DIRTY;
-	raidwrite_component_label(dev, b_vp, clabel);
-	FREE(clabel, M_RAIDFRAME);
-	return(0);
-}
-
-/* ARGSUSED */
-int
-raidread_component_label(dev, b_vp, clabel)
-	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. */ 
-
-	if (b_vp == NULL) {
-		/* 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... */
-	bp = geteblk((int)RF_COMPONENT_INFO_SIZE);
-	bp->b_dev = dev;
-
-	/* get our ducks in a row for the read */
-	bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
-	bp->b_iooffset = RF_COMPONENT_INFO_OFFSET;
-	bp->b_bcount = RF_COMPONENT_INFO_SIZE;
-	bp->b_iocmd = BIO_READ;
- 	bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE;
-
-	DEV_STRATEGY(bp);
-	error = bufwait(bp); 
-
-	if (!error) {
-		memcpy(clabel, bp->b_data, sizeof(RF_ComponentLabel_t));
-#if 0
-		rf_print_component_label( clabel );
-#endif
-        } else {
-#if 0
-		rf_printf(0, "Failed to read RAID component label!\n");
-#endif
-	}
-
-	bp->b_flags |= B_INVAL | B_AGE;
-	brelse(bp); 
-	return(error);
-}
-/* ARGSUSED */
-int 
-raidwrite_component_label(dev, b_vp, clabel)
-	dev_t dev; 
-	struct vnode *b_vp;
-	RF_ComponentLabel_t *clabel;
-{
-	struct buf *bp;
-	int error;
-
-	/* 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 */
-	bp->b_flags = 0;
-	bp->b_blkno = RF_COMPONENT_INFO_OFFSET / DEV_BSIZE;
-	bp->b_iooffset = RF_COMPONENT_INFO_OFFSET;
-	bp->b_bcount = RF_COMPONENT_INFO_SIZE;
-	bp->b_iocmd = BIO_WRITE;
- 	bp->b_resid = RF_COMPONENT_INFO_SIZE / DEV_BSIZE;
-
-	memset(bp->b_data, 0, RF_COMPONENT_INFO_SIZE );
-
-	memcpy(bp->b_data, clabel, sizeof(RF_ComponentLabel_t));
-
-	DEV_STRATEGY(bp);
-	error = bufwait(bp); 
-
-	bp->b_flags |= B_INVAL | B_AGE;
-	brelse(bp);
-	if (error) {
-#if 1
-		rf_printf(0, "Failed to write RAID component info!\n");
-		rf_printf(0, "b_error= %d\n", bp->b_error);
-#endif
-	}
-
-	return(error);
-}
-
-void 
-rf_markalldirty(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	RF_ComponentLabel_t *clabel;
-	int r,c;
-
-	MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t),
-	    M_RAIDFRAME, M_NOWAIT | M_ZERO);
-
-	if (clabel == NULL) {
-		printf("rf_markalldirty: Out of memory?\n");
-		return;
-	}
-
-	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 */
-			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);
-				if (clabel->status == rf_ds_spared) {
-					/* 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);
-#endif
-				raidmarkdirty( 
-				       raidPtr->Disks[r][c].dev, 
-				       raidPtr->raid_cinfo[r][c].ci_vp,
-				       raidPtr->mod_counter);
-				}
-			}
-		} 
-	}
-	/* 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.
-
-			 */
-			/* 
-			   
-			   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 == 
-					     r) &&
-					    (raidPtr->Disks[i][j].spareCol ==
-					     sparecol)) {
-						srow = r;
-						scol = sparecol;
-						break;
-					}
-				}
-			}
-			
-			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.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);
-		}
-	}
-
-#endif
-	FREE(clabel, M_RAIDFRAME);
-}
-
-
-void
-rf_update_component_labels(raidPtr, final)
-	RF_Raid_t *raidPtr;
-	int final;
-{
-	RF_ComponentLabel_t *clabel;
-	int sparecol;
-	int r,c;
-	int i,j;
-	int srow, scol;
-
-	srow = -1;
-	scol = -1;
-
-	MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t),
-	    M_RAIDFRAME, M_NOWAIT | M_ZERO);
-	if (clabel == NULL) {
-		printf("rf_update_component_labels: Out of memory?\n");
-		return;
-	}
-
-	/* XXX should do extra checks to make sure things really are clean, 
-	   rather than blindly setting the clean bit... */
-
-	raidPtr->mod_counter++;
-
-	for (r = 0; r < raidPtr->numRow; r++) {
-		for (c = 0; c < raidPtr->numCol; c++) {
-			if (raidPtr->Disks[r][c].status == rf_ds_optimal) {
-				raidread_component_label(
-					raidPtr->Disks[r][c].dev,
-					raidPtr->raid_cinfo[r][c].ci_vp,
-					clabel);
-				/* make sure status is noted */
-				clabel->status = rf_ds_optimal;
-				/* bump the counter */
-				clabel->mod_counter = raidPtr->mod_counter;
-
-				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);
-					}
-				}
-			} 
-			/* 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...
-
-			 */
-
-			for(i=0;i<raidPtr->numRow;i++) {
-				for(j=0;j<raidPtr->numCol;j++) {
-					if ((raidPtr->Disks[i][j].spareRow == 
-					     0) &&
-					    (raidPtr->Disks[i][j].spareCol ==
-					     sparecol)) {
-						srow = i;
-						scol = j;
-						break;
-					}
-				}
-			}
-			
-			/* 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);
-
-			clabel->mod_counter = raidPtr->mod_counter;
-			clabel->row = srow;
-			clabel->column = scol;
-			clabel->status = rf_ds_optimal;
-
-			raidwrite_component_label(
-				      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);
-				}
-			}
-		}
-	}
-	FREE(clabel, M_RAIDFRAME);
-	rf_printf(1, "Component labels updated\n");
-}
-
-void
-rf_close_component(raidPtr, vp, auto_configured)
-	RF_Raid_t *raidPtr;
-	struct vnode *vp;
-	int auto_configured;
-{
-	struct thread *td;
-
-	td = raidPtr->engine_thread;
-
-	if (vp != NULL) {
-		if (auto_configured == 1) {
-			VOP_CLOSE(vp, FREAD | FWRITE, td->td_ucred, td);
-			
-			vrele(vp);
-		} else {				
-			vn_close(vp, FREAD | FWRITE, td->td_ucred, td);
-		}
-	} else {
-		rf_printf(1, "vnode was NULL\n");
-	}
-}
-
-
-void
-rf_UnconfigureVnodes(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	int r,c; 
-	struct thread *td;
-	struct vnode *vp;
-	int acd;
-
-
-	/* We take this opportunity to close the vnodes like we should.. */
-
-	td = raidPtr->engine_thread;
-
-	for (r = 0; r < raidPtr->numRow; r++) {
-		for (c = 0; c < raidPtr->numCol; c++) {
-			rf_printf(1, "Closing vnode for row: %d col: %d\n", r, c);
-			vp = raidPtr->raid_cinfo[r][c].ci_vp;
-			acd = raidPtr->Disks[r][c].auto_configured;
-			rf_close_component(raidPtr, vp, acd);
-			raidPtr->raid_cinfo[r][c].ci_vp = NULL;
-			raidPtr->Disks[r][c].auto_configured = 0;
-		}
-	}
-	for (r = 0; r < raidPtr->numSpare; r++) {
-		rf_printf(1, "Closing vnode for spare: %d\n", r);
-		vp = raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp;
-		acd = raidPtr->Disks[0][raidPtr->numCol + r].auto_configured;
-		rf_close_component(raidPtr, vp, acd);
-		raidPtr->raid_cinfo[0][raidPtr->numCol + r].ci_vp = NULL;
-		raidPtr->Disks[0][raidPtr->numCol + r].auto_configured = 0;
-	}
-}
-
-
-void 
-rf_ReconThread(req)
-	struct rf_recon_req *req;
-{
-	RF_Raid_t *raidPtr;
-
-	mtx_lock(&Giant);
-	raidPtr = (RF_Raid_t *) req->raidPtr;
-	raidPtr->recon_in_progress = 1;
-
-	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.. */
-	RF_Free(req, sizeof(*req));
-
-	raidPtr->recon_in_progress = 0;
-
-	/* That's all... */
-	RF_THREAD_EXIT(0);        /* does not return */
-}
-
-void
-rf_RewriteParityThread(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	int retcode;
-
-	mtx_lock(&Giant);
-	raidPtr->parity_rewrite_in_progress = 1;
-	retcode = rf_RewriteParity(raidPtr);
-	if (retcode) {
-		rf_printf(0, "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 */
-		raidPtr->parity_good = RF_RAID_CLEAN;
-	}
-	raidPtr->parity_rewrite_in_progress = 0;
-
-	/* Anyone waiting for us to stop?  If so, inform them... */
-	if (raidPtr->waitShutdown) {
-		wakeup(&raidPtr->parity_rewrite_in_progress);
-	}
-
-	/* That's all... */
-	RF_THREAD_EXIT(0);        /* does not return */
-}
-
-
-void
-rf_CopybackThread(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	mtx_lock(&Giant);
-	raidPtr->copyback_in_progress = 1;
-	rf_CopybackReconstructedData(raidPtr);
-	raidPtr->copyback_in_progress = 0;
-
-	/* That's all... */
-	RF_THREAD_EXIT(0);        /* does not return */
-}
-
-
-void
-rf_ReconstructInPlaceThread(req)
-	struct rf_recon_req *req;
-{
-	int retcode;
-	RF_Raid_t *raidPtr;
-	
-	mtx_lock(&Giant);
-	raidPtr = req->raidPtr;
-	raidPtr->recon_in_progress = 1;
-	retcode = rf_ReconstructInPlace(raidPtr, req->row, req->col);
-	RF_Free(req, sizeof(*req));
-	raidPtr->recon_in_progress = 0;
-
-	/* That's all... */
-	RF_THREAD_EXIT(0);        /* does not return */
-}
-
-RF_AutoConfig_t *
-rf_find_raid_components()
-{
-	RF_AutoConfig_t *ac_list = NULL;
-#if 0 /* XXX GEOM */
-	struct vnode *vp;
-	struct disklabel *label;
-	struct diskslice *slice;
-	struct diskslices *slices;
-	struct disk *disk;
-	struct thread *td;
-	dev_t dev;
-	char *devname;
-	int error, j;
-	int nslices;
-
-	td = curthread;
-
-	MALLOC(label, struct disklabel *, sizeof(struct disklabel),
-	    M_RAIDFRAME, M_NOWAIT|M_ZERO);
-	MALLOC(slices, struct diskslices *, sizeof(struct diskslices),
-	    M_RAIDFRAME, M_NOWAIT|M_ZERO);
-	if ((label == NULL) || (slices == NULL)) {
-		printf("rf_find_raid_components: Out of Memory?\n");
-		return (NULL);
-	}
-
-	/* initialize the AutoConfig list */
-	ac_list = NULL;
-
-	/* we begin by trolling through *all* the disk devices on the system */
-
-	disk = NULL;
-	while ((disk = disk_enumerate(disk))) {
-
-		/* we don't care about floppies... */
-		devname = disk->d_dev->si_name;
-		if (!strncmp(devname, "fd", 2) ||
-		    !strncmp(devname, "cd", 2) ||
-		    !strncmp(devname, "acd", 3))
-			continue;
-
-		rf_printf(1, "Examining %s\n", disk->d_dev->si_name);
-		if (bdevvp(disk->d_dev, &vp))
-			panic("RAIDframe can't alloc vnode");
-		vref(vp);
-
-		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
-		error = VOP_OPEN(vp, FREAD, td->td_ucred, td, -1);
-		VOP_UNLOCK(vp, 0, td);
-		if (error) {
-			vput(vp);
-			continue;
-		}
-
-		error = VOP_IOCTL(vp, DIOCGSLICEINFO, (caddr_t)slices,
-		    FREAD, td->td_ucred, td);
-		VOP_CLOSE(vp, FREAD | FWRITE, td->td_ucred, td);
-		vrele(vp);
-		if (error) {
-			/* No slice table. */
-			continue;
-		}
-
-		nslices = slices->dss_nslices;
-		if ((nslices == 0) || (nslices > MAX_SLICES))
-			continue;
-
-		/* Iterate through the slices */
-		for (j = 1; j < nslices; j++) {
-
-			rf_printf(1, "Examining slice %d\n", j);
-			slice = &slices->dss_slices[j - 1];
-			dev = dkmodslice(disk->d_dev, j);
-			if (bdevvp(dev, &vp))
-				panic("RAIDframe can't alloc vnode");
-
-			vref(vp);
-			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
-			error = VOP_OPEN(vp, FREAD, td->td_ucred, td, -1);
-			VOP_UNLOCK(vp, 0, td);
-			if (error) {
-				continue;
-			}
-
-			error = VOP_IOCTL(vp, DIOCGDINFO, (caddr_t)label,
-			    FREAD, td->td_ucred, td);
-			VOP_CLOSE(vp, FREAD | FWRITE, td->td_ucred, td);
-			vrele(vp);
-			if (error)
-				continue;
-
-			rf_search_label(dev, label, &ac_list);
-		}
-	}
-
-	FREE(label, M_RAIDFRAME);
-	FREE(slices, M_RAIDFRAME);
-#endif
-	return (ac_list);
-}
-
-static void
-rf_search_label(dev_t dev, struct disklabel *label, RF_AutoConfig_t **ac_list)
-{
-	RF_AutoConfig_t *ac;
-	RF_ComponentLabel_t *clabel;
-	struct vnode *vp;
-	struct thread *td;
-	dev_t dev1;
-	int i, error, good_one;
-
-	td = curthread;
-
-	/* Iterate through the partitions */
-	for (i=0; i < label->d_npartitions; i++) {
-		/* We only support partitions marked as RAID */
-		if (label->d_partitions[i].p_fstype != FS_RAID)
-			continue;
-
-#if 0 /* GEOM */
-		dev1 = dkmodpart(dev, i);
-#else
-		dev1 = NULL;
-#endif
-		if (dev1 == NULL) {
-			rf_printf(1, "dev1 == null\n");
-			continue;
-		}
-		if (bdevvp(dev1, &vp))
-			panic("RAIDframe can't alloc vnode");
-
-		vref(vp);
-		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
-		error = VOP_OPEN(vp, FREAD, td->td_ucred, td, -1);
-		VOP_UNLOCK(vp, 0, td);
-		if (error) {
-			/* Whatever... */
-			continue;
-		}
-
-		good_one = 0;
-
-		clabel = (RF_ComponentLabel_t *) 
-			malloc(sizeof(RF_ComponentLabel_t), M_RAIDFRAME,
-			       M_NOWAIT);
-		if (clabel == NULL) {
-			/* XXX CLEANUP HERE */
-			panic("RAID autoconfig: no memory!\n");
-		}
-
-		if (!raidread_component_label(dev1, vp, clabel)) {
-			/* Got the label.  Is it reasonable? */
-			if (rf_reasonable_label(clabel) &&
-			    (clabel->partitionSize <= 
-			     label->d_partitions[i].p_size)) {
-				rf_printf(1, "Component on: %s: %d\n",
-				    dev1->si_name, label->d_partitions[i].p_size);
-				rf_print_component_label(clabel);
-				/* if it's reasonable, add it, else ignore it */
-				ac = (RF_AutoConfig_t *)
-					malloc(sizeof(RF_AutoConfig_t),
-					       M_RAIDFRAME, M_NOWAIT);
-				if (ac == NULL) {
-					/* XXX should panic? */
-					panic("RAID autoconfig: no memory!\n");
-				}
-			
-				sprintf(ac->devname, "%s", dev->si_name);
-				ac->dev = dev1;
-				ac->vp = vp;
-				ac->clabel = clabel;
-				ac->next = *ac_list;
-				*ac_list = ac;
-				good_one = 1;
-			} 
-		}
-		if (!good_one) {
-			/* cleanup */
-			free(clabel, M_RAIDFRAME);
-			VOP_CLOSE(vp, FREAD | FWRITE, td->td_ucred, td);
-			vrele(vp);
-		}
-	}
-}
-
-static int
-rf_reasonable_label(clabel)
-	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->num_rows > 0 &&
-	    clabel->num_columns > 0 &&
-	    clabel->row < clabel->num_rows && 
-	    clabel->column < clabel->num_columns &&
-	    clabel->blockSize > 0 &&
-	    clabel->numBlocks > 0) {
-		/* label looks reasonable enough... */
-		return(1);
-	}
-	return(0);
-}
-
-
-void
-rf_print_component_label(clabel)
-	RF_ComponentLabel_t *clabel;
-{
-	rf_printf(1, "   Row: %d Column: %d Num Rows: %d Num Columns: %d\n",
-	       clabel->row, clabel->column, 
-	       clabel->num_rows, clabel->num_columns);
-	rf_printf(1, "   Version: %d Serial Number: %d Mod Counter: %d\n",
-	       clabel->version, clabel->serial_number,
-	       clabel->mod_counter);
-	rf_printf(1, "   Clean: %s Status: %d\n",
-	       clabel->clean ? "Yes" : "No", clabel->status );
-	rf_printf(1, "   sectPerSU: %d SUsPerPU: %d SUsPerRU: %d\n",
-	       clabel->sectPerSU, clabel->SUsPerPU, clabel->SUsPerRU);
-	rf_printf(1, "   RAID Level: %c  blocksize: %d numBlocks: %d\n",
-	       (char) clabel->parityConfig, clabel->blockSize, 
-	       clabel->numBlocks);
-	rf_printf(1, "   Autoconfig: %s\n", clabel->autoconfigure ? "Yes":"No");
-	rf_printf(1, "   Contains root partition: %s\n",  
-	       clabel->root_partition ? "Yes" : "No" );
-	rf_printf(1, "   Last configured as: raid%d\n", clabel->last_unit );
-#if 0
-	rf_printf(1, "   Config order: %d\n", clabel->config_order);
-#endif
-	       
-}
-
-RF_ConfigSet_t *
-rf_create_auto_sets(ac_list)
-	RF_AutoConfig_t *ac_list;
-{
-	RF_AutoConfig_t *ac;
-	RF_ConfigSet_t *config_sets;
-	RF_ConfigSet_t *cset;
-	RF_AutoConfig_t *ac_next;
-
-
-	config_sets = NULL;
-
-	/* 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 */
-		ac_next = ac->next;
-
-		if (config_sets == NULL) {
-			/* will need at least this one... */
-			config_sets = (RF_ConfigSet_t *)
-				malloc(sizeof(RF_ConfigSet_t), 
-				       M_RAIDFRAME, M_NOWAIT);
-			if (config_sets == NULL) {
-				panic("rf_create_auto_sets: No memory!\n");
-			}
-			/* 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? */
-			cset = config_sets;
-			while(cset!=NULL) {
-				if (rf_does_it_fit(cset, ac)) {
-					/* looks like it matches... */
-					ac->next = cset->ac;
-					cset->ac = ac;
-					break;
-				}
-				cset = cset->next;
-			}
-			if (cset==NULL) {
-				/* didn't find a match above... new set..*/
-				cset = (RF_ConfigSet_t *)
-					malloc(sizeof(RF_ConfigSet_t), 
-					       M_RAIDFRAME, M_NOWAIT);
-				if (cset == NULL) {
-					panic("rf_create_auto_sets: No memory!\n");
-				}
-				cset->ac = ac;
-				ac->next = NULL;
-				cset->next = config_sets;
-				cset->rootable = 0;
-				config_sets = cset;
-			}
-		}
-		ac = ac_next;
-	}
-
-
-	return(config_sets);
-}
-
-static int
-rf_does_it_fit(cset, ac)	
-	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.
-
-	*/
-
-	clabel1 = cset->ac->clabel;
-	clabel2 = ac->clabel;
-	if ((clabel1->version == clabel2->version) &&
-	    (clabel1->serial_number == clabel2->serial_number) &&
-	    (clabel1->num_rows == clabel2->num_rows) &&
-	    (clabel1->num_columns == clabel2->num_columns) &&
-	    (clabel1->sectPerSU == clabel2->sectPerSU) &&
-	    (clabel1->SUsPerPU == clabel2->SUsPerPU) &&
-	    (clabel1->SUsPerRU == clabel2->SUsPerRU) &&
-	    (clabel1->parityConfig == clabel2->parityConfig) &&
-	    (clabel1->maxOutstanding == clabel2->maxOutstanding) &&
-	    (clabel1->blockSize == clabel2->blockSize) &&
-	    (clabel1->numBlocks == clabel2->numBlocks) &&
-	    (clabel1->autoconfigure == clabel2->autoconfigure) &&
-	    (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 */
-	} else {
-		/* it's not consistent with somebody in the set.. 
-		   punt */
-		return(0);
-	}
-	/* all was fine.. it must fit... */
-	return(1);
-}
-
-int
-rf_have_enough_components(cset)
-	RF_ConfigSet_t *cset;
-{
-	RF_AutoConfig_t *ac;
-	RF_AutoConfig_t *auto_config;
-	RF_ComponentLabel_t *clabel;
-	int r,c;
-	int num_rows;
-	int num_cols;
-	int num_missing;
-	int mod_counter;
-	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 */
-
-	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!?!?!? */
-
-	/* Determine what the mod_counter is supposed to be for this set. */
-
-	mod_counter_found = 0;
-	mod_counter = 0;
-	ac = cset->ac;
-	while(ac!=NULL) {
-		if (mod_counter_found==0) {
-			mod_counter = ac->clabel->mod_counter;
-			mod_counter_found = 1;
-		} else {
-			if (ac->clabel->mod_counter > mod_counter) {
-				mod_counter = ac->clabel->mod_counter;
-			}
-		}
-		ac = ac->next;
-	}
-
-	num_missing = 0;
-	auto_config = cset->ac;
-
-	for(r=0; r<num_rows; r++) {
-		even_pair_failed = 0;
-		for(c=0; c<num_cols; c++) {
-			ac = auto_config;
-			while(ac!=NULL) {
-				if ((ac->clabel->row == r) &&
-				    (ac->clabel->column == c) && 
-				    (ac->clabel->mod_counter == mod_counter)) {
-					/* it's this one... */
-					rf_printf(1, "Found: %s at %d,%d\n",
-					       ac->devname,r,c);
-					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 :( ) */
-				if (parity_type == '1') {
-					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" */
-						if (even_pair_failed == 1) {
-							return(0);
-						}
-					}
-				} else {
-					/* 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.... */
-				even_pair_failed = 0;
-			}
-		}
-	}
-
-	clabel = cset->ac->clabel;
-
-	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 */
-		return(0);
-	}
-	/* 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_ComponentLabel_t *clabel;
-	int i;
-
-	clabel = ac->clabel;
-
-	/* 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->sectPerSU = clabel->sectPerSU;
-	config->SUsPerPU = clabel->SUsPerPU;
-	config->SUsPerRU = clabel->SUsPerRU;
-	config->parityConfig = clabel->parityConfig;
-	/* XXX... */
-	strcpy(config->diskQueueType,"fifo");
-	config->maxOutstandingDiskReqs = clabel->maxOutstanding;
-	config->layoutSpecificSize = 0; /* XXX ? */
-
-	while(ac!=NULL) {
-		/* 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 = ac->next;
-	}
-
-	for(i=0;i<RF_MAXDBGV;i++) {
-		config->debugVars[i][0] = '\0';
-	}
-}
-
-int
-rf_set_autoconfig(raidPtr, new_value)
-	RF_Raid_t *raidPtr;
-	int new_value;
-{
-	RF_ComponentLabel_t *clabel;
-	struct vnode *vp;
-	dev_t dev;
-	int row, column;
-
-	MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t),
-	    M_RAIDFRAME, M_WAITOK | M_ZERO);
-
-	raidPtr->autoconfigure = new_value;
-	for(row=0; row<raidPtr->numRow; row++) {
-		for(column=0; column<raidPtr->numCol; column++) {
-			if (raidPtr->Disks[row][column].status == 
-			    rf_ds_optimal) {
-				dev = raidPtr->Disks[row][column].dev;
-				vp = raidPtr->raid_cinfo[row][column].ci_vp;
-				raidread_component_label(dev, vp, clabel);
-				clabel->autoconfigure = new_value;
-				raidwrite_component_label(dev, vp, clabel);
-			}
-		}
-	}
-	FREE(clabel, M_RAIDFRAME);
-	return(new_value);
-}
-
-int
-rf_set_rootpartition(raidPtr, new_value)
-	RF_Raid_t *raidPtr;
-	int new_value;
-{
-	RF_ComponentLabel_t *clabel;
-	struct vnode *vp;
-	dev_t dev;
-	int row, column;
-
-	MALLOC(clabel, RF_ComponentLabel_t *, sizeof(RF_ComponentLabel_t),
-	    M_RAIDFRAME, M_WAITOK | M_ZERO);
-
-	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 == 
-			    rf_ds_optimal) {
-				dev = raidPtr->Disks[row][column].dev;
-				vp = raidPtr->raid_cinfo[row][column].ci_vp;
-				raidread_component_label(dev, vp, clabel);
-				clabel->root_partition = new_value;
-				raidwrite_component_label(dev, vp, clabel);
-			}
-		}
-	}
-	FREE(clabel, M_RAIDFRAME);
-	return(new_value);
-}
-
-void
-rf_release_all_vps(cset)
-	RF_ConfigSet_t *cset;
-{
-	RF_AutoConfig_t *ac;
-	struct thread *td;
-
-	td = curthread;
-	ac = cset->ac;
-	while(ac!=NULL) {
-		/* Close the vp, and give it back */
-		if (ac->vp) {
-			VOP_CLOSE(ac->vp, FREAD, td->td_ucred, td);
-			vrele(ac->vp);
-			ac->vp = NULL;
-		}
-		ac = ac->next;
-	}
-}
-
-
-void
-rf_cleanup_config_set(cset)
-	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 */
-		free(ac->clabel, M_RAIDFRAME);
-		/* cleanup the config structure */
-		free(ac, M_RAIDFRAME);
-		/* "next.." */
-		ac = next_ac;
-	}
-	/* 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;
-{
-	/* 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->sectPerSU = raidPtr->Layout.sectorsPerStripeUnit;
-	clabel->SUsPerPU = raidPtr->Layout.SUsPerPU;
-	clabel->SUsPerRU = raidPtr->Layout.SUsPerRU;
-
-	clabel->blockSize = raidPtr->bytesPerSector;
-	clabel->numBlocks = raidPtr->sectorsPerDisk;
-
-	/* XXX not portable */
-	clabel->parityConfig = raidPtr->Layout.map->parityConfig;
-	clabel->maxOutstanding = raidPtr->maxOutstanding;
-	clabel->autoconfigure = raidPtr->autoconfigure;
-	clabel->root_partition = raidPtr->root_partition;
-	clabel->last_unit = raidPtr->raidid;
-	clabel->config_order = raidPtr->config_order;
-}
-
-int
-rf_auto_config_set(cset, unit, parent_sc)
-	RF_ConfigSet_t *cset;
-	int *unit;
-	struct raidctl_softc *parent_sc;
-{
-	int retcode = 0;
-	RF_Raid_t *raidPtr;
-	RF_Config_t *config;
-	int raidID;
-
-	rf_printf(0, "RAIDframe autoconfigure\n");
-
-	*unit = -1;
-
-	/* 1. Create a config structure */
-
-	config = (RF_Config_t *)malloc(sizeof(RF_Config_t), M_RAIDFRAME,
-				       M_NOWAIT|M_ZERO);
-	if (config==NULL) {
-		rf_printf(0, "Out of mem at rf_auto_config_set\n");
-				/* XXX do something more intelligent here. */
-		return(1);
-	}
-
-	/* 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.. 
-	*/
-
-	raidID = cset->ac->clabel->last_unit;
-	if (raidID < 0) {
-		/* let's not wander off into lala land. */
-		raidID = raidgetunit(parent_sc, 0);
-	} else {
-		raidID = raidgetunit(parent_sc, raidID);
-	}
-
-	if (raidID < 0) {
-		/* punt... */
-		rf_printf(0, "Unable to auto configure this set!\n");
-		rf_printf(1, "Out of RAID devs!\n");
-		return(1);
-	}
-	rf_printf(0, "Configuring raid%d:\n",raidID);
-	RF_Malloc(raidPtr, sizeof(*raidPtr), (RF_Raid_t *));
-	if (raidPtr == NULL) {
-		rf_printf(0, "Out of mem at rf_auto_config_set\n");
-		return (1);
-	}
-	bzero((char *)raidPtr, sizeof(RF_Raid_t));
-
-	/* XXX all this stuff should be done SOMEWHERE ELSE! */
-	raidPtr->raidid = raidID;
-	raidPtr->openings = RAIDOUTSTANDING;
-
-	/* 3. Build the configuration structure */
-	rf_create_configuration(cset->ac, config, raidPtr);
-
-	/* 4. Do the configuration */
-	retcode = rf_Configure(raidPtr, config, cset->ac);
-	
-	if (retcode == 0) {
-
-		parent_sc->sc_raiddevs[raidID] = raidinit(raidPtr);
-		if (parent_sc->sc_raiddevs[raidID] == NULL) {
-			rf_printf(0, "Could not create RAID device\n");
-			RF_Free(raidPtr, sizeof(RF_Raid_t));
-			free(config, M_RAIDFRAME);
-			return (1);
-		}
-
-		parent_sc->sc_numraid++;
-		((struct raid_softc *)raidPtr->sc)->sc_parent_dev =
-		    parent_sc->sc_dev;
-		rf_markalldirty(raidPtr);
-		raidPtr->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. */
-			cset->rootable = 1;
-			/* XXX do this here? */
-			raidPtr->root_partition = 1; 
-		}
-	}
-
-	/* 5. Cleanup */
-	free(config, M_RAIDFRAME);
-	
-	*unit = raidID;
-	return(retcode);
-}
-
-void
-rf_disk_unbusy(desc)
-	RF_RaidAccessDesc_t *desc;
-{
-	struct raid_softc *sc;
-	struct bio *bp;
-
-	sc = desc->raidPtr->sc;
-	bp = (struct bio *)desc->bp;
-}
-
-/*
- * Get the next available unit number from the bitmap.  You can also request
- * a particular unit number by passing it in the second arg.  If it's not
- * available, then grab the next free one.  Return -1 if none are available.
- */
-static int
-raidgetunit(struct raidctl_softc *parent_sc, int id)
-{
-	int i;
-
-	if (id >= RF_MAX_ARRAYS)
-		return (-1);
-
-	for (i = id; i < RF_MAX_ARRAYS; i++) {
-		if (parent_sc->sc_raiddevs[i] == NULL)
-			return (i);
-	}
-
-	if (id != 0) {
-		for (i = 0; i < id; i++) {
-			if (parent_sc->sc_raiddevs[i] == NULL)
-				return (i);
-		}
-	}
-
-	return (-1);
-}
-
-static int
-raidshutdown(void)
-{
-	struct raidctl_softc *parent_sc;
-	int i, error = 0;
-
-	parent_sc = raidctl_dev->si_drv1;
-
-	if (parent_sc->sc_numraid != 0) {
-#if XXX_KTHREAD_EXIT_RACE
-		return (EBUSY);
-#else
-		for (i = 0; i < RF_MAX_ARRAYS; i++) {
-			if (parent_sc->sc_raiddevs[i] != NULL) {
-				rf_printf(0, "Shutting down raid%d\n", i);
-				error = raidctlioctl(raidctl_dev,
-				    RAIDFRAME_SHUTDOWN, (caddr_t)&i, 0, NULL);
-				if (error)
-					return (error);
-				if (parent_sc->sc_numraid == 0)
-					break;
-			}
-		}
-#endif
-	}
-
-	destroy_dev(raidctl_dev);
-
-	return (error);
-}
-
-int
-raid_getcomponentsize(RF_Raid_t *raidPtr, RF_RowCol_t row, RF_RowCol_t col)
-{
-	struct vnode *vp;
-	struct vattr va;
-	RF_Thread_t td;
-	off_t mediasize;
-	u_int secsize;
-	int retcode;
-
-	td = raidPtr->engine_thread;
-
-	retcode = raidlookup(raidPtr->Disks[row][col].devname, td, &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 be still dead :-( */
-		raidPtr->reconInProgress--;
-		return(retcode);
-
-	} else {
-
-		/* Ok, so we can at least do a lookup... 
-		   How about actually getting a vp for it? */
-
-		if ((retcode = VOP_GETATTR(vp, &va, rf_getucred(td),
-					   td)) != 0) {
-			raidPtr->reconInProgress--;
-			return(retcode);
-		}
-		
-		retcode = VOP_IOCTL(vp, DIOCGSECTORSIZE, (caddr_t)&secsize,
-		    FREAD, rf_getucred(td), td);
-		if (retcode)
-			return (retcode);
-		raidPtr->Disks[row][col].blockSize = secsize;
-
-		retcode = VOP_IOCTL(vp, DIOCGMEDIASIZE, (caddr_t)&mediasize,
-		    FREAD, rf_getucred(td), td);
-		if (retcode)
-			return (retcode);
-		raidPtr->Disks[row][col].numBlocks = mediasize / secsize;
-
-		raidPtr->raid_cinfo[row][col].ci_vp = vp;
-		raidPtr->raid_cinfo[row][col].ci_dev = udev2dev(va.va_rdev);
-		raidPtr->Disks[row][col].dev = udev2dev(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 */
-		raidPtr->Disks[row][col].numBlocks =
-			raidPtr->Disks[row][col].numBlocks *
-			rf_sizePercentage / 100;
-	}
-
-	return(retcode);
-}
-
-static int
-raid_modevent(mod, type, data)
-	module_t mod;
-	int type;
-	void *data;
-{
-	int error = 0;
-
-	switch (type) {
-	case MOD_LOAD:
-		raidattach();
-		break;
-
-	case MOD_UNLOAD:
-	case MOD_SHUTDOWN:
-		error = raidshutdown();
-		break;
-
-	default:
-		break;
-	}
-
-	return (error);
-}
-
-moduledata_t raid_mod = {
-	"raidframe",
-	(modeventhand_t) raid_modevent,
-	0};
-
-DECLARE_MODULE(raidframe, raid_mod, SI_SUB_RAID, SI_ORDER_MIDDLE);
diff --git a/sys/dev/raidframe/rf_freelist.h b/sys/dev/raidframe/rf_freelist.h
deleted file mode 100644
index 13a5e83..0000000
--- a/sys/dev/raidframe/rf_freelist.h
+++ /dev/null
@@ -1,702 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_freelist.h,v 1.6 2002/08/08 02:53:01 oster Exp $	*/
-/*
- * rf_freelist.h
- */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_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
- * in the arena, or really free it, depending on the maximum arena
- * size.
- */
-
-#ifndef _RF__RF_FREELIST_H_
-#define _RF__RF_FREELIST_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_threadstuff.h>
-
-#define 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 */
-
-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 */
-};
-/*
- * 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, "RF_FREELIST"); \
-	if (rc) { \
-		RF_Free(_fl_, sizeof(RF_FreeList_t)); \
-		_fl_ = NULL; \
-	} \
-	RF_FREELIST_STAT_INIT(_fl_); \
-}
-
-/*
- * 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; \
-	for(_i=0;_i<(_cnt_);_i++) { \
-		RF_Calloc(_p,1,(_fl_)->obj_size,(void *)); \
-		if (_p) { \
-			RF_LOCK_MUTEX((_fl_)->lock); \
-			(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-			(_fl_)->objlist = _p; \
-			(_fl_)->free_cnt++; \
-			RF_UNLOCK_MUTEX((_fl_)->lock); \
-		} \
-		else { \
-			break; \
-		} \
-	} \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	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); \
-}
-
-/*
- * 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; \
-	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) { \
-			RF_LOCK_MUTEX((_fl_)->lock); \
-			(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-			(_fl_)->objlist = _p; \
-			(_fl_)->free_cnt++; \
-			RF_UNLOCK_MUTEX((_fl_)->lock); \
-		} \
-		else { \
-			break; \
-		} \
-	} \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
-	RF_UNLOCK_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
- * arg   = arg to init obj func
- */
-#define RF_FREELIST_PRIME_INIT_ARG(_fl_,_cnt_,_nextp_,_cast_,_init_,_arg_) { \
-	void *_p; \
-	int _i; \
-	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) { \
-			RF_LOCK_MUTEX((_fl_)->lock); \
-			(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-			(_fl_)->objlist = _p; \
-			(_fl_)->free_cnt++; \
-			RF_UNLOCK_MUTEX((_fl_)->lock); \
-		} \
-		else { \
-			break; \
-		} \
-	} \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_FREELIST_STAT_FREE_UPDATE(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
-
-/*
- * 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--; \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-	} \
-	else { \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-		/* \
-		 * 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; \
-						} \
-						RF_LOCK_MUTEX((_fl_)->lock); \
-						(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-						(_fl_)->objlist = _p; \
-						RF_UNLOCK_MUTEX((_fl_)->lock); \
-					} \
-					else { \
-						break; \
-					} \
-				} \
-			} \
-		} \
-		RF_LOCK_MUTEX((_fl_)->lock); \
-		RF_FREELIST_STAT_GROW(_fl_); \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-	} \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_FREELIST_STAT_ALLOC(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
-
-/*
- * 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--; \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-	} \
-	else { \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-		/* \
-		 * 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; \
-						} \
-						RF_LOCK_MUTEX((_fl_)->lock); \
-						(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-						(_fl_)->objlist = _p; \
-						RF_UNLOCK_MUTEX((_fl_)->lock); \
-					} \
-					else { \
-						break; \
-					} \
-				} \
-			} \
-		} \
-		RF_LOCK_MUTEX((_fl_)->lock); \
-		RF_FREELIST_STAT_GROW(_fl_); \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-	} \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_FREELIST_STAT_ALLOC(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
-
-/*
- * 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_); \
-}
-
-/*
- * 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--; \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-	} \
-	else { \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-		/* \
-		 * 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) { \
-					RF_LOCK_MUTEX((_fl_)->lock); \
-					(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-					(_fl_)->objlist = _p; \
-					RF_UNLOCK_MUTEX((_fl_)->lock); \
-				} \
-				else { \
-					break; \
-				} \
-			} \
-		} \
-		RF_LOCK_MUTEX((_fl_)->lock); \
-		RF_FREELIST_STAT_GROW(_fl_); \
-		RF_UNLOCK_MUTEX((_fl_)->lock); \
-	} \
-	RF_LOCK_MUTEX((_fl_)->lock); \
-	RF_FREELIST_STAT_ALLOC(_fl_); \
-	RF_UNLOCK_MUTEX((_fl_)->lock); \
-}
-
-/*
- * 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_ASSERT(sizeof(*(_obj_))==((_fl_)->obj_size)); \
-	for(_n=0;_n<_num_;_n++) { \
-		RF_LOCK_MUTEX((_fl_)->lock); \
-		if (_fl_->objlist) { \
-			_obj_ = _cast_((_fl_)->objlist); \
-			(_fl_)->objlist = (void *)((_obj_)->_nextp_); \
-			(_fl_)->free_cnt--; \
-			RF_UNLOCK_MUTEX((_fl_)->lock); \
-		} \
-		else { \
-			RF_UNLOCK_MUTEX((_fl_)->lock); \
-			/* \
-			 * 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) { \
-						RF_LOCK_MUTEX((_fl_)->lock); \
-						(_cast_(_p))->_nextp_ = (_fl_)->objlist; \
-						(_fl_)->objlist = _p; \
-						RF_UNLOCK_MUTEX((_fl_)->lock); \
-					} \
-					else { \
-						break; \
-					} \
-				} \
-			} \
-			RF_LOCK_MUTEX((_fl_)->lock); \
-			RF_FREELIST_STAT_GROW(_fl_); \
-			RF_UNLOCK_MUTEX((_fl_)->lock); \
-		} \
-		RF_LOCK_MUTEX((_fl_)->lock); \
-		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); \
-	} \
-}
-
-/*
- * 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); \
-}
-
-/*
- * 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); \
-}
-
-/*
- * 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); \
-}
-
-/*
- * 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); \
-}
-
-/*
- * 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_); \
-}
-
-/*
- * 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)); \
-}
-
-/*
- * 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)); \
-}
-
-/*
- * 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_ */
diff --git a/sys/dev/raidframe/rf_general.h b/sys/dev/raidframe/rf_general.h
deleted file mode 100644
index e709899..0000000
--- a/sys/dev/raidframe/rf_general.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_general.h,v 1.6 2000/12/15 02:12:58 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_general.h -- some general-use definitions
- */
-
-/*#define NOASSERT*/
-
-#ifndef _RF__RF_GENERAL_H_
-#define _RF__RF_GENERAL_H_
-
-/* error reporting and handling */
-
-#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))
-
-void rf_print_panic_message(int, char *);
-void rf_print_assert_panic_message(int, char *, char *);
-
-extern char rf_panicbuf[];
-#define RF_PANIC() {rf_print_panic_message(__LINE__,__FILE__); panic(rf_panicbuf);}
-
-#ifdef _KERNEL
-#ifdef RF_ASSERT
-#undef RF_ASSERT
-#endif				/* RF_ASSERT */
-#ifndef NOASSERT
-#define RF_ASSERT(_x_) { \
-  if (!(_x_)) { \
-    rf_print_assert_panic_message(__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))
-
-/*
- * 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 */
-
-#if defined(__FreeBSD__)
-#define NBPG PAGE_SIZE
-#endif
-
-#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
deleted file mode 100644
index c21cb1b..0000000
--- a/sys/dev/raidframe/rf_geniq.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/*	$NetBSD: rf_geniq.c,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_geniq.c
- *  code which implements Reed-Solomon encoding for RAID level 6
- */
-
-
-#define RF_UTILITY 1
-#include <dev/raidframe/rf_pqdeg.h>
-
-/*
-   five bit lfsr
-   poly - feedback connections
-
-   val  = value;
-*/
-int 
-lsfr_shift(val, poly)
-	unsigned val, poly;
-{
-	unsigned new;
-	unsigned int i;
-	unsigned high = (val >> 4) & 1;
-	unsigned bit;
-
-	new = (poly & 1) ? high : 0;
-
-	for (i = 1; i <= 4; i++) {
-		bit = (val >> (i - 1)) & 1;
-		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 */
-
-RF_ua32_t rf_qfor[32];
-
-void 
-main()
-{
-	unsigned int i, j, l, a, b;
-	unsigned int val;
-	unsigned int r;
-	unsigned int m, p, q;
-
-	RF_ua32_t k;
-
-	printf("/*\n");
-	printf(" * rf_invertq.h\n");
-	printf(" */\n");
-	printf("/*\n");
-	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("\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(" */\n");
-	printf("/* #include \"rf_archs.h\" */\n");
-	printf("\n");
-	printf("#if (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");
-	k[0] = 1;
-	for (j = 0; j < 31; j++)
-		k[j + 1] = lsfr_shift(k[j], 5);
-	for (j = 0; j < 32; j++)
-		printf("%d, ", k[j]);
-	printf("};\n");
-
-	printf("RF_ua32_t rf_qfor[32] = {\n");
-	for (i = 0; i < 32; i++) {
-		printf("/* i = %d */ { 0, ", i);
-		rf_qfor[i][0] = 0;
-		for (j = 1; j < 32; j++) {
-			val = j;
-			for (l = 0; l < i; l++)
-				val = lsfr_shift(val, 5);
-			rf_qfor[i][j] = val;
-			printf("%d, ", val);
-		}
-		printf("},\n");
-	}
-	printf("};\n");
-	printf("#define RF_Q_DATA_COL(col_num) rf_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("RF_ua1024_t rf_qinv[29*29];\n");
-	printf("#else /* !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);
-			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
-						 * ^ rf_rn[i+1]] ^
-						 * qfor[(28-j)][b ^
-						 * 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)
-								break;
-						}
-						if (a == 32)
-							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");
-	exit(0);
-}
diff --git a/sys/dev/raidframe/rf_hist.h b/sys/dev/raidframe/rf_hist.h
deleted file mode 100644
index b8b12c3..0000000
--- a/sys/dev/raidframe/rf_hist.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_hist.h,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
-/*
- * rf_hist.h
- *
- * Histgram operations for RAIDframe stats
- */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_HIST_H_
-#define _RF__RF_HIST_H_
-
-#include <dev/raidframe/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)
-
-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]++; \
-}
-
-#endif				/* !_RF__RF_HIST_H_ */
diff --git a/sys/dev/raidframe/rf_interdecluster.c b/sys/dev/raidframe/rf_interdecluster.c
deleted file mode 100644
index 8b1dbdb..0000000
--- a/sys/dev/raidframe/rf_interdecluster.c
+++ /dev/null
@@ -1,285 +0,0 @@
-/*	$NetBSD: rf_interdecluster.c,v 1.5 2001/01/26 05:09:13 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Khalil Amiri
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/************************************************************
- *
- * rf_interdecluster.c -- implements interleaved declustering
- *
- ************************************************************/
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_INTERDECLUSTER > 0
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_interdecluster.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/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)
-{
-	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);
-	if (info == NULL)
-		return (ENOMEM);
-	layoutPtr->layoutSpecificInfo = (void *) info;
-
-	/* 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);
-	if (info->stripeIdentifier == NULL)
-		return (ENOMEM);
-	for (i = 0; i < SUs_per_region; i++) {
-		info->stripeIdentifier[i][0] = i / (raidPtr->numCol - 1);
-		tmp = i / raidPtr->numCol;
-		info->stripeIdentifier[i][1] = (i + 1 + tmp) % raidPtr->numCol;
-	}
-
-	/* no spare tables */
-	RF_ASSERT(raidPtr->numRow == 1);
-
-	/* fill in the remaining layout parameters */
-
-	/* 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;
-	layoutPtr->numDataCol = 1;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numParityCol = 1;
-
-	layoutPtr->dataStripeUnitsPerDisk = num_used_stripeUnitsPerDisk;
-
-	raidPtr->sectorsPerDisk =
-	    num_used_stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
-
-	raidPtr->totalSectors =
-	    (layoutPtr->numStripe) * layoutPtr->sectorsPerStripeUnit;
-
-	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
-
-	return (0);
-}
-
-int 
-rf_GetDefaultNumFloatingReconBuffersInterDecluster(RF_Raid_t * raidPtr)
-{
-	return (30);
-}
-
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimitInterDecluster(RF_Raid_t * raidPtr)
-{
-	return (raidPtr->sectorsPerDisk);
-}
-
-RF_ReconUnitCount_t 
-rf_GetNumSpareRUsInterDecluster(
-    RF_Raid_t * raidPtr)
-{
-	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 */
-}
-/* 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_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;
-
-	*row = 0;
-	sparing_region_id = SUID / info->stripeUnitsPerSparingRegion;
-	index_within_region = SUID % info->stripeUnitsPerSparingRegion;
-	su_offset_into_disk = index_within_region % (raidPtr->numCol - 1);
-	mirror_su_offset_into_disk = index_within_region / raidPtr->numCol;
-	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);
-	} 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;
-		*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)
-{
-	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_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	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;
-
-	*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);
-	} 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);
-		*col = index_within_region / (raidPtr->numCol - 1);
-		*col = (*col + 1) % raidPtr->numCol;
-		if (*col == col_before_remap)
-			*col = (*col + 1) % raidPtr->numCol;
-	}
-}
-
-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_StripeNum_t SUID;
-
-	SUID = addr / raidPtr->Layout.sectorsPerStripeUnit;
-	SUID = SUID % info->stripeUnitsPerSparingRegion;
-
-	*outRow = 0;
-	*diskids = info->stripeIdentifier[SUID];
-}
-
-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
- *
- * 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)
-{
-	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");
-		*createFunc = NULL;
-		return;
-	}
-	*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;
-		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneDegradedReadDAG;
-	} else
-		*createFunc = (RF_VoidFuncPtr) rf_CreateRaidOneWriteDAG;
-}
-#endif /* RF_INCLUDE_INTERDECLUSTER > 0 */
diff --git a/sys/dev/raidframe/rf_interdecluster.h b/sys/dev/raidframe/rf_interdecluster.h
deleted file mode 100644
index 9bf3825..0000000
--- a/sys/dev/raidframe/rf_interdecluster.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_interdecluster.h,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Khalil Amiri
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_interdecluster.h
- * header file for Interleaved Declustering
- */
-
-#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);
-
-#endif				/* !_RF__RF_INTERDECLUSTER_H_ */
diff --git a/sys/dev/raidframe/rf_invertq.c b/sys/dev/raidframe/rf_invertq.c
deleted file mode 100644
index 66337b6..0000000
--- a/sys/dev/raidframe/rf_invertq.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/*	$NetBSD: rf_invertq.c,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_pqdeg.h>
-#include <dev/raidframe/rf_invertq.h>
diff --git a/sys/dev/raidframe/rf_invertq.h b/sys/dev/raidframe/rf_invertq.h
deleted file mode 100644
index fde2cae..0000000
--- a/sys/dev/raidframe/rf_invertq.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_invertq.h,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
-/*
- * rf_invertq.h
- */
-/*
- * This is normally a generated file.  Not so for NetBSD.
- */
-
-#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)
- */
-/* #include <dev/raidframe/rf_archs.h> */
-
-#if (RF_INCLUDE_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
-
-#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] = {
-	 /* i = 0 */ {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,},
-	 /* i = 1 */ {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 5, 7, 1, 3, 13, 15, 9, 11, 21, 23, 17, 19, 29, 31, 25, 27,},
-	 /* i = 2 */ {0, 4, 8, 12, 16, 20, 24, 28, 5, 1, 13, 9, 21, 17, 29, 25, 10, 14, 2, 6, 26, 30, 18, 22, 15, 11, 7, 3, 31, 27, 23, 19,},
-	 /* i = 3 */ {0, 8, 16, 24, 5, 13, 21, 29, 10, 2, 26, 18, 15, 7, 31, 23, 20, 28, 4, 12, 17, 25, 1, 9, 30, 22, 14, 6, 27, 19, 11, 3,},
-	 /* i = 4 */ {0, 16, 5, 21, 10, 26, 15, 31, 20, 4, 17, 1, 30, 14, 27, 11, 13, 29, 8, 24, 7, 23, 2, 18, 25, 9, 28, 12, 19, 3, 22, 6,},
-	 /* i = 5 */ {0, 5, 10, 15, 20, 17, 30, 27, 13, 8, 7, 2, 25, 28, 19, 22, 26, 31, 16, 21, 14, 11, 4, 1, 23, 18, 29, 24, 3, 6, 9, 12,},
-	 /* i = 6 */ {0, 10, 20, 30, 13, 7, 25, 19, 26, 16, 14, 4, 23, 29, 3, 9, 17, 27, 5, 15, 28, 22, 8, 2, 11, 1, 31, 21, 6, 12, 18, 24,},
-	 /* i = 7 */ {0, 20, 13, 25, 26, 14, 23, 3, 17, 5, 28, 8, 11, 31, 6, 18, 7, 19, 10, 30, 29, 9, 16, 4, 22, 2, 27, 15, 12, 24, 1, 21,},
-	 /* i = 8 */ {0, 13, 26, 23, 17, 28, 11, 6, 7, 10, 29, 16, 22, 27, 12, 1, 14, 3, 20, 25, 31, 18, 5, 8, 9, 4, 19, 30, 24, 21, 2, 15,},
-	 /* i = 9 */ {0, 26, 17, 11, 7, 29, 22, 12, 14, 20, 31, 5, 9, 19, 24, 2, 28, 6, 13, 23, 27, 1, 10, 16, 18, 8, 3, 25, 21, 15, 4, 30,},
-	 /* i = 10 */ {0, 17, 7, 22, 14, 31, 9, 24, 28, 13, 27, 10, 18, 3, 21, 4, 29, 12, 26, 11, 19, 2, 20, 5, 1, 16, 6, 23, 15, 30, 8, 25,},
-	 /* i = 11 */ {0, 7, 14, 9, 28, 27, 18, 21, 29, 26, 19, 20, 1, 6, 15, 8, 31, 24, 17, 22, 3, 4, 13, 10, 2, 5, 12, 11, 30, 25, 16, 23,},
-	 /* i = 12 */ {0, 14, 28, 18, 29, 19, 1, 15, 31, 17, 3, 13, 2, 12, 30, 16, 27, 21, 7, 9, 6, 8, 26, 20, 4, 10, 24, 22, 25, 23, 5, 11,},
-	 /* i = 13 */ {0, 28, 29, 1, 31, 3, 2, 30, 27, 7, 6, 26, 4, 24, 25, 5, 19, 15, 14, 18, 12, 16, 17, 13, 8, 20, 21, 9, 23, 11, 10, 22,},
-	 /* i = 14 */ {0, 29, 31, 2, 27, 6, 4, 25, 19, 14, 12, 17, 8, 21, 23, 10, 3, 30, 28, 1, 24, 5, 7, 26, 16, 13, 15, 18, 11, 22, 20, 9,},
-	 /* i = 15 */ {0, 31, 27, 4, 19, 12, 8, 23, 3, 28, 24, 7, 16, 15, 11, 20, 6, 25, 29, 2, 21, 10, 14, 17, 5, 26, 30, 1, 22, 9, 13, 18,},
-	 /* i = 16 */ {0, 27, 19, 8, 3, 24, 16, 11, 6, 29, 21, 14, 5, 30, 22, 13, 12, 23, 31, 4, 15, 20, 28, 7, 10, 17, 25, 2, 9, 18, 26, 1,},
-	 /* i = 17 */ {0, 19, 3, 16, 6, 21, 5, 22, 12, 31, 15, 28, 10, 25, 9, 26, 24, 11, 27, 8, 30, 13, 29, 14, 20, 7, 23, 4, 18, 1, 17, 2,},
-	 /* i = 18 */ {0, 3, 6, 5, 12, 15, 10, 9, 24, 27, 30, 29, 20, 23, 18, 17, 21, 22, 19, 16, 25, 26, 31, 28, 13, 14, 11, 8, 1, 2, 7, 4,},
-	 /* i = 19 */ {0, 6, 12, 10, 24, 30, 20, 18, 21, 19, 25, 31, 13, 11, 1, 7, 15, 9, 3, 5, 23, 17, 27, 29, 26, 28, 22, 16, 2, 4, 14, 8,},
-	 /* i = 20 */ {0, 12, 24, 20, 21, 25, 13, 1, 15, 3, 23, 27, 26, 22, 2, 14, 30, 18, 6, 10, 11, 7, 19, 31, 17, 29, 9, 5, 4, 8, 28, 16,},
-	 /* i = 21 */ {0, 24, 21, 13, 15, 23, 26, 2, 30, 6, 11, 19, 17, 9, 4, 28, 25, 1, 12, 20, 22, 14, 3, 27, 7, 31, 18, 10, 8, 16, 29, 5,},
-	 /* i = 22 */ {0, 21, 15, 26, 30, 11, 17, 4, 25, 12, 22, 3, 7, 18, 8, 29, 23, 2, 24, 13, 9, 28, 6, 19, 14, 27, 1, 20, 16, 5, 31, 10,},
-	 /* i = 23 */ {0, 15, 30, 17, 25, 22, 7, 8, 23, 24, 9, 6, 14, 1, 16, 31, 11, 4, 21, 26, 18, 29, 12, 3, 28, 19, 2, 13, 5, 10, 27, 20,},
-	 /* i = 24 */ {0, 30, 25, 7, 23, 9, 14, 16, 11, 21, 18, 12, 28, 2, 5, 27, 22, 8, 15, 17, 1, 31, 24, 6, 29, 3, 4, 26, 10, 20, 19, 13,},
-	 /* i = 25 */ {0, 25, 23, 14, 11, 18, 28, 5, 22, 15, 1, 24, 29, 4, 10, 19, 9, 16, 30, 7, 2, 27, 21, 12, 31, 6, 8, 17, 20, 13, 3, 26,},
-	 /* i = 26 */ {0, 23, 11, 28, 22, 1, 29, 10, 9, 30, 2, 21, 31, 8, 20, 3, 18, 5, 25, 14, 4, 19, 15, 24, 27, 12, 16, 7, 13, 26, 6, 17,},
-	 /* i = 27 */ {0, 11, 22, 29, 9, 2, 31, 20, 18, 25, 4, 15, 27, 16, 13, 6, 1, 10, 23, 28, 8, 3, 30, 21, 19, 24, 5, 14, 26, 17, 12, 7,},
-	 /* i = 28 */ {0, 22, 9, 31, 18, 4, 27, 13, 1, 23, 8, 30, 19, 5, 26, 12, 2, 20, 11, 29, 16, 6, 25, 15, 3, 21, 10, 28, 17, 7, 24, 14,},
-	 /* i = 29 */ {0, 9, 18, 27, 1, 8, 19, 26, 2, 11, 16, 25, 3, 10, 17, 24, 4, 13, 22, 31, 5, 12, 23, 30, 6, 15, 20, 29, 7, 14, 21, 28,},
-	 /* 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)]
-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_ */
diff --git a/sys/dev/raidframe/rf_kintf.h b/sys/dev/raidframe/rf_kintf.h
deleted file mode 100644
index ae2697b..0000000
--- a/sys/dev/raidframe/rf_kintf.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_kintf.h,v 1.15 2000/10/20 02:24:45 oster Exp $	*/
-/*
- * rf_kintf.h
- *
- * RAIDframe exported kernel interface
- */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_KINTF_H_
-#define _RF__RF_KINTF_H_
-
-#include <dev/raidframe/rf_types.h>
-
-#if defined(__NetBSD__)
-#define RF_LTSLEEP(cond, pri, text, time, mutex)	\
-		ltsleep(cond, pri, text, time, mutex)
-#elif defined(__FreeBSD__)
-#if __FreeBSD_version > 500005
-#define RF_LTSLEEP(cond, pri, text, time, mutex) \
-		msleep(cond, mutex, pri, text, time);
-#else
-static __inline int
-RF_LTSLEEP(void *cond, int pri, const char *text, int time, struct simplelock *mutex)
-{
-	int ret;
-	if (mutex != NULL)
-		simple_unlock(mutex);
-	ret = tsleep(cond, pri, text, time);
-	if (mutex != NULL)
-		simple_lock(mutex);
-	return (ret);
-}
-#endif
-#endif
-
-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 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
-void rf_update_component_labels(RF_Raid_t *, int);
-int raidlookup(char *, RF_Thread_t, 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 *);
-int raid_getcomponentsize(RF_Raid_t *, RF_RowCol_t, RF_RowCol_t);
-#endif				/* _RF__RF_KINTF_H_ */
diff --git a/sys/dev/raidframe/rf_layout.c b/sys/dev/raidframe/rf_layout.c
deleted file mode 100644
index 53badbd..0000000
--- a/sys/dev/raidframe/rf_layout.c
+++ /dev/null
@@ -1,492 +0,0 @@
-/*	$NetBSD: rf_layout.c,v 1.9 2001/01/27 19:34:43 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_layout.c -- driver code dealing with layout and mapping issues
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_decluster.h>
-#include <dev/raidframe/rf_pq.h>
-#include <dev/raidframe/rf_declusterPQ.h>
-#include <dev/raidframe/rf_raid0.h>
-#include <dev/raidframe/rf_raid1.h>
-#include <dev/raidframe/rf_raid4.h>
-#include <dev/raidframe/rf_raid5.h>
-#include <dev/raidframe/rf_states.h>
-#if RF_INCLUDE_RAID5_RS > 0
-#include <dev/raidframe/rf_raid5_rotatedspare.h>
-#endif				/* RF_INCLUDE_RAID5_RS > 0 */
-#if RF_INCLUDE_CHAINDECLUSTER > 0
-#include <dev/raidframe/rf_chaindecluster.h>
-#endif				/* RF_INCLUDE_CHAINDECLUSTER > 0 */
-#if RF_INCLUDE_INTERDECLUSTER > 0
-#include <dev/raidframe/rf_interdecluster.h>
-#endif				/* RF_INCLUDE_INTERDECLUSTER > 0 */
-#if RF_INCLUDE_PARITYLOGGING > 0
-#include <dev/raidframe/rf_paritylogging.h>
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
-#if RF_INCLUDE_EVENODD > 0
-#include <dev/raidframe/rf_evenodd.h>
-#endif				/* RF_INCLUDE_EVENODD > 0 */
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_driver.h>
-#include <dev/raidframe/rf_parityscan.h>
-#include <dev/raidframe/rf_reconbuffer.h>
-#include <dev/raidframe/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.
- *
- ***********************************************************************/
-
-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};
-
-#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
-
-/* Note that if you add any new RAID types to this list, that you must
-   also update the mapsw[] table in the raidctl sources */
-
-static RF_LayoutSW_t mapsw[] = {
-#if RF_INCLUDE_PARITY_DECLUSTERING > 0
-	/* parity declustering */
-	{'T', "Parity declustering",
-		RF_NU(
-		    rf_ConfigureDeclustered,
-		    rf_MapSectorDeclustered, rf_MapParityDeclustered, NULL,
-		    rf_IdentifyStripeDeclustered,
-		    rf_RaidFiveDagSelect,
-		    rf_MapSIDToPSIDDeclustered,
-		    rf_GetDefaultHeadSepLimitDeclustered,
-		    rf_GetDefaultNumFloatingReconBuffersDeclustered,
-		    NULL, NULL,
-		    rf_SubmitReconBufferBasic,
-		    rf_VerifyParityBasic,
-		    1,
-		    DefaultStates,
-		    0)
-	},
-#endif
-
-#if RF_INCLUDE_PARITY_DECLUSTERING_DS > 0
-	/* parity declustering with distributed sparing */
-	{'D', "Distributed sparing parity declustering",
-		RF_NU(
-		    rf_ConfigureDeclusteredDS,
-		    rf_MapSectorDeclustered, rf_MapParityDeclustered, NULL,
-		    rf_IdentifyStripeDeclustered,
-		    rf_RaidFiveDagSelect,
-		    rf_MapSIDToPSIDDeclustered,
-		    rf_GetDefaultHeadSepLimitDeclustered,
-		    rf_GetDefaultNumFloatingReconBuffersDeclustered,
-		    rf_GetNumSpareRUsDeclustered, rf_InstallSpareTable,
-		    rf_SubmitReconBufferBasic,
-		    rf_VerifyParityBasic,
-		    1,
-		    DefaultStates,
-		    RF_DISTRIBUTE_SPARE | RF_BD_DECLUSTERED)
-	},
-#endif
-
-#if RF_INCLUDE_DECL_PQ > 0
-	/* declustered P+Q */
-	{'Q', "Declustered P+Q",
-		RF_NU(
-		    rf_ConfigureDeclusteredPQ,
-		    rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ, rf_MapQDeclusteredPQ,
-		    rf_IdentifyStripeDeclusteredPQ,
-		    rf_PQDagSelect,
-		    rf_MapSIDToPSIDDeclustered,
-		    rf_GetDefaultHeadSepLimitDeclustered,
-		    rf_GetDefaultNumFloatingReconBuffersPQ,
-		    NULL, NULL,
-		    NULL,
-		    rf_VerifyParityBasic,
-		    2,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_DECL_PQ > 0 */
-
-#if RF_INCLUDE_RAID5_RS > 0
-	/* RAID 5 with rotated sparing */
-	{'R', "RAID Level 5 rotated sparing",
-		RF_NU(
-		    rf_ConfigureRAID5_RS,
-		    rf_MapSectorRAID5_RS, rf_MapParityRAID5_RS, NULL,
-		    rf_IdentifyStripeRAID5_RS,
-		    rf_RaidFiveDagSelect,
-		    rf_MapSIDToPSIDRAID5_RS,
-		    rf_GetDefaultHeadSepLimitRAID5,
-		    rf_GetDefaultNumFloatingReconBuffersRAID5,
-		    rf_GetNumSpareRUsRAID5_RS, NULL,
-		    rf_SubmitReconBufferBasic,
-		    rf_VerifyParityBasic,
-		    1,
-		    DefaultStates,
-		    RF_DISTRIBUTE_SPARE)
-	},
-#endif				/* RF_INCLUDE_RAID5_RS > 0 */
-
-#if RF_INCLUDE_CHAINDECLUSTER > 0
-	/* Chained Declustering */
-	{'C', "Chained Declustering",
-		RF_NU(
-		    rf_ConfigureChainDecluster,
-		    rf_MapSectorChainDecluster, rf_MapParityChainDecluster, NULL,
-		    rf_IdentifyStripeChainDecluster,
-		    rf_RAIDCDagSelect,
-		    rf_MapSIDToPSIDChainDecluster,
-		    NULL,
-		    NULL,
-		    rf_GetNumSpareRUsChainDecluster, NULL,
-		    rf_SubmitReconBufferBasic,
-		    rf_VerifyParityBasic,
-		    1,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_CHAINDECLUSTER > 0 */
-
-#if RF_INCLUDE_INTERDECLUSTER > 0
-	/* Interleaved Declustering */
-	{'I', "Interleaved Declustering",
-		RF_NU(
-		    rf_ConfigureInterDecluster,
-		    rf_MapSectorInterDecluster, rf_MapParityInterDecluster, NULL,
-		    rf_IdentifyStripeInterDecluster,
-		    rf_RAIDIDagSelect,
-		    rf_MapSIDToPSIDInterDecluster,
-		    rf_GetDefaultHeadSepLimitInterDecluster,
-		    rf_GetDefaultNumFloatingReconBuffersInterDecluster,
-		    rf_GetNumSpareRUsInterDecluster, NULL,
-		    rf_SubmitReconBufferBasic,
-		    rf_VerifyParityBasic,
-		    1,
-		    DefaultStates,
-		    RF_DISTRIBUTE_SPARE)
-	},
-#endif				/* RF_INCLUDE_INTERDECLUSTER > 0 */
-
-#if RF_INCLUDE_RAID0 > 0
-	/* RAID level 0 */
-	{'0', "RAID Level 0",
-		RF_NU(
-		    rf_ConfigureRAID0,
-		    rf_MapSectorRAID0, rf_MapParityRAID0, NULL,
-		    rf_IdentifyStripeRAID0,
-		    rf_RAID0DagSelect,
-		    rf_MapSIDToPSIDRAID0,
-		    NULL,
-		    NULL,
-		    NULL, NULL,
-		    NULL,
-		    rf_VerifyParityRAID0,
-		    0,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_RAID0 > 0 */
-
-#if RF_INCLUDE_RAID1 > 0
-	/* RAID level 1 */
-	{'1', "RAID Level 1",
-		RF_NU(
-		    rf_ConfigureRAID1,
-		    rf_MapSectorRAID1, rf_MapParityRAID1, NULL,
-		    rf_IdentifyStripeRAID1,
-		    rf_RAID1DagSelect,
-		    rf_MapSIDToPSIDRAID1,
-		    NULL,
-		    NULL,
-		    NULL, NULL,
-		    rf_SubmitReconBufferRAID1,
-		    rf_VerifyParityRAID1,
-		    1,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_RAID1 > 0 */
-
-#if RF_INCLUDE_RAID4 > 0
-	/* RAID level 4 */
-	{'4', "RAID Level 4",
-		RF_NU(
-		    rf_ConfigureRAID4,
-		    rf_MapSectorRAID4, rf_MapParityRAID4, NULL,
-		    rf_IdentifyStripeRAID4,
-		    rf_RaidFiveDagSelect,
-		    rf_MapSIDToPSIDRAID4,
-		    rf_GetDefaultHeadSepLimitRAID4,
-		    rf_GetDefaultNumFloatingReconBuffersRAID4,
-		    NULL, NULL,
-		    rf_SubmitReconBufferBasic,
-		    rf_VerifyParityBasic,
-		    1,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_RAID4 > 0 */
-
-#if RF_INCLUDE_RAID5 > 0
-	/* RAID level 5 */
-	{'5', "RAID Level 5",
-		RF_NU(
-		    rf_ConfigureRAID5,
-		    rf_MapSectorRAID5, rf_MapParityRAID5, NULL,
-		    rf_IdentifyStripeRAID5,
-		    rf_RaidFiveDagSelect,
-		    rf_MapSIDToPSIDRAID5,
-		    rf_GetDefaultHeadSepLimitRAID5,
-		    rf_GetDefaultNumFloatingReconBuffersRAID5,
-		    NULL, NULL,
-		    rf_SubmitReconBufferBasic,
-		    rf_VerifyParityBasic,
-		    1,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_RAID5 > 0 */
-
-#if RF_INCLUDE_EVENODD > 0
-	/* Evenodd */
-	{'E', "EvenOdd",
-		RF_NU(
-		    rf_ConfigureEvenOdd,
-		    rf_MapSectorRAID5, rf_MapParityEvenOdd, rf_MapEEvenOdd,
-		    rf_IdentifyStripeEvenOdd,
-		    rf_EODagSelect,
-		    rf_MapSIDToPSIDRAID5,
-		    NULL,
-		    NULL,
-		    NULL, NULL,
-		    NULL,	/* no reconstruction, yet */
-		    rf_VerifyParityEvenOdd,
-		    2,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_EVENODD > 0 */
-
-#if RF_INCLUDE_EVENODD > 0
-	/* Declustered Evenodd */
-	{'e', "Declustered EvenOdd",
-		RF_NU(
-		    rf_ConfigureDeclusteredPQ,
-		    rf_MapSectorDeclusteredPQ, rf_MapParityDeclusteredPQ, rf_MapQDeclusteredPQ,
-		    rf_IdentifyStripeDeclusteredPQ,
-		    rf_EODagSelect,
-		    rf_MapSIDToPSIDRAID5,
-		    rf_GetDefaultHeadSepLimitDeclustered,
-		    rf_GetDefaultNumFloatingReconBuffersPQ,
-		    NULL, NULL,
-		    NULL,	/* no reconstruction, yet */
-		    rf_VerifyParityEvenOdd,
-		    2,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_EVENODD > 0 */
-
-#if RF_INCLUDE_PARITYLOGGING > 0
-	/* parity logging */
-	{'L', "Parity logging",
-		RF_NU(
-		    rf_ConfigureParityLogging,
-		    rf_MapSectorParityLogging, rf_MapParityParityLogging, NULL,
-		    rf_IdentifyStripeParityLogging,
-		    rf_ParityLoggingDagSelect,
-		    rf_MapSIDToPSIDParityLogging,
-		    rf_GetDefaultHeadSepLimitParityLogging,
-		    rf_GetDefaultNumFloatingReconBuffersParityLogging,
-		    NULL, NULL,
-		    rf_SubmitReconBufferBasic,
-		    NULL,
-		    1,
-		    DefaultStates,
-		    0)
-	},
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
-
-	/* end-of-list marker */
-	{'\0', NULL,
-		RF_NU(
-		    NULL,
-		    NULL, NULL, NULL,
-		    NULL,
-		    NULL,
-		    NULL,
-		    NULL,
-		    NULL,
-		    NULL, NULL,
-		    NULL,
-		    NULL,
-		    0,
-		    NULL,
-		    0)
-	}
-};
-
-RF_LayoutSW_t *
-rf_GetLayout(RF_ParityConfig_t parityConfig)
-{
-	RF_LayoutSW_t *p;
-
-	/* look up the specific layout */
-	for (p = &mapsw[0]; p->parityConfig; p++)
-		if (p->parityConfig == parityConfig)
-			break;
-	if (!p->parityConfig)
-		return (NULL);
-	RF_ASSERT(p->parityConfig == parityConfig);
-	return (p);
-}
-
-/*****************************************************************************
- *
- * 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.
- *
- ****************************************************************************/
-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;
-
-	layoutPtr->sectorsPerStripeUnit = cfgPtr->sectPerSU;
-	layoutPtr->SUsPerPU = cfgPtr->SUsPerPU;
-	layoutPtr->SUsPerRU = cfgPtr->SUsPerRU;
-	parityConfig = cfgPtr->parityConfig;
-
-	if (layoutPtr->sectorsPerStripeUnit <= 0) {
-		RF_ERRORMSG2("raid%d: Invalid sectorsPerStripeUnit: %d\n",
-			     raidPtr->raidid, 
-			     (int)layoutPtr->sectorsPerStripeUnit );
-		return (EINVAL); 
-	}
-
-	layoutPtr->stripeUnitsPerDisk = raidPtr->sectorsPerDisk / layoutPtr->sectorsPerStripeUnit;
-
-	p = rf_GetLayout(parityConfig);
-	if (p == NULL) {
-		RF_ERRORMSG1("Unknown parity configuration '%c'", parityConfig);
-		return (EINVAL);
-	}
-	RF_ASSERT(p->parityConfig == parityConfig);
-	layoutPtr->map = p;
-
-	/* 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;
-
-	if (rf_forceNumFloatingReconBufs >= 0) {
-		raidPtr->numFloatingReconBufs = rf_forceNumFloatingReconBufs;
-	} else {
-		raidPtr->numFloatingReconBufs = rf_GetDefaultNumFloatingReconBuffers(raidPtr);
-	}
-
-	if (rf_forceHeadSepLimit >= 0) {
-		raidPtr->headSepLimit = rf_forceHeadSepLimit;
-	} else {
-		raidPtr->headSepLimit = rf_GetDefaultHeadSepLimit(raidPtr);
-	}
-
-	printf("RAIDFRAME: Configure (%s): total number of sectors is %lu (%lu MB)\n",
-	    layoutPtr->map->configName,
-	    (unsigned long) raidPtr->totalSectors,
-	    (unsigned long) (raidPtr->totalSectors / 1024 * (1 << raidPtr->logBytesPerSector) / 1024));
-	if (raidPtr->headSepLimit >= 0) {
-		printf("RAIDFRAME(%s): Using %ld floating recon bufs 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, (long) raidPtr->numFloatingReconBufs);
-	}
-
-	return (0);
-}
-/* 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
- * 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 parityStripeID;
-
-	/* 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);
-	}
-	return (parityStripeID);
-}
diff --git a/sys/dev/raidframe/rf_layout.h b/sys/dev/raidframe/rf_layout.h
deleted file mode 100644
index 2482556..0000000
--- a/sys/dev/raidframe/rf_layout.h
+++ /dev/null
@@ -1,349 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_layout.h,v 1.5 2001/01/26 04:14:14 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_layout.h -- header file defining layout data structures
- */
-
-#ifndef _RF__RF_LAYOUT_H_
-#define _RF__RF_LAYOUT_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_alloclist.h>
-
-#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,
-	            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);
-
-	/* get default head separation limit (may be NULL) */
-	        RF_HeadSepLimit_t(*GetDefaultHeadSepLimit) (RF_Raid_t * raidPtr);
-
-	/* get default num recon buffers (may be NULL) */
-	int     (*GetDefaultNumFloatingReconBuffers) (RF_Raid_t * raidPtr);
-
-	/* get number of spare recon units (may be NULL) */
-	        RF_ReconUnitCount_t(*GetNumSpareRUs) (RF_Raid_t * raidPtr);
-
-	/* spare table installation (may be NULL) */
-	int     (*InstallSpareTable) (RF_Raid_t * raidPtr, RF_RowCol_t frow, RF_RowCol_t fcol);
-
-	/* recon buffer submission function */
-	int     (*SubmitReconBuffer) (RF_ReconBuffer_t * rbuf, int keep_it,
-	            int use_committed);
-
-	/*
-         * 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);
-
-	/* 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;
-
-	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
-
-/*
- * 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 */
-
-/*************************************************************************
- *
- * 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 */
-};
-/*****************************************************************************************
- *
- * 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
-
-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;
-};
-#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 */
-#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 */
-#else
-	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;
-};
-/* 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_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.
- *
- ****************************************************************************************/
-
-/* 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 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 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 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 )
-
-/* 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 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 )
-
-/* 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 ) )
-
-/* 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_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);
-
-#endif				/* !_RF__RF_LAYOUT_H_ */
diff --git a/sys/dev/raidframe/rf_map.c b/sys/dev/raidframe/rf_map.c
deleted file mode 100644
index 22af549..0000000
--- a/sys/dev/raidframe/rf_map.c
+++ /dev/null
@@ -1,909 +0,0 @@
-/*	$NetBSD: rf_map.c,v 1.5 2000/06/29 00:22:27 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/**************************************************************************
- *
- * map.c -- main code for mapping RAID addresses to physical disk addresses
- *
- **************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/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);
-
-/*****************************************************************************************
- *
- * 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.
- *
- * 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.
- *
- * 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_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 */
-	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 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 */
-	lastRaidAddr = raidAddress + numBlocks - 1;
-	stripeID = rf_RaidAddressToStripeID(layoutPtr, raidAddress);
-	lastSID = rf_RaidAddressToStripeID(layoutPtr, lastRaidAddr);
-	totStripes = lastSID - stripeID + 1;
-	SUID = rf_RaidAddressToStripeUnitID(layoutPtr, raidAddress);
-	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 */
-
-	if (raidAddress + numBlocks > raidPtr->totalSectors) {
-		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 */
-		RF_ASSERT(asmList);
-		t_asm = asmList;
-		asmList = asmList->next;
-		bzero((char *) t_asm, sizeof(RF_AccessStripeMap_t));
-		if (!asm_p)
-			asm_list = asm_p = t_asm;
-		else {
-			asm_p->next = t_asm;
-			asm_p = asm_p->next;
-		}
-		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);
-		stripeEndAddress = RF_MIN(endAddress, stripeRealEndAddress);
-		asm_p->raidAddress = raidAddress;
-		asm_p->endRaidAddress = stripeEndAddress;
-
-		/* 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 */
-		for (; raidAddress < stripeEndAddress;) {
-			RF_ASSERT(pdaList);
-			t_pda = pdaList;
-			pdaList = pdaList->next;
-			bzero((char *) t_pda, sizeof(RF_PhysDiskAddr_t));
-			if (!pda_p)
-				asm_p->physInfo = pda_p = t_pda;
-			else {
-				pda_p->next = t_pda;
-				pda_p = pda_p->next;
-			}
-
-			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;
-			RF_ASSERT(pda_p->numSector != 0);
-			rf_ASMCheckStatus(raidPtr, pda_p, asm_p, disks, 0);
-			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
-							 * harmless to do this
-							 * in every loop
-							 * iteration */
-
-			raidAddress = RF_MIN(endAddress, nextStripeUnitAddress);
-		}
-
-		/* 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. */
-		switch (faultsTolerated) {
-		case 0:
-			break;
-		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);
-			pda_p->numSector = layoutPtr->sectorsPerStripeUnit;
-			/* 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);
-
-			break;
-		case 2:	/* two fault tolerant */
-			RF_ASSERT(pdaList && pdaList->next);
-			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;
-			t_pda = pdaList;
-			pdaList = pdaList->next;
-			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 */
-			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);
-			break;
-		}
-	}
-	RF_ASSERT(asmList == NULL && pdaList == NULL);
-	/* make the header structure */
-	asm_hdr = rf_AllocAccessStripeMapHeader();
-	RF_ASSERT(numStripes == totStripes);
-	asm_hdr->numStripes = numStripes;
-	asm_hdr->stripeMap = asm_list;
-
-	if (rf_mapDebug)
-		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;
-{
-	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->numFailedPDAs = 0;
-		bzero((char *) asmap->failedPDAs,
-		    RF_MAX_FAILED_PDA * sizeof(RF_PhysDiskAddr_t *));
-		for (pda = asmap->physInfo; pda; pda = pda->next) {
-			if (RF_DEAD_DISK(disks[pda->row][pda->col].status)) {
-				asmap->numDataFailed++;
-				asmap->failedPDAs[asmap->numFailedPDAs] = pda;
-				asmap->numFailedPDAs++;
-			}
-		}
-		pda = asmap->parityInfo;
-		if (pda && RF_DEAD_DISK(disks[pda->row][pda->col].status)) {
-			asmap->numParityFailed++;
-			asmap->failedPDAs[asmap->numFailedPDAs] = pda;
-			asmap->numFailedPDAs++;
-		}
-		pda = asmap->qInfo;
-		if (pda && RF_DEAD_DISK(disks[pda->row][pda->col].status)) {
-			asmap->numQFailed++;
-			asmap->failedPDAs[asmap->numFailedPDAs] = pda;
-			asmap->numFailedPDAs++;
-		}
-	}
-}
-/*****************************************************************************************
- *
- * DuplicateASM -- duplicates an ASM and returns the new one
- *
- ****************************************************************************************/
-RF_AccessStripeMap_t *
-rf_DuplicateASM(asmap)
-	RF_AccessStripeMap_t *asmap;
-{
-	RF_AccessStripeMap_t *new_asm;
-	RF_PhysDiskAddr_t *pda, *new_pda, *t_pda;
-
-	new_pda = NULL;
-	new_asm = rf_AllocAccessStripeMapComponent();
-	bcopy((char *) asmap, (char *) new_asm, sizeof(RF_AccessStripeMap_t));
-	new_asm->numFailedPDAs = 0;	/* ??? */
-	new_asm->failedPDAs[0] = NULL;
-	new_asm->physInfo = NULL;
-	new_asm->parityInfo = NULL;
-	new_asm->next = NULL;
-
-	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;
-		if (!new_asm->physInfo) {
-			new_asm->physInfo = t_pda;
-			new_pda = t_pda;
-		} else {
-			new_pda->next = t_pda;
-			new_pda = new_pda->next;
-		}
-		if (pda == asmap->failedPDAs[0])
-			new_asm->failedPDAs[0] = t_pda;
-	}
-	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;
-		if (!new_asm->parityInfo) {
-			new_asm->parityInfo = t_pda;
-			new_pda = t_pda;
-		} else {
-			new_pda->next = t_pda;
-			new_pda = new_pda->next;
-		}
-		if (pda == asmap->failedPDAs[0])
-			new_asm->failedPDAs[0] = t_pda;
-	}
-	return (new_asm);
-}
-/*****************************************************************************************
- *
- * DuplicatePDA -- duplicates a PDA and returns the new one
- *
- ****************************************************************************************/
-RF_PhysDiskAddr_t *
-rf_DuplicatePDA(pda)
-	RF_PhysDiskAddr_t *pda;
-{
-	RF_PhysDiskAddr_t *new;
-
-	new = rf_AllocPhysDiskAddr();
-	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.
- *
- * 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
-
-static RF_FreeList_t *rf_asm_freelist;
-#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;
-{
-	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     rc;
-
-	RF_FREELIST_CREATE(rf_asmhdr_freelist, RF_MAX_FREE_ASMHDR,
-	    RF_ASMHDR_INC, sizeof(RF_AccessStripeMapHeader_t));
-	if (rf_asmhdr_freelist == NULL) {
-		return (ENOMEM);
-	}
-	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 *));
-		return (ENOMEM);
-	}
-	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 *));
-		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_ShutdownMapModule(NULL);
-		return (rc);
-	}
-	RF_FREELIST_PRIME(rf_asmhdr_freelist, RF_ASMHDR_INITIAL, next,
-	    (RF_AccessStripeMapHeader_t *));
-	RF_FREELIST_PRIME(rf_asm_freelist, RF_ASM_INITIAL, next,
-	    (RF_AccessStripeMap_t *));
-	RF_FREELIST_PRIME(rf_pda_freelist, RF_PDA_INITIAL, next,
-	    (RF_PhysDiskAddr_t *));
-
-	return (0);
-}
-
-RF_AccessStripeMapHeader_t *
-rf_AllocAccessStripeMapHeader()
-{
-	RF_AccessStripeMapHeader_t *p;
-
-	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;
-{
-	RF_FREELIST_FREE(rf_asmhdr_freelist, p, next);
-}
-
-RF_PhysDiskAddr_t *
-rf_AllocPhysDiskAddr()
-{
-	RF_PhysDiskAddr_t *p;
-
-	RF_FREELIST_GET(rf_pda_freelist, p, next, (RF_PhysDiskAddr_t *));
-	bzero((char *) p, sizeof(RF_PhysDiskAddr_t));
-
-	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
- * much of a performance hit, because it should be very infrequently executed.
- */
-RF_PhysDiskAddr_t *
-rf_AllocPDAList(count)
-	int     count;
-{
-	RF_PhysDiskAddr_t *p = NULL;
-
-	RF_FREELIST_GET_N(rf_pda_freelist, p, next, (RF_PhysDiskAddr_t *), count);
-	return (p);
-}
-
-void 
-rf_FreePhysDiskAddr(p)
-	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 */
-{
-	RF_FREELIST_FREE_N(rf_pda_freelist, l_start, next, (RF_PhysDiskAddr_t *), count);
-}
-
-RF_AccessStripeMap_t *
-rf_AllocAccessStripeMapComponent()
-{
-	RF_AccessStripeMap_t *p;
-
-	RF_FREELIST_GET(rf_asm_freelist, p, next, (RF_AccessStripeMap_t *));
-	bzero((char *) p, sizeof(RF_AccessStripeMap_t));
-
-	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
- * much of a performance hit, because it should be very infrequently executed.
- */
-RF_AccessStripeMap_t *
-rf_AllocASMList(count)
-	int     count;
-{
-	RF_AccessStripeMap_t *p = NULL;
-
-	RF_FREELIST_GET_N(rf_asm_freelist, p, next, (RF_AccessStripeMap_t *), count);
-	return (p);
-}
-
-void 
-rf_FreeAccessStripeMapComponent(p)
-	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;
-{
-	RF_FREELIST_FREE_N(rf_asm_freelist, l_start, next, (RF_AccessStripeMap_t *), count);
-}
-
-void 
-rf_FreeAccessStripeMap(hdr)
-	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;
-
-	for (p = hdr->stripeMap; p; p = p->next) {
-
-		/* link the 3 pda lists into the accumulating pda list */
-
-		if (!pdaList)
-			pdaList = p->qInfo;
-		else
-			pdaEnd->next = p->qInfo;
-		for (trailer = NULL, pdp = p->qInfo; pdp;) {
-			trailer = pdp;
-			pdp = pdp->next;
-			count++;
-		}
-		if (trailer)
-			pdaEnd = trailer;
-
-		if (!pdaList)
-			pdaList = p->parityInfo;
-		else
-			pdaEnd->next = p->parityInfo;
-		for (trailer = NULL, pdp = p->parityInfo; pdp;) {
-			trailer = pdp;
-			pdp = pdp->next;
-			count++;
-		}
-		if (trailer)
-			pdaEnd = trailer;
-
-		if (!pdaList)
-			pdaList = p->physInfo;
-		else
-			pdaEnd->next = p->physInfo;
-		for (trailer = NULL, pdp = p->physInfo; pdp;) {
-			trailer = pdp;
-			pdp = pdp->next;
-			count++;
-		}
-		if (trailer)
-			pdaEnd = trailer;
-
-		pt = p;
-		asm_count++;
-	}
-
-	/* debug only */
-	for (t = 0, pdp = pdaList; pdp; pdp = pdp->next)
-		t++;
-	RF_ASSERT(t == count);
-
-	if (pdaList)
-		rf_FreePDAList(pdaList, pdaEnd, count);
-	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.
- *
- * ASSUMES AT MOST ONE FAILURE IN THE STRIPE.
- */
-int 
-rf_CheckStripeForFailures(raidPtr, asmap)
-	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;
-	RF_RaidAddr_t sosAddr;
-	RF_SectorNum_t diskOffset, poffset;
-	RF_RowCol_t testrow;
-
-	/* 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);
-	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); */
-	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)
-					return (1);
-				RF_ASSERT(raidPtr->reconControl[testrow]->fcol == diskids[i]);
-				layoutPtr->map->MapSector(raidPtr,
-				    sosAddr + stripeOffset * layoutPtr->sectorsPerStripeUnit,
-				    &trow, &tcol, &diskOffset, 0);
-				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);
-			}
-			stripeOffset++;
-		}
-	}
-	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;
-{
-	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_RowCol_t trow, tcol, row, i;
-	RF_SectorNum_t diskOffset;
-	RF_RaidAddr_t sosAddr;
-	int     numFailures;
-
-	/* 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);
-	numFailures = 0;
-
-	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,
-		    &trow, &tcol, &diskOffset, 0);
-		if (RF_DEAD_DISK(raidPtr->Disks[trow][tcol].status))
-			numFailures++;
-	}
-
-	return numFailures;
-}
-
-
-/*****************************************************************************************
- *
- * debug routines
- *
- ****************************************************************************************/
-
-void 
-rf_PrintAccessStripeMap(asm_h)
-	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 */
-{
-	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("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,
-			    (int) asmap->parityInfo->startSector,
-			    (int) (asmap->parityInfo->startSector +
-				asmap->parityInfo->numSector - 1));
-			if (prbuf)
-				printf(" b0x%lx", (unsigned long) asmap->parityInfo->bufPtr);
-			if (asmap->parityInfo->next) {
-				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));
-				if (prbuf)
-					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,
-			    (int) (p->startSector + p->numSector - 1));
-			if (prbuf)
-				printf("b0x%lx ", (unsigned long) p->bufPtr);
-			if (i && !(i & 1))
-				printf("\n\t");
-		}
-		printf("\n");
-		p = asm_h->stripeMap->failedPDAs[0];
-		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));
-	}
-}
-
-void 
-rf_PrintRaidAddressInfo(raidPtr, raidAddr, numBlocks)
-	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);
-
-	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");
-	printf("Offset into stripe unit: %d (0x%x)\n",
-	    (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 
-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 *new_pda;
-
-	/* 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
-	 * boundary and is less than a stripe unit in size, it uses two
-	 * 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. */
-	if (asm_p->numStripeUnitsAccessed == 1) {
-		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 */
-			RF_ASSERT(toAdjust->next == NULL);
-			new_pda = toAdjust->next = rf_AllocPhysDiskAddr();
-			*new_pda = *toAdjust;	/* structure assignment */
-			new_pda->next = NULL;
-
-			/* 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;
-			RF_ASSERT(toAdjust->numSector != 0);
-
-			/* adjust the second pda */
-			new_pda->numSector = endAddress - rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, endAddress);
-			/* new_pda->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 
-rf_ASMCheckStatus(
-    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;
-
-	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 */
-		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 */
-			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);
-			else
-				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);
-			}
-		} else
-			if (RF_DEAD_DISK(dstatus)) {
-				/* 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");
-#endif
-				}
-				asm_p->failedPDAs[asm_p->numFailedPDAs] = pda_p;
-				asm_p->numFailedPDAs++;
-#if 0
-				switch (asm_p->numParityFailed + asm_p->numDataFailed) {
-				case 1:
-					asm_p->failedPDAs[0] = pda_p;
-					break;
-				case 2:
-					asm_p->failedPDAs[1] = pda_p;
-				default:
-					break;
-				}
-#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));
-	RF_ASSERT(pda_p->col != -1);
-}
diff --git a/sys/dev/raidframe/rf_map.h b/sys/dev/raidframe/rf_map.h
deleted file mode 100644
index d7c6d19..0000000
--- a/sys/dev/raidframe/rf_map.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_map.h,v 1.3 1999/02/05 00:06:12 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_map.h */
-
-#ifndef _RF__RF_MAP_H_
-#define _RF__RF_MAP_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/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);
-
-void 
-rf_MarkFailuresInASMList(RF_Raid_t * raidPtr,
-    RF_AccessStripeMapHeader_t * asm_h);
-
-RF_AccessStripeMap_t *rf_DuplicateASM(RF_AccessStripeMap_t * asmap);
-
-RF_PhysDiskAddr_t *rf_DuplicatePDA(RF_PhysDiskAddr_t * pda);
-
-int     rf_ConfigureMapModule(RF_ShutdownList_t ** listp);
-
-RF_AccessStripeMapHeader_t *rf_AllocAccessStripeMapHeader(void);
-
-void    rf_FreeAccessStripeMapHeader(RF_AccessStripeMapHeader_t * p);
-
-RF_PhysDiskAddr_t *rf_AllocPhysDiskAddr(void);
-
-RF_PhysDiskAddr_t *rf_AllocPDAList(int count);
-
-void    rf_FreePhysDiskAddr(RF_PhysDiskAddr_t * p);
-
-RF_AccessStripeMap_t *rf_AllocAccessStripeMapComponent(void);
-
-RF_AccessStripeMap_t *rf_AllocASMList(int count);
-
-void    rf_FreeAccessStripeMapComponent(RF_AccessStripeMap_t * p);
-
-void    rf_FreeAccessStripeMap(RF_AccessStripeMapHeader_t * hdr);
-
-int     rf_CheckStripeForFailures(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap);
-
-int     rf_NumFailedDataUnitsInStripe(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap);
-
-void    rf_PrintAccessStripeMap(RF_AccessStripeMapHeader_t * asm_h);
-
-void    rf_PrintFullAccessStripeMap(RF_AccessStripeMapHeader_t * asm_h, int prbuf);
-
-void 
-rf_PrintRaidAddressInfo(RF_Raid_t * raidPtr, RF_RaidAddr_t raidAddr,
-    RF_SectorCount_t numBlocks);
-
-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_ASMCheckStatus(RF_Raid_t * raidPtr, RF_PhysDiskAddr_t * pda_p,
-    RF_AccessStripeMap_t * asm_p, RF_RaidDisk_t ** disks, int parity);
-
-#endif				/* !_RF__RF_MAP_H_ */
diff --git a/sys/dev/raidframe/rf_mcpair.c b/sys/dev/raidframe/rf_mcpair.c
deleted file mode 100644
index 7b327ac..0000000
--- a/sys/dev/raidframe/rf_mcpair.c
+++ /dev/null
@@ -1,143 +0,0 @@
-/*	$NetBSD: rf_mcpair.c,v 1.4 2000/09/11 02:23:14 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_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 <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_mcpair.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-#include <sys/proc.h>
-
-static RF_FreeList_t *rf_mcpair_freelist;
-
-#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 *);
-
-
-
-static int 
-init_mcpair(t)
-	RF_MCPair_t *t;
-{
-	int     rc;
-
-	rc = rf_mutex_init(&t->mutex, __FUNCTION__);
-	if (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_mutex_destroy(&t->mutex);
-		return (rc);
-	}
-	return (0);
-}
-
-static void 
-clean_mcpair(t)
-	RF_MCPair_t *t;
-{
-	rf_mutex_destroy(&t->mutex);
-	rf_cond_destroy(&t->cond);
-}
-
-static void 
-rf_ShutdownMCPair(ignored)
-	void   *ignored;
-{
-	RF_FREELIST_DESTROY_CLEAN(rf_mcpair_freelist, next, (RF_MCPair_t *), clean_mcpair);
-}
-
-int 
-rf_ConfigureMCPair(listp)
-	RF_ShutdownList_t **listp;
-{
-	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_ShutdownMCPair(NULL);
-		return (rc);
-	}
-	RF_FREELIST_PRIME_INIT(rf_mcpair_freelist, RF_MCPAIR_INITIAL, next,
-	    (RF_MCPair_t *), init_mcpair);
-	return (0);
-}
-
-RF_MCPair_t *
-rf_AllocMCPair()
-{
-	RF_MCPair_t *t;
-
-	RF_FREELIST_GET_INIT(rf_mcpair_freelist, t, next, (RF_MCPair_t *), init_mcpair);
-	if (t) {
-		t->flag = 0;
-		t->next = NULL;
-	}
-	return (t);
-}
-
-void 
-rf_FreeMCPair(t)
-	RF_MCPair_t *t;
-{
-	RF_FREELIST_FREE_CLEAN(rf_mcpair_freelist, t, next, 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;
-{
-	RF_LOCK_MUTEX(mcpair->mutex);
-	mcpair->flag = 1;
-	wakeup(&(mcpair->cond));
-	RF_UNLOCK_MUTEX(mcpair->mutex);
-}
diff --git a/sys/dev/raidframe/rf_mcpair.h b/sys/dev/raidframe/rf_mcpair.h
deleted file mode 100644
index d43c728..0000000
--- a/sys/dev/raidframe/rf_mcpair.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_mcpair.h,v 1.6 2000/09/21 01:45:46 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_mcpair.h
- * see comments in rf_mcpair.c
- */
-
-#ifndef _RF__RF_MCPAIR_H_
-#define _RF__RF_MCPAIR_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-
-struct RF_MCPair_s {
-	RF_DECLARE_MUTEX(mutex)
-	RF_DECLARE_COND(cond)
-	int     flag;
-	RF_MCPair_t *next;
-};
-#define RF_WAIT_MCPAIR(_mcp) \
-	RF_LTSLEEP(&((_mcp)->cond), PRIBIO, "mcpair", 0, &((_mcp)->mutex))
-
-int     rf_ConfigureMCPair(RF_ShutdownList_t ** listp);
-RF_MCPair_t *rf_AllocMCPair(void);
-void    rf_FreeMCPair(RF_MCPair_t * t);
-void    rf_MCPairWakeupFunc(RF_MCPair_t * t);
-
-#endif				/* !_RF__RF_MCPAIR_H_ */
diff --git a/sys/dev/raidframe/rf_memchunk.c b/sys/dev/raidframe/rf_memchunk.c
deleted file mode 100644
index b6e8bd9..0000000
--- a/sys/dev/raidframe/rf_memchunk.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/*	$NetBSD: rf_memchunk.c,v 1.4 1999/08/13 03:41:56 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*********************************************************************************
- * rf_memchunk.c
- *
- * experimental code.  I've found that the malloc and free calls in the DAG
- * creation code are very expensive.  Since for any given workload the DAGs
- * created for different accesses are likely to be similar to each other, the
- * amount of memory used for any given DAG data structure is likely to be one
- * of a small number of values.  For example, in UNIX, all reads and writes will
- * be less than 8k and will not span stripe unit boundaries.  Thus in the absence
- * of failure, the only DAGs that will ever get created are single-node reads
- * and single-stripe-unit atomic read-modify-writes.  So, I'm very likely to
- * be continually asking for chunks of memory equal to the sizes of these two
- * DAGs.
- *
- * This leads to the idea of holding on to these chunks of memory when the DAG is
- * freed and then, when a new DAG is created, trying to find such a chunk before
- * calling malloc.
- *
- * the "chunk list" is a list of lists.  Each header node contains a size value
- * and a pointer to a list of chunk descriptors, each of which holds a pointer
- * to a chunk of memory of the indicated size.
- *
- * There is currently no way to purge memory out of the chunk list.  My
- * initial thought on this is to have a low-priority thread that wakes up every
- * 1 or 2 seconds, purges all the chunks with low reuse counts, and sets all
- * the reuse counts to zero.
- *
- * This whole idea may be bad, since malloc may be able to do this more efficiently.
- * It's worth a try, though, and it can be turned off by setting useMemChunks to 0.
- *
- ********************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_memchunk.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_options.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-typedef struct RF_ChunkHdr_s RF_ChunkHdr_t;
-struct RF_ChunkHdr_s {
-	int     size;
-	RF_ChunkDesc_t *list;
-	RF_ChunkHdr_t *next;
-};
-
-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 *);
-
-
-	static void rf_ShutdownMemChunk(ignored)
-	void   *ignored;
-{
-	RF_ChunkDesc_t *pt, *p;
-	RF_ChunkHdr_t *hdr, *ht;
-
-	if (rf_memChunkDebug)
-		printf("Chunklist:\n");
-	for (hdr = chunklist; hdr;) {
-		for (p = hdr->list; p;) {
-			if (rf_memChunkDebug)
-				printf("Size %d reuse count %d\n", p->size, p->reuse_count);
-			pt = p;
-			p = p->next;
-			RF_Free(pt->buf, pt->size);
-			RF_Free(pt, sizeof(*pt));
-		}
-		ht = hdr;
-		hdr = hdr->next;
-		RF_Free(ht, sizeof(*ht));
-	}
-
-	rf_mutex_destroy(&chunkmutex);
-}
-
-int 
-rf_ConfigureMemChunk(listp)
-	RF_ShutdownList_t **listp;
-{
-	int     rc;
-
-	chunklist = NULL;
-	chunk_hdr_free_list = NULL;
-	chunk_desc_free_list = NULL;
-	rc = rf_mutex_init(&chunkmutex, __FUNCTION__);
-	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
-	}
-	rc = rf_ShutdownCreate(listp, rf_ShutdownMemChunk, NULL);
-	if (rc) {
-		RF_ERRORMSG3("Unable to add to shutdown list file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
-		rf_mutex_destroy(&chunkmutex);
-	}
-	return (rc);
-}
-/* called to get a chunk descriptor for a newly-allocated chunk of memory
- * MUTEX MUST BE LOCKED
- *
- * free list is not currently used
- */
-static RF_ChunkDesc_t *
-NewMemChunk(size, buf)
-	int     size;
-	char   *buf;
-{
-	RF_ChunkDesc_t *p;
-
-	if (chunk_desc_free_list) {
-		p = chunk_desc_free_list;
-		chunk_desc_free_list = p->next;
-	} else
-		RF_Malloc(p, sizeof(RF_ChunkDesc_t), (RF_ChunkDesc_t *));
-	p->size = size;
-	p->buf = buf;
-	p->next = NULL;
-	p->reuse_count = 0;
-	return (p);
-}
-/* looks for a chunk of memory of acceptable size.  If none, allocates one and returns
- * a chunk descriptor for it, but does not install anything in the list.  This is done
- * when the chunk is released.
- */
-RF_ChunkDesc_t *
-rf_GetMemChunk(size)
-	int     size;
-{
-	RF_ChunkHdr_t *hdr = chunklist;
-	RF_ChunkDesc_t *p = NULL;
-	char   *buf;
-
-	RF_LOCK_MUTEX(chunkmutex);
-	for (hdr = chunklist; hdr; hdr = hdr->next)
-		if (hdr->size >= size) {
-			p = hdr->list;
-			if (p) {
-				hdr->list = p->next;
-				p->next = NULL;
-				p->reuse_count++;
-			}
-			break;
-		}
-	if (!p) {
-		RF_Malloc(buf, size, (char *));
-		p = NewMemChunk(size, buf);
-	}
-	RF_UNLOCK_MUTEX(chunkmutex);
-	(void) bzero(p->buf, size);
-	return (p);
-}
-
-void 
-rf_ReleaseMemChunk(chunk)
-	RF_ChunkDesc_t *chunk;
-{
-	RF_ChunkHdr_t *hdr, *ht = NULL, *new;
-
-	RF_LOCK_MUTEX(chunkmutex);
-	for (hdr = chunklist; hdr && hdr->size < chunk->size; ht = hdr, hdr = hdr->next);
-	if (hdr && hdr->size == chunk->size) {
-		chunk->next = hdr->list;
-		hdr->list = chunk;
-	} else {
-		RF_Malloc(new, sizeof(RF_ChunkHdr_t), (RF_ChunkHdr_t *));
-		new->size = chunk->size;
-		new->list = chunk;
-		chunk->next = NULL;
-		if (ht) {
-			new->next = ht->next;
-			ht->next = new;
-		} else {
-			new->next = hdr;
-			chunklist = new;
-		}
-	}
-	RF_UNLOCK_MUTEX(chunkmutex);
-}
diff --git a/sys/dev/raidframe/rf_memchunk.h b/sys/dev/raidframe/rf_memchunk.h
deleted file mode 100644
index 5806d20..0000000
--- a/sys/dev/raidframe/rf_memchunk.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_memchunk.h,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* header file for rf_memchunk.c.  See comments there */
-
-#ifndef _RF__RF_MEMCHUNK_H_
-#define _RF__RF_MEMCHUNK_H_
-
-#include <dev/raidframe/rf_types.h>
-
-struct RF_ChunkDesc_s {
-	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);
-
-#endif				/* !_RF__RF_MEMCHUNK_H_ */
diff --git a/sys/dev/raidframe/rf_nwayxor.c b/sys/dev/raidframe/rf_nwayxor.c
deleted file mode 100644
index 170db6a..0000000
--- a/sys/dev/raidframe/rf_nwayxor.c
+++ /dev/null
@@ -1,451 +0,0 @@
-/*	$NetBSD: rf_nwayxor.c,v 1.4 2000/03/30 12:45:41 augustss Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/************************************************************
- *
- * 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.
- *
- ************************************************************/
-
-#include <dev/raidframe/rf_nwayxor.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-static int callcount[10];
-static void rf_ShutdownNWayXor(void *);
-
-static void 
-rf_ShutdownNWayXor(ignored)
-	void   *ignored;
-{
-	int     i;
-
-	if (rf_showXorCallCounts == 0)
-		return;
-	printf("Call counts for n-way xor routines:  ");
-	for (i = 0; i < 10; i++)
-		printf("%d ", callcount[i]);
-	printf("\n");
-}
-
-int 
-rf_ConfigureNWayXor(listp)
-	RF_ShutdownList_t **listp;
-{
-	int     i, rc;
-
-	for (i = 0; i < 10; i++)
-		callcount[i] = 0;
-	rc = rf_ShutdownCreate(listp, rf_ShutdownNWayXor, NULL);
-	return (rc);
-}
-
-void 
-rf_nWayXor1(src_rbs, dest_rb, len)
-	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;
-	unsigned long *end = src + len;
-	unsigned long d0, d1, d2, d3, s0, s1, s2, s3;
-
-	callcount[1]++;
-	while (len >= 4) {
-		d0 = dest[0];
-		d1 = dest[1];
-		d2 = dest[2];
-		d3 = dest[3];
-		s0 = src[0];
-		s1 = src[1];
-		s2 = src[2];
-		s3 = src[3];
-		dest[0] = d0 ^ s0;
-		dest[1] = d1 ^ s1;
-		dest[2] = d2 ^ s2;
-		dest[3] = d3 ^ s3;
-		src += 4;
-		dest += 4;
-		len -= 4;
-	}
-	while (src < end) {
-		*dest++ ^= *src++;
-	}
-}
-
-void 
-rf_nWayXor2(src_rbs, dest_rb, len)
-	RF_ReconBuffer_t **src_rbs;
-	RF_ReconBuffer_t *dest_rb;
-	int     len;
-{
-	unsigned long *dst = (unsigned long *) dest_rb->buffer;
-	unsigned long *a = dst;
-	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
-	unsigned long *c = (unsigned long *) src_rbs[1]->buffer;
-	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-
-	callcount[2]++;
-	/* align dest to cache line */
-	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ = *a++ ^ *b++ ^ *c++;
-		len--;
-	}
-	while (len > 4) {
-		a0 = a[0];
-		len -= 4;
-
-		a1 = a[1];
-		a2 = a[2];
-
-		a3 = a[3];
-		a += 4;
-
-		b0 = b[0];
-		b1 = b[1];
-
-		b2 = b[2];
-		b3 = b[3];
-		/* start dual issue */
-		a0 ^= b0;
-		b0 = c[0];
-
-		b += 4;
-		a1 ^= b1;
-
-		a2 ^= b2;
-		a3 ^= b3;
-
-		b1 = c[1];
-		a0 ^= b0;
-
-		b2 = c[2];
-		a1 ^= b1;
-
-		b3 = c[3];
-		a2 ^= b2;
-
-		dst[0] = a0;
-		a3 ^= b3;
-		dst[1] = a1;
-		c += 4;
-		dst[2] = a2;
-		dst[3] = a3;
-		dst += 4;
-	}
-	while (len) {
-		*dst++ = *a++ ^ *b++ ^ *c++;
-		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;
-{
-	unsigned long *dst = (unsigned long *) dest_rb->buffer;
-	unsigned long *b = (unsigned long *) src_rbs[0]->buffer;
-	unsigned long *c = (unsigned long *) src_rbs[1]->buffer;
-	unsigned long *d = (unsigned long *) src_rbs[2]->buffer;
-	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-
-	callcount[3]++;
-	/* align dest to cache line */
-	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++;
-		len--;
-	}
-	while (len > 4) {
-		LOAD_FIRST(dst, b);
-		XOR_AND_LOAD_NEXT(c);
-		XOR_AND_LOAD_NEXT(d);
-		XOR_AND_STORE(dst);
-	}
-	while (len) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++;
-		len--;
-	}
-}
-
-void 
-rf_nWayXor4(src_rbs, dest_rb, len)
-	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;
-	unsigned long *c = (unsigned long *) src_rbs[1]->buffer;
-	unsigned long *d = (unsigned long *) src_rbs[2]->buffer;
-	unsigned long *e = (unsigned long *) src_rbs[3]->buffer;
-	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-
-	callcount[4]++;
-	/* align dest to cache line */
-	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++;
-		len--;
-	}
-	while (len > 4) {
-		LOAD_FIRST(dst, b);
-		XOR_AND_LOAD_NEXT(c);
-		XOR_AND_LOAD_NEXT(d);
-		XOR_AND_LOAD_NEXT(e);
-		XOR_AND_STORE(dst);
-	}
-	while (len) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++;
-		len--;
-	}
-}
-
-void 
-rf_nWayXor5(src_rbs, dest_rb, len)
-	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;
-	unsigned long *c = (unsigned long *) src_rbs[1]->buffer;
-	unsigned long *d = (unsigned long *) src_rbs[2]->buffer;
-	unsigned long *e = (unsigned long *) src_rbs[3]->buffer;
-	unsigned long *f = (unsigned long *) src_rbs[4]->buffer;
-	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-
-	callcount[5]++;
-	/* align dest to cache line */
-	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++;
-		len--;
-	}
-	while (len > 4) {
-		LOAD_FIRST(dst, b);
-		XOR_AND_LOAD_NEXT(c);
-		XOR_AND_LOAD_NEXT(d);
-		XOR_AND_LOAD_NEXT(e);
-		XOR_AND_LOAD_NEXT(f);
-		XOR_AND_STORE(dst);
-	}
-	while (len) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++;
-		len--;
-	}
-}
-
-void 
-rf_nWayXor6(src_rbs, dest_rb, len)
-	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;
-	unsigned long *c = (unsigned long *) src_rbs[1]->buffer;
-	unsigned long *d = (unsigned long *) src_rbs[2]->buffer;
-	unsigned long *e = (unsigned long *) src_rbs[3]->buffer;
-	unsigned long *f = (unsigned long *) src_rbs[4]->buffer;
-	unsigned long *g = (unsigned long *) src_rbs[5]->buffer;
-	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-
-	callcount[6]++;
-	/* align dest to cache line */
-	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++;
-		len--;
-	}
-	while (len > 4) {
-		LOAD_FIRST(dst, b);
-		XOR_AND_LOAD_NEXT(c);
-		XOR_AND_LOAD_NEXT(d);
-		XOR_AND_LOAD_NEXT(e);
-		XOR_AND_LOAD_NEXT(f);
-		XOR_AND_LOAD_NEXT(g);
-		XOR_AND_STORE(dst);
-	}
-	while (len) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++;
-		len--;
-	}
-}
-
-void 
-rf_nWayXor7(src_rbs, dest_rb, len)
-	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;
-	unsigned long *c = (unsigned long *) src_rbs[1]->buffer;
-	unsigned long *d = (unsigned long *) src_rbs[2]->buffer;
-	unsigned long *e = (unsigned long *) src_rbs[3]->buffer;
-	unsigned long *f = (unsigned long *) src_rbs[4]->buffer;
-	unsigned long *g = (unsigned long *) src_rbs[5]->buffer;
-	unsigned long *h = (unsigned long *) src_rbs[6]->buffer;
-	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-
-	callcount[7]++;
-	/* align dest to cache line */
-	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++;
-		len--;
-	}
-	while (len > 4) {
-		LOAD_FIRST(dst, b);
-		XOR_AND_LOAD_NEXT(c);
-		XOR_AND_LOAD_NEXT(d);
-		XOR_AND_LOAD_NEXT(e);
-		XOR_AND_LOAD_NEXT(f);
-		XOR_AND_LOAD_NEXT(g);
-		XOR_AND_LOAD_NEXT(h);
-		XOR_AND_STORE(dst);
-	}
-	while (len) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++;
-		len--;
-	}
-}
-
-void 
-rf_nWayXor8(src_rbs, dest_rb, len)
-	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;
-	unsigned long *c = (unsigned long *) src_rbs[1]->buffer;
-	unsigned long *d = (unsigned long *) src_rbs[2]->buffer;
-	unsigned long *e = (unsigned long *) src_rbs[3]->buffer;
-	unsigned long *f = (unsigned long *) src_rbs[4]->buffer;
-	unsigned long *g = (unsigned long *) src_rbs[5]->buffer;
-	unsigned long *h = (unsigned long *) src_rbs[6]->buffer;
-	unsigned long *i = (unsigned long *) src_rbs[7]->buffer;
-	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-
-	callcount[8]++;
-	/* align dest to cache line */
-	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++ ^ *i++;
-		len--;
-	}
-	while (len > 4) {
-		LOAD_FIRST(dst, b);
-		XOR_AND_LOAD_NEXT(c);
-		XOR_AND_LOAD_NEXT(d);
-		XOR_AND_LOAD_NEXT(e);
-		XOR_AND_LOAD_NEXT(f);
-		XOR_AND_LOAD_NEXT(g);
-		XOR_AND_LOAD_NEXT(h);
-		XOR_AND_LOAD_NEXT(i);
-		XOR_AND_STORE(dst);
-	}
-	while (len) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++ ^ *i++;
-		len--;
-	}
-}
-
-
-void 
-rf_nWayXor9(src_rbs, dest_rb, len)
-	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;
-	unsigned long *c = (unsigned long *) src_rbs[1]->buffer;
-	unsigned long *d = (unsigned long *) src_rbs[2]->buffer;
-	unsigned long *e = (unsigned long *) src_rbs[3]->buffer;
-	unsigned long *f = (unsigned long *) src_rbs[4]->buffer;
-	unsigned long *g = (unsigned long *) src_rbs[5]->buffer;
-	unsigned long *h = (unsigned long *) src_rbs[6]->buffer;
-	unsigned long *i = (unsigned long *) src_rbs[7]->buffer;
-	unsigned long *j = (unsigned long *) src_rbs[8]->buffer;
-	unsigned long a0, a1, a2, a3, b0, b1, b2, b3;
-
-	callcount[9]++;
-	/* align dest to cache line */
-	while ((((unsigned long) dst) & 0x1f)) {
-		*dst++ ^= *b++ ^ *c++ ^ *d++ ^ *e++ ^ *f++ ^ *g++ ^ *h++ ^ *i++ ^ *j++;
-		len--;
-	}
-	while (len > 4) {
-		LOAD_FIRST(dst, b);
-		XOR_AND_LOAD_NEXT(c);
-		XOR_AND_LOAD_NEXT(d);
-		XOR_AND_LOAD_NEXT(e);
-		XOR_AND_LOAD_NEXT(f);
-		XOR_AND_LOAD_NEXT(g);
-		XOR_AND_LOAD_NEXT(h);
-		XOR_AND_LOAD_NEXT(i);
-		XOR_AND_LOAD_NEXT(j);
-		XOR_AND_STORE(dst);
-	}
-	while (len) {
-		*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
deleted file mode 100644
index 1460d9b..0000000
--- a/sys/dev/raidframe/rf_nwayxor.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_nwayxor.h,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
-/*
- * rf_nwayxor.h
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-/*
- * rf_nwayxor.h -- types and prototypes for nwayxor module
- */
-
-#ifndef _RF__RF_NWAYXOR_H_
-#define _RF__RF_NWAYXOR_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_NWAYXOR_H_ */
diff --git a/sys/dev/raidframe/rf_options.c b/sys/dev/raidframe/rf_options.c
deleted file mode 100644
index 107c509..0000000
--- a/sys/dev/raidframe/rf_options.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/*	$NetBSD: rf_options.c,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * rf_options.c
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_options.h>
-
-#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__ */
-
-#include <dev/raidframe/rf_optnames.h>
-
-#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__ */
-
-RF_DebugName_t rf_debugNames[] = {
-#include <dev/raidframe/rf_optnames.h>
-	{NULL, NULL}
-};
-#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__ */
-
-void 
-rf_ResetDebugOptions()
-{
-#include <dev/raidframe/rf_optnames.h>
-}
diff --git a/sys/dev/raidframe/rf_options.h b/sys/dev/raidframe/rf_options.h
deleted file mode 100644
index 22b6341..0000000
--- a/sys/dev/raidframe/rf_options.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_options.h,v 1.3 1999/02/05 00:06:13 oster Exp $	*/
-/*
- * rf_options.h
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_OPTIONS_H_
-#define _RF__RF_OPTIONS_H_
-
-#define RF_DEFAULT_LOCK_TABLE_SIZE 256
-
-typedef struct RF_DebugNames_s {
-	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__ */
-#include <dev/raidframe/rf_optnames.h>
-
-void    rf_ResetDebugOptions(void);
-
-#endif				/* !_RF__RF_OPTIONS_H_ */
diff --git a/sys/dev/raidframe/rf_optnames.h b/sys/dev/raidframe/rf_optnames.h
deleted file mode 100644
index f04fbc1..0000000
--- a/sys/dev/raidframe/rf_optnames.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_optnames.h,v 1.6 1999/12/07 02:54:08 oster Exp $	*/
-/*
- * rf_optnames.h
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * Don't protect against multiple inclusion here- we actually want this.
- */
-
-RF_DBG_OPTION(accessDebug, 0)
-RF_DBG_OPTION(accessTraceBufSize, 0)
-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
-					 * the disk arm during small-write
-					 * operations.  Setting this variable
-					 * to anything other than 0 will
-					 * result in deadlock.  (wvcii) */
-RF_DBG_OPTION(engineDebug, 0)
-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(lockTableSize, RF_DEFAULT_LOCK_TABLE_SIZE)
-RF_DBG_OPTION(mapDebug, 0)
-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(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(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(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(sizePercentage, 100)
-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(verifyParityDebug, 0)
-RF_DBG_OPTION(debugKernelAccess, 0)	/* 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, 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 */
-
diff --git a/sys/dev/raidframe/rf_paritylog.c b/sys/dev/raidframe/rf_paritylog.c
deleted file mode 100644
index 87c33e6..0000000
--- a/sys/dev/raidframe/rf_paritylog.c
+++ /dev/null
@@ -1,871 +0,0 @@
-/*	$NetBSD: rf_paritylog.c,v 1.5 2000/01/07 03:41:01 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* Code for manipulating in-core parity logs
- *
- */
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_PARITYLOGGING > 0
-
-/*
- * Append-only log for recording parity "update" and "overwrite" records
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_mcpair.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_paritylog.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_paritylogging.h>
-#include <dev/raidframe/rf_paritylogDiskMgr.h>
-
-static RF_CommonLogData_t *
-AllocParityLogCommonData(RF_Raid_t * raidPtr)
-{
-	RF_CommonLogData_t *common = NULL;
-	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 */
-
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	if (raidPtr->parityLogDiskQueue.freeCommonList) {
-		common = raidPtr->parityLogDiskQueue.freeCommonList;
-		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 *));
-		rc = rf_mutex_init(&common->mutex, __FUNCTION__);
-		if (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;
-		}
-	}
-	common->next = NULL;
-	return (common);
-}
-
-static void 
-FreeParityLogCommonData(RF_CommonLogData_t * common)
-{
-	RF_Raid_t *raidPtr;
-
-	/* Insert a single struct for holding parity log information (data)
-	 * into the free list (rf_parityLogDiskQueue.freeCommonList).
-	 * NON-BLOCKING */
-
-	raidPtr = common->raidPtr;
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	common->next = raidPtr->parityLogDiskQueue.freeCommonList;
-	raidPtr->parityLogDiskQueue.freeCommonList = common;
-	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-}
-
-static RF_ParityLogData_t *
-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 */
-
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	if (raidPtr->parityLogDiskQueue.freeDataList) {
-		data = raidPtr->parityLogDiskQueue.freeDataList;
-		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 *));
-	}
-	data->next = NULL;
-	data->prev = NULL;
-	return (data);
-}
-
-
-static void 
-FreeParityLogData(RF_ParityLogData_t * data)
-{
-	RF_ParityLogData_t *nextItem;
-	RF_Raid_t *raidPtr;
-
-	/* Insert a linked list of structs for holding parity log information
-	 * (data) into the free list (parityLogDiskQueue.freeList).
-	 * NON-BLOCKING */
-
-	raidPtr = data->common->raidPtr;
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	while (data) {
-		nextItem = data->next;
-		data->next = raidPtr->parityLogDiskQueue.freeDataList;
-		raidPtr->parityLogDiskQueue.freeDataList = data;
-		data = nextItem;
-	}
-	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-}
-
-
-static void 
-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 */
-
-	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);
-	RF_ASSERT(data->prev == NULL);
-	RF_ASSERT(data->next == NULL);
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	if (*head) {
-		/* 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 */
-		RF_ASSERT(*head == NULL);
-		RF_ASSERT(*tail == NULL);
-		*head = data;
-		*tail = data;
-	}
-	RF_ASSERT((*head)->prev == NULL);
-	RF_ASSERT((*tail)->next == NULL);
-	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 *data;
-
-	/* 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 */
-	if (!ignoreLocks)
-		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	data = *tail;
-	if (data) {
-		if (*head == *tail) {
-			/* removing last item from queue */
-			*head = NULL;
-			*tail = NULL;
-		} else {
-			*tail = (*tail)->prev;
-			(*tail)->next = NULL;
-			RF_ASSERT((*head)->prev == NULL);
-			RF_ASSERT((*tail)->next == NULL);
-		}
-		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);
-	}
-	if (*head) {
-		RF_ASSERT((*head)->prev == NULL);
-		RF_ASSERT((*tail)->next == NULL);
-	}
-	if (!ignoreLocks)
-		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	return (data);
-}
-
-
-static void 
-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 */
-
-	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);
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	if (*tail) {
-		/* append to tail of list */
-		data->prev = *tail;
-		data->next = NULL;
-		(*tail)->next = data;
-		*tail = data;
-	} else {
-		/* inserting into an empty list */
-		*head = data;
-		*tail = data;
-		(*head)->prev = NULL;
-		(*tail)->next = NULL;
-	}
-	RF_ASSERT((*head)->prev == NULL);
-	RF_ASSERT((*tail)->next == NULL);
-	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-}
-
-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 *data, *resultHead = NULL, *resultTail = NULL;
-	RF_CommonLogData_t *common;
-	RF_PhysDiskAddr_t *diskAddress;
-	int     boundary, offset = 0;
-
-	/* Return an initialized struct of info to be logged. Build one item
-	 * per physical disk address, one item per region.
-	 * 
-	 * NON-BLOCKING */
-
-	diskAddress = pda;
-	common = AllocParityLogCommonData(raidPtr);
-	RF_ASSERT(common);
-
-	common->operation = operation;
-	common->bufPtr = bufPtr;
-	common->raidPtr = raidPtr;
-	common->wakeFunc = wakeFunc;
-	common->wakeArg = wakeArg;
-	common->tracerec = tracerec;
-	common->startTime = startTime;
-	common->cnt = 0;
-
-	if (rf_parityLogDebug)
-		printf("[entering CreateParityLogData]\n");
-	while (diskAddress) {
-		common->cnt++;
-		data = 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->diskAddress = *diskAddress;
-			data->bufOffset = offset;
-			offset = offset + diskAddress->numSector;
-			EnqueueParityLogData(data, &resultHead, &resultTail);
-			/* adjust disk address */
-			diskAddress = diskAddress->next;
-		} else {
-			/* disk address crosses a region boundary */
-			/* find address where region is crossed */
-			boundary = 0;
-			while (data->regionID == rf_MapRegionIDParityLogging(raidPtr, diskAddress->startSector + boundary))
-				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 */
-			diskAddress->startSector += boundary;
-			diskAddress->numSector -= boundary;
-		}
-	}
-	if (rf_parityLogDebug)
-		printf("[leaving CreateParityLogData]\n");
-	return (resultHead);
-}
-
-
-RF_ParityLogData_t *
-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
-	 * (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 */
-	if (!ignoreLocks)
-		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	w = (*tail);
-	while (w) {
-		if (w->regionID == regionID) {
-			/* remove an element from the list */
-			if (w == *tail) {
-				if (*head == *tail) {
-					/* removing only element in the list */
-					*head = NULL;
-					*tail = NULL;
-				} else {
-					/* removing last item in the list */
-					*tail = (*tail)->prev;
-					(*tail)->next = NULL;
-					RF_ASSERT((*head)->prev == NULL);
-					RF_ASSERT((*tail)->next == NULL);
-				}
-			} else {
-				if (w == *head) {
-					/* 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 */
-					w->prev->next = w->next;
-					w->next->prev = w->prev;
-					RF_ASSERT((*head)->prev == NULL);
-					RF_ASSERT((*tail)->next == NULL);
-				}
-			}
-			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);
-			return (w);
-		} else
-			w = w->prev;
-	}
-	if (!ignoreLocks)
-		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	return (NULL);
-}
-
-static RF_ParityLogData_t *
-DequeueMatchingLogData(
-    RF_Raid_t * raidPtr,
-    RF_ParityLogData_t ** head,
-    RF_ParityLogData_t ** tail)
-{
-	RF_ParityLogData_t *logDataList, *logData;
-	int     regionID;
-
-	/* 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 */
-
-	logDataList = DequeueParityLogData(raidPtr, head, tail, RF_TRUE);
-	if (logDataList) {
-		regionID = logDataList->regionID;
-		logData = logDataList;
-		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);
-		}
-	}
-	return (logDataList);
-}
-
-
-static RF_ParityLog_t *
-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 */
-	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;
-		log->regionID = logData->regionID;
-		log->numRecords = 0;
-		log->next = NULL;
-		raidPtr->logsInUse++;
-		RF_ASSERT(raidPtr->logsInUse >= 0 && raidPtr->logsInUse <= raidPtr->numParityLogs);
-	} else {
-		/* 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. */
-		if (rf_parityLogDebug)
-			printf("[blocked on log, region %d, finish %d]\n", logData->regionID, finish);
-		if (finish)
-			RequeueParityLogData(logData, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
-		else
-			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)
-{
-	RF_ParityLogData_t *logDataList;
-	RF_ParityLog_t *log, *lastLog;
-	int     cnt;
-
-	/* Insert a linked list of parity logs (firstLog) to the free list
-	 * (parityLogPool.parityLogPool)
-	 * 
-	 * 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(). */
-	RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	logDataList = DequeueMatchingLogData(raidPtr, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
-	log = firstLog;
-	if (firstLog)
-		firstLog = firstLog->next;
-	log->numRecords = 0;
-	log->next = NULL;
-	while (logDataList && log) {
-		RF_UNLOCK_MUTEX(raidPtr->parityLogPool.mutex);
-		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);
-		if (log == NULL) {
-			log = firstLog;
-			if (firstLog) {
-				firstLog = firstLog->next;
-				log->numRecords = 0;
-				log->next = NULL;
-			}
-		}
-		RF_LOCK_MUTEX(raidPtr->parityLogPool.mutex);
-		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-		if (log)
-			logDataList = DequeueMatchingLogData(raidPtr, &raidPtr->parityLogDiskQueue.logBlockHead, &raidPtr->parityLogDiskQueue.logBlockTail);
-	}
-	/* return remaining logs to pool */
-	if (log) {
-		log->next = firstLog;
-		firstLog = log;
-	}
-	if (firstLog) {
-		lastLog = firstLog;
-		raidPtr->logsInUse--;
-		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);
-		}
-		lastLog->next = raidPtr->parityLogPool.parityLogs;
-		raidPtr->parityLogPool.parityLogs = firstLog;
-		cnt = 0;
-		log = raidPtr->parityLogPool.parityLogs;
-		while (log) {
-			cnt++;
-			log = log->next;
-		}
-		RF_ASSERT(cnt + raidPtr->logsInUse == raidPtr->numParityLogs);
-	}
-	RF_UNLOCK_MUTEX(raidPtr->parityLogPool.mutex);
-	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-}
-
-static void 
-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
-	 * specified region (regionID) to indicate that reintegration is in
-	 * progress for this region. NON-BLOCKING */
-
-	RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
-	raidPtr->regionInfo[regionID].reintInProgress = RF_TRUE;	/* cleared when reint
-									 * complete */
-
-	if (rf_parityLogDebug)
-		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;
-	RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
-	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
-}
-
-static void 
-FlushLog(
-    RF_Raid_t * raidPtr,
-    RF_ParityLog_t * log)
-{
-	/* insert a core log (log) into a list of logs
-	 * (parityLogDiskQueue.flushQueue) waiting to be written to disk.
-	 * NON-BLOCKING */
-
-	RF_ASSERT(log);
-	RF_ASSERT(log->numRecords == raidPtr->numSectorsPerLog);
-	RF_ASSERT(log->next == NULL);
-	/* move log to flush queue */
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	log->next = raidPtr->parityLogDiskQueue.flushQueue;
-	raidPtr->parityLogDiskQueue.flushQueue = log;
-	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
-}
-
-static int 
-DumpParityLogToDisk(
-    int finish,
-    RF_ParityLogData_t * logData)
-{
-	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
-	 * 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 */
-
-	if (rf_parityLogDebug)
-		printf("[dumping parity log to disk, region %d]\n", regionID);
-	log = raidPtr->regionInfo[regionID].coreLog;
-	RF_ASSERT(log->numRecords == raidPtr->numSectorsPerLog);
-	RF_ASSERT(log->next == NULL);
-
-	/* 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
-		 * reintegrated. We can not block, so queue remaining work and
-		 * 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"? */
-		if (finish)
-			RequeueParityLogData(logData, &raidPtr->parityLogDiskQueue.reintBlockHead, &raidPtr->parityLogDiskQueue.reintBlockTail);
-		else
-			EnqueueParityLogData(logData, &raidPtr->parityLogDiskQueue.reintBlockHead, &raidPtr->parityLogDiskQueue.reintBlockTail);
-		RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
-		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 */
-	{
-		/* 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;
-		}
-		log->diskOffset = diskCount;
-		raidPtr->regionInfo[regionID].diskCount += raidPtr->numSectorsPerLog;
-		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);
-	}
-	if (rf_parityLogDebug)
-		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     regionID, logItem, itemDone;
-	RF_ParityLogData_t *item;
-	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;
-
-	/* 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
-	 * 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 */
-
-	RF_ASSERT(logData != NULL);
-	raidPtr = logData->common->raidPtr;
-	/* lock the region for the first item in logData */
-	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 */
-		RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].reintMutex);
-		RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-		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 */
-		RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	}
-	/* process each item in logData */
-	while (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);
-
-		/* 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
-				 * 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 */
-		if (item->diskAddress.numSector > 0)
-			done = RF_FALSE;
-		else
-			RF_ASSERT(0);
-		while (!punt && !done) {
-			/* verify that a core log exists for this region */
-			if (!raidPtr->regionInfo[regionID].coreLog) {
-				/* Attempt to acquire a parity log. If
-				 * acquisition fails, queue remaining work in
-				 * 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;
-						*incomingLog = NULL;
-					} else
-						raidPtr->regionInfo[regionID].coreLog = AcquireParityLog(item, finish);
-				else
-					raidPtr->regionInfo[regionID].coreLog = AcquireParityLog(item, finish);
-				/* Note: AcquireParityLog either returns a log
-				 * or enqueues currentItem */
-			}
-			if (!raidPtr->regionInfo[regionID].coreLog)
-				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 */
-					else {
-						/* 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;
-							} else
-								raidPtr->regionInfo[regionID].coreLog = AcquireParityLog(item, finish);
-						else
-							raidPtr->regionInfo[regionID].coreLog = 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 */
-					}
-				}
-			}
-			/* 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 */
-				log = raidPtr->regionInfo[regionID].coreLog;
-				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.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));
-				item->diskAddress.numSector--;
-				item->diskAddress.startSector++;
-				if (item->diskAddress.numSector == 0)
-					done = RF_TRUE;
-			}
-		}
-
-		if (!punt) {
-			/* 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--;
-			if (item->common->cnt == 0)
-				itemDone = RF_TRUE;
-			else
-				itemDone = RF_FALSE;
-			RF_UNLOCK_MUTEX(item->common->mutex);
-			if (itemDone) {
-				/* 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 */
-				RF_ETIMER_STOP(timer);
-				RF_ETIMER_EVAL(timer);
-				item->common->tracerec->plog_us += RF_ETIMER_VAL_US(timer);
-				if (rf_parityLogDebug)
-					printf("[waking process for region %d]\n", item->regionID);
-				wakeFunc = item->common->wakeFunc;
-				wakeArg = item->common->wakeArg;
-				FreeParityLogCommonData(item->common);
-				FreeParityLogData(item);
-				(wakeFunc) (wakeArg, 0);
-			} else
-				FreeParityLogData(item);
-		}
-	}
-	RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-	if (rf_parityLogDebug)
-		printf("[exiting ParityLogAppend]\n");
-	return (0);
-}
-
-
-void 
-rf_EnableParityLogging(RF_Raid_t * raidPtr)
-{
-	int     regionID;
-
-	for (regionID = 0; regionID < rf_numParityRegions; regionID++) {
-		RF_LOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-		raidPtr->regionInfo[regionID].loggingEnabled = RF_TRUE;
-		RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-	}
-	if (rf_parityLogDebug)
-		printf("[parity logging enabled]\n");
-}
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
diff --git a/sys/dev/raidframe/rf_paritylog.h b/sys/dev/raidframe/rf_paritylog.h
deleted file mode 100644
index 1f2b80d..0000000
--- a/sys/dev/raidframe/rf_paritylog.h
+++ /dev/null
@@ -1,181 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_paritylog.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* header file for parity log
- *
- */
-
-#ifndef _RF__RF_PARITYLOG_H_
-#define _RF__RF_PARITYLOG_H_
-
-#include <dev/raidframe/rf_types.h>
-
-#define RF_DEFAULT_NUM_SECTORS_PER_LOG 64
-
-typedef int RF_RegionId_t;
-
-typedef enum RF_ParityRecordType_e {
-	RF_STOP,
-	RF_UPDATE,
-	RF_OVERWRITE
-}       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)(RF_Buf_t); */
-	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;
-};
-
-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;
-};
-
-struct RF_ParityLogAppendQueue_s {
-	RF_DECLARE_MUTEX(mutex)
-};
-
-struct RF_ParityLogRecord_s {
-	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;
-};
-
-struct RF_ParityLogQueue_s {
-	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 */
-};
-#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
-						 * 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 */
-};
-
-struct RF_DiskMap_s {
-	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_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_ */
diff --git a/sys/dev/raidframe/rf_paritylogDiskMgr.c b/sys/dev/raidframe/rf_paritylogDiskMgr.c
deleted file mode 100644
index 5d864e2..0000000
--- a/sys/dev/raidframe/rf_paritylogDiskMgr.c
+++ /dev/null
@@ -1,703 +0,0 @@
-/*	$NetBSD: rf_paritylogDiskMgr.c,v 1.10 2000/01/15 01:57:57 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-/* Code for flushing and reintegration operations related to parity logging.
- *
- */
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_PARITYLOGGING > 0
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_mcpair.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_paritylog.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_paritylogging.h>
-#include <dev/raidframe/rf_engine.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_parityscan.h>
-#include <dev/raidframe/rf_kintf.h>
-
-#include <dev/raidframe/rf_paritylogDiskMgr.h>
-
-static caddr_t AcquireReintBuffer(RF_RegionBufferQueue_t *);
-
-static caddr_t 
-AcquireReintBuffer(pool)
-	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 */
-
-	RF_LOCK_MUTEX(pool->mutex);
-	if (pool->availableBuffers > 0) {
-		bufPtr = pool->buffers[pool->availBuffersIndex];
-		pool->availableBuffers--;
-		pool->availBuffersIndex++;
-		if (pool->availBuffersIndex == pool->totalBuffers)
-			pool->availBuffersIndex = 0;
-		RF_UNLOCK_MUTEX(pool->mutex);
-	} else {
-		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)
-{
-	/* Insert a region buffer (bufPtr) into the free list (pool).
-	 * NON-BLOCKING */
-
-	RF_LOCK_MUTEX(pool->mutex);
-	pool->availableBuffers++;
-	pool->buffers[pool->emptyBuffersIndex] = bufPtr;
-	pool->emptyBuffersIndex++;
-	if (pool->emptyBuffersIndex == pool->totalBuffers)
-		pool->emptyBuffersIndex = 0;
-	RF_ASSERT(pool->availableBuffers <= pool->totalBuffers);
-	RF_UNLOCK_MUTEX(pool->mutex);
-	RF_SIGNAL_COND(pool->cond);
-}
-
-
-
-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)
-{
-	/* Initiate the read a region log from disk.  Once initiated, return
-	 * to the calling routine.
-	 * 
-	 * NON-BLOCKING */
-
-	RF_AccTraceEntry_t *tracerec;
-	RF_DagNode_t *rrd_rdNode;
-
-	/* 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_pda = rf_AllocPDAList(1);
-	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 *));
-	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[2].v = 0;
-	rrd_rdNode->params[3].v = RF_CREATE_PARAM3(RF_IO_NORMAL_PRIORITY, 
-						   0, 0, 0);
-
-	/* 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)
-{
-	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
-	 * initiated, return to the calling routine.
-	 * 
-	 * NON-BLOCKING */
-
-	/* 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);
-
-	/* 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));
-	(*fwr_pda)->numSector = raidPtr->numSectorsPerLog;
-
-	/* 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[2].v = 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 */
-	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)
-{
-	/* Initiate the read region parity from disk. Once initiated, return
-	 * to the calling routine.
-	 * 
-	 * NON-BLOCKING */
-
-	RF_AccTraceEntry_t *tracerec;
-	RF_DagNode_t *prd_rdNode;
-
-	/* 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_pda = rf_AllocPDAList(1);
-	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);
-	if ((*prd_pda)->next) {
-		(*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 *));
-	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);
-	if (rf_validateDAGDebug)
-		rf_ValidateDAG(*prd_dag_h);
-	/* 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)
-{
-	/* Initiate the write of region parity to disk. Once initiated, return
-	 * to the calling routine.
-	 * 
-	 * NON-BLOCKING */
-
-	RF_AccTraceEntry_t *tracerec;
-	RF_DagNode_t *pwr_wrNode;
-
-	/* 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_pda = rf_AllocPDAList(1);
-	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 *));
-	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[2].v = 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 */
-	rf_DispatchDAG(*pwr_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
-	    (void *) pwr_mcpair);
-}
-
-static void 
-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
-	 * FIFO order and that order must be preserved.
-	 * 
-	 * Recommended optimizations: 1) allow multiple flushes to occur
-	 * simultaneously 2) coalesce contiguous flush operations
-	 * 
-	 * BLOCKING */
-
-	RF_ParityLog_t *log;
-	RF_RegionId_t regionID;
-	RF_MCPair_t *fwr_mcpair;
-	RF_DagHeader_t *fwr_dag_h;
-	RF_AllocListElem_t *fwr_alloclist;
-	RF_PhysDiskAddr_t *fwr_pda;
-
-	fwr_mcpair = rf_AllocMCPair();
-	RF_LOCK_MUTEX(fwr_mcpair->mutex);
-
-	RF_ASSERT(logList);
-	log = logList;
-	while (log) {
-		regionID = log->regionID;
-
-		/* create and launch a DAG to write the core log */
-		if (rf_parityLogDebug)
-			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);
-
-		/* 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_ASSERT(0);
-		}
-		/* RF_Free(fwr_pda, sizeof(RF_PhysDiskAddr_t)); */
-		rf_FreePhysDiskAddr(fwr_pda);
-		rf_FreeDAG(fwr_dag_h);
-		rf_FreeAllocList(fwr_alloclist);
-
-		log = log->next;
-	}
-	RF_UNLOCK_MUTEX(fwr_mcpair->mutex);
-	rf_FreeMCPair(fwr_mcpair);
-	rf_ReleaseParityLogs(raidPtr, logList);
-}
-
-static void 
-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;
-	RF_AllocListElem_t *rrd_alloclist, *prd_alloclist, *pwr_alloclist;
-	RF_PhysDiskAddr_t *rrd_pda, *prd_pda, *pwr_pda;
-	caddr_t parityBuffer, regionBuffer = NULL;
-
-	/* 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 */
-
-	if (rf_parityLogDebug)
-		printf("[reintegrating region %d]\n", regionID);
-
-	/* initiate read of region parity */
-	if (rf_parityLogDebug)
-		printf("[initiating read of parity for region %d]\n",regionID);
-	parityBuffer = AcquireReintBuffer(&raidPtr->parityBufferPool);
-	prd_mcpair = rf_AllocMCPair();
-	RF_LOCK_MUTEX(prd_mcpair->mutex);
-	prd_mcpair->flag = RF_FALSE;
-	ReadRegionParity(regionID, prd_mcpair, parityBuffer, raidPtr, 
-			 &prd_dag_h, &prd_alloclist, &prd_pda);
-
-	/* 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);
-		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);
-	}
-	/* 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 */
-		RF_ASSERT(0);
-	}
-	/* apply core log to parity */
-	/* if (coreLog) ApplyLogsToParity(coreLog, parityBuffer); */
-
-	if (raidPtr->regionInfo[regionID].diskCount > 0) {
-		/* 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 */
-			RF_ASSERT(0);
-		}
-		/* apply region log to parity */
-		/* ApplyRegionToParity(regionID, regionBuffer, parityBuffer); */
-		/* 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);
-	}
-	/* write reintegrated parity to disk */
-	if (rf_parityLogDebug)
-		printf("[initiating write of parity for region %d]\n",
-		       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);
-	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 */
-		RF_ASSERT(0);
-	}
-	/* 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);
-	/* RF_Free(pwr_pda, sizeof(RF_PhysDiskAddr_t)); */
-	rf_FreePhysDiskAddr(pwr_pda);
-	rf_FreeDAG(pwr_dag_h);
-	rf_FreeAllocList(pwr_alloclist);
-	rf_FreeMCPair(pwr_mcpair);
-
-	if (rf_parityLogDebug)
-		printf("[finished reintegrating region %d]\n", regionID);
-}
-
-
-
-static void 
-ReintegrateLogs(
-    RF_Raid_t * raidPtr,
-    RF_ParityLog_t * logList)
-{
-	RF_ParityLog_t *log, *freeLogList = NULL;
-	RF_ParityLogData_t *logData, *logDataList;
-	RF_RegionId_t regionID;
-
-	RF_ASSERT(logList);
-	while (logList) {
-		log = logList;
-		logList = logList->next;
-		log->next = NULL;
-		regionID = log->regionID;
-		ReintegrateRegion(raidPtr, regionID, log);
-		log->numRecords = 0;
-
-		/* 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);
-		logDataList = logData;
-		while (logData) {
-			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 */
-		if (logDataList)
-			rf_ParityLogAppend(logDataList, RF_TRUE, &log, RF_TRUE);
-		else {
-			/* Enable flushing for this region.  Holding both
-			 * locks provides a synchronization barrier with
-			 * 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;
-			RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-			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) {
-			log->next = freeLogList;
-			freeLogList = log;
-		}
-	}
-	if (freeLogList)
-		rf_ReleaseParityLogs(raidPtr, freeLogList);
-}
-
-int 
-rf_ShutdownLogging(RF_Raid_t * raidPtr)
-{
-	/* shutdown parity logging 1) disable parity logging in all regions 2)
-	 * reintegrate all regions */
-
-	RF_SectorCount_t diskCount;
-	RF_RegionId_t regionID;
-	RF_ParityLog_t *log;
-
-	if (rf_parityLogDebug)
-		printf("[shutting down parity logging]\n");
-	/* 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;
-			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);
-			if (log != NULL)
-				rf_ReleaseParityLogs(raidPtr, log);
-		}
-	}
-	if (rf_parityLogDebug) {
-		printf("[parity logging disabled]\n");
-		printf("[should be done!]\n");
-	}
-	return (0);
-}
-
-int 
-rf_ParityLoggingDiskManager(RF_Raid_t * raidPtr)
-{
-	RF_ParityLog_t *reintQueue, *flushQueue;
-	int     workNeeded, done = RF_FALSE;
-	int s;
-
-	/* 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 */
-
-	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.
-         */
-	raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_RUNNING;
-	RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
-
-	/* empty the work queues */
-	flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
-	raidPtr->parityLogDiskQueue.flushQueue = NULL;
-	reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
-	raidPtr->parityLogDiskQueue.reintQueue = NULL;
-	workNeeded = (flushQueue || reintQueue);
-
-	while (!done) {
-		while (workNeeded) {
-			/* First, flush all logs in the flush queue, freeing
-			 * buffers Second, reintegrate all regions which 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
-			 * 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. */
-
-			RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-
-			/* empty flushQueue, using free'd log buffers to
-			 * process bufTail */
-			if (flushQueue)
-			       FlushLogsToDisk(raidPtr, flushQueue);
-
-			/* empty reintQueue, flushing from reintTail as we go */
-			if (reintQueue)
-				ReintegrateLogs(raidPtr, reintQueue);
-
-			RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-			flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
-			raidPtr->parityLogDiskQueue.flushQueue = NULL;
-			reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
-			raidPtr->parityLogDiskQueue.reintQueue = NULL;
-			workNeeded = (flushQueue || reintQueue);
-		}
-		/* 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 */
-			RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-			rf_ShutdownLogging(raidPtr);
-		}
-		if (!done) {
-			/* 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);
-			if (rf_parityLogDebug)
-				printf("[parity logging disk manager just woke up]\n");
-			flushQueue = raidPtr->parityLogDiskQueue.flushQueue;
-			raidPtr->parityLogDiskQueue.flushQueue = NULL;
-			reintQueue = raidPtr->parityLogDiskQueue.reintQueue;
-			raidPtr->parityLogDiskQueue.reintQueue = NULL;
-			workNeeded = (flushQueue || reintQueue);
-		}
-	}
-	/*
-         * Announce that we're done.
-         */
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	raidPtr->parityLogDiskQueue.threadState |= RF_PLOG_SHUTDOWN;
-	RF_UNLOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	RF_SIGNAL_COND(raidPtr->parityLogDiskQueue.cond);
-
-	splx(s);
-
-	/*
-         * In the NetBSD 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 */
diff --git a/sys/dev/raidframe/rf_paritylogDiskMgr.h b/sys/dev/raidframe/rf_paritylogDiskMgr.h
deleted file mode 100644
index bdcc2a5..0000000
--- a/sys/dev/raidframe/rf_paritylogDiskMgr.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_paritylogDiskMgr.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* header file for parity log disk mgr code
- *
- */
-
-#ifndef _RF__RF_PARITYLOGDISKMGR_H_
-#define _RF__RF_PARITYLOGDISKMGR_H_
-
-#include <dev/raidframe/rf_types.h>
-
-int     rf_ShutdownLogging(RF_Raid_t * raidPtr);
-int     rf_ParityLoggingDiskManager(RF_Raid_t * raidPtr);
-
-#endif				/* !_RF__RF_PARITYLOGDISKMGR_H_ */
diff --git a/sys/dev/raidframe/rf_paritylogging.c b/sys/dev/raidframe/rf_paritylogging.c
deleted file mode 100644
index 2f9cf5e..0000000
--- a/sys/dev/raidframe/rf_paritylogging.c
+++ /dev/null
@@ -1,1076 +0,0 @@
-/*	$NetBSD: rf_paritylogging.c,v 1.10 2000/02/12 16:06:27 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-
-/*
-  parity logging configuration, dag selection, and mapping is implemented here
- */
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_PARITYLOGGING > 0
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_paritylog.h>
-#include <dev/raidframe/rf_paritylogDiskMgr.h>
-#include <dev/raidframe/rf_paritylogging.h>
-#include <dev/raidframe/rf_parityloggingdags.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_shutdown.h>
-#include <dev/raidframe/rf_kintf.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)
-{
-	int     i, j, startdisk, rc;
-	RF_SectorCount_t totalLogCapacity, fragmentation, lastRegionCapacity;
-	RF_SectorCount_t parityBufferCapacity, maxRegionParityRange;
-	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_ParityLoggingConfigInfo_t *info;
-	RF_ParityLog_t *l = NULL, *next;
-	caddr_t lHeapPtr;
-
-	if (rf_numParityRegions <= 0)
-		return(EINVAL);
-
-	/*
-         * We create multiple entries on the shutdown list here, since
-         * this configuration routine is fairly complicated in and of
-         * 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 *), 
-			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);
-	if (info->stripeIdentifier == NULL)
-		return (ENOMEM);
-
-	startdisk = 0;
-	for (i = 0; i < (raidPtr->numCol); i++) {
-		for (j = 0; j < (raidPtr->numCol); j++) {
-			info->stripeIdentifier[i][j] = (startdisk + j) % 
-				(raidPtr->numCol - 1);
-		}
-		if ((--startdisk) < 0)
-			startdisk = raidPtr->numCol - 1 - 1;
-	}
-
-	/* fill in the remaining layout parameters */
-	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	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->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
-	 * 
-	 */
-
-	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
-	 * of regions in an attempt to allow an integral number of logs to fit
-	 * 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)) % 
-			     raidPtr->numSectorsPerLog) < fragmentation) {
-				rf_numParityRegions++;
-				raidPtr->regionLogCapacity = totalLogCapacity /
-					rf_numParityRegions;
-				fragmentation = raidPtr->regionLogCapacity % 
-					raidPtr->numSectorsPerLog;
-			}
-			if (((totalLogCapacity / (rf_numParityRegions - i)) % 
-			     raidPtr->numSectorsPerLog) < fragmentation) {
-				rf_numParityRegions--;
-				raidPtr->regionLogCapacity = totalLogCapacity /
-					rf_numParityRegions;
-				fragmentation = raidPtr->regionLogCapacity % 
-					raidPtr->numSectorsPerLog;
-			}
-		}
-	/* ensure integral number of regions per log */
-	raidPtr->regionLogCapacity = (raidPtr->regionLogCapacity / 
-				      raidPtr->numSectorsPerLog) * 
-		raidPtr->numSectorsPerLog;
-
-	raidPtr->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 */
-	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_RegionInfo_t *));
-	if (raidPtr->regionInfo == NULL)
-		return (ENOMEM);
-
-	/* last region may not be full capacity */
-	lastRegionCapacity = raidPtr->regionLogCapacity;
-	while ((rf_numParityRegions - 1) * raidPtr->regionLogCapacity + 
-	       lastRegionCapacity > totalLogCapacity)
-		lastRegionCapacity = lastRegionCapacity - 
-			raidPtr->numSectorsPerLog;
-
-	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++; */
-
-	/* build pool of unused parity logs */
-	printf("Allocating %d bytes for %d parity logs\n",
-	       raidPtr->numParityLogs * raidPtr->numSectorsPerLog * 
-	       raidPtr->bytesPerSector,
-	       raidPtr->numParityLogs);
-	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, "RF_PARITYLOGGING1");
-	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
-			     __FILE__, __LINE__, rc);
-		RF_Free(raidPtr->parityLogBufferHeap, raidPtr->numParityLogs * 
-			raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
-		return (ENOMEM);
-	}
-	for (i = 0; i < raidPtr->numParityLogs; i++) {
-		if (i == 0) {
-			RF_Calloc(raidPtr->parityLogPool.parityLogs, 1, 
-				  sizeof(RF_ParityLog_t), (RF_ParityLog_t *));
-			if (raidPtr->parityLogPool.parityLogs == NULL) {
-				RF_Free(raidPtr->parityLogBufferHeap, 
-					raidPtr->numParityLogs * 
-					raidPtr->numSectorsPerLog * 
-					raidPtr->bytesPerSector);
-				return (ENOMEM);
-			}
-			l = raidPtr->parityLogPool.parityLogs;
-		} else {
-			RF_Calloc(l->next, 1, sizeof(RF_ParityLog_t), 
-				  (RF_ParityLog_t *));
-			if (l->next == NULL) {
-				RF_Free(raidPtr->parityLogBufferHeap, 
-					raidPtr->numParityLogs * 
-					raidPtr->numSectorsPerLog * 
-					raidPtr->bytesPerSector);
-				for (l = raidPtr->parityLogPool.parityLogs; 
-				     l;
-				     l = next) {
-					next = l->next;
-					if (l->records)
-						RF_Free(l->records, (raidPtr->numSectorsPerLog * sizeof(RF_ParityLogRecord_t)));
-					RF_Free(l, sizeof(RF_ParityLog_t));
-				}
-				return (ENOMEM);
-			}
-			l = l->next;
-		}
-		l->bufPtr = lHeapPtr;
-		lHeapPtr += raidPtr->numSectorsPerLog * 
-			raidPtr->bytesPerSector;
-		RF_Malloc(l->records, (raidPtr->numSectorsPerLog * 
-				       sizeof(RF_ParityLogRecord_t)), 
-			  (RF_ParityLogRecord_t *));
-		if (l->records == NULL) {
-			RF_Free(raidPtr->parityLogBufferHeap, 
-				raidPtr->numParityLogs * 
-				raidPtr->numSectorsPerLog * 
-				raidPtr->bytesPerSector);
-			for (l = raidPtr->parityLogPool.parityLogs; 
-			     l; 
-			     l = next) {
-				next = l->next;
-				if (l->records)
-					RF_Free(l->records, 
-						(raidPtr->numSectorsPerLog * 
-						 sizeof(RF_ParityLogRecord_t)));
-				RF_Free(l, sizeof(RF_ParityLog_t));
-			}
-			return (ENOMEM);
-		}
-	}
-	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_ShutdownParityLoggingPool(raidPtr);
-		return (rc);
-	}
-	/* build pool of region buffers */
-	rc = rf_mutex_init(&raidPtr->regionBufferPool.mutex, "RF_PARITYLOGGING3");
-	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
-			     __FILE__, __LINE__, rc);
-		return (ENOMEM);
-	}
-	rc = rf_cond_init(&raidPtr->regionBufferPool.cond);
-	if (rc) {
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", 
-			     __FILE__, __LINE__, rc);
-		rf_mutex_destroy(&raidPtr->regionBufferPool.mutex);
-		return (ENOMEM);
-	}
-	raidPtr->regionBufferPool.bufferSize = raidPtr->regionLogCapacity * 
-		raidPtr->bytesPerSector;
-	printf("regionBufferPool.bufferSize %d\n", 
-	       raidPtr->regionBufferPool.bufferSize);
-
-	/* for now, only one region at a time may be reintegrated */
-	raidPtr->regionBufferPool.totalBuffers = 1;	
-
-	raidPtr->regionBufferPool.availableBuffers = 
-		raidPtr->regionBufferPool.totalBuffers;
-	raidPtr->regionBufferPool.availBuffersIndex = 0;
-	raidPtr->regionBufferPool.emptyBuffersIndex = 0;
-	printf("Allocating %d bytes for regionBufferPool\n",
-	       (int) (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);
-		rf_cond_destroy(&raidPtr->regionBufferPool.cond);
-		return (ENOMEM);
-	}
-	for (i = 0; i < raidPtr->regionBufferPool.totalBuffers; i++) {
-		printf("Allocating %d bytes for regionBufferPool#%d\n",
-		       (int) (raidPtr->regionBufferPool.bufferSize * 
-			      sizeof(char)), 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], 
-					raidPtr->regionBufferPool.bufferSize *
-					sizeof(char));
-			}
-			RF_Free(raidPtr->regionBufferPool.buffers, 
-				raidPtr->regionBufferPool.totalBuffers * 
-				sizeof(caddr_t));
-			return (ENOMEM);
-		}
-		printf("raidPtr->regionBufferPool.buffers[%d] = %lx\n", i,
-		    (long) raidPtr->regionBufferPool.buffers[i]);
-	}
-	rc = rf_ShutdownCreate(listp, 
-			       rf_ShutdownParityLoggingRegionBufferPool,
-			       raidPtr);
-	if (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 */
-	parityBufferCapacity = maxRegionParityRange;
-	rc = rf_mutex_init(&raidPtr->parityBufferPool.mutex, "RF_PARITYLOGGING3");
-	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
-			     __FILE__, __LINE__, rc);
-		return (rc);
-	}
-	rc = rf_cond_init(&raidPtr->parityBufferPool.cond);
-	if (rc) {
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", 
-			     __FILE__, __LINE__, rc);
-		rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
-		return (ENOMEM);
-	}
-	raidPtr->parityBufferPool.bufferSize = parityBufferCapacity * 
-		raidPtr->bytesPerSector;
-	printf("parityBufferPool.bufferSize %d\n", 
-	       raidPtr->parityBufferPool.bufferSize);
-
-	/* for now, only one region at a time may be reintegrated */
-	raidPtr->parityBufferPool.totalBuffers = 1;	
-
-	raidPtr->parityBufferPool.availableBuffers = 
-		raidPtr->parityBufferPool.totalBuffers;
-	raidPtr->parityBufferPool.availBuffersIndex = 0;
-	raidPtr->parityBufferPool.emptyBuffersIndex = 0;
-	printf("Allocating %d bytes for parityBufferPool of %d units\n",
-	       (int) (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);
-		rf_cond_destroy(&raidPtr->parityBufferPool.cond);
-		return (ENOMEM);
-	}
-	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], 
-			  raidPtr->parityBufferPool.bufferSize * sizeof(char),
-			  (caddr_t));
-		if (raidPtr->parityBufferPool.buffers == NULL) {
-			rf_mutex_destroy(&raidPtr->parityBufferPool.mutex);
-			rf_cond_destroy(&raidPtr->parityBufferPool.cond);
-			for (j = 0; j < i; j++) {
-				RF_Free(raidPtr->parityBufferPool.buffers[i], 
-					raidPtr->regionBufferPool.bufferSize * 
-					sizeof(char));
-			}
-			RF_Free(raidPtr->parityBufferPool.buffers, 
-				raidPtr->regionBufferPool.totalBuffers * 
-				sizeof(caddr_t));
-			return (ENOMEM);
-		}
-		printf("parityBufferPool.buffers[%d] = %lx\n", i,
-		    (long) raidPtr->parityBufferPool.buffers[i]);
-	}
-	rc = rf_ShutdownCreate(listp, 
-			       rf_ShutdownParityLoggingParityBufferPool, 
-			       raidPtr);
-	if (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, 
-				     &raidPtr->parityLogDiskQueue.mutex);
-	if (rc) {
-		RF_ERRORMSG3("Unable to init mutex file %s line %d rc=%d\n", 
-			     __FILE__, __LINE__, rc);
-		return (rc);
-	}
-	rc = rf_create_managed_cond(listp, &raidPtr->parityLogDiskQueue.cond);
-	if (rc) {
-		RF_ERRORMSG3("Unable to init cond file %s line %d rc=%d\n", 
-			     __FILE__, __LINE__, rc);
-		return (rc);
-	}
-	raidPtr->parityLogDiskQueue.flushQueue = NULL;
-	raidPtr->parityLogDiskQueue.reintQueue = NULL;
-	raidPtr->parityLogDiskQueue.bufHead = NULL;
-	raidPtr->parityLogDiskQueue.bufTail = NULL;
-	raidPtr->parityLogDiskQueue.reintHead = NULL;
-	raidPtr->parityLogDiskQueue.reintTail = NULL;
-	raidPtr->parityLogDiskQueue.logBlockHead = NULL;
-	raidPtr->parityLogDiskQueue.logBlockTail = NULL;
-	raidPtr->parityLogDiskQueue.reintBlockHead = NULL;
-	raidPtr->parityLogDiskQueue.reintBlockTail = NULL;
-	raidPtr->parityLogDiskQueue.freeDataList = NULL;
-	raidPtr->parityLogDiskQueue.freeCommonList = NULL;
-
-	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);
-		return (rc);
-	}
-	for (i = 0; i < rf_numParityRegions; i++) {
-		rc = rf_mutex_init(&raidPtr->regionInfo[i].mutex, "RF_PARITYLOGGING3");
-		if (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 * 
-				 sizeof(RF_RegionInfo_t)));
-			return (ENOMEM);
-		}
-		rc = rf_mutex_init(&raidPtr->regionInfo[i].reintMutex, "RF_PARITYLOGGING4");
-		if (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 * 
-				 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;
-		if (i < rf_numParityRegions - 1) {
-			raidPtr->regionInfo[i].capacity = 
-				raidPtr->regionLogCapacity;
-			raidPtr->regionInfo[i].numSectorsParity = 
-				raidPtr->regionParityRange;
-		} else {
-			raidPtr->regionInfo[i].capacity = 
-				lastRegionCapacity;
-			raidPtr->regionInfo[i].numSectorsParity = 
-				raidPtr->sectorsPerDisk - 
-				raidPtr->regionParityRange * i;
-			if (raidPtr->regionInfo[i].numSectorsParity > 
-			    maxRegionParityRange)
-				maxRegionParityRange = 
-					raidPtr->regionInfo[i].numSectorsParity;
-		}
-		raidPtr->regionInfo[i].diskCount = 0;
-		RF_ASSERT(raidPtr->regionInfo[i].capacity + 
-			  raidPtr->regionInfo[i].regionStartAddr <= 
-			  totalLogCapacity);
-		RF_ASSERT(raidPtr->regionInfo[i].parityStartAddr + 
-			  raidPtr->regionInfo[i].numSectorsParity <= 
-			  raidPtr->sectorsPerDisk);
-		printf("Allocating %d bytes for region %d\n",
-		       (int) (raidPtr->regionInfo[i].capacity *
-			   sizeof(RF_DiskMap_t)), i);
-		RF_Malloc(raidPtr->regionInfo[i].diskMap, 
-			  (raidPtr->regionInfo[i].capacity *
-			   sizeof(RF_DiskMap_t)), 
-			  (RF_DiskMap_t *));
-		if (raidPtr->regionInfo[i].diskMap == NULL) {
-			rf_mutex_destroy(&raidPtr->regionInfo[i].mutex);
-			rf_mutex_destroy(&raidPtr->regionInfo[i].reintMutex);
-			for (j = 0; j < i; j++)
-				FreeRegionInfo(raidPtr, j);
-			RF_Free(raidPtr->regionInfo, 
-				(rf_numParityRegions * 
-				 sizeof(RF_RegionInfo_t)));
-			return (ENOMEM);
-		}
-		raidPtr->regionInfo[i].loggingEnabled = RF_FALSE;
-		raidPtr->regionInfo[i].coreLog = NULL;
-	}
-	rc = rf_ShutdownCreate(listp,
-			       rf_ShutdownParityLoggingRegionInfo, 
-			       raidPtr);
-	if (rc) {
-		RF_ERRORMSG3("Unable to create shutdown entry file %s line %d rc=%d\n", __FILE__,
-		    __LINE__, rc);
-		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");
-	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);
-		return (ENOMEM);
-	}
-	/* wait for thread to start */
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_RUNNING)) {
-		RF_WAIT_COND(raidPtr->parityLogDiskQueue.cond, 
-			     raidPtr->parityLogDiskQueue.mutex);
-	}
-	RF_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_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);
-	}
-	rf_EnableParityLogging(raidPtr);
-
-	return (0);
-}
-
-static void 
-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 * 
-		 sizeof(RF_DiskMap_t)));
-	if (!rf_forceParityLogReint && raidPtr->regionInfo[regionID].coreLog) {
-		rf_ReleaseParityLogs(raidPtr, 
-				     raidPtr->regionInfo[regionID].coreLog);
-		raidPtr->regionInfo[regionID].coreLog = NULL;
-	} else {
-		RF_ASSERT(raidPtr->regionInfo[regionID].coreLog == NULL);
-		RF_ASSERT(raidPtr->regionInfo[regionID].diskCount == 0);
-	}
-	RF_UNLOCK_MUTEX(raidPtr->regionInfo[regionID].mutex);
-	rf_mutex_destroy(&raidPtr->regionInfo[regionID].mutex);
-	rf_mutex_destroy(&raidPtr->regionInfo[regionID].reintMutex);
-}
-
-
-static void 
-FreeParityLogQueue(
-    RF_Raid_t * raidPtr,
-    RF_ParityLogQueue_t * queue)
-{
-	RF_ParityLog_t *l1, *l2;
-
-	RF_LOCK_MUTEX(queue->mutex);
-	l1 = queue->parityLogs;
-	while (l1) {
-		l2 = l1;
-		l1 = l2->next;
-		RF_Free(l2->records, (raidPtr->numSectorsPerLog * 
-				      sizeof(RF_ParityLogRecord_t)));
-		RF_Free(l2, sizeof(RF_ParityLog_t));
-	}
-	RF_UNLOCK_MUTEX(queue->mutex);
-	rf_mutex_destroy(&queue->mutex);
-}
-
-
-static void 
-FreeRegionBufferQueue(RF_RegionBufferQueue_t * queue)
-{
-	int     i;
-
-	RF_LOCK_MUTEX(queue->mutex);
-	if (queue->availableBuffers != queue->totalBuffers) {
-		printf("Attempt to free region queue which is still in use!\n");
-		RF_ASSERT(0);
-	}
-	for (i = 0; i < queue->totalBuffers; i++)
-		RF_Free(queue->buffers[i], queue->bufferSize);
-	RF_Free(queue->buffers, queue->totalBuffers * sizeof(caddr_t));
-	RF_UNLOCK_MUTEX(queue->mutex);
-	rf_mutex_destroy(&queue->mutex);
-}
-
-static void 
-rf_ShutdownParityLoggingRegionInfo(RF_ThreadArg_t arg)
-{
-	RF_Raid_t *raidPtr;
-	RF_RegionId_t i;
-
-	raidPtr = (RF_Raid_t *) arg;
-	if (rf_parityLogDebug) {
-		printf("raid%d: ShutdownParityLoggingRegionInfo\n", 
-		       raidPtr->raidid);
-	}
-	/* free region information structs */
-	for (i = 0; i < rf_numParityRegions; i++)
-		FreeRegionInfo(raidPtr, i);
-	RF_Free(raidPtr->regionInfo, (rf_numParityRegions * 
-				      sizeof(raidPtr->regionInfo)));
-	raidPtr->regionInfo = NULL;
-}
-
-static void 
-rf_ShutdownParityLoggingPool(RF_ThreadArg_t arg)
-{
-	RF_Raid_t *raidPtr;
-
-	raidPtr = (RF_Raid_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 * 
-		raidPtr->numSectorsPerLog * raidPtr->bytesPerSector);
-}
-
-static void 
-rf_ShutdownParityLoggingRegionBufferPool(RF_ThreadArg_t arg)
-{
-	RF_Raid_t *raidPtr;
-
-	raidPtr = (RF_Raid_t *) arg;
-	if (rf_parityLogDebug) {
-		printf("raid%d: ShutdownParityLoggingRegionBufferPool\n", 
-		       raidPtr->raidid);
-	}
-	FreeRegionBufferQueue(&raidPtr->regionBufferPool);
-}
-
-static void 
-rf_ShutdownParityLoggingParityBufferPool(RF_ThreadArg_t arg)
-{
-	RF_Raid_t *raidPtr;
-
-	raidPtr = (RF_Raid_t *) arg;
-	if (rf_parityLogDebug) {
-		printf("raid%d: ShutdownParityLoggingParityBufferPool\n",
-		       raidPtr->raidid);
-	}
-	FreeRegionBufferQueue(&raidPtr->parityBufferPool);
-}
-
-static void 
-rf_ShutdownParityLoggingDiskQueue(RF_ThreadArg_t arg)
-{
-	RF_ParityLogData_t *d;
-	RF_CommonLogData_t *c;
-	RF_Raid_t *raidPtr;
-
-	raidPtr = (RF_Raid_t *) arg;
-	if (rf_parityLogDebug) {
-		printf("raid%d: ShutdownParityLoggingDiskQueue\n",
-		       raidPtr->raidid);
-	}
-	/* 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;
-		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;
-		RF_Free(c, sizeof(RF_CommonLogData_t));
-	}
-}
-
-static void 
-rf_ShutdownParityLogging(RF_ThreadArg_t arg)
-{
-	RF_Raid_t *raidPtr;
-
-	raidPtr = (RF_Raid_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. */
-
-	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
-         */
-	RF_LOCK_MUTEX(raidPtr->parityLogDiskQueue.mutex);
-	while (!(raidPtr->parityLogDiskQueue.threadState & RF_PLOG_SHUTDOWN)) {
-		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);
-	}
-}
-
-int 
-rf_GetDefaultNumFloatingReconBuffersParityLogging(RF_Raid_t * raidPtr)
-{
-	return (20);
-}
-
-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)
-{
-	RF_RegionId_t regionID;
-
-/*  regionID = address / (raidPtr->regionParityRange * raidPtr->Layout.numDataCol); */
-	regionID = address / raidPtr->regionParityRange;
-	if (regionID == rf_numParityRegions) {
-		/* last region may be larger than other regions */
-		regionID--;
-	}
-	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)
-{
-	RF_StripeNum_t SUID = raidSector / 
-		raidPtr->Layout.sectorsPerStripeUnit;
-	*row = 0;
-	/* *col = (SUID % (raidPtr->numCol -
-	 * raidPtr->Layout.numParityLogCol)); */
-	*col = SUID % raidPtr->Layout.numDataCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * 
-		raidPtr->Layout.sectorsPerStripeUnit +
-		(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)
-{
-	RF_StripeNum_t SUID = raidSector / 
-		raidPtr->Layout.sectorsPerStripeUnit;
-
-	*row = 0;
-	/* *col =
-	 * raidPtr->Layout.numDataCol-(SUID/raidPtr->Layout.numDataCol)%(raidPt
-	 * r->numCol - raidPtr->Layout.numParityLogCol); */
-	*col = raidPtr->Layout.numDataCol;
-	*diskSector = (SUID / (raidPtr->Layout.numDataCol)) * 
-		raidPtr->Layout.sectorsPerStripeUnit +
-		(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)
-{
-	*row = 0;
-	*col = raidPtr->numCol - 1;
-	*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)
-{
-	*row = 0;
-	*col = raidPtr->numCol - 2;
-	*startSector = raidPtr->regionInfo[regionID].parityStartAddr;
-	*numSector = raidPtr->regionInfo[regionID].numSectorsParity;
-}
-
-
-/* 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, 
-							   addr);
-	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)
-{
-	*which_ru = 0;
-	*psID = stripeID;
-}
-
-
-/* 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)
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_PhysDiskAddr_t *failedPDA = NULL;
-	RF_RowCol_t frow, fcol;
-	RF_RowStatus_t rstat;
-	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");
-		 /* *infoFunc = */ *createFunc = NULL;
-		return;
-	} else
-		if (asmp->numDataFailed + asmp->numParityFailed == 1) {
-
-			/* if under recon & already reconstructed, redirect
-			 * the access to the spare drive and eliminate the
-			 * 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
-			    );
-			if (prior_recon) {
-				RF_RowCol_t or = failedPDA->row, oc = failedPDA->col;
-				RF_SectorNum_t oo = failedPDA->startSector;
-				if (layoutPtr->map->flags & 
-				    RF_DISTRIBUTE_SPARE) {	
-					/* redirect to dist spare space */
-
-					if (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;
-							p->row = failedPDA->row;
-							p->col = failedPDA->col;
-							p->startSector = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, failedPDA->startSector) +
-							    SUoffs;	/* cheating:
-									 * startSector is not
-									 * really a RAID address */
-						}
-					} else
-						if (asmp->parityInfo->next && failedPDA == asmp->parityInfo->next) {
-							RF_ASSERT(0);	/* should not ever
-									 * happen */
-						} else {
-
-							/* data has failed */
-							(layoutPtr->map->MapSector) (raidPtr, failedPDA->raidAddress, &failedPDA->row,
-							    &failedPDA->col, &failedPDA->startSector, RF_REMAP);
-
-						}
-
-				} else {	
-					/* redirect to dedicated spare space */
-
-					failedPDA->row = raidPtr->Disks[frow][fcol].spareRow;
-					failedPDA->col = raidPtr->Disks[frow][fcol].spareCol;
-
-					/* the parity may have two distinct
-					 * components, both of which may need
-					 * 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;
-							}
-					}
-				}
-
-				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);
-				}
-				asmp->numDataFailed = asmp->numParityFailed = 0;
-			}
-		}
-	if (type == RF_IO_TYPE_READ) {
-
-		if (asmp->numDataFailed == 0)
-			*createFunc = (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;
-		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateRaidFiveDegradedReadDAG;
-
-	} else {
-
-
-		/* 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
-		 * 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. */
-		if ((asmp->numDataFailed + asmp->numParityFailed) == 0) {
-			if (((asmp->numStripeUnitsAccessed <= 
-			      (layoutPtr->numDataCol / 2)) && 
-			     (layoutPtr->numDataCol != 1)) ||
-			    (asmp->parityInfo->next != NULL) || 
-			    rf_CheckStripeForFailures(raidPtr, asmp)) {
-				*createFunc = (RF_VoidFuncPtr) rf_CreateParityLoggingSmallWriteDAG;
-			} else
-				*createFunc = (RF_VoidFuncPtr) rf_CreateParityLoggingLargeWriteDAG;
-		} else
-			if (asmp->numParityFailed == 1)
-				*createFunc = (RF_VoidFuncPtr) rf_CreateNonRedundantWriteDAG;
-			else
-				if (asmp->numStripeUnitsAccessed != 1 && failedPDA->numSector != layoutPtr->sectorsPerStripeUnit)
-					*createFunc = NULL;
-				else
-					*createFunc = (RF_VoidFuncPtr) rf_CreateDegradedWriteDAG;
-	}
-}
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
diff --git a/sys/dev/raidframe/rf_paritylogging.h b/sys/dev/raidframe/rf_paritylogging.h
deleted file mode 100644
index 5b7dd25..0000000
--- a/sys/dev/raidframe/rf_paritylogging.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_paritylogging.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* header file for Parity Logging */
-
-#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);
-
-#endif				/* !_RF__RF_PARITYLOGGING_H_ */
diff --git a/sys/dev/raidframe/rf_parityloggingdags.c b/sys/dev/raidframe/rf_parityloggingdags.c
deleted file mode 100644
index 30a5892..0000000
--- a/sys/dev/raidframe/rf_parityloggingdags.c
+++ /dev/null
@@ -1,675 +0,0 @@
-/*	$NetBSD: rf_parityloggingdags.c,v 1.4 2000/01/07 03:41:04 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_PARITYLOGGING > 0
-
-/*
-  DAGs specific to parity logging are created here
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_paritylog.h>
-#include <dev/raidframe/rf_memchunk.h>
-#include <dev/raidframe/rf_general.h>
-
-#include <dev/raidframe/rf_parityloggingdags.h>
-
-/******************************************************************************
- *
- * 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.
- *
- * 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
- *
- *****************************************************************************/
-
-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_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_AccessStripeMapHeader_t *new_asm_h[2];
-	int     nodeNum, asmNum;
-	RF_ReconUnitNum_t which_ru;
-	char   *sosBuffer, *eosBuffer;
-	RF_PhysDiskAddr_t *pda;
-	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 */
-	dag_h->creator = "ParityLoggingLargeWriteDAG";
-
-	/* 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);
-	i = 0;
-	wndNodes = &nodes[i];
-	i += nWndNodes;
-	xorNode = &nodes[i];
-	i += 1;
-	lpoNode = &nodes[i];
-	i += 1;
-	blockNode = &nodes[i];
-	i += 1;
-	syncNode = &nodes[i];
-	i += 1;
-	unblockNode = &nodes[i];
-	i += 1;
-	termNode = &nodes[i];
-	i += 1;
-
-	dag_h->numCommitNodes = nWndNodes + 1;
-	dag_h->numCommits = 0;
-	dag_h->numSuccedents = 1;
-
-	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 */
-	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);
-				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);
-				nodeNum++;
-				pda = pda->next;
-			}
-		}
-	}
-	RF_ASSERT(nodeNum == nRodNodes);
-
-	/* 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_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);
-		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);
-	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 */
-	}
-	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 + nRodNodes)].p = raidPtr;	/* xor node needs to get
-									 * at RAID information */
-
-	/* 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. */
-	for (i = 0; i < nRodNodes; i++)
-		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);
-	} 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);
-
-	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 */
-
-	/* connect nodes to form graph */
-
-	/* 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 */
-	RF_ASSERT(blockNode->numSuccedents == nRodNodes + 1);
-	for (i = 0; i < nRodNodes; i++) {
-		RF_ASSERT(rodNodes[i].numAntecedents == 1);
-		blockNode->succedents[i] = &rodNodes[i];
-		rodNodes[i].antecedents[0] = blockNode;
-		rodNodes[i].antType[0] = rf_control;
-	}
-
-	/* 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 */
-	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 */
-	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 */
-
-	/* 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];
-		wndNodes[i].antecedents[0] = syncNode;
-		wndNodes[i].antType[0] = rf_control;
-	}
-
-	/* 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 */
-	RF_ASSERT(unblockNode->numAntecedents == nWndNodes + 1);
-	for (i = 0; i < nWndNodes; i++) {
-		RF_ASSERT(wndNodes->numSuccedents == 1);
-		wndNodes[i].succedents[0] = unblockNode;
-		unblockNode->antecedents[i] = &wndNodes[i];
-		unblockNode->antType[i] = rf_control;
-	}
-
-	/* 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 */
-	RF_ASSERT(unblockNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	unblockNode->succedents[0] = termNode;
-	termNode->antecedents[0] = unblockNode;
-	termNode->antType[0] = rf_control;
-}
-
-
-
-
-/******************************************************************************
- *
- * 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
- *
- *
- * 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.
- * There is one Rod -- Wnd -- T branch for each stripe unit being updated.
- *
- * 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.
- *
- * 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)
-{
-	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;
-	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 */
-
-	if (rf_dagDebug)
-		printf("[Creating parity-logging small-write DAG]\n");
-	RF_ASSERT(numDataNodes > 0);
-	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;
-	if (lu_flag)
-		totalNumNodes += numDataNodes;
-
-	nNodes = numDataNodes + numParityNodes;
-
-	dag_h->numCommitNodes = numDataNodes + numParityNodes;
-	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);
-	i = 0;
-	blockNode = &nodes[i];
-	i += 1;
-	unblockNode = &nodes[i];
-	i += 1;
-	readDataNodes = &nodes[i];
-	i += numDataNodes;
-	readParityNodes = &nodes[i];
-	i += numParityNodes;
-	writeDataNodes = &nodes[i];
-	i += numDataNodes;
-	lpuNodes = &nodes[i];
-	i += numParityNodes;
-	xorNodes = &nodes[i];
-	i += numParityNodes;
-	termNode = &nodes[i];
-	i += 1;
-	if (lu_flag) {
-		unlockDataNodes = &nodes[i];
-		i += numDataNodes;
-	}
-	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);
-
-	/* 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 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_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 */
-		readDataNodes[i].params[2].v = parityStripeID;
-		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) */
-	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);
-		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[2].v = parityStripeID;
-		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) */
-	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 */
-		writeDataNodes[i].params[2].v = parityStripeID;
-		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);
-		}
-		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
-	 * 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;
-		if (qfuncs) {
-			qfunc = qfuncs->simple;
-			qname = qfuncs->SimpleName;
-		}
-	} else {
-		func = pfuncs->regular;
-		undoFunc = rf_NullNodeUndoFunc;
-		name = pfuncs->RegularName;
-		if (qfuncs) {
-			qfunc = qfuncs->regular;
-			qname = qfuncs->RegularName;
-		}
-	}
-	/* 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 */
-			xorNodes[i].flags |= RF_DAGNODE_FLAG_YIELD;
-			xorNodes[i].params[0] = readDataNodes[i].params[0];
-			xorNodes[i].params[1] = readDataNodes[i].params[1];
-			xorNodes[i].params[2] = readParityNodes[i].params[0];
-			xorNodes[i].params[3] = readParityNodes[i].params[1];
-			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 */
-		}
-	} 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);
-		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 */
-		}
-		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 */
-		}
-		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) */
-	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 */
-		pda = pda->next;
-	}
-
-
-	/* Step 4. connect the nodes */
-
-	/* 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 */
-	RF_ASSERT(blockNode->numSuccedents == (numDataNodes + numParityNodes));
-	for (i = 0; i < numDataNodes; i++) {
-		blockNode->succedents[i] = &readDataNodes[i];
-		RF_ASSERT(readDataNodes[i].numAntecedents == 1);
-		readDataNodes[i].antecedents[0] = blockNode;
-		readDataNodes[i].antType[0] = rf_control;
-	}
-
-	/* 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);
-		readParityNodes[i].antecedents[0] = blockNode;
-		readParityNodes[i].antType[0] = rf_control;
-	}
-
-	/* connect read old data nodes to write new data nodes */
-	for (i = 0; i < numDataNodes; i++) {
-		RF_ASSERT(readDataNodes[i].numSuccedents == numDataNodes + numParityNodes);
-		for (j = 0; j < numDataNodes; j++) {
-			RF_ASSERT(writeDataNodes[j].numAntecedents == numDataNodes + numParityNodes);
-			readDataNodes[i].succedents[j] = &writeDataNodes[j];
-			writeDataNodes[j].antecedents[i] = &readDataNodes[i];
-			if (i == j)
-				writeDataNodes[j].antType[i] = rf_antiData;
-			else
-				writeDataNodes[j].antType[i] = rf_control;
-		}
-	}
-
-	/* 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];
-			xorNodes[j].antecedents[i] = &readDataNodes[i];
-			xorNodes[j].antType[i] = rf_trueData;
-		}
-
-	/* connect read old parity nodes to write new data nodes */
-	for (i = 0; i < numParityNodes; i++) {
-		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;
-		}
-	}
-
-	/* 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];
-			xorNodes[j].antType[numDataNodes + i] = rf_trueData;
-		}
-
-	/* 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);
-		xorNodes[i].succedents[0] = &lpuNodes[i];
-		lpuNodes[i].antecedents[0] = &xorNodes[i];
-		lpuNodes[i].antType[0] = rf_trueData;
-	}
-
-	for (i = 0; i < numDataNodes; i++) {
-		if (lu_flag) {
-			/* 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 */
-			RF_ASSERT(unlockDataNodes[i].numSuccedents == 1);
-			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 */
-			RF_ASSERT(writeDataNodes[i].numSuccedents == 1);
-			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 */
-	for (i = 0; i < numParityNodes; i++) {
-		RF_ASSERT(lpuNodes[i].numSuccedents == 1);
-		lpuNodes[i].succedents[0] = unblockNode;
-		unblockNode->antecedents[numDataNodes + i] = &lpuNodes[i];
-		unblockNode->antType[numDataNodes + i] = rf_control;
-	}
-
-	/* connect unblock node to terminator */
-	RF_ASSERT(unblockNode->numSuccedents == 1);
-	RF_ASSERT(termNode->numAntecedents == 1);
-	RF_ASSERT(termNode->numSuccedents == 0);
-	unblockNode->succedents[0] = termNode;
-	termNode->antecedents[0] = unblockNode;
-	termNode->antType[0] = rf_control;
-}
-
-
-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);
-}
-
-
-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);
-}
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
diff --git a/sys/dev/raidframe/rf_parityloggingdags.h b/sys/dev/raidframe/rf_parityloggingdags.h
deleted file mode 100644
index dc0fc9b..0000000
--- a/sys/dev/raidframe/rf_parityloggingdags.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_parityloggingdags.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/****************************************************************************
- *                                                                          *
- * rf_parityloggingdags.h -- header file for parity logging dags            *
- *                                                                          *
- ****************************************************************************/
-
-#ifndef _RF__RF_PARITYLOGGINGDAGS_H_
-#define _RF__RF_PARITYLOGGINGDAGS_H_
-
-/* 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_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);
-
-#endif				/* !_RF__RF_PARITYLOGGINGDAGS_H_ */
diff --git a/sys/dev/raidframe/rf_parityscan.c b/sys/dev/raidframe/rf_parityscan.c
deleted file mode 100644
index 34834cb..0000000
--- a/sys/dev/raidframe/rf_parityscan.c
+++ /dev/null
@@ -1,445 +0,0 @@
-/*	$NetBSD: rf_parityscan.c,v 1.9 2000/05/28 03:00:31 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * rf_parityscan.c -- misc utilities related to parity verification
- *
- *****************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_mcpair.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_engine.h>
-#include <dev/raidframe/rf_parityscan.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_kintf.h>
-
-/*****************************************************************************************
- *
- * 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
- * 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.
- *
- ****************************************************************************************/
-
-int 
-rf_RewriteParity(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_AccessStripeMapHeader_t *asm_h;
-	int ret_val;
-	int rc;
-	RF_PhysDiskAddr_t pda;
-	RF_SectorNum_t i;
-
-	if (raidPtr->Layout.map->faultsTolerated == 0) {
-		/* There isn't any parity. Call it "okay." */
-		return (RF_PARITY_OKAY);
-	}
-	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. 
-		 */
-		return (RF_PARITY_COULD_NOT_VERIFY);
-	}
-
-	ret_val = 0;
-
-	pda.startSector = 0;
-	pda.numSector = raidPtr->Layout.sectorsPerStripeUnit;
-	rc = RF_PARITY_OKAY;
-
-	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 */
-			return (1);
-		}
-		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) {
-		case RF_PARITY_OKAY:
-		case RF_PARITY_CORRECTED:
-			break;
-		case RF_PARITY_BAD:
-			printf("Parity bad during correction\n");
-			ret_val = 1;
-			break;
-		case RF_PARITY_COULD_NOT_CORRECT:
-			printf("Could not correct bad parity\n");
-			ret_val = 1;
-			break;
-		case RF_PARITY_COULD_NOT_VERIFY:
-			printf("Could not verify parity\n");
-			ret_val = 1;
-			break;
-		default:
-			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
- * 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;
-{
-	RF_PhysDiskAddr_t *parityPDA;
-	RF_AccessStripeMap_t *doasm;
-	RF_LayoutSW_t *lp;
-	int     lrc, rc;
-
-	lp = raidPtr->Layout.map;
-	if (lp->faultsTolerated == 0) {
-		/*
-	         * 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; 
-			     parityPDA = parityPDA->next) {
-				lrc = lp->VerifyParity(raidPtr, 
-						       doasm->raidAddress, 
-						       parityPDA,
-						       correct_it, flags);
-				if (lrc > rc) {
-					/* see rf_parityscan.h for why this
-					 * works */
-					rc = lrc;
-				}
-			}
-		}
-	} else {
-		rc = RF_PARITY_COULD_NOT_VERIFY;
-	}
-	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;
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	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 */
-	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;
-	RF_ReconUnitNum_t which_ru;
-	RF_StripeNum_t psID = rf_RaidAddressToParityStripeID(layoutPtr, 
-							     raidAddr, 
-							     &which_ru);
-	int     stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
-	RF_AccTraceEntry_t tracerec;
-	RF_MCPair_t *mcpair;
-
-	retcode = RF_PARITY_OKAY;
-
-	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 */
-	end_p = buf + bytesPerStripe;
-
-	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);
-	asmap = asm_h->stripeMap;
-
-	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 */
-		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);
-	}
-
-	RF_ASSERT(!asmap->parityInfo->next);
-	rf_RangeRestrictPDA(raidPtr, parityPDA, asmap->parityInfo, 0, 1);
-	RF_ASSERT(asmap->parityInfo->numSector != 0);
-	if (rf_TryToRedirectPDA(raidPtr, asmap->parityInfo, 1))
-		goto out;
-	blockNode->succedents[layoutPtr->numDataCol]->params[0].p = asmap->parityInfo;
-
-	/* fire off the DAG */
-	bzero((char *) &tracerec, sizeof(tracerec));
-	rd_dag_h->tracerec = &tracerec;
-
-	if (rf_verifyParityDebug) {
-		printf("Parity verify read dag:\n");
-		rf_PrintDAGList(rd_dag_h);
-	}
-	RF_LOCK_MUTEX(mcpair->mutex);
-	mcpair->flag = 0;
-	rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
-	    (void *) mcpair);
-	while (!mcpair->flag)
-		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");
-		retcode = RF_PARITY_COULD_NOT_VERIFY;
-		goto out;
-	}
-	for (p = buf; p < end_p; p += numbytes) {
-		rf_bxor(p, pbuf, numbytes, NULL);
-	}
-	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]);
-		}
-#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]);
-			retcode = RF_PARITY_BAD;
-			break;
-		}
-	}
-
-	if (retcode && correct_it) {
-		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);
-		bzero((char *) &tracerec, sizeof(tracerec));
-		wr_dag_h->tracerec = &tracerec;
-		if (rf_verifyParityDebug) {
-			printf("Parity verify write dag:\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);
-		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");
-			retcode = RF_PARITY_COULD_NOT_CORRECT;
-		}
-		rf_FreeDAG(wr_dag_h);
-		if (retcode == RF_PARITY_BAD)
-			retcode = RF_PARITY_CORRECTED;
-	}
-out:
-	rf_FreeAccessStripeMap(asm_h);
-	rf_FreeAllocList(alloclist);
-	rf_FreeDAG(rd_dag_h);
-	rf_FreeMCPair(mcpair);
-	return (retcode);
-}
-
-int 
-rf_TryToRedirectPDA(raidPtr, pda, parity)
-	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 (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);
-					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);
-				} else {
-					(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);
-				}
-			} else {
-				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;
-			}
-		}
-	}
-	if (RF_DEAD_DISK(raidPtr->Disks[pda->row][pda->col].status))
-		return (1);
-	return (0);
-}
-/*****************************************************************************************
- *
- * 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.
- *
- * 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 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;
-{
-	return (0);
-}
-/* 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
- * 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
- */
-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_DagHeader_t *dag_h;
-	RF_DagNode_t *nodes, *termNode, *blockNode, *unblockNode;
-	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);
-	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->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 */
-	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);
-	unblockNode->succedents[0] = termNode;
-	for (i = 0; i < nNodes; 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);
-		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);
-	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
deleted file mode 100644
index babca41..0000000
--- a/sys/dev/raidframe/rf_parityscan.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_parityscan.h,v 1.3 1999/02/05 00:06:14 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_PARITYSCAN_H_
-#define _RF__RF_PARITYSCAN_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/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);
-
-#define RF_DO_CORRECT_PARITY   1
-#define RF_DONT_CORRECT_PARITY 0
-
-/*
- * 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
-
-#endif				/* !_RF__RF_PARITYSCAN_H_ */
diff --git a/sys/dev/raidframe/rf_pq.c b/sys/dev/raidframe/rf_pq.c
deleted file mode 100644
index 98b53e8..0000000
--- a/sys/dev/raidframe/rf_pq.c
+++ /dev/null
@@ -1,928 +0,0 @@
-/*	$NetBSD: rf_pq.c,v 1.7 2000/01/07 03:41:02 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * Code for RAID level 6 (P + Q) disk array architecture.
- */
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_pqdeg.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/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;
-{
-	return (rf_RegularXorFunc(node));
-}
-/*
-   same as simpleONQ func, but the coefficient is always 1
-*/
-
-int 
-rf_SimpleONPFunc(node)
-	RF_DagNode_t *node;
-{
-	return (rf_SimpleXorFunc(node));
-}
-
-int 
-rf_RecoveryPFunc(node)
-	RF_DagNode_t *node;
-{
-	return (rf_RecoveryXorFunc(node));
-}
-
-int 
-rf_RegularPFunc(node)
-	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)
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	unsigned ndfail = asmap->numDataFailed;
-	unsigned npfail = asmap->numParityFailed;
-	unsigned ntfail = npfail + ndfail;
-
-	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");
-		 /* *infoFunc = */ *createFunc = NULL;
-		return;
-	}
-	/* 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 */
-			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;
-				else
-					*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;
-				else
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_100_CreateReadDAG;
-			}
-			break;
-		case 2:
-			/* lost two data units */
-			/* *infoFunc = PQOneTwo; */
-			*createFunc = (RF_VoidFuncPtr) rf_PQ_200_CreateReadDAG;
-			break;
-		}
-		return;
-	}
-	/* a write */
-	switch (ntfail) {
-	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))) {
-
-			*createFunc = (RF_VoidFuncPtr) rf_PQCreateSmallWriteDAG;
-		} else {
-			*createFunc = (RF_VoidFuncPtr) rf_PQCreateLargeWriteDAG;
-		}
-		break;
-
-	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;
-				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;
-				else
-					*createFunc = (RF_VoidFuncPtr) rf_PQ_010_CreateLargeWriteDAG;
-			}
-		} else {	/* data missing. Do a P reconstruct write if
-				 * only a single data unit is lost in the
-				 * stripe, otherwise a PQ reconstruct write. */
-			if (rf_NumFailedDataUnitsInStripe(raidPtr, asmap) == 2)
-				*createFunc = (RF_VoidFuncPtr) rf_PQ_200_CreateWriteDAG;
-			else
-				*createFunc = (RF_VoidFuncPtr) rf_PQ_100_CreateWriteDAG;
-		}
-		break;
-
-	case 2:		/* two disk faults */
-		switch (npfail) {
-		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));
-			if (asmap->failedPDAs[1]->type == RF_PDA_TYPE_Q)
-				*createFunc = (RF_VoidFuncPtr) rf_PQ_101_CreateWriteDAG;
-			else
-				*createFunc = (RF_VoidFuncPtr) rf_PQ_110_CreateWriteDAG;
-			break;
-		case 0:	/* double data loss */
-			*createFunc = (RF_VoidFuncPtr) rf_PQ_200_CreateWriteDAG;
-			break;
-		}
-		break;
-
-	default:		/* more than 2 disk faults */
-		*createFunc = NULL;
-		RF_PANIC();
-	}
-	return;
-}
-/*
-   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;
-{
-	*nSucc = *nAnte = 1;
-}
-
-static void 
-PQOneTwo(raidPtr, nSucc, nAnte, asmap)
-	RF_Raid_t *raidPtr;
-	int    *nSucc;
-	int    *nAnte;
-	RF_AccessStripeMap_t *asmap;
-{
-	*nSucc = 1;
-	*nAnte = 2;
-}
-#endif
-
-RF_CREATE_DAG_FUNC_DECL(rf_PQCreateLargeWriteDAG)
-{
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, allocList, 2,
-	    rf_RegularPQFunc, RF_FALSE);
-}
-
-int 
-rf_RegularONQFunc(node)
-	RF_DagNode_t *node;
-{
-	int     np = node->numParams;
-	int     d;
-	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
-	int     i;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	RF_Etimer_t timer;
-	char   *qbuf, *qpbuf;
-	char   *obuf, *nbuf;
-	RF_PhysDiskAddr_t *old, *new;
-	unsigned long coeff;
-	unsigned secPerSU = raidPtr->Layout.sectorsPerStripeUnit;
-
-	RF_ETIMER_START(timer);
-
-	d = (np - 3) / 4;
-	RF_ASSERT(4 * d + 3 == np);
-	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;
-		new = (RF_PhysDiskAddr_t *) node->params[2 * (d + 1 + i)].p;
-		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 */
-		coeff = (coeff % raidPtr->Layout.numDataCol);
-		qpbuf = qbuf + rf_RaidAddressToByte(raidPtr, old->startSector % secPerSU);
-		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 */
-	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
-*/
-
-int 
-rf_SimpleONQFunc(node)
-	RF_DagNode_t *node;
-{
-	int     np = node->numParams;
-	int     d;
-	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 1].p;
-	int     i;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-	RF_Etimer_t timer;
-	char   *qbuf;
-	char   *obuf, *nbuf;
-	RF_PhysDiskAddr_t *old, *new;
-	unsigned long coeff;
-
-	RF_ETIMER_START(timer);
-
-	d = (np - 3) / 4;
-	RF_ASSERT(4 * d + 3 == np);
-	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;
-		new = (RF_PhysDiskAddr_t *) node->params[2 * (d + 1 + i)].p;
-		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 */
-		coeff = (coeff % raidPtr->Layout.numDataCol);
-		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 */
-	return (0);
-}
-RF_CREATE_DAG_FUNC_DECL(rf_PQCreateSmallWriteDAG)
-{
-	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;
-{
-	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   *obuf, *qpbuf;
-	RF_PhysDiskAddr_t *old;
-	unsigned long coeff;
-
-	RF_ETIMER_START(timer);
-
-	d = (np - 1) / 2;
-	RF_ASSERT(2 * d + 1 == np);
-	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 = (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);
-	}
-
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->q_us += RF_ETIMER_VAL_US(timer);
-}
-/*
-   used in degraded writes.
-*/
-
-static void DegrQSubr(RF_DagNode_t *node);
-
-static void 
-DegrQSubr(node)
-	RF_DagNode_t *node;
-{
-	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;
-	RF_PhysDiskAddr_t *old;
-	unsigned long coeff;
-	unsigned fail_start;
-	int     j;
-
-	old = (RF_PhysDiskAddr_t *) node->params[np - 2].p;
-	fail_start = old->startSector % secPerSU;
-
-	RF_ETIMER_START(timer);
-
-	d = (np - 2) / 2;
-	RF_ASSERT(2 * d + 2 == np);
-	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 = (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 */
-		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_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.
-*/
-
-int 
-rf_RegularPQFunc(node)
-	RF_DagNode_t *node;
-{
-	RegularQSubr(node, node->results[1]);
-	return (rf_RegularXorFunc(node));	/* does the wakeup */
-}
-
-int 
-rf_RegularQFunc(node)
-	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 */
-	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.
-*/
-
-void 
-rf_Degraded_100_PQFunc(node)
-	RF_DagNode_t *node;
-{
-	int     np = node->numParams;
-
-	RF_ASSERT(np >= 2);
-	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.
-
-*/
-
-/* 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
- *
- * so to recover data_j we need
- *
- *    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
- *   data_j /= J
- *
- *
- */
-int 
-rf_RecoveryQFunc(node)
-	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 *pda;
-	RF_RaidAddr_t suoffset, 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 */
-	bcopy(node->params[node->numParams - 3].p, node->results[0],
-	    rf_RaidAddressToByte(raidPtr, failedPDA->numSector));
-	for (i = 0; i < node->numParams - 4; i += 2) {
-		RF_ASSERT(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);
-		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);
-	}
-	/* 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);
-	rf_GenericWakeupFunc(node, 0);
-	return (0);
-}
-
-int 
-rf_RecoveryPQFunc(node)
-	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);
-	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.
-*/
-
-void 
-rf_PQ_DegradedWriteQFunc(node)
-	RF_DagNode_t *node;
-{
-	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;
-	RF_PhysDiskAddr_t *old;
-	unsigned long coeff;
-	int     fail_start, j;
-
-	old = (RF_PhysDiskAddr_t *) node->params[np - 2].p;
-	fail_start = old->startSector % secPerSU;
-
-	RF_ETIMER_START(timer);
-
-	d = (np - 2) / 2;
-	RF_ASSERT(2 * d + 2 == np);
-
-	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 = (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_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->q_us += RF_ETIMER_VAL_US(timer);
-	rf_GenericWakeupFunc(node, 0);
-}
-
-
-
-
-/* Q computations */
-
-/*
-   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;
-{
-	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))
-
-	length /= 8;
-	/* 13 5 bit quants in a 64 bit word */
-	while (length) {
-		a = *buf++;
-		d = *dest;
-		a1 = EXTRACT(a, 0) ^ r;
-		a2 = EXTRACT(a, 1) ^ r;
-		new = INSERT(a2, 1) | a1;
-		a1 = EXTRACT(a, 2) ^ r;
-		a2 = EXTRACT(a, 3) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 2) | INSERT(a2, 3);
-		a1 = EXTRACT(a, 4) ^ r;
-		a2 = EXTRACT(a, 5) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 4) | INSERT(a2, 5);
-		a1 = EXTRACT(a, 5) ^ r;
-		a2 = EXTRACT(a, 6) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 5) | INSERT(a2, 6);
-#if RF_LONGSHIFT > 2
-		a1 = EXTRACT(a, 7) ^ r;
-		a2 = EXTRACT(a, 8) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 7) | INSERT(a2, 8);
-		a1 = EXTRACT(a, 9) ^ r;
-		a2 = EXTRACT(a, 10) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 9) | INSERT(a2, 10);
-		a1 = EXTRACT(a, 11) ^ r;
-		a2 = EXTRACT(a, 12) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 11) | INSERT(a2, 12);
-#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.
-*/
-
-static void 
-QDelta(
-    char *dest,
-    char *obuf,
-    char *nbuf,
-    unsigned length,
-    unsigned char coeff)
-{
-	unsigned long a, d, new;
-	unsigned long a1, a2;
-	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 */
-
-#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 */
-	length /= 8;
-	while (length) {
-		a = *obuf++;	/* XXX need to reorg to avoid cache conflicts */
-		a ^= *nbuf++;
-		d = *dest;
-		a1 = EXTRACT(a, 0) ^ r;
-		a2 = EXTRACT(a, 1) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = INSERT(a2, 1) | a1;
-		a1 = EXTRACT(a, 2) ^ r;
-		a2 = EXTRACT(a, 3) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 2) | INSERT(a2, 3);
-		a1 = EXTRACT(a, 4) ^ r;
-		a2 = EXTRACT(a, 5) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 4) | INSERT(a2, 5);
-		a1 = EXTRACT(a, 5) ^ r;
-		a2 = EXTRACT(a, 6) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 5) | INSERT(a2, 6);
-#if RF_LONGSHIFT > 2
-		a1 = EXTRACT(a, 7) ^ r;
-		a2 = EXTRACT(a, 8) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 7) | INSERT(a2, 8);
-		a1 = EXTRACT(a, 9) ^ r;
-		a2 = EXTRACT(a, 10) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 9) | INSERT(a2, 10);
-		a1 = EXTRACT(a, 11) ^ r;
-		a2 = EXTRACT(a, 12) ^ r;
-		a1 = q[a1];
-		a2 = q[a2];
-		new = new | INSERT(a1, 11) | INSERT(a2, 12);
-#endif				/* RF_LONGSHIFT > 2 */
-		d ^= new;
-		*dest++ = d;
-		length--;
-	}
-#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.
-*/
-
-
-/*
- * 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;
-{
-	unsigned long p, q, a, a0, a1;
-	int     col = (29 * coeff_a) + coeff_b;
-	unsigned char *q0 = &(rf_qinv[col][0]);
-
-	length /= 8;
-	while (length) {
-		p = *pbuf++;
-		q = *qbuf++;
-		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)
-
-		MF(1);
-		MF(2);
-		MF(3);
-		MF(4);
-		MF(5);
-		MF(6);
-#if 0
-		MF(7);
-		MF(8);
-		MF(9);
-		MF(10);
-		MF(11);
-		MF(12);
-#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.
-*/
-
-
-
-static void 
-rf_InvertQ(
-    unsigned long *qbuf,
-    unsigned long *abuf,
-    unsigned length,
-    unsigned coeff)
-{
-	unsigned long a, new;
-	unsigned long a1, a2;
-	unsigned int *q = &(rf_qfor[3 + coeff][0]);
-	unsigned r = rf_rn[coeff + 1];
-
-	/* 13 5 bit quants in a 64 bit word */
-	length /= 8;
-	while (length) {
-		a = *qbuf++;
-		a1 = EXTRACT(a, 0);
-		a2 = EXTRACT(a, 1);
-		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)
-
-		M(2, 3);
-		M(4, 5);
-		M(5, 6);
-#if RF_LONGSHIFT > 2
-		M(7, 8);
-		M(9, 10);
-		M(11, 12);
-#endif				/* RF_LONGSHIFT > 2 */
-		*abuf++ = new;
-		length--;
-	}
-}
-#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
deleted file mode 100644
index 9a2ce23..0000000
--- a/sys/dev/raidframe/rf_pq.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_pq.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
-/*
- * rf_pq.h
- */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_PQ_H_
-#define _RF__RF_PQ_H_
-
-#include <dev/raidframe/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);
-
-#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);
-RF_CREATE_DAG_FUNC_DECL(rf_PQCreateLargeWriteDAG);
-int     rf_RegularONQFunc(RF_DagNode_t * node);
-int     rf_SimpleONQFunc(RF_DagNode_t * node);
-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);
-
-#endif				/* (RF_INCLUDE_DECL_PQ > 0) ||
-				 * (RF_INCLUDE_RAID6 > 0) */
-
-#endif				/* !_RF__RF_PQ_H_ */
diff --git a/sys/dev/raidframe/rf_pqdeg.c b/sys/dev/raidframe/rf_pqdeg.c
deleted file mode 100644
index 0d3356c..0000000
--- a/sys/dev/raidframe/rf_pqdeg.c
+++ /dev/null
@@ -1,219 +0,0 @@
-/*	$NetBSD: rf_pqdeg.c,v 1.5 2000/01/07 03:41:04 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <dev/raidframe/rf_archs.h>
-
-#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_pqdeg.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_pqdegdags.h>
-#include <dev/raidframe/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.
-*/
-
-/* 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);
-}
-/* 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);
-}
-/*
-  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 */
-	temp = asmap->parityInfo;
-	asmap->parityInfo = asmap->qInfo;
-	asmap->qInfo = temp;
-	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.
-*/
-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);
-}
-/* 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 != 
-	    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);
-}
-/* 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 */
-	temp = asmap->parityInfo;
-	asmap->parityInfo = asmap->qInfo;
-	asmap->qInfo = temp;
-	rf_CommonCreateSmallWriteDAG(raidPtr, asmap, dag_h, bp, flags, 
-				     allocList, &rf_qFuncs, NULL);
-}
-/* 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);
-}
-/* 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 */
-	temp = asmap->parityInfo;
-	asmap->parityInfo = asmap->qInfo;
-	asmap->qInfo = temp;
-	rf_CommonCreateLargeWriteDAG(raidPtr, asmap, dag_h, bp, flags, 
-				     allocList, 1, rf_RegularQFunc, RF_FALSE);
-}
-/* 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);
-}
-
-
-/*
- * writes, double failure
- */
-
-/*
- * 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);
-}
-/*
-   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.
-*/
-RF_CREATE_DAG_FUNC_DECL(rf_PQ_110_CreateWriteDAG)
-{
-	RF_PhysDiskAddr_t *temp;
-
-	if (asmap->numStripeUnitsAccessed != 1 &&
-	    asmap->failedPDAs[0]->numSector != raidPtr->Layout.sectorsPerStripeUnit) {
-		RF_PANIC();
-	}
-	/* 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? */
-}
-/*
-   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)
-		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) */
diff --git a/sys/dev/raidframe/rf_pqdeg.h b/sys/dev/raidframe/rf_pqdeg.h
deleted file mode 100644
index 83371e6..0000000
--- a/sys/dev/raidframe/rf_pqdeg.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_pqdeg.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_PQDEG_H_
-#define _RF__RF_PQDEG_H_
-
-#include <dev/raidframe/rf_types.h>
-
-#if RF_UTILITY == 0
-#include <dev/raidframe/rf_dag.h>
-
-/* extern decl's of the failure mode PQ functions.
- * See pddeg.c for nomenclature discussion.
- */
-
-/* reads, single failure  */
-RF_CREATE_DAG_FUNC_DECL(rf_PQ_100_CreateReadDAG);
-/* reads, two failure */
-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 */
-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 */
-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 */
-
-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 */
-extern RF_ua1024_t rf_qinv[29 * 29];
-#else				/* !_KERNEL */
-extern RF_ua1024_t rf_qinv[1];
-#endif				/* !_KERNEL */
-
-#endif				/* !_RF__RF_PQDEG_H_ */
diff --git a/sys/dev/raidframe/rf_pqdegdags.c b/sys/dev/raidframe/rf_pqdegdags.c
deleted file mode 100644
index 3606005..0000000
--- a/sys/dev/raidframe/rf_pqdegdags.c
+++ /dev/null
@@ -1,432 +0,0 @@
-/*	$NetBSD: rf_pqdegdags.c,v 1.5 1999/08/15 02:36:40 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * rf_pqdegdags.c
- * Degraded mode dags for double fault cases.
-*/
-
-
-#include <dev/raidframe/rf_archs.h>
-
-#if (RF_INCLUDE_DECL_PQ > 0) || (RF_INCLUDE_RAID6 > 0)
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_pqdegdags.h>
-#include <dev/raidframe/rf_pq.h>
-
-static void 
-applyPDA(RF_Raid_t * raidPtr, RF_PhysDiskAddr_t * pda, RF_PhysDiskAddr_t * ppda,
-    RF_PhysDiskAddr_t * qpda, void *bp);
-
-/*
-   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.
- * This DAG is as follows:
- *
- *                                      Hdr
- *                                       |
- *                                     Block
- *                       /         /           \         \     \   \
- *                      Rud  ...  Rud         Rrd  ...  Rrd    Rp  Rq
- *                      | \       | \         | \       | \    | \ | \
- *
- *                                 |                 |
- *                              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
- *
- * 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.
- *
- * 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)
-
-RF_CREATE_DAG_FUNC_DECL(rf_PQ_DoubleDegRead)
-{
-	rf_DoubleDegRead(raidPtr, asmap, dag_h, bp, flags, allocList,
-	    "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;
-{
-	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;
-
-	suoffset = rf_StripeUnitOffset(layoutPtr, pda->startSector);
-	len = pda->numSector;
-	/* 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 = (coeff % raidPtr->Layout.numDataCol);
-
-		if (suoffset < s0off) {
-			delta = s0off - suoffset;
-			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);
-		}
-		if ((suoffset + len) > (s0len + s0off))
-			len = s0len + s0off - suoffset;
-
-		/* 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);
-	}
-}
-/*
-   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.
-*/
-
-
-int 
-rf_PQDoubleRecoveryFunc(node)
-	RF_DagNode_t *node;
-{
-	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;
-	unsigned coeff;
-	RF_RaidAddr_t sosAddr, suoffset;
-	RF_SectorCount_t len, secPerSU = layoutPtr->sectorsPerStripeUnit;
-	int     two = 0;
-	RF_PhysDiskAddr_t *ppda, *ppda2, *qpda, *qpda2, *pda, npda;
-	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)) {
-		RF_ASSERT(0);
-		ppda = node->params[np - 6].p;
-		ppda2 = node->params[np - 5].p;
-		qpda = node->params[np - 4].p;
-		qpda2 = node->params[np - 3].p;
-		d = (np - 6);
-		two = 1;
-	} else {
-		ppda = node->params[np - 4].p;
-		qpda = node->params[np - 3].p;
-		d = (np - 4);
-	}
-
-	for (i = 0; i < d; i++) {
-		pda = node->params[i].p;
-		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 = (coeff % raidPtr->Layout.numDataCol);
-		/* see if pda intersects a recovery pda */
-		applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
-		if (two)
-			applyPDA(raidPtr, pda, ppda, qpda, node->dagHdr->bp);
-	}
-
-	/* 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. */
-
-	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 */
-		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))
-				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);
-	} else
-		RF_PANIC();
-
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	if (tracerec)
-		tracerec->q_us += RF_ETIMER_VAL_US(timer);
-	rf_GenericWakeupFunc(node, 0);
-	return (0);
-}
-
-int 
-rf_PQWriteDoubleRecoveryFunc(node)
-	RF_DagNode_t *node;
-{
-	/* 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;
-	RF_Raid_t *raidPtr = (RF_Raid_t *) node->params[np - 2].p;
-	RF_RaidLayout_t *layoutPtr = (RF_RaidLayout_t *) & (raidPtr->Layout);
-	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;
-	RF_Etimer_t timer;
-	RF_AccTraceEntry_t *tracerec = node->dagHdr->tracerec;
-
-	RF_ASSERT(node->numResults == 2);
-	RF_ASSERT(asmap->failedPDAs[1] == NULL);
-	RF_ETIMER_START(timer);
-	ppda = node->results[0];
-	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);
-
-	/* 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 */
-	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))
-			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);
-
-	/* 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_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 */
-	for (i = 0; i < numDataCol - 2; i++)
-		applyPDA(raidPtr, node->params[i].p, ppda, qpda, node->dagHdr->bp);
-
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	if (tracerec)
-		tracerec->q_us += RF_ETIMER_VAL_US(timer);
-
-	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 overwriten)
-	    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;
-
-	sum = asmap->failedPDAs[0]->numSector;
-	if (nf == 2)
-		sum += asmap->failedPDAs[1]->numSector;
-
-	if ((nf == 2) && (sum == (2 * sectorsPerSU))) {
-		/* 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);
-		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);
-}
-#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
deleted file mode 100644
index 11ce820..0000000
--- a/sys/dev/raidframe/rf_pqdegdags.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_pqdegdags.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
-/*
- * rf_pqdegdags.h
- */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Daniel Stodolsky
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-/*
- * rf_pqdegdags.c
- * Degraded mode dags for double fault cases.
- */
-
-#ifndef _RF__RF_PQDEGDAGS_H_
-#define _RF__RF_PQDEGDAGS_H_
-
-#include <dev/raidframe/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);
-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_ */
diff --git a/sys/dev/raidframe/rf_psstatus.c b/sys/dev/raidframe/rf_psstatus.c
deleted file mode 100644
index a6968cf..0000000
--- a/sys/dev/raidframe/rf_psstatus.c
+++ /dev/null
@@ -1,378 +0,0 @@
-/*	$NetBSD: rf_psstatus.c,v 1.5 2000/01/08 22:57:31 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * psstatus.c
- *
- * The reconstruction code maintains a bunch of status related to the parity
- * stripes that are currently under reconstruction.  This header file defines
- * the status structures.
- *
- *****************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_debugprint.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_psstatus.h>
-#include <dev/raidframe/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;
-{
-	RF_Calloc(p->issued, raidPtr->numCol, sizeof(char), (char *));
-	if (p->issued == NULL)
-		return (ENOMEM);
-	return (0);
-}
-
-static void 
-clean_pss(p, raidPtr)
-	RF_ReconParityStripeStatus_t *p;
-	RF_Raid_t *raidPtr;
-{
-	RF_Free(p->issued, raidPtr->numCol * sizeof(char));
-}
-
-static void 
-rf_ShutdownPSStatus(arg)
-	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);
-}
-
-int 
-rf_ConfigurePSStatus(
-    RF_ShutdownList_t ** listp,
-    RF_Raid_t * raidPtr,
-    RF_Config_t * cfgPtr)
-{
-	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));
-	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_ShutdownPSStatus(raidPtr);
-		return (rc);
-	}
-	RF_FREELIST_PRIME_INIT_ARG(raidPtr->pss_freelist, RF_PSS_INITIAL, next,
-	    (RF_ReconParityStripeStatus_t *), init_pss, raidPtr);
-	return (0);
-}
-/*****************************************************************************************
- * 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_PSStatusHeader_t *pssTable;
-	int     i, j, rc;
-
-	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, __FUNCTION__);
-		if (rc) {
-			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));
-			return (NULL);
-		}
-	}
-	return (pssTable);
-}
-
-void 
-rf_FreeParityStripeStatusTable(raidPtr, pssTable)
-	RF_Raid_t *raidPtr;
-	RF_PSStatusHeader_t *pssTable;
-{
-	int     i;
-
-	if (rf_pssDebug)
-		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");
-		}
-		rf_mutex_destroy(&pssTable[i].mutex);
-	}
-	RF_Free(pssTable, raidPtr->pssTableSize * sizeof(RF_PSStatusHeader_t));
-}
-
-
-/* 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
- *
- * 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 */
-    int *created)
-{
-	RF_PSStatusHeader_t *hdr = &pssTable[RF_HASH_PSID(raidPtr, psID)];
-	RF_ReconParityStripeStatus_t *p, *pssPtr = hdr->chain;
-
-	*created = 0;
-	for (p = pssPtr; p; p = p->next) {
-		if (p->parityStripeID == psID && p->which_ru == which_ru)
-			break;
-	}
-
-	if (!p && (flags & RF_PSS_CREATE)) {
-		Dprintf2("PSS: creating pss for psid %ld ru %d\n", psID, which_ru);
-		p = rf_AllocPSStatus(raidPtr);
-		p->next = hdr->chain;
-		hdr->chain = p;
-
-		p->parityStripeID = psID;
-		p->which_ru = which_ru;
-		p->flags = flags;
-		p->rbuf = NULL;
-		p->writeRbuf = NULL;
-		p->blockCount = 0;
-		p->procWaitList = NULL;
-		p->blockWaitList = NULL;
-		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 && (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",
-			 raidPtr->raidid, psID, p->blockCount);
-	}
-	return (p);
-}
-/* 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
- * chain is ALREADY LOCKED.
- */
-void 
-rf_PSStatusDelete(raidPtr, pssTable, pssPtr)
-	RF_Raid_t *raidPtr;
-	RF_PSStatusHeader_t *pssTable;
-	RF_ReconParityStripeStatus_t *pssPtr;
-{
-	RF_PSStatusHeader_t *hdr = &(pssTable[RF_HASH_PSID(raidPtr, pssPtr->parityStripeID)]);
-	RF_ReconParityStripeStatus_t *p = hdr->chain, *pt = NULL;
-
-	while (p) {
-		if (p == pssPtr) {
-			if (pt)
-				pt->next = p->next;
-			else
-				hdr->chain = p->next;
-			p->next = NULL;
-			rf_FreePSStatus(raidPtr, p);
-			return;
-		}
-		pt = p;
-		p = p->next;
-	}
-	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;
-{
-	RF_PSStatusHeader_t *hdr = &(raidPtr->reconControl[row]->pssTable[RF_HASH_PSID(raidPtr, psid)]);
-	RF_ReconParityStripeStatus_t *p, *pt;
-	RF_CallbackDesc_t *cb, *cb1;
-
-	RF_LOCK_MUTEX(hdr->mutex);
-	for (pt = NULL, p = hdr->chain; p; pt = p, p = p->next) {
-		if ((p->parityStripeID == psid) && (p->which_ru == which_ru))
-			break;
-	}
-	if (p == NULL) {
-		rf_PrintPSStatusTable(raidPtr, row);
-	}
-	RF_ASSERT(p);		/* it must be there */
-
-	Dprintf2("PSS: deleting pss for psid %ld ru %d\n", psid, which_ru);
-
-	/* delete this entry from the hash chain */
-	if (pt)
-		pt->next = p->next;
-	else
-		hdr->chain = p->next;
-	p->next = NULL;
-
-	RF_UNLOCK_MUTEX(hdr->mutex);
-
-	/* wakup 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);
-		cb1 = cb->next;
-		(cb->callbackFunc) (cb->callbackArg);
-
-		/* THIS IS WHAT THE ORIGINAL CODE HAD... the extra 0 is bogus,
-		 * IMHO */
-		/* (cb->callbackFunc)(cb->callbackArg, 0); */
-		rf_FreeCallbackDesc(cb);
-		cb = cb1;
-	}
-
-	rf_FreePSStatus(raidPtr, p);
-}
-
-RF_ReconParityStripeStatus_t *
-rf_AllocPSStatus(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	RF_ReconParityStripeStatus_t *p;
-
-	RF_FREELIST_GET_INIT_ARG(raidPtr->pss_freelist, p, next, (RF_ReconParityStripeStatus_t *), 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 */
-	return (p);
-}
-
-void 
-rf_FreePSStatus(raidPtr, p)
-	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);
-}
-
-static void 
-RealPrintPSStatusTable(raidPtr, pssTable)
-	RF_Raid_t *raidPtr;
-	RF_PSStatusHeader_t *pssTable;
-{
-	int     i, j, procsWaiting, blocksWaiting, bufsWaiting;
-	RF_ReconParityStripeStatus_t *p;
-	RF_CallbackDesc_t *cb;
-
-	printf("\nParity Stripe Status Table\n");
-	for (i = 0; i < raidPtr->pssTableSize; i++) {
-		for (p = pssTable[i].chain; p; p = p->next) {
-			procsWaiting = blocksWaiting = bufsWaiting = 0;
-			for (cb = p->procWaitList; cb; cb = cb->next)
-				procsWaiting++;
-			for (cb = p->blockWaitList; cb; cb = cb->next)
-				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);
-			for (j = 0; j < raidPtr->numCol; j++)
-				printf("%c", (p->issued[j]) ? '1' : '0');
-			if (!p->flags)
-				printf(" flags: (none)");
-			else {
-				if (p->flags & RF_PSS_UNDER_RECON)
-					printf(" under-recon");
-				if (p->flags & RF_PSS_FORCED_ON_WRITE)
-					printf(" forced-w");
-				if (p->flags & RF_PSS_FORCED_ON_READ)
-					printf(" forced-r");
-				if (p->flags & RF_PSS_RECON_BLOCKED)
-					printf(" blocked");
-				if (p->flags & RF_PSS_BUFFERWAIT)
-					printf(" bufwait");
-			}
-			printf("\n");
-		}
-	}
-}
-
-void 
-rf_PrintPSStatusTable(raidPtr, row)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-{
-	RF_PSStatusHeader_t *pssTable = raidPtr->reconControl[row]->pssTable;
-	RealPrintPSStatusTable(raidPtr, pssTable);
-}
diff --git a/sys/dev/raidframe/rf_psstatus.h b/sys/dev/raidframe/rf_psstatus.h
deleted file mode 100644
index c836d49..0000000
--- a/sys/dev/raidframe/rf_psstatus.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_psstatus.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * psstatus.h
- *
- * The reconstruction code maintains a bunch of status related to the parity
- * stripes that are currently under reconstruction.  This header file defines
- * the status structures.
- *
- *****************************************************************************/
-
-#ifndef _RF__RF_PSSTATUS_H_
-#define _RF__RF_PSSTATUS_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_callback.h>
-
-#define RF_PS_MAX_BUFS 10	/* max number of bufs we'll accumulate before
-				 * we do an XOR */
-
-#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)
-
-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
-						 * 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
-						 * waiting for user write to
-						 * 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 */
-};
-/* 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
-						 * 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
-						 * 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);
-
-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);
-
-#endif				/* !_RF__RF_PSSTATUS_H_ */
diff --git a/sys/dev/raidframe/rf_raid.h b/sys/dev/raidframe/rf_raid.h
deleted file mode 100644
index e91a2ae..0000000
--- a/sys/dev/raidframe/rf_raid.h
+++ /dev/null
@@ -1,299 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_raid.h,v 1.12 2000/02/24 17:12:10 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/**********************************************
- * rf_raid.h -- main header file for RAID driver
- **********************************************/
-
-
-#ifndef _RF__RF_RAID_H_
-#define _RF__RF_RAID_H_
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-
-#include <dev/raidframe/rf_bsd.h>
-
-#include <sys/disklabel.h>
-#include <sys/types.h>
-
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_stripelocks.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_disks.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_reconstruct.h>
-#include <dev/raidframe/rf_acctrace.h>
-
-#if RF_INCLUDE_PARITYLOGGING > 0
-#include <dev/raidframe/rf_paritylog.h>
-#endif				/* RF_INCLUDE_PARITYLOGGING > 0 */
-
-#define RF_MAX_DISKS 128	/* max disks per array */
-#if defined(__NetBSD__)
-#define RF_DEV2RAIDID(_dev)  (DISKUNIT(_dev))
-#endif
-
-#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
- * each has it's own status, which is one of the following.
- */
-typedef enum RF_RowStatus_e {
-	rf_rs_optimal,
-	rf_rs_degraded,
-	rf_rs_reconstructing,
-	rf_rs_reconfigured
-}       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 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 */
-};
-
-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
-	 * 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. */
-
-	/*
-         * 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 */
-
-	/*
-         * 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;
-
-	/*
-         * 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;
-
-	/*
-         * 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;
-
-	RF_DiskId_t **diskids;
-	RF_DiskId_t *sparediskids;
-
-	int     raidid;
-	RF_AccTotals_t acc_totals;
-	int     keep_acc_totals;
-
-	struct raidcinfo **raid_cinfo;	/* array of component info */
-
-	int     terminate_disk_queues;
-
-	/*
-         * 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 declustering */
-	int     noRotate;
-
-#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 */
-	/* Point back to the softc for this device.  This is needed to rid
-	 * ourselves of the ugly static device arrays.
-	 * XXX Will this affect compatibility with NetBSD?
-	 */
-	void 	*sc;
-};
-#endif				/* !_RF__RF_RAID_H_ */
diff --git a/sys/dev/raidframe/rf_raid0.c b/sys/dev/raidframe/rf_raid0.c
deleted file mode 100644
index 5eefabb..0000000
--- a/sys/dev/raidframe/rf_raid0.c
+++ /dev/null
@@ -1,163 +0,0 @@
-/*	$NetBSD: rf_raid0.c,v 1.4 2000/01/07 03:41:02 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/***************************************
- *
- * rf_raid0.c -- implements RAID Level 0
- *
- ***************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_raid0.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_parityscan.h>
-
-typedef struct RF_Raid0ConfigInfo_s {
-	RF_RowCol_t *stripeIdentifier;
-}       RF_Raid0ConfigInfo_t;
-
-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);
-	if (info == NULL)
-		return (ENOMEM);
-	layoutPtr->layoutSpecificInfo = (void *) info;
-
-	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;
-	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	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)
-{
-	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	*row = 0;
-	*col = SUID % raidPtr->numCol;
-	*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)
-{
-	*row = *col = 0;
-	*diskSector = 0;
-}
-
-void 
-rf_IdentifyStripeRAID0(
-    RF_Raid_t * raidPtr,
-    RF_RaidAddr_t addr,
-    RF_RowCol_t ** diskids,
-    RF_RowCol_t * outRow)
-{
-	RF_Raid0ConfigInfo_t *info;
-
-	info = raidPtr->Layout.layoutSpecificInfo;
-	*diskids = info->stripeIdentifier;
-	*outRow = 0;
-}
-
-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)
-{
-	*createFunc = ((type == RF_IO_TYPE_READ) ?
-	    (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)
-{
-	/*
-         * 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
deleted file mode 100644
index 36aae81..0000000
--- a/sys/dev/raidframe/rf_raid0.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_raid0.h,v 1.3 1999/02/05 00:06:15 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_raid0.h - header file for RAID Level 0 */
-
-#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);
-
-#endif				/* !_RF__RF_RAID0_H_ */
diff --git a/sys/dev/raidframe/rf_raid1.c b/sys/dev/raidframe/rf_raid1.c
deleted file mode 100644
index 845e316..0000000
--- a/sys/dev/raidframe/rf_raid1.c
+++ /dev/null
@@ -1,691 +0,0 @@
-/*	$NetBSD: rf_raid1.c,v 1.5 2000/01/08 22:57:30 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * rf_raid1.c -- implements RAID Level 1
- *
- *****************************************************************************/
-
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_raid1.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_parityscan.h>
-#include <dev/raidframe/rf_mcpair.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_engine.h>
-#include <dev/raidframe/rf_reconbuffer.h>
-#include <dev/raidframe/rf_kintf.h>
-
-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_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);
-	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);
-	if (info->stripeIdentifier == NULL)
-		return (ENOMEM);
-	for (i = 0; i < (raidPtr->numCol / 2); i++) {
-		info->stripeIdentifier[i][0] = (2 * i);
-		info->stripeIdentifier[i][1] = (2 * i) + 1;
-	}
-
-	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
-	 * 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);
-	layoutPtr->dataSectorsPerStripe = layoutPtr->sectorsPerStripeUnit;
-	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)
-{
-	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);
-}
-
-
-/* Map Parity
- *
- * 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)
-{
-	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	RF_RowCol_t mirrorPair = SUID % (raidPtr->numCol / 2);
-
-	*row = 0;
-	*col = (2 * mirrorPair) + 1;
-
-	*diskSector = ((SUID / (raidPtr->numCol / 2)) * raidPtr->Layout.sectorsPerStripeUnit) + (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
-}
-
-
-/* IdentifyStripeRAID1
- *
- * 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)
-{
-	RF_StripeNum_t stripeID = rf_RaidAddressToStripeID(&raidPtr->Layout, addr);
-	RF_Raid1ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
-	RF_ASSERT(stripeID >= 0);
-	RF_ASSERT(addr >= 0);
-	*outRow = 0;
-	*diskids = info->stripeIdentifier[stripeID % (raidPtr->numCol / 2)];
-	RF_ASSERT(*diskids);
-}
-
-
-/* MapSIDToPSIDRAID1
- *
- * 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)
-{
-	*which_ru = 0;
-	*psID = stripeID;
-}
-
-
-
-/******************************************************************************
- * 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
- *****************************************************************************/
-
-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;
-	RF_RowStatus_t rstat;
-	RF_SectorNum_t oo;
-
-
-	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");
-		*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
-	         */
-		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
-		    );
-		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
-		         */
-			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.
-		         */
-			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 (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);
-			}
-			asmap->numDataFailed = asmap->numParityFailed = 0;
-		}
-	}
-	if (type == RF_IO_TYPE_READ) {
-		if (asmap->numDataFailed == 0)
-			*createFunc = (RF_VoidFuncPtr) rf_CreateMirrorIdleReadDAG;
-		else
-			*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     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;
-	RF_AllocListElem_t *allocList;
-	RF_AccTraceEntry_t tracerec;
-	RF_ReconUnitNum_t which_ru;
-	RF_RaidLayout_t *layoutPtr;
-	RF_AccessStripeMap_t *aasm;
-	RF_SectorCount_t nsector;
-	RF_RaidAddr_t startAddr;
-	char   *buf, *buf1, *buf2;
-	RF_PhysDiskAddr_t *pda;
-	RF_StripeNum_t psID;
-	RF_MCPair_t *mcpair;
-
-	layoutPtr = &raidPtr->Layout;
-	startAddr = rf_RaidAddressOfPrevStripeBoundary(layoutPtr, raidAddr);
-	nsector = parityPDA->numSector;
-	nbytes = rf_RaidAddressToByte(raidPtr, nsector);
-	psID = rf_RaidAddressToParityStripeID(layoutPtr, raidAddr, &which_ru);
-
-	asm_h = NULL;
-	rd_dag_h = wr_dag_h = NULL;
-	mcpair = NULL;
-
-	ret = RF_PARITY_COULD_NOT_VERIFY;
-
-	rf_MakeAllocList(allocList);
-	if (allocList == NULL)
-		return (RF_PARITY_COULD_NOT_VERIFY);
-	mcpair = rf_AllocMCPair();
-	if (mcpair == NULL)
-		goto done;
-	RF_ASSERT(layoutPtr->numDataCol == layoutPtr->numParityCol);
-	stripeWidth = layoutPtr->numDataCol + layoutPtr->numParityCol;
-	bcount = nbytes * (layoutPtr->numDataCol + layoutPtr->numParityCol);
-	RF_MallocAndAdd(buf, bcount, (char *), allocList);
-	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);
-	}
-	/*
-         * Generate a DAG which 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,
-	    RF_IO_NORMAL_PRIORITY);
-	if (rd_dag_h == NULL)
-		goto done;
-	blockNode = rd_dag_h->succedents[0];
-	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);
-	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) {
-		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 */
-			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);
-		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) {
-		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 */
-			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);
-		buf1 += nbytes;
-	}
-	RF_ASSERT(pda == NULL);
-
-	bzero((char *) &tracerec, sizeof(tracerec));
-	rd_dag_h->tracerec = &tracerec;
-
-	if (rf_verifyParityDebug > 1) {
-		printf("raid%d: RAID1 parity verify read dag:\n", 
-		       raidPtr->raidid);
-		rf_PrintDAGList(rd_dag_h);
-	}
-	RF_LOCK_MUTEX(mcpair->mutex);
-	mcpair->flag = 0;
-	rf_DispatchDAG(rd_dag_h, (void (*) (void *)) rf_MCPairWakeupFunc,
-	    (void *) mcpair);
-	while (mcpair->flag == 0) {
-		RF_WAIT_MCPAIR(mcpair);
-	}
-	RF_UNLOCK_MUTEX(mcpair->mutex);
-
-	if (rd_dag_h->status != rf_enable) {
-		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 = 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).
-         */
-	RF_MallocAndAdd(bbufs, layoutPtr->numParityCol * sizeof(int), (int *),
-	    allocList);
-	nbad = 0;
-	/*
-         * 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);
-		}
-		ret = bcmp(buf1, buf2, nbytes);
-		if (ret) {
-			if (rf_verifyParityDebug > 1) {
-				for (j = 0; j < nbytes; j++) {
-					if (buf1[j] != buf2[j])
-						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);
-			}
-			if (rf_verifyParityDebug) {
-				printf("raid%d: RAID1: found bad parity, i=%d\n", raidPtr->raidid, i);
-			}
-			/*
-		         * Parity is bad. Keep track of which columns were bad.
-		         */
-			if (bbufs)
-				bbufs[nbad] = i;
-			nbad++;
-			ret = RF_PARITY_BAD;
-		}
-		buf1 += nbytes;
-		buf2 += nbytes;
-	}
-
-	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);
-		}
-		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.
-	         */
-		wr_dag_h = rf_MakeSimpleDAG(raidPtr, nbad, nbytes, buf,
-		    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.
-	         */
-		for (i = 0; i < nbad; i++) {
-			j = i + layoutPtr->numDataCol;
-			pda = blockNode->succedents[j]->params[0].p;
-			pda->bufPtr = blockNode->succedents[i]->params[1].p;
-			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);
-		}
-		bzero((char *) &tracerec, sizeof(tracerec));
-		wr_dag_h->tracerec = &tracerec;
-		if (rf_verifyParityDebug > 1) {
-			printf("Parity verify write dag:\n");
-			rf_PrintDAGList(wr_dag_h);
-		}
-		RF_LOCK_MUTEX(mcpair->mutex);
-		mcpair->flag = 0;
-		/* 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");
-			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.
-         */
-	if (asm_h)
-		rf_FreeAccessStripeMap(asm_h);
-	if (rd_dag_h)
-		rf_FreeDAG(rd_dag_h);
-	if (wr_dag_h)
-		rf_FreeDAG(wr_dag_h);
-	if (mcpair)
-		rf_FreeMCPair(mcpair);
-	rf_FreeAllocList(allocList);
-	if (rf_verifyParityDebug) {
-		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 */
-{
-	RF_ReconParityStripeStatus_t *pssPtr;
-	RF_ReconCtrl_t *reconCtrlPtr;
-	RF_RaidLayout_t *layoutPtr;
-	int     retcode, created;
-	RF_CallbackDesc_t *cb, *p;
-	RF_ReconBuffer_t *t;
-	RF_Raid_t *raidPtr;
-	caddr_t ta;
-
-	retcode = 0;
-	created = 0;
-
-	raidPtr = rbuf->raidPtr;
-	layoutPtr = &raidPtr->Layout;
-	reconCtrlPtr = raidPtr->reconControl[rbuf->row];
-
-	RF_ASSERT(rbuf);
-	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,
-		       (long) rbuf->failedDiskSectorOffset);
-	}
-	if (rf_reconDebug) {
-		printf("RAID1 reconbuffer submit psid %ld buf %lx\n",
-		    (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]);
-	}
-	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 */
-
-	/*
-         * 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);
-		}
-		t = rbuf;
-	} else {
-		if (use_committed) {
-			if (rf_reconbufferDebug) {
-				printf("raid%d: RAID1 rbuf submission: using committed rbuf\n", raidPtr->raidid);
-			}
-			t = reconCtrlPtr->committedRbufs;
-			RF_ASSERT(t);
-			reconCtrlPtr->committedRbufs = t->next;
-			t->next = NULL;
-		} else
-			if (reconCtrlPtr->floatingRbufs) {
-				if (rf_reconbufferDebug) {
-					printf("raid%d: RAID1 rbuf submission: using floating rbuf\n", raidPtr->raidid);
-				}
-				t = reconCtrlPtr->floatingRbufs;
-				reconCtrlPtr->floatingRbufs = t->next;
-				t->next = NULL;
-			}
-	}
-	if (t == NULL) {
-		if (rf_reconbufferDebug) {
-			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_PrintPSStatusTable(raidPtr, rbuf->row);
-			RF_PANIC();
-		}
-		pssPtr->flags |= RF_PSS_BUFFERWAIT;
-		cb = rf_AllocCallbackDesc();
-		cb->row = rbuf->row;
-		cb->col = rbuf->col;
-		cb->callbackArg.v = rbuf->parityStripeID;
-		cb->callbackArg2.v = rbuf->which_ru;
-		cb->next = NULL;
-		if (reconCtrlPtr->bufferWaitList == NULL) {
-			/* we are the wait list- lucky us */
-			reconCtrlPtr->bufferWaitList = cb;
-		} else {
-			/* append to wait list */
-			for (p = reconCtrlPtr->bufferWaitList; p->next; p = p->next);
-			p->next = cb;
-		}
-		retcode = 1;
-		goto out;
-	}
-	if (t != rbuf) {
-		t->row = rbuf->row;
-		t->col = reconCtrlPtr->fcol;
-		t->parityStripeID = rbuf->parityStripeID;
-		t->which_ru = rbuf->which_ru;
-		t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset;
-		t->spRow = rbuf->spRow;
-		t->spCol = rbuf->spCol;
-		t->spOffset = rbuf->spOffset;
-		/* Swap buffers. DANCE! */
-		ta = t->buffer;
-		t->buffer = rbuf->buffer;
-		rbuf->buffer = ta;
-	}
-	/*
-         * 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.
-         */
-	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);
-	}
-	return (retcode);
-}
diff --git a/sys/dev/raidframe/rf_raid1.h b/sys/dev/raidframe/rf_raid1.h
deleted file mode 100644
index 484cbcf..0000000
--- a/sys/dev/raidframe/rf_raid1.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_raid1.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: William V. Courtright II
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* header file for RAID Level 1 */
-
-#ifndef _RF__RF_RAID1_H_
-#define _RF__RF_RAID1_H_
-
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_RAID1_H_ */
diff --git a/sys/dev/raidframe/rf_raid4.c b/sys/dev/raidframe/rf_raid4.c
deleted file mode 100644
index d080319..0000000
--- a/sys/dev/raidframe/rf_raid4.c
+++ /dev/null
@@ -1,159 +0,0 @@
-/*	$NetBSD: rf_raid4.c,v 1.4 2000/01/07 03:41:02 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Rachad Youssef
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/***************************************
- *
- * rf_raid4.c -- implements RAID Level 4
- *
- ***************************************/
-
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_raid4.h>
-#include <dev/raidframe/rf_general.h>
-
-typedef struct RF_Raid4ConfigInfo_s {
-	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)
-{
-	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_Raid4ConfigInfo_t *info;
-	int     i;
-
-	/* 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);
-	if (info->stripeIdentifier == NULL)
-		return (ENOMEM);
-	for (i = 0; i < raidPtr->numCol; i++)
-		info->stripeIdentifier[i] = i;
-
-	RF_ASSERT(raidPtr->numRow == 1);
-
-	/* fill in the remaining layout parameters */
-	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
-	layoutPtr->numDataCol = raidPtr->numCol - 1;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numParityCol = 1;
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-
-	return (0);
-}
-
-int 
-rf_GetDefaultNumFloatingReconBuffersRAID4(RF_Raid_t * raidPtr)
-{
-	return (20);
-}
-
-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)
-{
-	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	*row = 0;
-	*col = SUID % raidPtr->Layout.numDataCol;
-	*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)
-{
-	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-
-	*row = 0;
-	*col = raidPtr->Layout.numDataCol;
-	*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)
-{
-	RF_Raid4ConfigInfo_t *info = raidPtr->Layout.layoutSpecificInfo;
-
-	*outRow = 0;
-	*diskids = info->stripeIdentifier;
-}
-
-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
deleted file mode 100644
index 56df05a..0000000
--- a/sys/dev/raidframe/rf_raid4.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_raid4.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Rachad Youssef
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_raid4.h header file for RAID Level 4 */
-
-#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);
-
-#endif				/* !_RF__RF_RAID4_H_ */
diff --git a/sys/dev/raidframe/rf_raid5.c b/sys/dev/raidframe/rf_raid5.c
deleted file mode 100644
index 794e5a3..0000000
--- a/sys/dev/raidframe/rf_raid5.c
+++ /dev/null
@@ -1,322 +0,0 @@
-/*	$NetBSD: rf_raid5.c,v 1.4 2000/01/08 22:57:30 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/******************************************************************************
- *
- * rf_raid5.c -- implements RAID Level 5
- *
- *****************************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_raid5.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagffrd.h>
-#include <dev/raidframe/rf_dagffwr.h>
-#include <dev/raidframe/rf_dagdegrd.h>
-#include <dev/raidframe/rf_dagdegwr.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/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_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);
-	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);
-	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;
-		}
-		if ((--startdisk) < 0)
-			startdisk = raidPtr->numCol - 1;
-	}
-
-	/* fill in the remaining layout parameters */
-	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
-	layoutPtr->numDataCol = raidPtr->numCol - 1;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numParityCol = 1;
-	layoutPtr->dataStripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk;
-
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-
-	return (0);
-}
-
-int 
-rf_GetDefaultNumFloatingReconBuffersRAID5(RF_Raid_t * raidPtr)
-{
-	return (20);
-}
-
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimitRAID5(RF_Raid_t * raidPtr)
-{
-	return (10);
-}
-#if !defined(__NetBSD__) && !defined(__FreeBSD__) && !defined(_KERNEL)
-/* 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)
-{
-	RF_StripeNum_t SUID = raidSector / raidPtr->Layout.sectorsPerStripeUnit;
-	*row = 0;
-	*col = (SUID % raidPtr->numCol);
-	*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)
-{
-	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 +
-	    (raidSector % raidPtr->Layout.sectorsPerStripeUnit);
-}
-
-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;
-
-	*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)
-{
-	*which_ru = 0;
-	*psID = stripeID;
-}
-/* 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)
-{
-	RF_RaidLayout_t *layoutPtr = &(raidPtr->Layout);
-	RF_PhysDiskAddr_t *failedPDA = NULL;
-	RF_RowCol_t frow, fcol;
-	RF_RowStatus_t rstat;
-	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");
-		 /* *infoFunc = */ *createFunc = NULL;
-		return;
-	} else
-		if (asmap->numDataFailed + asmap->numParityFailed == 1) {
-
-			/* if under recon & already reconstructed, redirect
-			 * the access to the spare drive and eliminate the
-			 * 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
-			    );
-			if (prior_recon) {
-				RF_RowCol_t or = failedPDA->row, oc = failedPDA->col;
-				RF_SectorNum_t oo = failedPDA->startSector;
-
-				if (layoutPtr->map->flags & RF_DISTRIBUTE_SPARE) {	/* redirect to dist
-											 * spare space */
-
-					if (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;
-							p->row = failedPDA->row;
-							p->col = failedPDA->col;
-							p->startSector = rf_RaidAddressOfPrevStripeUnitBoundary(layoutPtr, failedPDA->startSector) +
-							    SUoffs;	/* cheating:
-									 * startSector is not
-									 * really a RAID address */
-						}
-					} else
-						if (asmap->parityInfo->next && failedPDA == asmap->parityInfo->next) {
-							RF_ASSERT(0);	/* should not ever
-									 * happen */
-						} else {
-
-							/* data has failed */
-							(layoutPtr->map->MapSector) (raidPtr, failedPDA->raidAddress, &failedPDA->row,
-							    &failedPDA->col, &failedPDA->startSector, RF_REMAP);
-
-						}
-
-				} else {	/* redirect to dedicated spare
-						 * space */
-
-					failedPDA->row = raidPtr->Disks[frow][fcol].spareRow;
-					failedPDA->col = raidPtr->Disks[frow][fcol].spareCol;
-
-					/* the parity may have two distinct
-					 * components, both of which may need
-					 * 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;
-							}
-					}
-				}
-
-				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);
-				}
-				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 */
-	if (type == RF_IO_TYPE_READ) {
-		if (asmap->numDataFailed == 0)
-			*createFunc = (RF_VoidFuncPtr) rf_CreateFaultFreeReadDAG;
-		else
-			*createFunc = (RF_VoidFuncPtr) rf_CreateRaidFiveDegradedReadDAG;
-	} else {
-
-
-		/* 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
-		 * 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. */
-		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;
-			} else
-				*createFunc = (RF_VoidFuncPtr) rf_CreateLargeWriteDAG;
-		} else {
-			if (asmap->numParityFailed == 1)
-				*createFunc = (RF_VoidFuncPtr) rf_CreateNonRedundantWriteDAG;
-			else
-				if (asmap->numStripeUnitsAccessed != 1 && failedPDA->numSector != layoutPtr->sectorsPerStripeUnit)
-					*createFunc = NULL;
-				else
-					*createFunc = (RF_VoidFuncPtr) rf_CreateDegradedWriteDAG;
-		}
-	}
-}
diff --git a/sys/dev/raidframe/rf_raid5.h b/sys/dev/raidframe/rf_raid5.h
deleted file mode 100644
index 17549fe..0000000
--- a/sys/dev/raidframe/rf_raid5.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_raid5.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_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);
-
-#endif				/* !_RF__RF_RAID5_H_ */
diff --git a/sys/dev/raidframe/rf_raid5_rotatedspare.c b/sys/dev/raidframe/rf_raid5_rotatedspare.c
deleted file mode 100644
index f167a5f..0000000
--- a/sys/dev/raidframe/rf_raid5_rotatedspare.c
+++ /dev/null
@@ -1,177 +0,0 @@
-/*	$NetBSD: rf_raid5_rotatedspare.c,v 1.5 2001/01/26 05:16:58 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Khalil Amiri
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/**************************************************************************
- *
- * rf_raid5_rotated_spare.c -- implements RAID Level 5 with rotated sparing
- *
- **************************************************************************/
-
-#include <dev/raidframe/rf_archs.h>
-
-#if RF_INCLUDE_RAID5_RS > 0
-
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_raid5.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_dagfuncs.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/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_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);
-	if (info == NULL)
-		return (ENOMEM);
-	layoutPtr->layoutSpecificInfo = (void *) info;
-
-	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);
-	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;
-		}
-		if ((--startdisk) < 0)
-			startdisk = raidPtr->numCol - 1;
-	}
-
-	/* fill in the remaining layout parameters */
-	layoutPtr->numStripe = layoutPtr->stripeUnitsPerDisk;
-	layoutPtr->bytesPerStripeUnit = layoutPtr->sectorsPerStripeUnit << raidPtr->logBytesPerSector;
-	layoutPtr->numDataCol = raidPtr->numCol - 2;
-	layoutPtr->dataSectorsPerStripe = layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-	layoutPtr->numParityCol = 1;
-	layoutPtr->dataStripeUnitsPerDisk = layoutPtr->stripeUnitsPerDisk;
-	raidPtr->sectorsPerDisk = layoutPtr->stripeUnitsPerDisk * layoutPtr->sectorsPerStripeUnit;
-
-	raidPtr->totalSectors = layoutPtr->stripeUnitsPerDisk * layoutPtr->numDataCol * layoutPtr->sectorsPerStripeUnit;
-
-	return (0);
-}
-
-RF_ReconUnitCount_t 
-rf_GetNumSpareRUsRAID5_RS(raidPtr)
-	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)
-{
-	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
-							 * with parity; line
-							 * above maps to parity */
-	} else {
-		*col = (SUID + (SUID / raidPtr->Layout.numDataCol)) % raidPtr->numCol;
-	}
-	*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)
-{
-	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 +
-	    (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)
-{
-	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)
-{
-	*which_ru = 0;
-	*psID = stripeID;
-}
-#endif /* RF_INCLUDE_RAID5_RS > 0 */
diff --git a/sys/dev/raidframe/rf_raid5_rotatedspare.h b/sys/dev/raidframe/rf_raid5_rotatedspare.h
deleted file mode 100644
index 779150f..0000000
--- a/sys/dev/raidframe/rf_raid5_rotatedspare.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*	$FreeBSD$ */
-/*	$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.
- *
- * Author: Khalil Amiri
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/* rf_raid5_rotatedspare.h - header file for RAID Level 5 with rotated sparing */
-
-#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);
-
-#endif				/* !_RF__RF_RAID5_ROTATEDSPARE_H_ */
diff --git a/sys/dev/raidframe/rf_raidframe.h b/sys/dev/raidframe/rf_raidframe.h
deleted file mode 100644
index fd711bd..0000000
--- a/sys/dev/raidframe/rf_raidframe.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_raidframe.h,v 1.11 2000/05/28 00:48:31 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************
- *
- * rf_raidframe.h
- *
- * main header file for using raidframe in the kernel.
- *
- *****************************************************/
-
-
-#ifndef _RF__RF_RAIDFRAME_H_
-#define _RF__RF_RAIDFRAME_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_configure.h>
-#include <dev/raidframe/rf_disks.h>
-#include <dev/raidframe/rf_raid.h>
-
-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_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 */
-};
-
-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;
-
-typedef struct RF_ProgressInfo_s {
-	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 RAIDFRAME_CONFIGURE	_IOW ('r',  1, void *)	/* config an array */
-#if defined(__NetBSD__)
-#define RAIDFRAME_SHUTDOWN	_IO  ('r',  2)		/* shutdown the array */
-#elif defined(__FreeBSD__)
-#define RAIDFRAME_SHUTDOWN	_IOW ('r',  2, int)	/* shutdown the array */
-#endif
-#define RAIDFRAME_TUR		_IOW ('r',  3, dev_t)	/* debug only: test
-							 * 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 _IOR('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 _IOR ('r', 26, int)
-#define RAIDFRAME_CHECK_COPYBACK_STATUS	_IOR ('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 _IOR('r',  32, RF_ProgressInfo_t)
-#define RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT _IOR ('r', 33, \
-							RF_ProgressInfo_t)
-#define RAIDFRAME_CHECK_COPYBACK_STATUS_EXT _IOR ('r', 34, RF_ProgressInfo_t)
-#define	RAIDFRAME_GET_UNIT		_IOWR ('r', 35, int)
-
-#endif				/* !_RF__RF_RAIDFRAME_H_ */
diff --git a/sys/dev/raidframe/rf_reconbuffer.c b/sys/dev/raidframe/rf_reconbuffer.c
deleted file mode 100644
index 5831d5a..0000000
--- a/sys/dev/raidframe/rf_reconbuffer.c
+++ /dev/null
@@ -1,468 +0,0 @@
-/*	$NetBSD: rf_reconbuffer.c,v 1.5 2001/01/27 20:10:49 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/***************************************************
- *
- * rf_reconbuffer.c -- reconstruction buffer manager
- *
- ***************************************************/
-
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_reconbuffer.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_debugprint.h>
-#include <dev/raidframe/rf_revent.h>
-#include <dev/raidframe/rf_reconutil.h>
-#include <dev/raidframe/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)
-
-/*****************************************************************************
- *
- * 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.
- *
- * 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.
- *
- ****************************************************************************/
-
-/*
- * nWayXorFuncs[i] is a pointer to a function that will xor "i"
- * bufs into the accumulating sum.
- */
-static RF_VoidFuncPtr nWayXorFuncs[] = {
-	NULL,
-	(RF_VoidFuncPtr) rf_nWayXor1,
-	(RF_VoidFuncPtr) rf_nWayXor2,
-	(RF_VoidFuncPtr) rf_nWayXor3,
-	(RF_VoidFuncPtr) rf_nWayXor4,
-	(RF_VoidFuncPtr) rf_nWayXor5,
-	(RF_VoidFuncPtr) rf_nWayXor6,
-	(RF_VoidFuncPtr) rf_nWayXor7,
-	(RF_VoidFuncPtr) rf_nWayXor8,
-	(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 */
-{
-	RF_LayoutSW_t *lp;
-	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 */
-{
-	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 */
-	RF_CallbackDesc_t *cb, *p;
-	int     retcode = 0, created = 0;
-
-	RF_Etimer_t timer;
-
-	/* 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);
-
-	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 */
-
-	/* 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. */
-
-	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);
-		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]);
-		}
-		rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, layoutPtr->numDataCol);
-
-		/* if use_committed is on, we _must_ consume a buffer off the
-		 * committed list. */
-		if (use_committed) {
-			t = reconCtrlPtr->committedRbufs;
-			RF_ASSERT(t);
-			reconCtrlPtr->committedRbufs = t->next;
-			rf_ReleaseFloatingReconBuffer(raidPtr, rbuf->row, t);
-		}
-		if (keep_it) {
-			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 */
-	if (keep_it) {
-		t = rbuf;
-	} else {
-		if (use_committed) {	/* if a buffer has been committed to
-					 * us, use it */
-			t = reconCtrlPtr->committedRbufs;
-			RF_ASSERT(t);
-			reconCtrlPtr->committedRbufs = t->next;
-			t->next = NULL;
-		} else
-			if (reconCtrlPtr->floatingRbufs) {
-				t = reconCtrlPtr->floatingRbufs;
-				reconCtrlPtr->floatingRbufs = t->next;
-				t->next = NULL;
-			}
-	}
-
-	/* 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);
-
-		raidPtr->procsInBufWait++;
-		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 */
-		cb->row = rbuf->row;
-		cb->col = rbuf->col;
-		cb->callbackArg.v = rbuf->parityStripeID;
-		cb->callbackArg2.v = rbuf->which_ru;
-		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);
-			p->next = cb;
-		}
-		retcode = 1;
-		goto out;
-	}
-	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);
-	RF_ETIMER_START(raidPtr->recon_tracerecs[rbuf->col].recon_timer);
-
-	rf_LogTraceRec(raidPtr, &raidPtr->recon_tracerecs[rbuf->col]);
-
-	/* initialize the buffer */
-	if (t != rbuf) {
-		t->row = rbuf->row;
-		t->col = reconCtrlPtr->fcol;
-		t->parityStripeID = rbuf->parityStripeID;
-		t->which_ru = rbuf->which_ru;
-		t->failedDiskSectorOffset = rbuf->failedDiskSectorOffset;
-		t->spRow = rbuf->spRow;
-		t->spCol = rbuf->spCol;
-		t->spOffset = rbuf->spOffset;
-
-		ta = t->buffer;
-		t->buffer = rbuf->buffer;
-		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 */
-	if (!pssPtr->rbuf) {
-		pssPtr->rbuf = t;
-		t->count = 1;
-	} else
-		pssPtr->rbufsForXor[pssPtr->xorBufCount++] = t;	/* install this buffer */
-
-	rf_CheckForFullRbuf(raidPtr, reconCtrlPtr, pssPtr, layoutPtr->numDataCol);	/* the buffer is full if
-											 * G=2 */
-
-out:
-	RF_UNLOCK_PSS_MUTEX(raidPtr, rbuf->row, rbuf->parityStripeID);
-	RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
-	return (retcode);
-}
-
-int 
-rf_MultiWayReconXor(raidPtr, pssPtr)
-	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);
-	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
-#ifndef __NetBSD__
-#ifndef __FreeBSD__
-	thread_block();		/* yield the processor before doing a big XOR */
-#endif
-#endif
-#endif				/* _KERNEL */
-	/*
-         * 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 */
-	for (i = 0; i < numBufs - 1; i++) {
-		if (rbufs[i]->type == RF_RBUF_TYPE_FLOATING)
-			rf_ReleaseFloatingReconBuffer(raidPtr, rbufs[i]->row, rbufs[i]);
-		else
-			if (rbufs[i]->type == RF_RBUF_TYPE_FORCED)
-				rf_FreeReconBuffer(rbufs[i]);
-			else
-				RF_ASSERT(0);
-	}
-	targetRbuf->count += pssPtr->xorBufCount;
-	pssPtr->xorBufCount = 0;
-	return (0);
-}
-/* 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_ReconBuffer_t *p;
-
-	RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
-
-	if ((p = reconCtrlPtr->priorityList) != NULL) {
-		reconCtrlPtr->priorityList = p->next;
-		p->next = NULL;
-		goto out;
-	}
-	if ((p = reconCtrlPtr->fullBufferList) != NULL) {
-		reconCtrlPtr->fullBufferList = p->next;
-		p->next = NULL;
-		goto out;
-	}
-out:
-	RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
-	return (p);
-}
-
-
-/* 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;
-{
-	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",
-		    (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);
-			rbuf->next = p;
-			pt->next = rbuf;
-			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
-							 * to be able to find
-							 * this rbuf while it's
-							 * awaiting write */
-#else
-		rbuf->pssPtr = pssPtr;
-#endif
-		pssPtr->rbuf = NULL;
-		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
- */
-void 
-rf_ReleaseFloatingReconBuffer(raidPtr, row, rbuf)
-	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",
-	    (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 (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 */
-		rf_FreeCallbackDesc(cb);
-		raidPtr->procsInBufWait--;
-	} else {
-		rbuf->next = rcPtr->floatingRbufs;
-		rcPtr->floatingRbufs = rbuf;
-	}
-}
-/* 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;
-{
-	RF_CallbackDesc_t *cb1, *cb = pssPtr->bufWaitList;
-
-	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 */
-		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
- * the forced-reconstruction process, we no longer have to wait for any
- * buffers, so we wakeup any waiter that we find in the bufferWaitList
- *
- * assumes the rb_mutex is LOCKED at entry
- */
-void 
-rf_ReleaseBufferWaiter(rcPtr, rbuf)
-	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);
-			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 */
-			rf_FreeCallbackDesc(cb);
-			return;
-		}
-	}
-}
diff --git a/sys/dev/raidframe/rf_reconbuffer.h b/sys/dev/raidframe/rf_reconbuffer.h
deleted file mode 100644
index 1a5407e..0000000
--- a/sys/dev/raidframe/rf_reconbuffer.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_reconbuffer.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*******************************************************************
- *
- * rf_reconbuffer.h -- header file for reconstruction buffer manager
- *
- *******************************************************************/
-
-#ifndef _RF__RF_RECONBUFFER_H_
-#define _RF__RF_RECONBUFFER_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_RECONBUFFER_H_ */
diff --git a/sys/dev/raidframe/rf_reconmap.c b/sys/dev/raidframe/rf_reconmap.c
deleted file mode 100644
index 261d339..0000000
--- a/sys/dev/raidframe/rf_reconmap.c
+++ /dev/null
@@ -1,396 +0,0 @@
-/*	$NetBSD: rf_reconmap.c,v 1.6 1999/08/14 21:44:24 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*************************************************************************
- * rf_reconmap.c
- *
- * code to maintain a map of what sectors have/have not been reconstructed
- *
- *************************************************************************/
-
-#include <dev/raidframe/rf_raid.h>
-#include <sys/time.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_utils.h>
-
-/* 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
- * 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);
-
-/*-----------------------------------------------------------------------------
- *
- * 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_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	RF_ReconUnitCount_t num_rus = layoutPtr->stripeUnitsPerDisk / layoutPtr->SUsPerRU;
-	RF_ReconMap_t *p;
-	int     rc;
-
-	RF_Malloc(p, sizeof(RF_ReconMap_t), (RF_ReconMap_t *));
-	p->sectorsPerReconUnit = ru_sectors;
-	p->sectorsInDisk = disk_sectors;
-
-	p->totalRUs = num_rus;
-	p->spareRUs = spareUnitsPerDisk;
-	p->unitsLeft = num_rus - spareUnitsPerDisk;
-
-	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 *));
-
-	p->size = sizeof(RF_ReconMap_t) + num_rus * sizeof(RF_ReconMapListElem_t *);
-	p->maxSize = p->size;
-
-	rc = rf_mutex_init(&p->mutex, __FUNCTION__);
-	if (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);
-	}
-	return (p);
-}
-
-
-/*-----------------------------------------------------------------------------
- *
- * 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()).
- * 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)
- *
- *-----------------------------------------------------------------------------*/
-
-void 
-rf_ReconMapUpdate(raidPtr, mapPtr, startSector, stopSector)
-	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);
-
-	while (startSector <= stopSector) {
-		i = startSector / mapPtr->sectorsPerReconUnit;
-		first_in_RU = i * sectorsPerReconUnit;
-		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 */
-					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));
-			}
-			compact_stat_entry(raidPtr, mapPtr, i);
-		}
-		startSector = RF_MIN(stopSector, last_in_RU) + 1;
-	}
-	RF_UNLOCK_MUTEX(mapPtr->mutex);
-}
-
-
-
-/*-----------------------------------------------------------------------------
- *
- * 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,
- * and the second block of code deletes the entire list if possible.
- * 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.
- *
- *-----------------------------------------------------------------------------*/
-
-static void 
-compact_stat_entry(raidPtr, mapPtr, i)
-	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);
-
-	if ((p->startSector == i * sectorsPerReconUnit) &&
-	    (p->stopSector == i * sectorsPerReconUnit + sectorsPerReconUnit - 1)) {
-		mapPtr->status[i] = RU_ALL;
-		mapPtr->unitsLeft--;
-		FreeReconMapListElem(mapPtr, p);
-	}
-}
-
-static void 
-crunch_list(mapPtr, listPtr)
-	RF_ReconMap_t *mapPtr;
-	RF_ReconMapListElem_t *listPtr;
-{
-	RF_ReconMapListElem_t *pt, *p = listPtr;
-
-	if (!p)
-		return;
-	pt = p;
-	p = p->next;
-	while (p) {
-		if (pt->stopSector >= p->startSector - 1) {
-			pt->stopSector = RF_MAX(pt->stopSector, p->stopSector);
-			pt->next = p->next;
-			FreeReconMapListElem(mapPtr, p);
-			p = pt->next;
-		} else {
-			pt = p;
-			p = p->next;
-		}
-	}
-}
-/*-----------------------------------------------------------------------------
- *
- * 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 *p;
-
-	RF_Malloc(p, sizeof(RF_ReconMapListElem_t), (RF_ReconMapListElem_t *));
-	if (p == NULL)
-		return (NULL);
-	p->startSector = startSector;
-	p->stopSector = stopSector;
-	p->next = next;
-	return (p);
-}
-/*-----------------------------------------------------------------------------
- *
- * Free a list element
- *
- *-----------------------------------------------------------------------------*/
-
-static void 
-FreeReconMapListElem(mapPtr, p)
-	RF_ReconMap_t *mapPtr;
-	RF_ReconMapListElem_t *p;
-{
-	int     delta;
-
-	if (mapPtr) {
-		delta = 0 - (int) sizeof(RF_ReconMapListElem_t);
-		update_size(mapPtr, delta);
-	}
-	RF_Free(p, sizeof(*p));
-}
-/*-----------------------------------------------------------------------------
- *
- * Free an entire status structure.  Inefficient, but can be called at any time.
- *
- *-----------------------------------------------------------------------------*/
-void 
-rf_FreeReconMap(mapPtr)
-	RF_ReconMap_t *mapPtr;
-{
-	RF_ReconMapListElem_t *p, *q;
-	RF_ReconUnitCount_t numRUs;
-	RF_ReconUnitNum_t i;
-
-	numRUs = mapPtr->sectorsInDisk / mapPtr->sectorsPerReconUnit;
-	if (mapPtr->sectorsInDisk % mapPtr->sectorsPerReconUnit)
-		numRUs++;
-
-	for (i = 0; i < numRUs; i++) {
-		p = mapPtr->status[i];
-		while (p != RU_NOTHING && p != RU_ALL) {
-			q = p;
-			p = p->next;
-			RF_Free(q, sizeof(*q));
-		}
-	}
-	rf_mutex_destroy(&mapPtr->mutex);
-	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
- *
- *---------------------------------------------------------------------------*/
-
-int 
-rf_CheckRUReconstructed(mapPtr, startSector)
-	RF_ReconMap_t *mapPtr;
-	RF_SectorNum_t startSector;
-{
-	RF_ReconMapListElem_t *l;	/* used for searching */
-	RF_ReconUnitNum_t i;
-
-	i = startSector / mapPtr->sectorsPerReconUnit;
-	l = mapPtr->status[i];
-	return ((l == RU_ALL) ? 1 : 0);
-}
-
-RF_ReconUnitCount_t 
-rf_UnitsLeftToReconstruct(mapPtr)
-	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;
-{
-	mapPtr->size += size;
-	mapPtr->maxSize = RF_MAX(mapPtr->size, mapPtr->maxSize);
-}
-
-static void 
-PrintList(listPtr)
-	RF_ReconMapListElem_t *listPtr;
-{
-	while (listPtr) {
-		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;
-{
-	RF_ReconUnitCount_t numRUs;
-	RF_ReconMapListElem_t *p;
-	RF_ReconUnitNum_t i;
-
-	numRUs = mapPtr->totalRUs;
-	if (mapPtr->sectorsInDisk % mapPtr->sectorsPerReconUnit)
-		numRUs++;
-
-	for (i = 0; i < numRUs; i++) {
-		p = mapPtr->status[i];
-		if (p == RU_ALL)/* printf("[%d] ALL\n",i) */
-			;
-		else
-			if (p == RU_NOTHING) {
-				printf("%d: Unreconstructed\n", i);
-			} else {
-				printf("%d: ", i);
-				PrintList(p);
-			}
-	}
-}
-
-void 
-rf_PrintReconSchedule(mapPtr, starttime)
-	RF_ReconMap_t *mapPtr;
-	struct timeval *starttime;
-{
-	static int old_pctg = -1;
-	struct timeval tv, diff;
-	int     new_pctg;
-
-	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);
-		old_pctg = new_pctg;
-	}
-}
diff --git a/sys/dev/raidframe/rf_reconmap.h b/sys/dev/raidframe/rf_reconmap.h
deleted file mode 100644
index 2fee059..0000000
--- a/sys/dev/raidframe/rf_reconmap.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_reconmap.h,v 1.3 1999/02/05 00:06:16 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/******************************************************************************
- * rf_reconMap.h -- Header file describing reconstruction status data structure
- ******************************************************************************/
-
-#ifndef _RF__RF_RECONMAP_H_
-#define _RF__RF_RECONMAP_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-
-/*
- * 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)
-};
-/* 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 */
-};
-
-RF_ReconMap_t *
-rf_MakeReconMap(RF_Raid_t * raidPtr, RF_SectorCount_t ru_sectors,
-    RF_SectorCount_t disk_sectors, RF_ReconUnitCount_t spareUnitsPerDisk);
-
-void 
-rf_ReconMapUpdate(RF_Raid_t * raidPtr, RF_ReconMap_t * mapPtr,
-    RF_SectorNum_t startSector, RF_SectorNum_t stopSector);
-
-void    rf_FreeReconMap(RF_ReconMap_t * mapPtr);
-
-int     rf_CheckRUReconstructed(RF_ReconMap_t * mapPtr, RF_SectorNum_t startSector);
-
-RF_ReconUnitCount_t rf_UnitsLeftToReconstruct(RF_ReconMap_t * mapPtr);
-
-void 
-rf_PrintReconMap(RF_Raid_t * raidPtr, RF_ReconMap_t * mapPtr,
-    RF_RowCol_t frow, RF_RowCol_t fcol);
-
-void    rf_PrintReconSchedule(RF_ReconMap_t * mapPtr, struct timeval * starttime);
-
-#endif				/* !_RF__RF_RECONMAP_H_ */
diff --git a/sys/dev/raidframe/rf_reconstruct.c b/sys/dev/raidframe/rf_reconstruct.c
deleted file mode 100644
index e24d440..0000000
--- a/sys/dev/raidframe/rf_reconstruct.c
+++ /dev/null
@@ -1,1682 +0,0 @@
-/*	$NetBSD: rf_reconstruct.c,v 1.27 2001/01/26 02:16:24 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/************************************************************
- *
- * rf_reconstruct.c -- code to perform on-line reconstruction
- *
- ************************************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <sys/time.h>
-#if defined(__FreeBSD__)
-#include <sys/systm.h>
-#if __FreeBSD_version > 500005
-#include <sys/bio.h>
-#endif
-#endif
-#include <sys/buf.h>
-#include <sys/errno.h>
-
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/systm.h>
-#include <sys/proc.h>
-#if defined(__NetBSD__)
-#include <sys/ioctl.h>
-#elif defined(__FreeBSD__)
-#include <sys/ioccom.h>
-#endif
-#include <sys/fcntl.h>
-#include <sys/vnode.h>
-
-
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_reconutil.h>
-#include <dev/raidframe/rf_revent.h>
-#include <dev/raidframe/rf_reconbuffer.h>
-#include <dev/raidframe/rf_acctrace.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_debugprint.h>
-#include <dev/raidframe/rf_driver.h>
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-#include <dev/raidframe/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)
-
-#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)
-
-static RF_FreeList_t *rf_recond_freelist;
-#define RF_MAX_FREE_RECOND  4
-#define RF_RECOND_INC       1
-
-static RF_RaidReconDesc_t *
-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);
-static void FreeReconDesc(RF_RaidReconDesc_t * reconDesc);
-static int 
-ProcessReconEvent(RF_Raid_t * raidPtr, RF_RowCol_t frow,
-    RF_ReconEvent_t * event);
-static int 
-IssueNextReadRequest(RF_Raid_t * raidPtr, RF_RowCol_t row,
-    RF_RowCol_t col);
-static int TryToRead(RF_Raid_t * raidPtr, RF_RowCol_t row, RF_RowCol_t col);
-static int 
-ComputePSDiskOffsets(RF_Raid_t * raidPtr, RF_StripeNum_t psid,
-    RF_RowCol_t row, RF_RowCol_t col, RF_SectorNum_t * outDiskOffset,
-    RF_SectorNum_t * outFailedDiskSectorOffset, RF_RowCol_t * spRow,
-    RF_RowCol_t * spCol, RF_SectorNum_t * spOffset);
-static int IssueNextWriteRequest(RF_Raid_t * raidPtr, RF_RowCol_t row);
-static int ReconReadDoneProc(void *arg, int status);
-static int ReconWriteDoneProc(void *arg, int status);
-static void 
-CheckForNewMinHeadSep(RF_Raid_t * raidPtr, RF_RowCol_t row,
-    RF_HeadSepLimit_t hsCtr);
-static int 
-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);
-static int 
-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);
-static void ForceReconReadDoneProc(void *arg, int status);
-
-static void rf_ShutdownReconstruction(void *);
-
-struct RF_ReconDoneProc_s {
-	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
-
-static void 
-SignalReconDone(RF_Raid_t * raidPtr)
-{
-	RF_ReconDoneProc_t *p;
-
-	RF_LOCK_MUTEX(raidPtr->recon_done_proc_mutex);
-	for (p = raidPtr->recon_done_procs; p; p = p->next) {
-		p->proc(raidPtr, p->arg);
-	}
-	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)
-{
-	RF_ReconDoneProc_t *p;
-
-	RF_FREELIST_GET(rf_rdp_freelist, p, next, (RF_ReconDoneProc_t *));
-	if (p == NULL)
-		return (ENOMEM);
-	p->proc = proc;
-	p->arg = arg;
-	RF_LOCK_MUTEX(raidPtr->recon_done_proc_mutex);
-	p->next = raidPtr->recon_done_procs;
-	raidPtr->recon_done_procs = p;
-	RF_UNLOCK_MUTEX(raidPtr->recon_done_proc_mutex);
-	if (handlep)
-		*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
- * configuration (e.g. rf_ConfigureDeclustered) routine sets up.
- *
- * in the kernel, we fire off the recon thread.
- *
- **************************************************************************/
-static void 
-rf_ShutdownReconstruction(ignored)
-	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     rc;
-
-	RF_FREELIST_CREATE(rf_recond_freelist, RF_MAX_FREE_RECOND,
-	    RF_RECOND_INC, sizeof(RF_RaidReconDesc_t));
-	if (rf_recond_freelist == NULL)
-		return (ENOMEM);
-	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 *));
-		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_ShutdownReconstruction(NULL);
-		return (rc);
-	}
-	return (0);
-}
-
-static RF_RaidReconDesc_t *
-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_RaidReconDesc_t *reconDesc;
-
-	RF_FREELIST_GET(rf_recond_freelist, reconDesc, next, (RF_RaidReconDesc_t *));
-
-	reconDesc->raidPtr = raidPtr;
-	reconDesc->row = row;
-	reconDesc->col = col;
-	reconDesc->spareDiskPtr = spareDiskPtr;
-	reconDesc->numDisksDone = numDisksDone;
-	reconDesc->srow = srow;
-	reconDesc->scol = scol;
-	reconDesc->state = 0;
-	reconDesc->next = NULL;
-
-	return (reconDesc);
-}
-
-static void 
-FreeReconDesc(reconDesc)
-	RF_RaidReconDesc_t *reconDesc;
-{
-#if RF_RECON_STATS > 0
-	printf("RAIDframe: %lu recon event waits, %lu recon delays\n",
-	    (long) reconDesc->numReconEventWaits, (long) reconDesc->numReconExecDelays);
-#endif				/* RF_RECON_STATS > 0 */
-	printf("RAIDframe: %lu max exec ticks\n",
-	    (long) reconDesc->maxReconExecTicks);
-#if (RF_RECON_STATS > 0) || defined(KERNEL)
-	printf("\n");
-#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,
- * fails, or is aborted.
- *****************************************************************************/
-int 
-rf_ReconstructFailedDisk(raidPtr, row, col)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t col;
-{
-	RF_LayoutSW_t *lp;
-	int     rc;
-
-	lp = raidPtr->Layout.map;
-	if (lp->SubmitReconBuffer) {
-		/*
-	         * 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);
-		}
-		raidPtr->reconInProgress++;
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-		rc = rf_ReconstructFailedDiskBasic(raidPtr, row, col);
-		RF_LOCK_MUTEX(raidPtr->mutex);
-		raidPtr->reconInProgress--;
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-	} else {
-		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 */
-	return (rc);
-}
-
-int 
-rf_ReconstructFailedDiskBasic(raidPtr, row, col)
-	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;
-
-	RF_Malloc(c_label, sizeof(RF_ComponentLabel_t), (RF_ComponentLabel_t *));
-	if (c_label == NULL) {
-		printf("rf_ReconstructInPlace: Out of memory?\n");
-		return (ENOMEM);
-	}
-
-	/* 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_UNLOCK_MUTEX(raidPtr->mutex);
-			RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-			return (EINVAL);
-		}
-		srow = row;
-		scol = (-1);
-	} else {
-		srow = 0;
-		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;
-				break;
-			}
-		}
-		if (!spareDiskPtr) {
-			RF_ERRORMSG2("Unable to reconstruct disk at row %d col %d because no spares are available\n", row, col);
-			RF_UNLOCK_MUTEX(raidPtr->mutex);
-			RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-			return (ENOSPC);
-		}
-		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 = AllocRaidReconDesc((void *) raidPtr, row, col, spareDiskPtr, numDisksDone, srow, scol);
-	raidPtr->reconDesc = (void *) reconDesc;
-#if RF_RECON_STATS > 0
-	reconDesc->hsStallCount = 0;
-	reconDesc->numReconExecDelays = 0;
-	reconDesc->numReconEventWaits = 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.. */
-		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);
-		c_label->row = row;
-		c_label->column = col;
-		c_label->clean = RF_RAID_DIRTY;
-		c_label->status = rf_ds_optimal;
-		c_label->partitionSize = raidPtr->Disks[srow][scol].partitionSize;
-
-		/* We've just done a rebuild based on all the other
-		   disks, so at this point the parity is known to be
-		   clean, even if it wasn't before. */
-
-		/* XXX doesn't hold for RAID 6!! */
-
-		raidPtr->parity_good = RF_RAID_CLEAN;
-
-		/* XXXX MORE NEEDED HERE */
-		
-		raidwrite_component_label(
-                        raidPtr->raid_cinfo[srow][scol].ci_dev,
-			raidPtr->raid_cinfo[srow][scol].ci_vp,
-			c_label);
-		
-	}
-	RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-	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".
-
-*/
-
-int
-rf_ReconstructInPlace(raidPtr, row, col)
-	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;
-	struct vnode *vp;
-	int retcode;
-	int ac;
-
-	RF_Malloc(c_label, sizeof(RF_ComponentLabel_t), (RF_ComponentLabel_t *));
-	if (c_label == NULL) {
-		printf("rf_ReconstructInPlace: Out of memory?\n");
-		return (ENOMEM);
-	}
-
-	lp = raidPtr->Layout.map;
-	if (lp->SubmitReconBuffer) {
-		/*
-	         * 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... */
-			printf("RAIDFRAME: Unable to reconstruct to disk at:\n");
-			printf("      Row: %d Col: %d   Too many failures.\n",
-			       row, col);
-			RF_UNLOCK_MUTEX(raidPtr->mutex);
-			RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-			return (EINVAL);
-		}
-		if (raidPtr->Disks[row][col].status == rf_ds_reconstructing) {
-			printf("RAIDFRAME: Unable to reconstruct to disk at:\n");
-			printf("      Row: %d Col: %d   Reconstruction already occuring!\n", row, col);
-
-			RF_UNLOCK_MUTEX(raidPtr->mutex);
-			RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-			return (EINVAL);
-		}
-
-
-		if (raidPtr->Disks[row][col].status != rf_ds_failed) {
-			/* "It's gone..." */
-			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);
-		}
-
-		while (raidPtr->reconInProgress) {
-			RF_WAIT_COND(raidPtr->waitForReconCond, raidPtr->mutex);
-		}
-
-		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 */
-
-		/* 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);
-		 */
-
-		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);
-
-			raidPtr->reconInProgress--;
-			RF_UNLOCK_MUTEX(raidPtr->mutex);
-			RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-			return (EINVAL);
-		}			
-
-		/* XXX need goop here to see if the disk is alive,
-		   and, if not, make it so...  */
-		
-
-
-		badDisk = &raidPtr->Disks[row][col];
-
-		/* 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("Closed the open device: %s\n",
-			       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)*/
-		raidPtr->Disks[row][col].auto_configured = 0;
-
-		printf("About to (re-)open the device for rebuilding: %s\n",
-		       raidPtr->Disks[row][col].devname);
-		
-		retcode = raid_getcomponentsize(raidPtr, row, col);
-	
-		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 be still dead :-( */
-			raidPtr->reconInProgress--;
-			RF_UNLOCK_MUTEX(raidPtr->mutex);
-			RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-			return(retcode);
-
-		}
-
-		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);
-
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-		
-		reconDesc = AllocRaidReconDesc((void *) raidPtr, row, col, 
-					       spareDiskPtr, numDisksDone, 
-					       row, col);
-		raidPtr->reconDesc = (void *) reconDesc;
-#if RF_RECON_STATS > 0
-		reconDesc->hsStallCount = 0;
-		reconDesc->numReconExecDelays = 0;
-		reconDesc->numReconEventWaits = 0;
-#endif				/* RF_RECON_STATS > 0 */
-		reconDesc->reconExecTimerRunning = 0;
-		reconDesc->reconExecTicks = 0;
-		reconDesc->maxReconExecTicks = 0;
-		rc = rf_ContinueReconstructFailedDisk(reconDesc);
-
-		RF_LOCK_MUTEX(raidPtr->mutex);
-		raidPtr->reconInProgress--;
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-
-	} else {
-		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 :-) */
-		
-		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);
-
-		raid_init_component_label(raidPtr, c_label);
-
-		c_label->row = row;
-		c_label->column = col;
-		
-		/* We've just done a rebuild based on all the other
-		   disks, so at this point the parity is known to be
-		   clean, even if it wasn't before. */
-
-		/* XXX doesn't hold for RAID 6!! */
-
-		raidPtr->parity_good = RF_RAID_CLEAN;
-
-		raidwrite_component_label(raidPtr->raid_cinfo[row][col].ci_dev,
-					  raidPtr->raid_cinfo[row][col].ci_vp,
-					  c_label);
-
-	}
-	RF_UNLOCK_MUTEX(raidPtr->mutex);
-	RF_SIGNAL_COND(raidPtr->waitForReconCond);
-	wakeup(&raidPtr->waitForReconCond);	
-	RF_Free(c_label, sizeof(RF_ComponentLabel_t));
-	return (rc);
-}
-
-
-int 
-rf_ContinueReconstructFailedDisk(reconDesc)
-	RF_RaidReconDesc_t *reconDesc;
-{
-	RF_Raid_t *raidPtr = reconDesc->raidPtr;
-	RF_RowCol_t row = reconDesc->row;
-	RF_RowCol_t col = reconDesc->col;
-	RF_RowCol_t srow = reconDesc->srow;
-	RF_RowCol_t scol = reconDesc->scol;
-	RF_ReconMap_t *mapPtr;
-
-	RF_ReconEvent_t *event;
-	struct timeval etime, elpsd;
-	unsigned long xor_s, xor_resid_us;
-	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 *));
-
-		/* 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. */
-		reconDesc->state = 1;
-
-		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 */
-
-	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);
-		mapPtr = raidPtr->reconControl[row]->reconMap;
-		raidPtr->status[row] = rf_rs_reconstructing;
-		raidPtr->Disks[row][col].status = rf_ds_reconstructing;
-		raidPtr->Disks[row][col].spareRow = srow;
-		raidPtr->Disks[row][col].spareCol = scol;
-
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-
-		RF_GETTIME(raidPtr->reconControl[row]->starttime);
-
-		/* 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 */
-				if (IssueNextReadRequest(raidPtr, row, i)) {
-					Dprintf2("RECON: done issuing for r%d c%d\n", row, i);
-					reconDesc->numDisksDone++;
-				}
-			}
-		}
-
-	case 2:
-		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 */
-		mapPtr = raidPtr->reconControl[row]->reconMap;
-
-
-
-		while (reconDesc->numDisksDone < raidPtr->numCol - 1) {
-
-			event = rf_GetNextReconEvent(reconDesc, row, (void (*) (void *)) rf_ContinueReconstructFailedDisk, reconDesc);
-			RF_ASSERT(event);
-
-			if (ProcessReconEvent(raidPtr, row, event))
-				reconDesc->numDisksDone++;
-			raidPtr->reconControl[row]->numRUsTotal = 
-				mapPtr->totalRUs;
-			raidPtr->reconControl[row]->numRUsComplete = 
-				mapPtr->totalRUs - 
-				rf_UnitsLeftToReconstruct(mapPtr);
-
-			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));
-			}
-		}
-
-
-
-		reconDesc->state = 4;
-
-
-	case 4:
-		mapPtr = raidPtr->reconControl[row]->reconMap;
-		if (rf_reconDebug) {
-			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 */
-
-		while (rf_UnitsLeftToReconstruct(raidPtr->reconControl[row]->reconMap) > 0) {
-
-			event = rf_GetNextReconEvent(reconDesc, row, (void (*) (void *)) rf_ContinueReconstructFailedDisk, reconDesc);
-			RF_ASSERT(event);
-
-			(void) ProcessReconEvent(raidPtr, row, event);	/* ignore return code */
-			raidPtr->reconControl[row]->percentComplete = 100 - (rf_UnitsLeftToReconstruct(mapPtr) * 100 / mapPtr->totalRUs);
-			if (rf_prReconSched) {
-				rf_PrintReconSchedule(raidPtr->reconControl[row]->reconMap, &(raidPtr->reconControl[row]->starttime));
-			}
-		}
-		reconDesc->state = 5;
-
-	case 5:
-		/* 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() */
-
-		reconDesc->state = 6;
-
-		retcode = rf_SuspendNewRequestsAndWait(raidPtr);
-		rf_StopUserStats(raidPtr);
-		rf_PrintUserStats(raidPtr);	/* print out the stats on user
-						 * accs accumulated during
-						 * recon */
-
-		/* 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;
-		RF_UNLOCK_MUTEX(raidPtr->mutex);
-		RF_GETTIME(etime);
-		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
-		 * below, so if you put a return here you'll have to fix this.
-		 * (also, FreeReconControl is called below) */
-
-	case 7:
-
-		rf_ResumeNewRequests(raidPtr);
-
-		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",
-		    (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",
-		    (int) reconDesc->hsStallCount);
-#endif				/* RF_RECON_STATS > 0 */
-		rf_FreeReconControl(raidPtr, row);
-		RF_Free(raidPtr->recon_tracerecs, raidPtr->numCol * sizeof(RF_AccTraceEntry_t));
-		FreeReconDesc(reconDesc);
-
-	}
-
-	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
- *****************************************************************************/
-static int 
-ProcessReconEvent(raidPtr, frow, event)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t frow;
-	RF_ReconEvent_t *event;
-{
-	int     retcode = 0, submitblocked;
-	RF_ReconBuffer_t *rbuf;
-	RF_SectorCount_t sectorsPerRU;
-
-	Dprintf1("RECON: ProcessReconEvent type %d\n", event->type);
-	switch (event->type) {
-
-		/* 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",
-		    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);
-		rf_FreeDiskQueueData((RF_DiskQueueData_t *) rbuf->arg);
-		submitblocked = rf_SubmitReconBuffer(rbuf, 0, 0);
-		Dprintf1("RECON: submitblocked=%d\n", submitblocked);
-		if (!submitblocked)
-			retcode = IssueNextReadRequest(raidPtr, frow, event->col);
-		break;
-
-		/* a write I/O has completed */
-	case RF_REVENT_WRITEDONE:
-		if (rf_floatingRbufDebug) {
-			rf_CheckFloatingRbufCount(raidPtr, 1);
-		}
-		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);
-
-		if (rbuf->type == RF_RBUF_TYPE_FLOATING) {
-			RF_LOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
-			raidPtr->numFullReconBuffers--;
-			rf_ReleaseFloatingReconBuffer(raidPtr, frow, rbuf);
-			RF_UNLOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
-		} else
-			if (rbuf->type == RF_RBUF_TYPE_FORCED)
-				rf_FreeReconBuffer(rbuf);
-			else
-				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
-						 * BUFCLEAR event if we
-						 * couldn't submit */
-		retcode = 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);
-		retcode = 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);
-		retcode = TryToRead(raidPtr, frow, event->col);
-		break;
-
-		/* a buffer has become ready to write */
-	case RF_REVENT_BUFREADY:
-		Dprintf2("RECON: BUFREADY EVENT: row %d col %d\n", frow, event->col);
-		retcode = 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 */
-	case RF_REVENT_SKIP:
-		DDprintf2("RECON: SKIP EVENT: row %d col %d\n", frow, event->col);
-		retcode = IssueNextReadRequest(raidPtr, frow, event->col);
-		break;
-
-		/* 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);
-		submitblocked = rf_SubmitReconBuffer(rbuf, 1, 0);
-		RF_ASSERT(!submitblocked);
-		break;
-
-	default:
-		RF_PANIC();
-	}
-	rf_FreeReconEventDesc(event);
-	return (retcode);
-}
-/*****************************************************************************
- *
- * 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
- * head-separation wait request and return.
- *
- * 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
- * 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
- * head separation or reconstruction-blockage events.
- *
- * returns nonzero if and only if there is nothing left unread on the
- * indicated disk
- *
- *****************************************************************************/
-static int 
-IssueNextReadRequest(raidPtr, row, col)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-	RF_RowCol_t 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)
-		do_new_check = 1;
-
-	while (1) {
-
-		ctrl->ru_count++;
-		if (ctrl->ru_count < RUsPerPU) {
-			ctrl->diskOffset += sectorsPerRU;
-			rbuf->failedDiskSectorOffset += sectorsPerRU;
-		} else {
-			ctrl->curPSID++;
-			ctrl->ru_count = 0;
-			/* code left over from when head-sep was based on
-			 * parity stripe id */
-			if (ctrl->curPSID >= raidPtr->reconControl[row]->lastPSID) {
-				CheckForNewMinHeadSep(raidPtr, row, ++(ctrl->headSepCounter));
-				return (1);	/* finito! */
-			}
-			/* 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 = ComputePSDiskOffsets(raidPtr, ctrl->curPSID, row, col, &ctrl->diskOffset, &rbuf->failedDiskSectorOffset,
-			    &rbuf->spRow, &rbuf->spCol, &rbuf->spOffset);
-			if (status) {
-				ctrl->ru_count = RUsPerPU - 1;
-				continue;
-			}
-		}
-		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);
-			continue;
-		}
-		break;
-	}
-	ctrl->headSepCounter++;
-	if (do_new_check)
-		CheckForNewMinHeadSep(raidPtr, row, ctrl->headSepCounter);	/* update min if needed */
-
-
-	/* 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]));
-	raidPtr->recon_tracerecs[col].reconacc = 1;
-	RF_ETIMER_START(raidPtr->recon_tracerecs[col].recon_timer);
-	retcode = TryToRead(raidPtr, row, col);
-	return (retcode);
-}
-
-/*
- * 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
- * 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.  
- */
-
-static int 
-TryToRead(raidPtr, row, col)
-	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_StripeNum_t psid = ctrl->curPSID;
-	RF_ReconUnitNum_t which_ru = ctrl->ru_count;
-	RF_DiskQueueData_t *req;
-	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 (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);
-
-	/* 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 = 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);
-		goto out;
-	} else
-		if (status == RF_PSS_FORCED_ON_WRITE) {
-			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
-	 * 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
-	 * 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);
-		if (created)
-			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);
-	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,
-	    ReconReadDoneProc, (void *) ctrl, NULL, &raidPtr->recon_tracerecs[col], (void *) raidPtr, 0, NULL);
-
-	RF_ASSERT(req);		/* XXX -- fix this -- XXX */
-
-	ctrl->rbuf->arg = (void *) req;
-	rf_DiskIOEnqueue(&raidPtr->Queues[row][col], req, RF_IO_RECON_PRIORITY);
-	pssPtr->issued[col] = 1;
-
-out:
-	RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid);
-	return (0);
-}
-
-
-/*
- * 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
- * parity stripe, and searching the list for the current and failed
- * 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
- * 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,
- * 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 */
-
-
-static int 
-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_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;
-	RF_RowCol_t prow, pcol;
-	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;
-
-	/* get a listing of the disks comprising that stripe */
-	sosRaidAddress = rf_ParityStripeIDToRaidAddress(layoutPtr, psid);
-	(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 */
-	if (row != stripe)
-		goto skipit;
-	for (i = 0; i < stripeWidth; i++) {
-		if (col == diskids[i])
-			break;
-	}
-	if (i == stripeWidth)
-		goto skipit;
-	for (j = 0; j < stripeWidth; j++) {
-		if (fcol == diskids[j])
-			break;
-	}
-	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 */
-	for (k = 0; k < stripeWidth; k++)
-		if (diskids[k] == pcol)
-			break;
-	RF_ASSERT(k < stripeWidth);
-	i_offset = i;
-	j_offset = j;
-	if (k < i)
-		i_offset--;
-	else
-		if (k == i) {
-			i_is_parity = 1;
-			i_offset = 0;
-		}		/* set offsets to zero to disable multiply
-				 * below */
-	if (k < j)
-		j_offset--;
-	else
-		if (k == j) {
-			j_is_parity = 1;
-			j_offset = 0;
-		}
-	/* 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. */
-
-	/* 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);
-	else
-		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);
-	else
-		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 */
-	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);
-		else
-			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;
-		*spOffset = *outFailedDiskSectorOffset;
-	}
-
-	return (0);
-
-skipit:
-	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 */
-static int 
-IssueNextWriteRequest(raidPtr, row)
-	RF_Raid_t *raidPtr;
-	RF_RowCol_t row;
-{
-	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	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->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",
-	    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 */
-	req = rf_CreateDiskQueueData(RF_IO_TYPE_WRITE, rbuf->spOffset,
-	    sectorsPerRU, rbuf->buffer,
-	    rbuf->parityStripeID, rbuf->which_ru,
-	    ReconWriteDoneProc, (void *) rbuf, NULL,
-	    &raidPtr->recon_tracerecs[fcol],
-	    (void *) raidPtr, 0, NULL);
-
-	RF_ASSERT(req);		/* XXX -- fix this -- XXX */
-
-	rbuf->arg = (void *) req;
-	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
- * control structure for the process that just finished a read.
- *
- * called at interrupt context in the kernel, so don't do anything
- * illegal here.  
- */
-static int 
-ReconReadDoneProc(arg, status)
-	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");
-		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);
-	RF_ETIMER_START(raidPtr->recon_tracerecs[ctrl->col].recon_timer);
-
-	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
- *
- * called at interrupt context in the kernel, so don't do anything illegal here.
- */
-static int 
-ReconWriteDoneProc(arg, status)
-	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);
-	if (status) {
-		printf("Recon write failed!\n");	/* fprintf(stderr,"Recon
-							 * write failed!\n"); */
-		RF_PANIC();
-	}
-	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 
- */
-static void 
-CheckForNewMinHeadSep(raidPtr, row, hsCtr)
-	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 */
-
-
-	RF_LOCK_MUTEX(reconCtrlPtr->rb_mutex);
-
-	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;
-		}
-	/* 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);
-		while (reconCtrlPtr->headSepCBList) {
-			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_FreeCallbackDesc(p);
-		}
-
-	}
-	RF_UNLOCK_MUTEX(reconCtrlPtr->rb_mutex);
-}
-
-/*
- * 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
- * ahead of the others and consumes all of the floating recon buffers.
- * 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.  
- */
-static int 
-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_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
-	RF_CallbackDesc_t *cb, *p, *pt;
-	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
-	 * 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);
-		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);
-		cb->row = row;
-		cb->col = col;
-		cb->next = NULL;
-
-		/* insert this callback descriptor into the sorted list of
-		 * pending head-sep callbacks */
-		p = reconCtrlPtr->headSepCBList;
-		if (!p)
-			reconCtrlPtr->headSepCBList = cb;
-		else
-			if (cb->callbackArg.v < p->callbackArg.v) {
-				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);
-				cb->next = p;
-				pt->next = cb;
-			}
-		retval = 1;
-#if RF_RECON_STATS > 0
-		ctrl->reconCtrl->reconDesc->hsStallCount++;
-#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.
- *
- * ASSUMES THE PSS MUTEX IS LOCKED UPON ENTRY 
- */
-static int 
-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_CallbackDesc_t *cb;
-	int     retcode = 0;
-
-	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
-							 * the blockage-wait
-							 * list */
-			cb->row = row;
-			cb->col = col;
-			cb->next = pssPtr->blockWaitList;
-			pssPtr->blockWaitList = cb;
-			retcode = RF_PSS_RECON_BLOCKED;
-		}
-	if (!retcode)
-		pssPtr->flags |= RF_PSS_UNDER_RECON;	/* mark this RU as under
-							 * reconstruction */
-
-	return (retcode);
-}
-/*
- * 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
- * and only if we return non-zero, we'll cause the cbFunc to get
- * 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;
-{
-	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_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_CallbackDesc_t *cb;
-	int     created = 0, nPromoted;
-
-	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);
-
-	/* 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
-	 * 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 */
-		fcol = raidPtr->reconControl[row]->fcol;
-
-		/* 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
-		 * found in the queue, and hence this will be a no-op. For
-		 * 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++)
-			if ((diskno = diskids[i]) != fcol) {
-				if (pssPtr->issued[diskno]) {
-					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);
-				} else {
-					new_rbuf = rf_MakeReconBuffer(raidPtr, row, diskno, RF_RBUF_TYPE_FORCED);	/* create new buf */
-					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 */
-					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)) ForceReconReadDoneProc, (void *) new_rbuf, NULL,
-					    NULL, (void *) raidPtr, 0, NULL);
-
-					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);
-				}
-			}
-		/* 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. */
-	cb = rf_AllocCallbackDesc();
-	/* 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);
-
-	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.
- */
-static void 
-ForceReconReadDoneProc(arg, status)
-	void   *arg;
-	int     status;
-{
-	RF_ReconBuffer_t *rbuf = arg;
-
-	if (status) {
-		printf("Forced recon read failed!\n");	/* fprintf(stderr,"Forced
-							 *  recon read
-							 * failed!\n"); */
-		RF_PANIC();
-	}
-	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;
-{
-	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;
-	RF_CallbackDesc_t *cb;
-
-	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);
-
-	/* 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? */
-	if (!pssPtr) {
-		/* 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);
-		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 */
-
-		/* unblock recon before calling CauseReconEvent in case
-		 * CauseReconEvent causes us to try to issue a new read before
-		 * returning here. */
-		pssPtr->flags &= ~RF_PSS_RECON_BLOCKED;
-
-
-		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_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);
-		}
-	}
-out:
-	RF_UNLOCK_PSS_MUTEX(raidPtr, row, psid);
-	return (0);
-}
diff --git a/sys/dev/raidframe/rf_reconstruct.h b/sys/dev/raidframe/rf_reconstruct.h
deleted file mode 100644
index 318d546..0000000
--- a/sys/dev/raidframe/rf_reconstruct.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_reconstruct.h,v 1.5 2000/05/28 00:48:30 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*********************************************************
- * rf_reconstruct.h -- header file for reconstruction code
- *********************************************************/
-
-#ifndef _RF__RF_RECONSTRUCT_H_
-#define _RF__RF_RECONSTRUCT_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <sys/time.h>
-#include <dev/raidframe/rf_reconmap.h>
-#include <dev/raidframe/rf_psstatus.h>
-
-/* 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 */
-};
-/* 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 */
-};
-/* 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,
-	RF_REVENT_WRITEDONE,
-	RF_REVENT_BUFREADY,
-	RF_REVENT_BLOCKCLEAR,
-	RF_REVENT_BUFCLEAR,
-	RF_REVENT_HEADSEPCLEAR,
-	RF_REVENT_SKIP,
-	RF_REVENT_FORCEDREADDONE
-}       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;
-};
-/*
- * 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 */
-};
-/* 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
-
-int     rf_ConfigureReconstruction(RF_ShutdownList_t ** listp);
-
-int 
-rf_ReconstructFailedDisk(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);
-
-int 
-rf_ReconstructInPlace(RF_Raid_t * raidPtr, RF_RowCol_t row, RF_RowCol_t col);
-
-int     rf_ContinueReconstructFailedDisk(RF_RaidReconDesc_t * reconDesc);
-
-int 
-rf_ForceOrBlockRecon(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap,
-    void (*cbFunc) (RF_Raid_t *, void *), void *cbArg);
-
-	int     rf_UnblockRecon(RF_Raid_t * raidPtr, RF_AccessStripeMap_t * asmap);
-
-	int     rf_RegisterReconDoneProc(RF_Raid_t * raidPtr, void (*proc) (RF_Raid_t *, void *), void *arg,
-            RF_ReconDoneProc_t ** handlep);
-
-#endif				/* !_RF__RF_RECONSTRUCT_H_ */
diff --git a/sys/dev/raidframe/rf_reconutil.c b/sys/dev/raidframe/rf_reconutil.c
deleted file mode 100644
index bafff69..0000000
--- a/sys/dev/raidframe/rf_reconutil.c
+++ /dev/null
@@ -1,338 +0,0 @@
-/*	$NetBSD: rf_reconutil.c,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/********************************************
- * rf_reconutil.c -- reconstruction utilities
- ********************************************/
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_reconutil.h>
-#include <dev/raidframe/rf_reconbuffer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_decluster.h>
-#include <dev/raidframe/rf_raid5_rotatedspare.h>
-#include <dev/raidframe/rf_interdecluster.h>
-#include <dev/raidframe/rf_chaindecluster.h>
-
-/*******************************************************************
- * 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_Raid_t *raidPtr = reconDesc->raidPtr;
-	RF_RaidLayout_t *layoutPtr = &raidPtr->Layout;
-	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;
-	RF_RowCol_t i;
-
-	lp = raidPtr->Layout.map;
-
-	/* 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 */
-	reconCtrlPtr->reconDesc = reconDesc;
-	reconCtrlPtr->fcol = fcol;
-	reconCtrlPtr->spareRow = srow;
-	reconCtrlPtr->spareCol = scol;
-	reconCtrlPtr->lastPSID = layoutPtr->numStripe / layoutPtr->SUsPerPU;
-	reconCtrlPtr->percentComplete = 0;
-
-	/* 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 */
-		reconCtrlPtr->perDiskInfo[i].ru_count = RUsPerPU - 1;
-	}
-
-	/* Get the number of spare units per disk and the sparemap in case
-	 * spare is distributed  */
-
-	if (lp->GetNumSpareRUs) {
-		numSpareRUs = lp->GetNumSpareRUs(raidPtr);
-	} else {
-		numSpareRUs = 0;
-	}
-
-	/*
-         * Not all distributed sparing archs need dynamic mappings
-         */
-	if (lp->InstallSpareTable) {
-		retcode = rf_InstallSpareTable(raidPtr, frow, fcol);
-		if (retcode) {
-			RF_PANIC();	/* XXX fix this */
-		}
-	}
-	/* make the reconstruction map */
-	reconCtrlPtr->reconMap = rf_MakeReconMap(raidPtr, (int) (layoutPtr->SUsPerRU * layoutPtr->sectorsPerStripeUnit),
-	    raidPtr->sectorsPerDisk, numSpareRUs);
-
-	/* 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);
-	}
-
-	/* initialize the event queue */
-	rc = rf_mutex_init(&reconCtrlPtr->eq_mutex, __FUNCTION__);
-	if (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);
-		return (NULL);
-	}
-	reconCtrlPtr->eventQueue = NULL;
-	reconCtrlPtr->eq_count = 0;
-
-	/* make the floating recon buffers and append them to the free list */
-	rc = rf_mutex_init(&reconCtrlPtr->rb_mutex, __FUNCTION__);
-	if (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;
-	reconCtrlPtr->priorityList = NULL;
-	reconCtrlPtr->floatingRbufs = NULL;
-	reconCtrlPtr->committedRbufs = NULL;
-	for (i = 0; i < raidPtr->numFloatingReconBufs; i++) {
-		rbuf = rf_MakeReconBuffer(raidPtr, frow, fcol, RF_RBUF_TYPE_FLOATING);
-		rbuf->next = reconCtrlPtr->floatingRbufs;
-		reconCtrlPtr->floatingRbufs = rbuf;
-	}
-
-	/* create the parity stripe status table */
-	reconCtrlPtr->pssTable = rf_MakeParityStripeStatusTable(raidPtr);
-
-	/* 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;
-{
-	RF_ReconCtrl_t *reconCtrlPtr = raidPtr->reconControl[row];
-	RF_ReconBuffer_t *t;
-	RF_ReconUnitNum_t i;
-
-	RF_ASSERT(reconCtrlPtr);
-	for (i = 0; i < raidPtr->numCol; i++)
-		if (reconCtrlPtr->perDiskInfo[i].rbuf)
-			rf_FreeReconBuffer(reconCtrlPtr->perDiskInfo[i].rbuf);
-	for (i = 0; i < raidPtr->numFloatingReconBufs; i++) {
-		t = reconCtrlPtr->floatingRbufs;
-		RF_ASSERT(t);
-		reconCtrlPtr->floatingRbufs = t->next;
-		rf_FreeReconBuffer(t);
-	}
-	rf_mutex_destroy(&reconCtrlPtr->rb_mutex);
-	rf_mutex_destroy(&reconCtrlPtr->eq_mutex);
-	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, sizeof(*reconCtrlPtr));
-}
-
-
-/******************************************************************************
- * computes the default head separation limit
- *****************************************************************************/
-RF_HeadSepLimit_t 
-rf_GetDefaultHeadSepLimit(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	RF_HeadSepLimit_t hsl;
-	RF_LayoutSW_t *lp;
-
-	lp = raidPtr->Layout.map;
-	if (lp->GetDefaultHeadSepLimit == NULL)
-		return (-1);
-	hsl = lp->GetDefaultHeadSepLimit(raidPtr);
-	return (hsl);
-}
-
-
-/******************************************************************************
- * computes the default number of floating recon buffers
- *****************************************************************************/
-int 
-rf_GetDefaultNumFloatingReconBuffers(raidPtr)
-	RF_Raid_t *raidPtr;
-{
-	RF_LayoutSW_t *lp;
-	int     nrb;
-
-	lp = raidPtr->Layout.map;
-	if (lp->GetDefaultNumFloatingReconBuffers == NULL)
-		return (3 * raidPtr->numCol);
-	nrb = lp->GetDefaultNumFloatingReconBuffers(raidPtr);
-	return (nrb);
-}
-
-
-/******************************************************************************
- * creates and initializes a reconstruction buffer
- *****************************************************************************/
-RF_ReconBuffer_t *
-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);
-
-	RF_Malloc(t, sizeof(RF_ReconBuffer_t), (RF_ReconBuffer_t *));
-	RF_Malloc(t->buffer, recon_buffer_size, (caddr_t));
-	RF_Malloc(t->arrived, raidPtr->numCol * sizeof(char), (char *));
-	t->raidPtr = raidPtr;
-	t->row = row;
-	t->col = col;
-	t->priority = RF_IO_RECON_PRIORITY;
-	t->type = type;
-	t->pssPtr = NULL;
-	t->next = NULL;
-	return (t);
-}
-/******************************************************************************
- * frees a reconstruction buffer
- *****************************************************************************/
-void 
-rf_FreeReconBuffer(rbuf)
-	RF_ReconBuffer_t *rbuf;
-{
-	RF_Raid_t *raidPtr = rbuf->raidPtr;
-	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);
-	RF_Free(rbuf, sizeof(*rbuf));
-}
-
-
-/******************************************************************************
- * debug only:  sanity check the number of floating recon bufs in use
- *****************************************************************************/
-void 
-rf_CheckFloatingRbufCount(raidPtr, dolock)
-	RF_Raid_t *raidPtr;
-	int     dolock;
-{
-	RF_ReconParityStripeStatus_t *p;
-	RF_PSStatusHeader_t *pssTable;
-	RF_ReconBuffer_t *rbuf;
-	int     i, j, sum = 0;
-	RF_RowCol_t frow = 0;
-
-	for (i = 0; i < raidPtr->numRow; i++)
-		if (raidPtr->reconControl[i]) {
-			frow = i;
-			break;
-		}
-	RF_ASSERT(frow >= 0);
-
-	if (dolock)
-		RF_LOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
-	pssTable = raidPtr->reconControl[frow]->pssTable;
-
-	for (i = 0; i < raidPtr->pssTableSize; i++) {
-		RF_LOCK_MUTEX(pssTable[i].mutex);
-		for (p = pssTable[i].chain; p; p = p->next) {
-			rbuf = (RF_ReconBuffer_t *) p->rbuf;
-			if (rbuf && rbuf->type == RF_RBUF_TYPE_FLOATING)
-				sum++;
-
-			rbuf = (RF_ReconBuffer_t *) p->writeRbuf;
-			if (rbuf && rbuf->type == RF_RBUF_TYPE_FLOATING)
-				sum++;
-
-			for (j = 0; j < p->xorBufCount; j++) {
-				rbuf = (RF_ReconBuffer_t *) p->rbufsForXor[j];
-				RF_ASSERT(rbuf);
-				if (rbuf->type == RF_RBUF_TYPE_FLOATING)
-					sum++;
-			}
-		}
-		RF_UNLOCK_MUTEX(pssTable[i].mutex);
-	}
-
-	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) {
-		if (rbuf->type == RF_RBUF_TYPE_FLOATING)
-			sum++;
-	}
-	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) {
-		if (rbuf->type == RF_RBUF_TYPE_FLOATING)
-			sum++;
-	}
-
-	RF_ASSERT(sum == raidPtr->numFloatingReconBufs);
-
-	if (dolock)
-		RF_UNLOCK_MUTEX(raidPtr->reconControl[frow]->rb_mutex);
-}
diff --git a/sys/dev/raidframe/rf_reconutil.h b/sys/dev/raidframe/rf_reconutil.h
deleted file mode 100644
index 744d7b9..0000000
--- a/sys/dev/raidframe/rf_reconutil.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_reconutil.h,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/************************************************************
- * rf_reconutil.h -- header file for reconstruction utilities
- ************************************************************/
-
-#ifndef _RF__RF_RECONUTIL_H_
-#define _RF__RF_RECONUTIL_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_RECONUTIL_H_ */
diff --git a/sys/dev/raidframe/rf_revent.c b/sys/dev/raidframe/rf_revent.c
deleted file mode 100644
index fcdf82e..0000000
--- a/sys/dev/raidframe/rf_revent.c
+++ /dev/null
@@ -1,230 +0,0 @@
-/*	$NetBSD: rf_revent.c,v 1.9 2000/09/21 01:45:46 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author:
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-/*
- * revent.c -- reconstruction event handling code
- */
-
-#include <sys/errno.h>
-
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_revent.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_shutdown.h>
-#include <dev/raidframe/rf_kintf.h>
-
-static RF_FreeList_t *rf_revent_freelist;
-#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)  \
-	RF_LTSLEEP(&(_rc)->eventQueue, PRIBIO,  "raidframe eventq", \
-		0, &((_rc)->eq_mutex))
-
-#define DO_SIGNAL(_rc)     wakeup(&(_rc)->eventQueue)
-
-
-static void rf_ShutdownReconEvent(void *);
-
-static RF_ReconEvent_t *
-GetReconEventDesc(RF_RowCol_t row, RF_RowCol_t col,
-    void *arg, RF_Revent_t type);
-
-static void rf_ShutdownReconEvent(ignored)
-	void   *ignored;
-{
-	RF_FREELIST_DESTROY(rf_revent_freelist, next, (RF_ReconEvent_t *));
-}
-
-int 
-rf_ConfigureReconEvent(listp)
-	RF_ShutdownList_t **listp;
-{
-	int     rc;
-
-	RF_FREELIST_CREATE(rf_revent_freelist, RF_MAX_FREE_REVENT,
-	    RF_REVENT_INC, sizeof(RF_ReconEvent_t));
-	if (rf_revent_freelist == NULL)
-		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_ShutdownReconEvent(NULL);
-		return (rc);
-	}
-	RF_FREELIST_PRIME(rf_revent_freelist, RF_REVENT_INITIAL, next,
-	    (RF_ReconEvent_t *));
-	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 */
-
-RF_ReconEvent_t *
-rf_GetNextReconEvent(reconDesc, row, continueFunc, continueArg)
-	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];
-	RF_ReconEvent_t *event;
-
-	RF_ASSERT(row >= 0 && row <= raidPtr->numRow);
-	RF_LOCK_MUTEX(rctrl->eq_mutex);
-	/* 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 */
-
-#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
-	 * forever.  If we run w/o blocking for more than MAX_RECON_EXEC_TICKS
-	 * ticks of the cycle counter, delay for RECON_DELAY before
-	 * continuing. this may murder us with context switches, so we may
-	 * need to increase both the MAX...TICKS and the RECON_DELAY_MS. */
-	if (reconDesc->reconExecTimerRunning) {
-		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);
-		if (reconDesc->reconExecTicks > reconDesc->maxReconExecTicks)
-			reconDesc->maxReconExecTicks = 
-				reconDesc->reconExecTicks;
-		if (reconDesc->reconExecTicks >= MAX_RECON_EXEC_USECS) {
-			/* we've been running too long.  delay for
-			 * RECON_DELAY_MS */
-#if RF_RECON_STATS > 0
-			reconDesc->numReconExecDelays++;
-#endif				/* RF_RECON_STATS > 0 */
-
-			status = RF_LTSLEEP(&reconDesc->reconExecTicks, PRIBIO, 
-					 "recon delay", RECON_TIMO,
-					 &rctrl->eq_mutex);
-			RF_ASSERT(status == EWOULDBLOCK);
-			reconDesc->reconExecTicks = 0;
-		}
-	}
-	while (!rctrl->eventQueue) {
-#if RF_RECON_STATS > 0
-		reconDesc->numReconEventWaits++;
-#endif				/* RF_RECON_STATS > 0 */
-		DO_WAIT(rctrl);
-		reconDesc->reconExecTicks = 0;	/* we've just waited */
-	}
-
-	reconDesc->reconExecTimerRunning = 1;
-	if (RF_ETIMER_VAL_US(reconDesc->recon_exec_timer)!=0) {
-		/* it moved!!  reset the timer. */
-		RF_ETIMER_START(reconDesc->recon_exec_timer);
-	}
-	event = rctrl->eventQueue;
-	rctrl->eventQueue = event->next;
-	event->next = NULL;
-	rctrl->eq_count--;
-
-	/* 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;
-{
-	RF_ReconCtrl_t *rctrl = raidPtr->reconControl[row];
-	RF_ReconEvent_t *event = GetReconEventDesc(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_LOCK_MUTEX(rctrl->eq_mutex);
-	/* 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;
-	rctrl->eq_count++;
-	RF_UNLOCK_MUTEX(rctrl->eq_mutex);
-
-	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;
-{
-	RF_ReconEvent_t *t;
-
-	RF_FREELIST_GET(rf_revent_freelist, t, next, (RF_ReconEvent_t *));
-	if (t == NULL)
-		return (NULL);
-	t->col = col;
-	t->arg = arg;
-	t->type = type;
-	return (t);
-}
-
-void 
-rf_FreeReconEventDesc(event)
-	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
deleted file mode 100644
index 51c3202..0000000
--- a/sys/dev/raidframe/rf_revent.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_revent.h,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author:
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*******************************************************************
- *
- * rf_revent.h -- header file for reconstruction event handling code
- *
- *******************************************************************/
-
-#ifndef _RF__RF_REVENT_H_
-#define _RF__RF_REVENT_H_
-
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_REVENT_H_ */
diff --git a/sys/dev/raidframe/rf_shutdown.c b/sys/dev/raidframe/rf_shutdown.c
deleted file mode 100644
index e6b5292..0000000
--- a/sys/dev/raidframe/rf_shutdown.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/*	$NetBSD: rf_shutdown.c,v 1.6 2000/01/13 23:41:18 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * rf_shutdown.c
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-/*
- * Maintain lists of cleanup functions. Also, mechanisms for coordinating
- * thread startup and shutdown.
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_shutdown.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_freelist.h>
-
-static 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)
-{
-	RF_ShutdownList_t *ent;
-
-	/*
-         * 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);
-	if (ent == NULL)
-		return (ENOMEM);
-	ent->cleanup = cleanup;
-	ent->arg = arg;
-	ent->file = file;
-	ent->line = line;
-	ent->next = *listp;
-	*listp = ent;
-	return (0);
-}
-
-int 
-rf_ShutdownList(RF_ShutdownList_t ** list)
-{
-	RF_ShutdownList_t *r, *next;
-	char   *file;
-	int     line;
-
-	for (r = *list; r; r = next) {
-		next = r->next;
-		file = r->file;
-		line = r->line;
-
-		if (rf_shutdownDebug) {
-			printf("call shutdown, created %s:%d\n", file, line);
-		}
-		r->cleanup(r->arg);
-
-		if (rf_shutdownDebug) {
-			printf("completed shutdown, created %s:%d\n", file, line);
-		}
-		rf_FreeShutdownEnt(r);
-	}
-	*list = NULL;
-	return (0);
-}
diff --git a/sys/dev/raidframe/rf_shutdown.h b/sys/dev/raidframe/rf_shutdown.h
deleted file mode 100644
index 5abc5ba..0000000
--- a/sys/dev/raidframe/rf_shutdown.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_shutdown.h,v 1.2 1999/02/05 00:06:17 oster Exp $	*/
-/*
- * rf_shutdown.h
- */
-/*
- * Copyright (c) 1996 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-/*
- * Maintain lists of cleanup functions. Also, mechanisms for coordinating
- * thread startup and shutdown.
- */
-
-#ifndef _RF__RF_SHUTDOWN_H_
-#define _RF__RF_SHUTDOWN_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-
-/*
- * 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
- * is there when you start another, it'll be there when you
- * shut down another. Hopefully, this subsystem will remove
- * more complexity than it introduces.
- */
-
-struct RF_ShutdownList_s {
-	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);
-
-#endif				/* !_RF__RF_SHUTDOWN_H_ */
diff --git a/sys/dev/raidframe/rf_sstf.c b/sys/dev/raidframe/rf_sstf.c
deleted file mode 100644
index cd9ea56..0000000
--- a/sys/dev/raidframe/rf_sstf.c
+++ /dev/null
@@ -1,658 +0,0 @@
-/*	$NetBSD: rf_sstf.c,v 1.6 2001/01/27 20:18:55 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*******************************************************************************
- *
- * sstf.c --  prioritized shortest seek time first disk queueing code
- *
- ******************************************************************************/
-
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_stripelocks.h>
-#include <dev/raidframe/rf_layout.h>
-#include <dev/raidframe/rf_diskqueue.h>
-#include <dev/raidframe/rf_sstf.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_options.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/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 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 *);
-
-
-static void 
-do_sstf_ord_q(queuep, tailp, req)
-	RF_DiskQueueData_t **queuep;
-	RF_DiskQueueData_t **tailp;
-	RF_DiskQueueData_t *req;
-{
-	RF_DiskQueueData_t *r, *s;
-
-	if (*queuep == NULL) {
-		*queuep = req;
-		*tailp = req;
-		req->next = NULL;
-		req->prev = NULL;
-		return;
-	}
-	if (req->sectorOffset <= (*queuep)->sectorOffset) {
-		req->next = *queuep;
-		req->prev = NULL;
-		(*queuep)->prev = req;
-		*queuep = req;
-		return;
-	}
-	if (req->sectorOffset > (*tailp)->sectorOffset) {
-		/* 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 */
-			RF_ASSERT(s);
-			req->next = r;
-			r->prev = req;
-			s->next = req;
-			req->prev = s;
-			return;
-		}
-	}
-q_at_end:
-	/* insert after s, at end of queue */
-	RF_ASSERT(r == NULL);
-	RF_ASSERT(s);
-	RF_ASSERT(s == (*tailp));
-	req->next = NULL;
-	req->prev = s;
-	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_); \
-	} \
-}
-
-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_SectorNum_t best_pos_l = 0, this_pos_l = 0, last_pos = 0;
-	RF_SectorNum_t best_pos_r = 0, this_pos_r = 0;
-	RF_DiskQueueData_t *r, *best_l, *best_r;
-
-	best_r = best_l = NULL;
-	for (r = queue->queue; r; r = r->next) {
-		if (r->sectorOffset < arm_pos) {
-			if (best_l == NULL) {
-				best_l = r;
-				last_pos = best_pos_l = this_pos_l;
-			} else {
-				this_pos_l = arm_pos - r->sectorOffset;
-				if (this_pos_l < best_pos_l) {
-					best_l = r;
-					last_pos = best_pos_l = this_pos_l;
-				} else {
-					last_pos = this_pos_l;
-				}
-			}
-		} else {
-			if (best_r == NULL) {
-				best_r = r;
-				last_pos = best_pos_r = this_pos_r;
-			} else {
-				this_pos_r = r->sectorOffset - arm_pos;
-				if (this_pos_r < best_pos_r) {
-					best_r = r;
-					last_pos = best_pos_r = this_pos_r;
-				} else {
-					last_pos = this_pos_r;
-				}
-				if (this_pos_r > last_pos) {
-					/* getting farther away */
-					break;
-				}
-			}
-		}
-	}
-	if ((best_r == NULL) && (best_l == NULL))
-		return (NULL);
-	if ((*dir == DIR_RIGHT) && best_r)
-		return (best_r);
-	if ((*dir == DIR_LEFT) && best_l)
-		return (best_l);
-	if (*dir == DIR_EITHER) {
-		if (best_l == NULL)
-			return (best_r);
-		if (best_r == NULL)
-			return (best_l);
-		if (best_pos_r < best_pos_l)
-			return (best_r);
-		else
-			return (best_l);
-	}
-	/*
-	 * Nothing in the direction we want to go. Reverse or
-	 * reset the arm. We know we have an I/O in the other
-	 * direction.
-	 */
-	if (allow_reverse) {
-		if (*dir == DIR_RIGHT) {
-			*dir = DIR_LEFT;
-			return (best_l);
-		} else {
-			*dir = DIR_RIGHT;
-			return (best_r);
-		}
-	}
-	/*
-	 * Reset (beginning of queue).
-	 */
-	RF_ASSERT(*dir == DIR_RIGHT);
-	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;
-{
-	RF_Sstf_t *sstfq;
-
-	RF_CallocAndAdd(sstfq, 1, sizeof(RF_Sstf_t), (RF_Sstf_t *), cl_list);
-	sstfq->dir = DIR_EITHER;
-	sstfq->allow_reverse = 1;
-	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;
-{
-	RF_Sstf_t *scanq;
-
-	RF_CallocAndAdd(scanq, 1, sizeof(RF_Sstf_t), (RF_Sstf_t *), cl_list);
-	scanq->dir = DIR_RIGHT;
-	scanq->allow_reverse = 1;
-	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;
-{
-	RF_Sstf_t *cscanq;
-
-	RF_CallocAndAdd(cscanq, 1, sizeof(RF_Sstf_t), (RF_Sstf_t *), cl_list);
-	cscanq->dir = DIR_RIGHT;
-	return ((void *) cscanq);
-}
-
-void 
-rf_SstfEnqueue(qptr, req, priority)
-	void   *qptr;
-	RF_DiskQueueData_t *req;
-	int     priority;
-{
-	RF_Sstf_t *sstfq;
-
-	sstfq = (RF_Sstf_t *) qptr;
-
-	if (priority == RF_IO_LOW_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, 
-			       sstfq->left.qlen, sstfq->right.qlen,
-			       sstfq->lopri.qlen);
-		}
-		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);
-			sstfq->left.qlen++;
-		} else {
-			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;
-{
-	RF_DiskQueueData_t *req2;
-
-	if (rf_sstfDebug || rf_scanDebug || rf_cscanDebug) {
-		printf("raid%d: do_dequeue\n", req->raidPtr->raidid);
-	}
-	if (req == queue->queue) {
-		DO_HEAD_DEQ(req2, queue);
-		RF_ASSERT(req2 == req);
-	} else
-		if (req == queue->qtail) {
-			DO_TAIL_DEQ(req2, queue);
-			RF_ASSERT(req2 == req);
-		} else {
-			/* dequeue from middle of list */
-			RF_ASSERT(req->next);
-			RF_ASSERT(req->prev);
-			queue->qlen--;
-			req->next->prev = req->prev;
-			req->prev->next = req->next;
-			req->next = req->prev = NULL;
-		}
-}
-
-RF_DiskQueueData_t *
-rf_SstfDequeue(qptr)
-	void   *qptr;
-{
-	RF_DiskQueueData_t *req = NULL;
-	RF_Sstf_t *sstfq;
-
-	sstfq = (RF_Sstf_t *) qptr;
-
-	if (rf_sstfDebug) {
-		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, 
-		       sstfq->left.qlen, sstfq->right.qlen, sstfq->lopri.qlen);
-	}
-	if (sstfq->left.queue == NULL) {
-		RF_ASSERT(sstfq->left.qlen == 0);
-		if (sstfq->right.queue == NULL) {
-			RF_ASSERT(sstfq->right.qlen == 0);
-			if (sstfq->lopri.queue == NULL) {
-				RF_ASSERT(sstfq->lopri.qlen == 0);
-				return (NULL);
-			}
-			if (rf_sstfDebug) {
-				printf("raid%d: sstf: check for close lopri",
-				       req->raidPtr->raidid);
-			}
-			req = 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);
-			}
-			if (req == NULL)
-				return (NULL);
-			do_dequeue(&sstfq->lopri, req);
-		} else {
-			DO_BEST_DEQ(sstfq->last_sector, req, &sstfq->right);
-		}
-	} else {
-		if (sstfq->right.queue == NULL) {
-			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)) {
-				DO_HEAD_DEQ(req, &sstfq->right);
-			} else {
-				DO_TAIL_DEQ(req, &sstfq->left);
-			}
-		}
-	}
-	RF_ASSERT(req);
-	sstfq->last_sector = req->sectorOffset;
-	return (req);
-}
-
-RF_DiskQueueData_t *
-rf_ScanDequeue(qptr)
-	void   *qptr;
-{
-	RF_DiskQueueData_t *req = NULL;
-	RF_Sstf_t *scanq;
-
-	scanq = (RF_Sstf_t *) qptr;
-
-	if (rf_scanDebug) {
-		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, 
-		       scanq->left.qlen, scanq->right.qlen, scanq->lopri.qlen);
-	}
-	if (scanq->left.queue == NULL) {
-		RF_ASSERT(scanq->left.qlen == 0);
-		if (scanq->right.queue == NULL) {
-			RF_ASSERT(scanq->right.qlen == 0);
-			if (scanq->lopri.queue == NULL) {
-				RF_ASSERT(scanq->lopri.qlen == 0);
-				return (NULL);
-			}
-			req = closest_to_arm(&scanq->lopri, scanq->last_sector,
-			    &scanq->dir, scanq->allow_reverse);
-			if (req == NULL)
-				return (NULL);
-			do_dequeue(&scanq->lopri, req);
-		} else {
-			scanq->dir = DIR_RIGHT;
-			DO_HEAD_DEQ(req, &scanq->right);
-		}
-	} else
-		if (scanq->right.queue == NULL) {
-			RF_ASSERT(scanq->right.qlen == 0);
-			RF_ASSERT(scanq->left.queue);
-			scanq->dir = DIR_LEFT;
-			DO_TAIL_DEQ(req, &scanq->left);
-		} else {
-			RF_ASSERT(scanq->right.queue);
-			RF_ASSERT(scanq->left.queue);
-			if (scanq->dir == DIR_RIGHT) {
-				DO_HEAD_DEQ(req, &scanq->right);
-			} else {
-				DO_TAIL_DEQ(req, &scanq->left);
-			}
-		}
-	RF_ASSERT(req);
-	scanq->last_sector = req->sectorOffset;
-	return (req);
-}
-
-RF_DiskQueueData_t *
-rf_CscanDequeue(qptr)
-	void   *qptr;
-{
-	RF_DiskQueueData_t *req = NULL;
-	RF_Sstf_t *cscanq;
-
-	cscanq = (RF_Sstf_t *) qptr;
-
-	RF_ASSERT(cscanq->dir == DIR_RIGHT);
-	if (rf_cscanDebug) {
-		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", 
-		       req->raidPtr->raidid, dq->row, dq->col,
-		       cscanq->left.qlen, cscanq->right.qlen,
-		       cscanq->lopri.qlen);
-	}
-	if (cscanq->right.queue) {
-		DO_HEAD_DEQ(req, &cscanq->right);
-	} else {
-		RF_ASSERT(cscanq->right.qlen == 0);
-		if (cscanq->left.queue == NULL) {
-			RF_ASSERT(cscanq->left.qlen == 0);
-			if (cscanq->lopri.queue == NULL) {
-				RF_ASSERT(cscanq->lopri.qlen == 0);
-				return (NULL);
-			}
-			req = closest_to_arm(&cscanq->lopri, cscanq->last_sector,
-			    &cscanq->dir, cscanq->allow_reverse);
-			if (req == NULL)
-				return (NULL);
-			do_dequeue(&cscanq->lopri, req);
-		} else {
-			/*
-			 * There's I/Os to the left of the arm. Swing
-			 * on back (swap queues).
-			 */
-			cscanq->right = cscanq->left;
-			cscanq->left.qlen = 0;
-			cscanq->left.queue = cscanq->left.qtail = NULL;
-			DO_HEAD_DEQ(req, &cscanq->right);
-		}
-	}
-	RF_ASSERT(req);
-	cscanq->last_sector = req->sectorOffset;
-	return (req);
-}
-
-RF_DiskQueueData_t *
-rf_SstfPeek(qptr)
-	void   *qptr;
-{
-	RF_DiskQueueData_t *req;
-	RF_Sstf_t *sstfq;
-
-	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);
-	} else {
-		if (sstfq->left.queue == NULL)
-			req = sstfq->right.queue;
-		else {
-			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)) {
-					req = sstfq->right.queue;
-				} else {
-					req = sstfq->left.qtail;
-				}
-			}
-		}
-	}
-	if (req == NULL) {
-		RF_ASSERT(QSUM(sstfq) == 0);
-	}
-	return (req);
-}
-
-RF_DiskQueueData_t *
-rf_ScanPeek(qptr)
-	void   *qptr;
-{
-	RF_DiskQueueData_t *req;
-	RF_Sstf_t *scanq;
-	int     dir;
-
-	scanq = (RF_Sstf_t *) qptr;
-	dir = scanq->dir;
-
-	if (scanq->left.queue == NULL) {
-		RF_ASSERT(scanq->left.qlen == 0);
-		if (scanq->right.queue == NULL) {
-			RF_ASSERT(scanq->right.qlen == 0);
-			if (scanq->lopri.queue == NULL) {
-				RF_ASSERT(scanq->lopri.qlen == 0);
-				return (NULL);
-			}
-			req = closest_to_arm(&scanq->lopri, scanq->last_sector,
-			    &dir, scanq->allow_reverse);
-		} else {
-			req = scanq->right.queue;
-		}
-	} else
-		if (scanq->right.queue == NULL) {
-			RF_ASSERT(scanq->right.qlen == 0);
-			RF_ASSERT(scanq->left.queue);
-			req = scanq->left.qtail;
-		} else {
-			RF_ASSERT(scanq->right.queue);
-			RF_ASSERT(scanq->left.queue);
-			if (scanq->dir == DIR_RIGHT) {
-				req = scanq->right.queue;
-			} else {
-				req = scanq->left.qtail;
-			}
-		}
-	if (req == NULL) {
-		RF_ASSERT(QSUM(scanq) == 0);
-	}
-	return (req);
-}
-
-RF_DiskQueueData_t *
-rf_CscanPeek(qptr)
-	void   *qptr;
-{
-	RF_DiskQueueData_t *req;
-	RF_Sstf_t *cscanq;
-
-	cscanq = (RF_Sstf_t *) qptr;
-
-	RF_ASSERT(cscanq->dir == DIR_RIGHT);
-	if (cscanq->right.queue) {
-		req = cscanq->right.queue;
-	} else {
-		RF_ASSERT(cscanq->right.qlen == 0);
-		if (cscanq->left.queue == NULL) {
-			RF_ASSERT(cscanq->left.qlen == 0);
-			if (cscanq->lopri.queue == NULL) {
-				RF_ASSERT(cscanq->lopri.qlen == 0);
-				return (NULL);
-			}
-			req = 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
-			 * up swinging on back.
-			 */
-			req = cscanq->left.queue;
-		}
-	}
-	if (req == NULL) {
-		RF_ASSERT(QSUM(cscanq) == 0);
-	}
-	return (req);
-}
-
-int 
-rf_SstfPromote(qptr, parityStripeID, which_ru)
-	void   *qptr;
-	RF_StripeNum_t parityStripeID;
-	RF_ReconUnitNum_t which_ru;
-{
-	RF_DiskQueueData_t *r, *next;
-	RF_Sstf_t *sstfq;
-	int     n;
-
-	sstfq = (RF_Sstf_t *) qptr;
-
-	n = 0;
-	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",
-			       r->raidPtr->raidid, (long) r);
-		}
-		if ((r->parityStripeID == parityStripeID)
-		    && (r->which_ru == which_ru)) {
-			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, 
-		       sstfq->right.qlen, sstfq->lopri.qlen);
-	}
-	return (n);
-}
diff --git a/sys/dev/raidframe/rf_sstf.h b/sys/dev/raidframe/rf_sstf.h
deleted file mode 100644
index 2fc1c0d..0000000
--- a/sys/dev/raidframe/rf_sstf.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_sstf.h,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_SSTF_H_
-#define _RF__RF_SSTF_H_
-
-#include <dev/raidframe/rf_diskqueue.h>
-
-typedef struct RF_SstfQ_s {
-	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;
-
-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);
-
-#endif				/* !_RF__RF_SSTF_H_ */
diff --git a/sys/dev/raidframe/rf_states.c b/sys/dev/raidframe/rf_states.c
deleted file mode 100644
index bc686ec..0000000
--- a/sys/dev/raidframe/rf_states.c
+++ /dev/null
@@ -1,669 +0,0 @@
-/*	$NetBSD: rf_states.c,v 1.15 2000/10/20 02:24:45 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, William V. Courtright II, Robby Findler
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <sys/errno.h>
-
-#include <dev/raidframe/rf_archs.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_dag.h>
-#include <dev/raidframe/rf_desc.h>
-#include <dev/raidframe/rf_aselect.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_states.h>
-#include <dev/raidframe/rf_dagutils.h>
-#include <dev/raidframe/rf_driver.h>
-#include <dev/raidframe/rf_engine.h>
-#include <dev/raidframe/rf_map.h>
-#include <dev/raidframe/rf_etimer.h>
-#include <dev/raidframe/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.
-
-     - increment desc->state when they have finished their work.
-*/
-
-static char *
-StateName(RF_AccessState_t state)
-{
-	switch (state) {
-		case rf_QuiesceState:return "QuiesceState";
-	case rf_MapState:
-		return "MapState";
-	case rf_LockState:
-		return "LockState";
-	case rf_CreateDAGState:
-		return "CreateDAGState";
-	case rf_ExecuteDAGState:
-		return "ExecuteDAGState";
-	case rf_ProcessDAGState:
-		return "ProcessDAGState";
-	case rf_CleanupState:
-		return "CleanupState";
-	case rf_LastState:
-		return "LastState";
-	case rf_IncrAccessesCountState:
-		return "IncrAccessesCountState";
-	case rf_DecrAccessesCountState:
-		return "DecrAccessesCountState";
-	default:
-		return "!!! UnnamedState !!!";
-	}
-}
-
-void 
-rf_ContinueRaidAccess(RF_RaidAccessDesc_t * desc)
-{
-	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;
-
-	do {
-
-		current_state_index = desc->state;
-		current_state = desc->states[current_state_index];
-
-		switch (current_state) {
-
-		case rf_QuiesceState:
-			suspended = rf_State_Quiesce(desc);
-			break;
-		case rf_IncrAccessesCountState:
-			suspended = rf_State_IncrAccessCount(desc);
-			break;
-		case rf_MapState:
-			suspended = rf_State_Map(desc);
-			break;
-		case rf_LockState:
-			suspended = rf_State_Lock(desc);
-			break;
-		case rf_CreateDAGState:
-			suspended = rf_State_CreateDAG(desc);
-			break;
-		case rf_ExecuteDAGState:
-			suspended = rf_State_ExecuteDAG(desc);
-			break;
-		case rf_ProcessDAGState:
-			suspended = rf_State_ProcessDAG(desc);
-			break;
-		case rf_CleanupState:
-			suspended = rf_State_Cleanup(desc);
-			break;
-		case rf_DecrAccessesCountState:
-			suspended = rf_State_DecrAccessCount(desc);
-			break;
-		case rf_LastState:
-			suspended = rf_State_LastState(desc);
-			break;
-		}
-
-		/* 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. */
-
-		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");
-		}
-	} while (!suspended && current_state != rf_LastState);
-
-	return;
-}
-
-
-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;
-
-	desc = dagList->desc;
-
-	timer = tracerec->timer;
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->specific.user.exec_us = RF_ETIMER_VAL_US(timer);
-	RF_ETIMER_START(tracerec->timer);
-
-	/* 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 */
-	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 */
-		{
-			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, (int) desc->numBlocks,
-			       (int) desc->numBlocks, 
-			       (unsigned long) (desc->bufPtr));
-		}
-	}
-	dagList->numDagsDone++;
-	rf_ContinueRaidAccess(desc);
-}
-
-int 
-rf_State_LastState(RF_RaidAccessDesc_t * desc)
-{
-	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 (desc->async_flag == 0)
-		wakeup(desc->bp);
-
-	/*
-	 * That's all the IO for this one... unbusy the 'disk'.
-	 */
-
-	rf_disk_unbusy(desc);
-
-	/* 
-	 * Wakeup any requests waiting to go.
-	 */
-	
-	RF_LOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
-	((RF_Raid_t *) desc->raidPtr)->openings++;
-	RF_UNLOCK_MUTEX(((RF_Raid_t *) desc->raidPtr)->mutex);
-
-	/* wake up any pending IO */
-	raidstart(((RF_Raid_t *) desc->raidPtr));
-		
-	/* printf("Calling biodone on 0x%x\n",desc->bp); */
-	biodone(desc->bp);	/* access came through ioctl */
-
-	if (callbackFunc)
-		callbackFunc(callbackArg);
-	rf_FreeRaidAccDesc(desc);
-
-	return RF_FALSE;
-}
-
-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 */
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
-	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)
-{
-	RF_Raid_t *raidPtr;
-
-	raidPtr = desc->raidPtr;
-
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
-	raidPtr->accs_in_flight--;
-	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_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
-
-	desc->state++;
-	return RF_FALSE;
-}
-
-int 
-rf_State_Quiesce(RF_RaidAccessDesc_t * desc)
-{
-	RF_AccTraceEntry_t *tracerec = &desc->tracerec;
-	RF_Etimer_t timer;
-	int     suspended = RF_FALSE;
-	RF_Raid_t *raidPtr;
-
-	raidPtr = desc->raidPtr;
-
-	RF_ETIMER_START(timer);
-	RF_ETIMER_START(desc->timer);
-
-	RF_LOCK_MUTEX(raidPtr->access_suspend_mutex);
-	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;
-		cb->callbackArg.p = (void *) desc;
-		cb->next = raidPtr->quiesce_wait_list;
-		raidPtr->quiesce_wait_list = cb;
-		suspended = RF_TRUE;
-	}
-	RF_UNLOCK_MUTEX(raidPtr->access_suspend_mutex);
-
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->specific.user.suspend_ovhd_us += RF_ETIMER_VAL_US(timer);
-
-	if (suspended && rf_quiesceDebug)
-		printf("Stalling access due to quiescence lock\n");
-
-	desc->state++;
-	return suspended;
-}
-
-int 
-rf_State_Map(RF_RaidAccessDesc_t * desc)
-{
-	RF_Raid_t *raidPtr = desc->raidPtr;
-	RF_AccTraceEntry_t *tracerec = &desc->tracerec;
-	RF_Etimer_t timer;
-
-	RF_ETIMER_START(timer);
-
-	if (!(desc->asmap = rf_MapAccess(raidPtr, desc->raidAddress, desc->numBlocks,
-		    desc->bufPtr, RF_DONT_REMAP)))
-		RF_PANIC();
-
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->specific.user.map_us = RF_ETIMER_VAL_US(timer);
-
-	desc->state++;
-	return RF_FALSE;
-}
-
-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;
-
-	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 */
-		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 &&
-			    asm_p->parityInfo &&
-			    !(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 */
-
-				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 (*) (RF_Buf_t)) rf_ContinueRaidAccess,
-				    desc, asm_p,
-				    raidPtr->Layout.dataSectorsPerStripe);
-				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);
-					if (val == 0) {
-						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, 
-						       (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, 
-					       (long) asm_p->stripeID);
-				}
-			}
-		}
-
-		RF_ETIMER_STOP(timer);
-		RF_ETIMER_EVAL(timer);
-		tracerec->specific.user.lock_us += RF_ETIMER_VAL_US(timer);
-
-		if (suspended)
-			return (RF_TRUE);
-	}
-	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
- *
- * repeat until all dags complete successfully -or- dag selection fails
- *
- * while !done
- *   create dag(s) (SelectAlgorithm)
- *   if dag
- *     execute dag (DispatchDAG)
- *     if dag successful
- *       done (SUCCESS)
- *     else
- *       !done (RETRY - start over with new dags)
- *   else
- *     done (FAIL)
- */
-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;
-
-	/* 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);
-	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 */
-	tracerec->specific.user.dag_create_us = RF_ETIMER_VAL_US(timer);
-
-	desc->status = 0;	/* good status */
-
-	if (selectStatus) {
-		/* 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 */
-		for (i = 0; i < desc->numStripes; i++) {
-			dag_h = desc->dagArray[i].dags;
-			while (dag_h) {
-				dag_h->bp = (RF_Buf_t) desc->bp;
-				dag_h->tracerec = tracerec;
-				dag_h = dag_h->next;
-			}
-		}
-		desc->flags |= RF_DAG_DISPATCH_RETURNED;
-		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)
-{
-	int     i;
-	RF_DagHeader_t *dag_h;
-	RF_DagList_t *dagArray = desc->dagArray;
-
-	/* next state is always rf_State_ProcessDAG important to do this
-	 * before firing the first dag (it may finish before we leave this
-	 * routine) */
-	desc->state++;
-
-	/* 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 */
-		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]);
-	}
-
-	/* 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_AccessStripeMapHeader_t *asmh = desc->asmap;
-	RF_Raid_t *raidPtr = desc->raidPtr;
-	RF_DagHeader_t *dag_h;
-	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 */
-	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 */
-			RF_ETIMER_START(timer);
-			/* 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 */
-			desc->state = desc->state - 2;
-			return RF_FALSE;
-		} else {
-			/* 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 */
-		for (i = 0; i < desc->numStripes; i++) {
-			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 */
-				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]);
-			}
-		}
-		return RF_TRUE;
-	}
-}
-/* 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;
-	RF_Raid_t *raidPtr = desc->raidPtr;
-	RF_AccessStripeMap_t *asm_p;
-	RF_DagHeader_t *dag_h;
-	RF_Etimer_t timer;
-	int i;
-
-	desc->state++;
-
-	timer = tracerec->timer;
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->specific.user.dag_retry_us = RF_ETIMER_VAL_US(timer);
-
-	/* 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 */
-		*(desc->paramDAG) = desc->dagArray[0].dags;
-		dag_h = *(desc->paramDAG);
-		for (i = 1; i < desc->numStripes; i++) {
-			/* 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 */
-		for (i = 0; i < desc->numStripes; i++) {
-			rf_FreeDAG(desc->dagArray[i].dags);
-		}
-	}
-
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->specific.user.cleanup_us = RF_ETIMER_VAL_US(timer);
-
-	RF_ETIMER_START(timer);
-	if (!(raidPtr->Layout.map->flags & RF_NO_STRIPE_LOCKS)) {
-		for (asm_p = asmh->stripeMap; asm_p; asm_p = asm_p->next) {
-			if (!rf_suppressLocksAndLargeWrites &&
-			    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);
-			}
-			if (asm_p->flags & RF_ASM_FLAGS_RECON_BLOCKED) {
-				rf_UnblockRecon(raidPtr, asm_p);
-			}
-		}
-	}
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->specific.user.lock_us += RF_ETIMER_VAL_US(timer);
-
-	RF_ETIMER_START(timer);
-	if (desc->flags & RF_DAG_RETURN_ASM)
-		*(desc->paramASM) = asmh;
-	else
-		rf_FreeAccessStripeMap(asmh);
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	tracerec->specific.user.cleanup_us += RF_ETIMER_VAL_US(timer);
-
-	RF_ETIMER_STOP(desc->timer);
-	RF_ETIMER_EVAL(desc->timer);
-
-	timer = desc->tracerec.tot_timer;
-	RF_ETIMER_STOP(timer);
-	RF_ETIMER_EVAL(timer);
-	desc->tracerec.total_us = RF_ETIMER_VAL_US(timer);
-
-	rf_LogTraceRec(raidPtr, tracerec);
-
-	desc->flags |= RF_DAG_ACCESS_COMPLETE;
-
-	return RF_FALSE;
-}
diff --git a/sys/dev/raidframe/rf_states.h b/sys/dev/raidframe/rf_states.h
deleted file mode 100644
index 6c0aee4..0000000
--- a/sys/dev/raidframe/rf_states.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_states.h,v 1.3 1999/02/05 00:06:17 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, William V. Courtright II, Robby Findler
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#ifndef _RF__RF_STATES_H_
-#define _RF__RF_STATES_H_
-
-#include <dev/raidframe/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);
-
-#endif				/* !_RF__RF_STATES_H_ */
diff --git a/sys/dev/raidframe/rf_stripelocks.c b/sys/dev/raidframe/rf_stripelocks.c
deleted file mode 100644
index 409c0f4..0000000
--- a/sys/dev/raidframe/rf_stripelocks.c
+++ /dev/null
@@ -1,669 +0,0 @@
-/*	$NetBSD: rf_stripelocks.c,v 1.6 2000/12/04 11:35:46 fvdl Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Authors: Mark Holland, Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * 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
- * 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
- * given the lock.
- *
- * The lock table size must be one less than a power of two, but HASH_STRIPEID
- * is the only function that requires this.
- *
- * The code now supports "range locks". When you ask to lock a stripe, you
- * specify a range of addresses in that stripe that you want to lock. When
- * 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
- * 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
- * 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.
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_raid.h>
-#include <dev/raidframe/rf_stripelocks.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_freelist.h>
-#include <dev/raidframe/rf_debugprint.h>
-#include <dev/raidframe/rf_driver.h>
-#include <dev/raidframe/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.
- * 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
- */
-#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
-
-static void rf_ShutdownStripeLockFreeList(void *);
-static void rf_RaidShutdownStripeLocks(void *);
-
-static void 
-rf_ShutdownStripeLockFreeList(ignored)
-	void   *ignored;
-{
-	RF_FREELIST_DESTROY(rf_stripelock_freelist, next, (RF_StripeLockDesc_t *));
-}
-
-int 
-rf_ConfigureStripeLockFreeList(listp)
-	RF_ShutdownList_t **listp;
-{
-	unsigned mask;
-	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_ShutdownStripeLockFreeList(NULL);
-		return (rc);
-	}
-	RF_FREELIST_PRIME(rf_stripelock_freelist, RF_STRIPELOCK_INITIAL, next,
-	    (RF_StripeLockDesc_t *));
-	for (mask = 0x1; mask; mask <<= 1)
-		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);
-		rf_lockTableSize = RF_DEFAULT_LOCK_TABLE_SIZE;
-	}
-	return (0);
-}
-
-RF_LockTableEntry_t *
-rf_MakeLockTable()
-{
-	RF_LockTableEntry_t *lockTable;
-	int     i, rc;
-
-	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, __FUNCTION__);
-		if (rc) {
-			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)
-{
-	int     i;
-
-	if (rf_stripeLockDebug) {
-		PrintLockedStripes(lockTable);
-	}
-	for (i = 0; i < rf_lockTableSize; i++) {
-		rf_mutex_destroy(&lockTable[i].mutex);
-	}
-	RF_Free(lockTable, rf_lockTableSize * sizeof(RF_LockTableEntry_t));
-}
-
-static void 
-rf_RaidShutdownStripeLocks(arg)
-	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     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_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
- * 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)
-{
-	RF_StripeLockDesc_t *lockDesc;
-	RF_LockReqDesc_t *p;
-	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);
-		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);
-			FLUSH;
-		}
-	}
-	if (stripeID == -1)
-		return (0);
-	lockReqDesc->next = NULL;	/* just to be sure */
-
-	RF_LOCK_MUTEX(lockTable[hashval].mutex);
-	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);
-		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);
-			FLUSH;
-		}
-	} else {
-
-		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 */
-			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);
-				FLUSH;
-			}
-		} else {
-
-			/* 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)) {
-					retcode = 1;
-					break;
-				}
-			if (!retcode)
-				for (p = lockDesc->waitersH; p; p = p->next)
-					if (STRIPELOCK_CONFLICT(lockReqDesc, p)) {
-						retcode = 2;
-						break;
-					}
-			if (!retcode) {
-				lockReqDesc->next = lockDesc->granted;	/* no conflicts found =>
-									 * grant lock */
-				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);
-					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,
-					    hashval);
-					Dprintf3("[%d] lock %ld retcode=%d\n", tid, stripeID, retcode);
-					FLUSH;
-				}
-				AddToWaitersQueue(lockTable, lockDesc, lockReqDesc);	/* conflict => the
-											 * current access must
-											 * wait */
-			}
-		}
-	}
-
-	RF_UNLOCK_MUTEX(lockTable[hashval].mutex);
-	return (retcode);
-}
-
-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;
-	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);
-		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);
-			FLUSH;
-		}
-	}
-	if (stripeID == -1)
-		return;
-
-	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) {
-		if (lockDesc->stripeID == stripeID)
-			break;
-	}
-	RF_ASSERT(lockDesc);	/* major error to release a lock that doesn't
-				 * exist */
-
-	/* 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
-						 * lock that hasn't been
-						 * granted */
-	if (lr_t)
-		lr_t->next = lr->next;
-	else {
-		RF_ASSERT(lr == lockDesc->granted);
-		lockDesc->granted = lr->next;
-	}
-	lr->next = NULL;
-
-	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
-	 * 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.
-	 * 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
-	 * 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. */
-
-	callbacklist = NULL;
-	if (lockDesc->nWriters == 0) {	/* performance tweak (1) */
-		while (lockDesc->waitersH) {
-
-			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 */
-			lockDesc->granted = lr;
-
-			RF_ASSERT(!lr->templink);
-			lr->templink = callbacklist;	/* put on callback list
-							 * so that we'll invoke
-							 * 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);
-				FLUSH;
-			}
-		}
-		lockDesc->waitersT = NULL;	/* we've purged the whole
-						 * waiters list */
-
-	} else
-		for (candidate_t = NULL, candidate = lockDesc->waitersH; candidate;) {
-
-			/* performance tweak (2) */
-			consider_it = 0;
-			if (RANGE_OVERLAP(lockReqDesc, candidate))
-				consider_it = 1;
-			else
-				for (t = callbacklist; t; t = t->templink)
-					if (RANGE_OVERLAP(t, candidate)) {
-						consider_it = 1;
-						break;
-					}
-			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,
-					    (unsigned long) lockTable);
-					FLUSH;
-				}
-				candidate_t = candidate;
-				candidate = candidate->next;
-				continue;
-			}
-			/* 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)) {
-					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,
-						    (unsigned long) lockTable);
-						FLUSH;
-					}
-					release_it = 0;
-					break;
-				}
-			}
-
-			/* now check to see if the candidate is blocked by any
-			 * waiters that occur before it it the wait queue */
-			if (release_it)
-				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);
-							FLUSH;
-						}
-						release_it = 0;
-						break;
-					}
-				}
-
-			/* 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,
-					    (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 */
-				} else {
-					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 */
-				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 */
-				callbacklist = candidate;
-
-				if (!candidate_t)
-					candidate = lockDesc->waitersH;
-				else
-					candidate = candidate_t->next;	/* continue with the
-									 * rest of the list */
-			} else {
-				candidate_t = candidate;
-				candidate = candidate->next;	/* continue with the
-								 * rest of the list */
-			}
-		}
-
-	/* 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);
-			FLUSH;
-		}
-		if (ld_t)
-			ld_t->next = lockDesc->next;
-		else {
-			RF_ASSERT(lockDesc == lockTable[hashval].descList);
-			lockTable[hashval].descList = lockDesc->next;
-		}
-		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
-							 * descriptor, we should
-							 * have no callbacks to
-							 * do */
-	for (candidate = callbacklist; candidate;) {
-		t = candidate;
-		candidate = candidate->templink;
-		t->templink = NULL;
-		(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)
-{
-#if 0 /* XXX fvdl -- unitialized use of 'tid' */
-	int     tid;
-
-	if (rf_stripeLockDebug) {
-		Dprintf3("[%d] Waiting on lock for stripe %ld table 0x%lx\n", tid, lockDesc->stripeID, (unsigned long) lockTable);
-		FLUSH;
-	}
-#endif
-	if (!lockDesc->waitersH) {
-		lockDesc->waitersH = lockDesc->waitersT = lockReqDesc;
-	} else {
-		lockDesc->waitersT->next = lockReqDesc;
-		lockDesc->waitersT = lockReqDesc;
-	}
-}
-
-static RF_StripeLockDesc_t *
-AllocStripeLockDesc(RF_StripeNum_t stripeID)
-{
-	RF_StripeLockDesc_t *p;
-
-	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)
-{
-	RF_FREELIST_FREE(rf_stripelock_freelist, p, next);
-}
-
-static void 
-PrintLockedStripes(lockTable)
-	RF_LockTableEntry_t *lockTable;
-{
-	int     i, j, foundone = 0, did;
-	RF_StripeLockDesc_t *p;
-	RF_LockReqDesc_t *q;
-
-	RF_LOCK_MUTEX(rf_printf_mutex);
-	printf("Locked stripes:\n");
-	for (i = 0; i < rf_lockTableSize; i++)
-		if (lockTable[i].descList) {
-			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);
-
-				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);
-					if (q->start2 != -1)
-						printf(",%ld-%ld) ", (long) q->start2,
-						    (long) q->stop2);
-					else
-						printf(") ");
-					if (j && !(j % 4)) {
-						printf("\n");
-						did = 1;
-					} else
-						did = 0;
-				}
-				if (!did)
-					printf("\n");
-
-				if (!(p->waitersH))
-					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);
-					if (q->start2 != -1)
-						printf(",%ld-%ld) ", (long) q->start2, (long) q->stop2);
-					else
-						printf(") ");
-					if (j && !(j % 4)) {
-						printf("\n         ");
-						did = 1;
-					} else
-						did = 0;
-				}
-				if (!did)
-					printf("\n");
-			}
-		}
-	if (!foundone)
-		printf("(none)\n");
-	else
-		printf("\n");
-	RF_UNLOCK_MUTEX(rf_printf_mutex);
-}
diff --git a/sys/dev/raidframe/rf_stripelocks.h b/sys/dev/raidframe/rf_stripelocks.h
deleted file mode 100644
index ab960c1..0000000
--- a/sys/dev/raidframe/rf_stripelocks.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_stripelocks.h,v 1.3 1999/02/05 00:06:18 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*****************************************************************************
- *
- * 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
- * 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
- * lock becomes free, the callback function is invoked.
- *
- *****************************************************************************/
-
-#ifndef _RF__RF_STRIPELOCKS_H_
-#define _RF__RF_STRIPELOCKS_H_
-
-#if defined(__FreeBSD__)
-#include <sys/types.h>
-#if __FreeBSD_version > 500005
-#include <sys/bio.h>
-#endif
-#if _KERNEL
-#include <sys/systm.h>
-#endif
-#endif
-#include <sys/buf.h>
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/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) (RF_Buf_t);	/* 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)); \
-}
-
-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 */
-};
-
-struct RF_LockTableEntry_s {
-	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
- * 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);                                                                        \
-  }
-
-int     rf_ConfigureStripeLockFreeList(RF_ShutdownList_t ** listp);
-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);
-
-#endif				/* !_RF__RF_STRIPELOCKS_H_ */
diff --git a/sys/dev/raidframe/rf_strutils.c b/sys/dev/raidframe/rf_strutils.c
deleted file mode 100644
index d434f0a..0000000
--- a/sys/dev/raidframe/rf_strutils.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*	$NetBSD: rf_strutils.c,v 1.3 1999/02/05 00:06:18 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * rf_strutils.c
- *
- * String-parsing funcs
- */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-/*
- * rf_strutils.c -- some simple utilities for munging on strings.
- * I put them in a file by themselves because they're needed in
- * setconfig, in the user-level driver, and in the kernel.
- *
- */
-
-#include <dev/raidframe/rf_utils.h>
-
-/* 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   *
-rf_find_white(char *p)
-{
-	for (; *p != '\0' && (*p != ' ' && *p != '\t'); p++);
-	return (p);
-}
diff --git a/sys/dev/raidframe/rf_threadstuff.c b/sys/dev/raidframe/rf_threadstuff.c
deleted file mode 100644
index 657ffee..0000000
--- a/sys/dev/raidframe/rf_threadstuff.c
+++ /dev/null
@@ -1,223 +0,0 @@
-/*	$NetBSD: rf_threadstuff.c,v 1.5 1999/12/07 02:13:28 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * rf_threadstuff.c
- */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_threadstuff.h>
-#include <dev/raidframe/rf_general.h>
-#include <dev/raidframe/rf_shutdown.h>
-
-static void mutex_destroyer(void *);
-static void cond_destroyer(void *);
-
-/*
- * Shared stuff
- */
-
-static void 
-mutex_destroyer(arg)
-	void   *arg;
-{
-	int     rc;
-
-	rc = rf_mutex_destroy(arg);
-	if (rc) {
-		RF_ERRORMSG1("RAIDFRAME: Error %d auto-destroying mutex\n", rc);
-	}
-}
-
-static void 
-cond_destroyer(arg)
-	void   *arg;
-{
-	int     rc;
-
-	rc = rf_cond_destroy(arg);
-	if (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     rc, rc1;
-
-	rc = rf_mutex_init(m, __FUNCTION__);
-	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);
-		}
-	}
-	return (rc);
-}
-
-int 
-_rf_create_managed_cond(listp, c, file, line)
-	RF_ShutdownList_t **listp;
-RF_DECLARE_COND(*c)
-	char   *file;
-	int     line;
-{
-	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);
-		}
-	}
-	return (rc);
-}
-
-int 
-_rf_init_managed_threadgroup(listp, g, file, line)
-	RF_ShutdownList_t **listp;
-	RF_ThreadGroup_t *g;
-	char   *file;
-	int     line;
-{
-	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     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     rc;
-
-	rc = rf_mutex_init(&g->mutex, __FUNCTION__);
-	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
- */
-#if defined(__FreeBSD__) && __FreeBSD_version > 500005
-int 
-rf_mutex_init(m, s)
-decl_simple_lock_data(, *m)
-const char *s;
-{
-	mtx_init(m, s, NULL, MTX_DEF);
-	return (0);
-}
-
-int 
-rf_mutex_destroy(m)
-decl_simple_lock_data(, *m)
-{
-	mtx_destroy(m);
-	return (0);
-}
-#else
-int 
-rf_mutex_init(m, s)
-decl_simple_lock_data(, *m)
-const char *s;
-{
-	simple_lock_init(m);
-	return (0);
-}
-
-int 
-rf_mutex_destroy(m)
-decl_simple_lock_data(, *m)
-{
-	return (0);
-}
-#endif
-
-int 
-rf_cond_init(c)
-RF_DECLARE_COND(*c)
-{
-	*c = 0;			/* no reason */
-	return (0);
-}
-
-int 
-rf_cond_destroy(c)
-RF_DECLARE_COND(*c)
-{
-	return (0);
-}
diff --git a/sys/dev/raidframe/rf_threadstuff.h b/sys/dev/raidframe/rf_threadstuff.h
deleted file mode 100644
index a3560cc..0000000
--- a/sys/dev/raidframe/rf_threadstuff.h
+++ /dev/null
@@ -1,229 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_threadstuff.h,v 1.10 2001/01/27 20:42:21 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland, Daniel Stodolsky, Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/*
- * 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
- * threadid.h
- *
- * this file should be included above stdio.h to get some necessary defines.
- *
- */
-
-#ifndef _RF__RF_THREADSTUFF_H_
-#define _RF__RF_THREADSTUFF_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <sys/types.h>
-#include <sys/param.h>
-#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);
-
-#include <sys/lock.h>
-#if defined(__FreeBSD__ ) && __FreeBSD_version > 500005
-#include <sys/mutex.h>
-#define decl_simple_lock_data(a,b) a struct mtx b;
-#define simple_lock_addr(a) ((struct mtx *)&(a))
-
-typedef struct thread *RF_Thread_t;
-typedef void *RF_ThreadArg_t;
-
-#ifdef _KERNEL
-static __inline struct ucred *
-rf_getucred(RF_Thread_t td)
-{
-	return (((struct thread *)td)->td_ucred);
-}
-#endif
-
-#define RF_LOCK_MUTEX(_m_)              mtx_lock(&(_m_))
-#define RF_UNLOCK_MUTEX(_m_)            mtx_unlock(&(_m_))
-#else
-#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;
-
-static __inline struct ucred *
-rf_getucred(RF_Thread_t td)
-{
-	return (((struct proc *)td)->p_ucred);
-}
-
-#define RF_LOCK_MUTEX(_m_)              simple_lock(&(_m_))
-#define RF_UNLOCK_MUTEX(_m_)            simple_unlock(&(_m_))
-#endif
-
-#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_;
-
-/*
- * In NetBSD, kernel threads are simply processes which share several
- * substructures and never run in userspace.
- */
-#define RF_WAIT_COND(_c_,_m_)		\
-	RF_LTSLEEP(&(_c_), PRIBIO, "rfwcond", 0, &(_m_))
-#define RF_SIGNAL_COND(_c_)            wakeup_one(&(_c_))
-#define RF_BROADCAST_COND(_c_)         wakeup(&(_c_))
-#if defined(__NetBSD__)
-#define	RF_CREATE_THREAD(_handle_, _func_, _arg_, _name_) \
-	kthread_create1((void (*)(void *))(_func_), (void *)(_arg_), \
-	    (struct proc **)&(_handle_), _name_)
-#define RF_THREAD_EXIT(ret)	\
-	kthread_exit(ret)
-#elif defined(__FreeBSD__)
-#if __FreeBSD_version > 500005
-#define RF_CREATE_THREAD(_handle_, _func_, _arg_, _name_) \
-	kthread_create((void (*)(void *))(_func_), (void *)(_arg_), \
-	    (struct proc **)&(_handle_), 0, 4, _name_)
-#define RF_THREAD_EXIT(ret)	\
-	kthread_exit(ret)
-#else
-#define RF_CREATE_THREAD(_handle_, _func_, _arg_, _name_) \
-	kthread_create((void (*)(void *))(_func_), (void *)(_arg_), \
-	    (struct proc **)&(_handle_), _name_)
-#define RF_THREAD_EXIT(ret)	\
-	kthread_exit(ret);
-#endif
-#endif
-
-struct RF_ThreadGroup_s {
-	int     created;
-	int     running;
-	int     shutdown;
-	        RF_DECLARE_MUTEX(mutex)
-	        RF_DECLARE_COND(cond)
-};
-/*
- * 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); \
-}
-
-/*
- * 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); \
-}
-
-/*
- * 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); \
-}
-
-/*
- * 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); \
-}
-
-/*
- * Wait for all threads to stop running
- */
-#ifndef __NetBSD__
-#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); \
-}
-#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); \
-}
-#endif
-
-#if defined(__FreeBSD__) && __FreeBSD_version > 500005
-int     rf_mutex_init(struct mtx *, const char *);
-int     rf_mutex_destroy(struct mtx *);
-int	_rf_create_managed_mutex(RF_ShutdownList_t **, struct mtx *,
-				 char *, int);
-#else
-int     rf_mutex_init(struct simplelock *, const char *);
-int     rf_mutex_destroy(struct simplelock *);
-int	_rf_create_managed_mutex(RF_ShutdownList_t **, struct simplelock *,
-				 char *, int);
-#endif
-int	_rf_create_managed_cond(RF_ShutdownList_t ** listp, int *,
-				char *file, int line);
-
-int     rf_cond_init(int *c);
-int     rf_cond_destroy(int *c);
-#endif				/* !_RF__RF_THREADSTUFF_H_ */
diff --git a/sys/dev/raidframe/rf_types.h b/sys/dev/raidframe/rf_types.h
deleted file mode 100644
index 25630ef..0000000
--- a/sys/dev/raidframe/rf_types.h
+++ /dev/null
@@ -1,247 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_types.h,v 1.6 1999/09/05 03:05:55 oster Exp $	*/
-/*
- * rf_types.h
- */
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Jim Zelenka
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-/***********************************************************
- *
- * rf_types.h -- standard types for RAIDframe
- *
- ***********************************************************/
-
-#ifndef _RF__RF_TYPES_H_
-#define _RF__RF_TYPES_H_
-
-
-#include <dev/raidframe/rf_archs.h>
-
-#include <sys/errno.h>
-#include <sys/types.h>
-
-#include <sys/uio.h>
-#include <sys/param.h>
-#ifdef _KERNEL
-#include <sys/lock.h>
-#endif
-
-/*
- * First, define system-dependent types and constants.
- *
- * If the machine is big-endian, RF_BIG_ENDIAN should be 1.
- * Otherwise, it should be 0.
- *
- * 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)
- *
- */
-
-#include <sys/types.h>
-#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
-#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
-#elif defined(__i386__)
-#define RF_LONGSHIFT	    2
-#elif defined(__alpha__)
-#define RF_LONGSHIFT	    3
-#else
-#error word size not defined
-#endif
-
-/*
- * These are just zero and non-zero. We don't use "TRUE"
- * and "FALSE" because there's too much nonsense trying
- * to get them defined exactly once on every platform, given
- * the different places they may be defined in system header
- * files.
- */
-#define RF_TRUE  1
-#define RF_FALSE 0
-
-/*
- * 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;
-
-/*
- * Important assumptions regarding ordering of the states in this list
- * 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 */
-	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_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 */
-
-union RF_GenericParam_u {
-	void   *p;
-	RF_uint64 v;
-};
-typedef union RF_GenericParam_u RF_DagParam_t;
-typedef union RF_GenericParam_u RF_CBParam_t;
-
-#if defined(__FreeBSD__) && __FreeBSD_version > 500005
-typedef struct bio	*RF_Buf_t;
-#else
-typedef struct buf	*RF_Buf_t;
-#endif
-#endif				/* _RF__RF_TYPES_H_ */
diff --git a/sys/dev/raidframe/rf_utils.c b/sys/dev/raidframe/rf_utils.c
deleted file mode 100644
index 71f7b93..0000000
--- a/sys/dev/raidframe/rf_utils.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*	$NetBSD: rf_utils.c,v 1.5 2000/01/07 03:41:03 oster Exp $	*/
-
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/****************************************
- *
- * rf_utils.c -- various support routines
- *
- ****************************************/
-
-
-#include <dev/raidframe/rf_threadstuff.h>
-
-#include <sys/time.h>
-
-#include <dev/raidframe/rf_utils.h>
-#include <dev/raidframe/rf_debugMem.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/rf_general.h>
-
-/* 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_RowCol_t **retval, i;
-
-	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));
-	}
-	return (retval);
-}
-
-void 
-rf_free_2d_array(a, b, k)
-	RF_RowCol_t **a;
-	int     b;
-	int     k;
-{
-	RF_RowCol_t i;
-
-	for (i = 0; i < b; i++)
-		RF_Free(a[i], k * sizeof(RF_RowCol_t));
-	RF_Free(a, b * sizeof(RF_RowCol_t));
-}
-
-
-/* creates & zeros a 1-d array with c columns */
-RF_RowCol_t *
-rf_make_1d_array(c, allocList)
-	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));
-	return (retval);
-}
-
-void 
-rf_free_1d_array(a, n)
-	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)
- */
-int 
-rf_gcd(m, n)
-	int     m;
-	int     n;
-{
-	int     t;
-
-	while (m > 0) {
-		t = n % m;
-		n = m;
-		m = t;
-	}
-	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') ) )
-
-int 
-rf_atoi(p)
-	char   *p;
-{
-	int     val = 0, negate = 0;
-
-	if (*p == '-') {
-		negate = 1;
-		p++;
-	}
-	for (; ISDIGIT(*p); p++)
-		val = 10 * val + (*p - '0');
-	return ((negate) ? -val : val);
-}
-
-int 
-rf_htoi(p)
-	char   *p;
-{
-	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
deleted file mode 100644
index 18eac84..0000000
--- a/sys/dev/raidframe/rf_utils.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/*	$FreeBSD$ */
-/*	$NetBSD: rf_utils.h,v 1.4 1999/08/13 03:26:55 oster Exp $	*/
-/*
- * Copyright (c) 1995 Carnegie-Mellon University.
- * All rights reserved.
- *
- * Author: Mark Holland
- *
- * Permission to use, copy, modify and distribute this software and
- * its documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
- * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie the
- * rights to redistribute these changes.
- */
-
-/***************************************
- *
- * rf_utils.c -- header file for utils.c
- *
- ***************************************/
-
-
-#ifndef _RF__RF_UTILS_H_
-#define _RF__RF_UTILS_H_
-
-#include <dev/raidframe/rf_types.h>
-#include <dev/raidframe/rf_alloclist.h>
-#include <dev/raidframe/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);
-
-#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; \
-	} \
-}
-
-#endif				/* !_RF__RF_UTILS_H_ */