Import of CMU's RAIDframe via NetBSD.

1 files changed, 2033 insertions, 0 deletions

diff --git a/sys/dev/raidframe/rf_openbsdkintf.c b/sys/dev/raidframe/rf_openbsdkintf.c
new file mode 100644
index 00000000000..55b7cfbcca4
--- /dev/null
+++ b/sys/dev/raidframe/rf_openbsdkintf.c
@@ -0,0 +1,2033 @@
+/*	$OpenBSD: rf_openbsdkintf.c,v 1.1 1999/01/11 14:29:32 niklas 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
+ *
+ ***********************************************************/
+/*
+ * :
+ * Log: rf_kintf.c,v
+ * Revision 1.57  1996/07/19 16:12:20  jimz
+ * remove addition of protectedSectors in InitBP- it's already
+ * done in the diskqueue code
+ *
+ * Revision 1.56  1996/07/17  21:00:58	jimz
+ * clean up timer interface, tracing
+ *
+ * Revision 1.55  1996/06/17  03:00:54	jimz
+ * Change RAIDFRAME_GET_INFO interface to do its own copyout()
+ * (because size of device config structure now exceeds 8k)
+ *
+ * Revision 1.54  1996/06/09  02:36:46	jimz
+ * lots of little crufty cleanup- fixup whitespace
+ * issues, comment #ifdefs, improve typing in some
+ * places (esp size-related)
+ *
+ * Revision 1.53  1996/06/07  21:33:04	jimz
+ * begin using consistent types for sector numbers,
+ * stripe numbers, row+col numbers, recon unit numbers
+ *
+ * Revision 1.52  1996/06/06  17:28:08	jimz
+ * track sector number of last I/O dequeued
+ *
+ * Revision 1.51  1996/06/05  18:06:02	jimz
+ * Major code cleanup. The Great Renaming is now done.
+ * Better modularity. Better typing. Fixed a bunch of
+ * synchronization bugs. Made a lot of global stuff
+ * per-desc or per-array. Removed dead code.
+ *
+ * Revision 1.50  1996/06/03  23:28:26	jimz
+ * more bugfixes
+ * check in tree to sync for IPDS runs with current bugfixes
+ * there still may be a problem with threads in the script test
+ * getting I/Os stuck- not trivially reproducible (runs ~50 times
+ * in a row without getting stuck)
+ *
+ * Revision 1.49  1996/06/02  17:31:48	jimz
+ * Moved a lot of global stuff into array structure, where it belongs.
+ * Fixed up paritylogging, pss modules in this manner. Some general
+ * code cleanup. Removed lots of dead code, some dead files.
+ *
+ * Revision 1.48  1996/05/31  22:26:54	jimz
+ * fix a lot of mapping problems, memory allocation problems
+ * found some weird lock issues, fixed 'em
+ * more code cleanup
+ *
+ * Revision 1.47  1996/05/30  12:59:18	jimz
+ * make etimer happier, more portable
+ *
+ * Revision 1.46  1996/05/30  11:29:41	jimz
+ * Numerous bug fixes. Stripe lock release code disagreed with the taking code
+ * about when stripes should be locked (I made it consistent: no parity, no lock)
+ * There was a lot of extra serialization of I/Os which I've removed- a lot of
+ * it was to calculate values for the cache code, which is no longer with us.
+ * More types, function, macro cleanup. Added code to properly quiesce the array
+ * on shutdown. Made a lot of stuff array-specific which was (bogusly) general
+ * before. Fixed memory allocation, freeing bugs.
+ *
+ * Revision 1.45  1996/05/27  18:56:37	jimz
+ * more code cleanup
+ * better typing
+ * compiles in all 3 environments
+ *
+ * Revision 1.44  1996/05/24  22:17:04	jimz
+ * continue code + namespace cleanup
+ * typed a bunch of flags
+ *
+ * Revision 1.43  1996/05/24  01:59:45	jimz
+ * another checkpoint in code cleanup for release
+ * time to sync kernel tree
+ *
+ * Revision 1.42  1996/05/23  22:17:54	jimz
+ * fix sector size hardcoding problems
+ *
+ * Revision 1.41  1996/05/23  21:46:35	jimz
+ * checkpoint in code cleanup (release prep)
+ * lots of types, function names have been fixed
+ *
+ * Revision 1.40  1996/05/23  13:18:07	jimz
+ * tracing_mutex -> rf_tracing_mutex
+ *
+ * Revision 1.39  1996/05/23  00:33:23	jimz
+ * code cleanup: move all debug decls to rf_options.c, all extern
+ * debug decls to rf_options.h, all debug vars preceded by rf_
+ *
+ * Revision 1.38  1996/05/20  16:15:32	jimz
+ * switch to rf_{mutex,cond}_{init,destroy}
+ *
+ * Revision 1.37  1996/05/10  16:23:47	jimz
+ * RF_offset -> RF_Offset
+ *
+ * Revision 1.36  1996/05/08  21:01:24	jimz
+ * fixed up enum type names that were conflicting with other
+ * enums and function names (ie, "panic")
+ * future naming trends will be towards RF_ and rf_ for
+ * everything raidframe-related
+ *
+ * Revision 1.35  1996/05/03  19:10:48	jimz
+ * change sanity checking for bogus I/Os to return more appropriate
+ * values (to make some user-level utilities happer with RAIDframe)
+ *
+ * Revision 1.34  1996/05/02  22:17:00	jimz
+ * When using DKUSAGE, send a bogus IO after configuring to let DKUSAGE know
+ * that we exist. This will let user-level programs doing group stats on the
+ * RF device function without error before RF gets its first IO
+ *
+ * Changed rf_device_config devs and spares fields to RF_RaidDisk_t
+ *
+ * Inc numOutstanding for the disk queue in rf_DispatchKernelIO if
+ * type is IO_TYPE_NOP. I'm not sure this is right, but it seems to be,
+ * because the disk IO completion routine wants to dec it, and doesn't
+ * care if there was no such IO.
+ *
+ * Revision 1.33  1996/05/02  15:05:44	jimz
+ * for now, rf_DoAccessKernel will reject non-sector-sized I/Os
+ * eventually, it should do something more clever...
+ * (and do it in DoAccess(), not just DoAccessKernel())
+ *
+ * Revision 1.32  1996/05/01  16:28:39	jimz
+ * get rid of uses of ccmn_ functions
+ *
+ * Revision 1.31  1996/05/01  15:42:17	jimz
+ * ccmn_* memory management is on the way out. This is an archival checkpoint-
+ * both the old and new code are in place (all the ccmn_ calls are #if 0). After
+ * this, the ccmn_ code will no longer appear.
+ *
+ * Revision 1.30  1996/04/22  15:53:13	jimz
+ * MAX_RAIDS -> NRAIDFRAME
+ *
+ * Revision 1.29  1995/12/12  18:10:06	jimz
+ * MIN -> RF_MIN, MAX -> RF_MAX, ASSERT -> RF_ASSERT
+ * fix 80-column brain damage in comments
+ *
+ * Revision 1.28  1995/12/01  19:11:01	root
+ * added copyright info
+ *
+ * Revision 1.27  1995/11/28  18:56:40	wvcii
+ * disabled buffer copy in rf_write
+ *
+ * Revision 1.26  1995/10/06  16:37:08	jimz
+ * get struct bufs from ubc, not cam
+ * copy all write data, and operate on copy
+ * (temporary hack to get around dags in PQ that want
+ * to Xor into user write buffers)
+ *
+ * Revision 1.25  1995/09/30  22:23:08	jimz
+ * do not require raid to be active to perform ACCTOTAL ioctl
+ *
+ * Revision 1.24  1995/09/30  20:39:08	jimz
+ * added new ioctls:
+ *   RAIDFRAME_RESET_ACCTOTALS
+ *   RAIDFRAME_GET_ACCTOTALS
+ *   RAIDFRAME_KEEP_ACCTOTALS
+ *
+ * Revision 1.23  1995/09/20  21:11:59	jimz
+ * include dfstrace.h in KERNEL block
+ * (even though it's a kernel-only file, this makes the depend process
+ * at user-level happy. Why the user-level Makefile wants to depend
+ * kintf.c is less clear, but this is a workaround).
+ *
+ * Revision 1.22  1995/09/19  23:19:03	jimz
+ * added DKUSAGE support
+ *
+ */
+
+#ifdef _KERNEL
+#define KERNEL
+#endif
+
+#ifdef KERNEL
+
+#include <sys/errno.h>
+
+#include "raid.h"
+#include <sys/param.h>
+#include <sys/malloc.h>
+#include <sys/queue.h>
+#include <sys/disk.h>
+#include <sys/device.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/fcntl.h>
+#include <sys/systm.h>
+#include <sys/namei.h>
+#include <sys/conf.h>
+#include <sys/lock.h>
+#include <sys/buf.h>
+#include <sys/user.h>
+
+#include "rf_raid.h"
+#include "rf_raidframe.h"
+#include "rf_dag.h"
+#include "rf_dagflags.h"
+#include "rf_diskqueue.h"
+#include "rf_acctrace.h"
+#include "rf_etimer.h"
+#include "rf_general.h"
+#include "rf_debugMem.h"
+#include "rf_kintf.h"
+#include "rf_options.h"
+#include "rf_driver.h"
+#include "rf_parityscan.h"
+#include "rf_debugprint.h"
+#include "rf_threadstuff.h"
+
+int rf_kdebug_level = 0;
+
+#define RFK_BOOT_NONE 0
+#define RFK_BOOT_GOOD 1
+#define RFK_BOOT_BAD  2
+static int rf_kbooted = RFK_BOOT_NONE;
+
+#ifdef RAIDDEBUG
+#define db0_printf(a) printf a
+#define db_printf(a) do if (rf_kdebug_level > 0) printf a; while(0)
+#define db1_printf(a) do if (rf_kdebug_level > 0) printf a; while(0)
+#define db2_printf(a) do if (rf_kdebug_level > 1) printf a; while(0)
+#define db3_printf(a) do if (rf_kdebug_level > 2) printf a; while(0)
+#define db4_printf(a) do if (rf_kdebug_level > 3) printf a; while(0)
+#define db5_printf(a) do if (rf_kdebug_level > 4) printf a; while(0)
+#else /* RAIDDEBUG */
+#define db0_printf(a) printf a
+#define db1_printf(a) (void)0
+#define db2_printf(a) (void)0
+#define db3_printf(a) (void)0
+#define db4_printf(a) (void)0
+#define db5_printf(a) (void)0
+#endif /* RAIDDEBUG */
+
+static RF_Raid_t **raidPtrs; /* global raid device descriptors */
+
+static int rf_pending_testaccs;
+
+RF_DECLARE_STATIC_MUTEX(rf_sparet_wait_mutex)
+RF_DECLARE_STATIC_MUTEX(rf_async_done_q_mutex)
+
+/* requests to install a spare table */
+static RF_SparetWait_t *rf_sparet_wait_queue;
+
+/* responses from installation process */
+static RF_SparetWait_t *rf_sparet_resp_queue;
+static struct rf_test_acc    *rf_async_done_qh, *rf_async_done_qt;
+
+/* used to communicate reconstruction requests */
+static struct rf_recon_req *recon_queue = NULL;
+
+decl_simple_lock_data(,recon_queue_mutex)
+
+#define LOCK_RECON_Q_MUTEX() simple_lock(&recon_queue_mutex)
+#define UNLOCK_RECON_Q_MUTEX() simple_unlock(&recon_queue_mutex)
+
+/* prototypes */
+void	rf_KernelWakeupFunc __P((struct buf *));
+void	rf_InitBP __P((struct buf *, struct vnode *, unsigned, dev_t,
+	    RF_SectorNum_t, RF_SectorCount_t, caddr_t, void (*)(struct buf *),
+	    void *, int, struct proc *));
+
+/* this is so that we can compile under 2.0 as well as 3.2 */
+#ifndef proc_to_task
+#define proc_to_task(x) ((x)->task)
+#endif /* !proc_to_task */
+
+void	raidattach __P((int));
+int	raidsize __P((dev_t));
+
+void	rf_DiskIOComplete(RF_DiskQueue_t *, RF_DiskQueueData_t *, int);
+void	rf_CopybackReconstructedData(RF_Raid_t *raidPtr);
+int	raidinit __P((dev_t,RF_Raid_t *,int));
+
+int	raidopen __P((dev_t, int, int, struct proc *));
+int	raidclose __P((dev_t, int, int, struct proc *));
+int	raidioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
+int	raidwrite __P((dev_t, struct uio *, int));
+int	raidread __P((dev_t, struct uio *, int));
+void	raidstrategy __P((struct buf *));
+int	raiddump __P((dev_t, daddr_t, caddr_t, size_t));
+
+/*
+ * Pilfered from ccd.c
+ */
+struct raidbuf {
+	struct buf	rf_buf;		/* new I/O buf.	 MUST BE FIRST!!! */
+	struct buf	*rf_obp;	/* ptr. to original I/O buf */
+	int		rf_flags;	/* misc. flags */
+	RF_DiskQueueData_t  *req;	/* the request that this was part of.. */
+};
+
+#define RAIDGETBUF() malloc(sizeof (struct raidbuf), M_DEVBUF, M_NOWAIT)
+#define	RAIDPUTBUF(buf) free(buf, M_DEVBUF)
+
+/*
+ * XXX Not sure if the following should be replacing the raidPtrs above,
+ * or if it should be used in conjunction with that...
+ */
+struct raid_softc {
+	int		 sc_unit;		/* logical unit number */
+	int		 sc_flags;		/* flags */
+	int		 sc_cflags;		/* configuration flags */
+	size_t		 sc_size;		/* size of the raid device */
+	dev_t		 sc_dev;		/* our device..*/
+	char		 sc_xname[20];		/* XXX external name */
+	struct disk	 sc_dkdev;		/* generic disk device info */
+};
+
+/* sc_flags */
+#define RAIDF_INITED	0x01	/* unit has been initialized */
+#define RAIDF_WLABEL	0x02	/* label area is writable */
+#define RAIDF_LABELLING	0x04	/* unit is currently being labelled */
+#define RAIDF_WANTED	0x40	/* someone is waiting to obtain a lock */
+#define RAIDF_LOCKED	0x80	/* unit is locked */
+
+#define	raidunit(x)	DISKUNIT(x)
+static int numraid=0;
+
+#define RAIDLABELDEV(dev)	\
+	(MAKEDISKDEV(major((dev)), raidunit((dev)), RAW_PART))
+
+/* declared here, and made public, for the benefit of KVM stuff.. */
+struct raid_softc *raid_softc;
+
+void	raidgetdefaultlabel
+	     __P((RF_Raid_t *, struct raid_softc *, struct disklabel *));
+void	raidgetdisklabel __P((dev_t));
+void	raidmakedisklabel __P((struct raid_softc *));
+
+int	raidlock __P((struct raid_softc *));
+void	raidunlock __P((struct raid_softc *));
+int	raidlookup __P((char *, struct proc *p, struct vnode **));
+
+
+void
+raidattach(num)
+	int num;
+{
+	int raidID;
+
+	db1_printf(("raidattach: Asked for %d units\n", num));
+
+	if (num <= 0) {
+#ifdef DIAGNOSTIC
+		panic("raidattach: count <= 0");
+#endif
+		return;
+	}
+
+	/*
+	 * This is where all the initialization stuff gets done.
+	 */
+
+	/* Make some space for requested number of units... */
+	RF_Calloc(raidPtrs, num, sizeof(RF_Raid_t *), (RF_Raid_t **));
+	if (raidPtrs == NULL) {
+		panic("raidPtrs is NULL!!\n");
+	}
+
+	rf_kbooted = rf_boot();
+	if (rf_kbooted) {
+		panic("Serious error booting RAID!!\n");
+	}
+	
+	rf_kbooted = RFK_BOOT_GOOD;
+
+	/*
+	   put together some datastructures like the CCD device does..
+	   This lets us lock the device and what-not when it gets opened.
+	*/
+	
+	raid_softc = (struct raid_softc *)
+		malloc(num * sizeof(struct raid_softc),
+		       M_DEVBUF, M_NOWAIT);
+	if (raid_softc == NULL) {
+		printf("WARNING: no memory for RAIDframe driver\n");
+		return;
+	}
+	numraid = num;
+	bzero(raid_softc, num * sizeof(struct raid_softc));
+
+	for(raidID=0;raidID < num;raidID++) {
+		RF_Calloc(raidPtrs[raidID], 1, sizeof(RF_Raid_t),
+			  (RF_Raid_t *));
+		if (raidPtrs[raidID]==NULL) {
+			printf("raidPtrs[%d] is NULL\n",raidID);
+		}
+	}
+}
+
+int
+raidsize(dev)
+	dev_t dev;
+{
+	struct raid_softc *rs;
+	struct disklabel *lp;
+	int part, unit, omask, size;
+
+	unit = raidunit(dev);
+	if (unit >= numraid)
+		return (-1);
+	rs = &raid_softc[unit];
+
+	if ((rs->sc_flags & RAIDF_INITED) == 0)
+		return (-1);
+
+	part = DISKPART(dev);
+	omask = rs->sc_dkdev.dk_openmask & (1 << part);
+	lp = rs->sc_dkdev.dk_label;
+
+	if (omask == 0 && raidopen(dev, 0, S_IFBLK, curproc))
+		return (-1);
+
+	if (lp->d_partitions[part].p_fstype != FS_SWAP)
+		size = -1;
+	else
+		size = lp->d_partitions[part].p_size *
+		    (lp->d_secsize / DEV_BSIZE);
+
+	if (omask == 0 && raidclose(dev, 0, S_IFBLK, curproc))
+		return (-1);
+
+	return (size);
+
+}
+
+int
+raiddump(dev, blkno, va, size)
+	dev_t dev;
+	daddr_t blkno;
+	caddr_t va;
+	size_t size;
+{
+	/* Not implemented. */
+	return (ENXIO);
+}
+
+/* ARGSUSED */
+int
+raidopen(dev, flags, fmt, p)
+	dev_t dev;
+	int flags, fmt;
+	struct proc *p;
+{
+	int unit = raidunit(dev);
+	struct raid_softc *rs;
+	struct disklabel *lp;
+	int part,pmask;
+	unsigned int raidID;
+	int rc;
+	int error = 0;
+	
+	/*
+	 * XXX This whole next chunk of code is somewhat suspect... Not sure
+	 * it's needed here at all.
+	 */
+	if (rf_kbooted == RFK_BOOT_NONE) {
+		printf("Doing restart on raidopen.\n");
+		rf_kbooted = RFK_BOOT_GOOD;
+		rc = rf_boot();
+		if (rc) {
+			rf_kbooted = RFK_BOOT_BAD;
+			printf("Someone is unhappy...\n");
+			return (rc);
+		}
+	}
+
+	if (unit >= numraid)
+		return (ENXIO);
+	rs = &raid_softc[unit];
+
+	if ((error = raidlock(rs)) != 0)
+		return (error);
+	lp = rs->sc_dkdev.dk_label;
+
+	raidID = raidunit(dev);
+
+	part = DISKPART(dev);
+	pmask = (1 << part);
+
+	db1_printf(
+	    ("Opening raid device number: %d partition: %d\n", raidID, part));
+
+
+	if ((rs->sc_flags & RAIDF_INITED) && (rs->sc_dkdev.dk_openmask == 0))
+		raidgetdisklabel(dev);
+
+	/* make sure that this partition exists */
+
+	if (part != RAW_PART) {
+		db1_printf(("Not a raw partition..\n"));
+		if (((rs->sc_flags & RAIDF_INITED) == 0) ||
+		    ((part >= lp->d_npartitions) ||
+		    (lp->d_partitions[part].p_fstype == FS_UNUSED))) {
+			error = ENXIO;
+			raidunlock(rs);
+			db1_printf(("Bailing out...\n"));
+			return (error);
+		}
+	}
+
+	/* Prevent this unit from being unconfigured while open. */
+	switch (fmt) {
+	case S_IFCHR:
+		rs->sc_dkdev.dk_copenmask |= pmask;
+		break;
+
+	case S_IFBLK:
+		rs->sc_dkdev.dk_bopenmask |= pmask;
+		break;
+	}
+	rs->sc_dkdev.dk_openmask =
+	    rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
+
+	raidunlock(rs);
+
+	return (error);
+}
+
+/* ARGSUSED */
+int
+raidclose(dev, flags, fmt, p)
+	dev_t dev;
+	int flags, fmt;
+	struct proc *p;
+{
+	int unit = raidunit(dev);
+	struct raid_softc *rs;
+	int error = 0;
+	int part;
+
+	if (unit >= numraid)
+		return (ENXIO);
+	rs = &raid_softc[unit];
+
+	if ((error = raidlock(rs)) != 0)
+		return (error);
+
+	part = DISKPART(dev);
+
+	/* ...that much closer to allowing unconfiguration... */
+	switch (fmt) {
+	case S_IFCHR:
+		rs->sc_dkdev.dk_copenmask &= ~(1 << part);
+		break;
+
+	case S_IFBLK:
+		rs->sc_dkdev.dk_bopenmask &= ~(1 << part);
+		break;
+	}
+	rs->sc_dkdev.dk_openmask =
+	    rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
+
+	raidunlock(rs);
+	return (0);
+}
+
+void
+raidstrategy(bp)
+	struct buf *bp;
+{
+	int s;
+
+	unsigned int raidID = raidunit(bp->b_dev);
+	RF_Raid_t *raidPtr;
+	struct raid_softc *rs = &raid_softc[raidID];
+	struct disklabel *lp;
+	int wlabel;
+
+	db1_printf(("Strategy: 0x%x 0x%x\n", bp, bp->b_data));
+	db1_printf(("Strategy(2): bp->b_bufsize %d\n", (int)bp->b_bufsize));
+	db1_printf(("bp->b_count=%d\n", (int)bp->b_bcount));
+	db1_printf(("bp->b_resid=%d\n", (int)bp->b_resid));
+	db1_printf(("bp->b_blkno=%d\n", (int)bp->b_blkno));
+
+	if (bp->b_flags & B_READ)
+		db1_printf(("READ\n"));
+	else
+		db1_printf(("WRITE\n"));
+
+	if (rf_kbooted != RFK_BOOT_GOOD)
+		return;
+	if (raidID >= numraid || !raidPtrs[raidID]) {
+		bp->b_error = ENODEV;
+		bp->b_flags |= B_ERROR;
+		bp->b_resid = bp->b_bcount;
+		biodone(bp);
+		return;
+	}
+	raidPtr = raidPtrs[raidID];
+	if (!raidPtr->valid) {
+		bp->b_error = ENODEV;
+		bp->b_flags |= B_ERROR;
+		bp->b_resid = bp->b_bcount;
+		biodone(bp);
+		return;
+	}
+	if (bp->b_bcount == 0) {
+		db1_printf(("b_bcount is zero..\n"));
+		biodone(bp);
+		return;
+	}
+	lp = rs->sc_dkdev.dk_label;
+
+	/*
+	 * Do bounds checking and adjust transfer.  If there's an
+	 * error, the bounds check will flag that for us.
+	 */
+	wlabel = rs->sc_flags & (RAIDF_WLABEL|RAIDF_LABELLING);
+	if (DISKPART(bp->b_dev) != RAW_PART)
+		if (bounds_check_with_label(bp, lp, rs->sc_dkdev.dk_cpulabel,
+		    wlabel) <= 0) {
+			db1_printf(("Bounds check failed!!:%d %d\n",
+			       (int)bp->b_blkno, (int)wlabel));
+			biodone(bp);
+			return;
+		}
+
+	/* XXX splbio() needed? */
+	s = splbio();
+	db1_printf(("Beginning strategy...\n"));
+	
+	bp->b_resid = 0;
+	bp->b_error =
+	    rf_DoAccessKernel(raidPtrs[raidID], bp, NULL, NULL, NULL);
+	if (bp->b_error) {
+		bp->b_flags |= B_ERROR;
+		db1_printf(
+		    ("bp->b_flags HAS B_ERROR SET!!!: %d\n", bp->b_error));
+	}
+	splx(s);
+	db1_printf(("Strategy exiting: 0x%x 0x%x %d %d\n", bp, bp->b_data,
+	    (int)bp->b_bcount, (int)bp->b_resid));
+}
+
+/* ARGSUSED */
+int
+raidread(dev, uio, flags)
+	dev_t dev;
+	struct uio *uio;
+	int flags;
+{
+	int unit = raidunit(dev);
+	struct raid_softc *rs;
+	int result;
+	int part;
+
+	if (unit >= numraid)
+		return (ENXIO);
+	rs = &raid_softc[unit];
+
+	if ((rs->sc_flags & RAIDF_INITED) == 0)
+		return (ENXIO);
+	part = DISKPART(dev);
+
+	db1_printf(("raidread: unit: %d partition: %d\n", unit, part));
+
+#if 0
+	return (physio(raidstrategy, NULL, dev, B_READ, minphys, uio));
+#endif
+	result=physio(raidstrategy, NULL, dev, B_READ, minphys, uio);
+	db1_printf(("raidread done.  Result is %d %d\n", result,
+	    uio->uio_resid));
+	return (result);
+}
+
+/* ARGSUSED */
+int
+raidwrite(dev, uio, flags)
+	dev_t dev;
+	struct uio *uio;
+	int flags;
+{
+	int unit = raidunit(dev);
+	struct raid_softc *rs;
+
+	if (unit >= numraid)
+		return (ENXIO);
+	rs = &raid_softc[unit];
+
+	if ((rs->sc_flags & RAIDF_INITED) == 0)
+		return (ENXIO);
+	db1_printf(("raidwrite\n"));
+	return (physio(raidstrategy, NULL, dev, B_WRITE, minphys, uio));
+}
+
+int
+raidioctl(dev, cmd, data, flag, p)
+	dev_t dev;
+	u_long cmd;
+	caddr_t data;
+	int flag;
+	struct proc *p;
+{
+	int unit = raidunit(dev);
+	int error = 0;
+	int part, pmask;
+	struct raid_softc *rs;
+#if 0
+	int r, c;
+#endif
+	/* struct raid_ioctl *ccio = (struct ccd_ioctl *)data; */
+
+	/* struct ccdbuf *cbp; */
+	/* struct raidbuf *raidbp; */
+	RF_Config_t *k_cfg, *u_cfg;
+	u_char *specific_buf;
+	int retcode = 0;
+
+	int row;
+	struct rf_recon_req *rrcopy, *rr;
+#if 0
+	int nbytes, spl, rw, row;
+	struct rf_test_acc *ta;
+	struct buf *bp;
+	RF_SparetWait_t *waitreq;
+	struct rf_test_acc *ta_p, *ta_copy;
+#endif
+
+	if (unit >= numraid)
+		return (ENXIO);
+	rs = &raid_softc[unit];
+
+	db1_printf(("raidioctl: %d %d %d %d\n", (int)dev, (int)DISKPART(dev),
+	    (int)unit, (int)cmd));
+
+	/* Must be open for writes for these commands... */
+	switch (cmd) {
+	case DIOCSDINFO:
+	case DIOCWDINFO:
+	case DIOCWLABEL:
+		if ((flag & FWRITE) == 0)
+			return (EBADF);
+	}
+
+	/* Must be initialized for these... */
+	switch (cmd) {
+	case DIOCGDINFO:
+	case DIOCSDINFO:
+	case DIOCWDINFO:
+	case DIOCGPART:
+	case DIOCWLABEL:
+	case RAIDFRAME_SHUTDOWN:
+	case RAIDFRAME_REWRITEPARITY:
+	case RAIDFRAME_GET_INFO:
+	case RAIDFRAME_RESET_ACCTOTALS:
+	case RAIDFRAME_GET_ACCTOTALS:
+	case RAIDFRAME_KEEP_ACCTOTALS:
+	case RAIDFRAME_GET_SIZE:
+	case RAIDFRAME_FAIL_DISK:
+	case RAIDFRAME_COPYBACK:
+	case RAIDFRAME_CHECKRECON:
+		if ((rs->sc_flags & RAIDF_INITED) == 0)
+			return (ENXIO);
+	}
+	
+	switch (cmd) {
+	case RAIDFRAME_CONFIGURE:
+		/* Configure the system */
+
+		db3_printf(("rf_ioctl: RAIDFRAME_CONFIGURE\n"));
+
+		/*
+		 * 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) {
+			db3_printf((
+			    "rf_ioctl: ENOMEM for config. Code is %d\n",
+			    retcode));
+			return (ENOMEM);
+		}
+		retcode = copyin((caddr_t)u_cfg, (caddr_t)k_cfg,
+		    sizeof (RF_Config_t));
+		if (retcode) {
+			db3_printf(("rf_ioctl: 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 */
+				db3_printf(("rf_ioctl: EINVAL %d\n", retcode));
+				return (EINVAL);
+			}
+			RF_Malloc(specific_buf, k_cfg->layoutSpecificSize,
+			    (u_char *));
+			if (specific_buf == NULL) {
+				RF_Free(k_cfg, sizeof (RF_Config_t));
+				db3_printf(("rf_ioctl: ENOMEM %d\n", retcode));
+				return (ENOMEM);
+			}
+			retcode = copyin(k_cfg->layoutSpecific,
+			    (caddr_t)specific_buf, k_cfg->layoutSpecificSize);
+			if (retcode) {
+				db3_printf(("rf_ioctl: retcode=%d copyin.2\n",
+				    retcode));
+				return (retcode);
+			}
+		} else
+			specific_buf = NULL;
+		k_cfg->layoutSpecific = specific_buf;
+		
+		/*
+		 * We should do some kind of sanity check on the
+		 * configuration.
+		 * Store the sum of all the bytes in the last byte?
+		 */
+
+		db1_printf(("Considering configuring the system.:%d 0x%x\n",
+		    unit, p));
+
+		/*
+		 * We need the pointer to this a little deeper,
+		 * so stash it here...
+		 */
+		raidPtrs[unit]->proc = p;
+
+		/* configure the system */
+		rf_pending_testaccs = 0;
+
+		raidPtrs[unit]->raidid = unit;
+		retcode = rf_Configure(raidPtrs[unit], k_cfg);
+
+		if (retcode == 0) {
+			retcode = raidinit(dev, raidPtrs[unit],unit);
+		}
+
+		/* 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));
+		
+		db3_printf(("rf_ioctl: retcode=%d RAIDFRAME_CONFIGURE\n",
+		    retcode));
+		return (retcode);
+		
+	case RAIDFRAME_SHUTDOWN:
+		/* Shutdown the system */
+		
+		if ((error = raidlock(rs)) != 0)
+			return (error);
+
+		/*
+		 * If somebody has a partition mounted, we shouldn't
+		 * shutdown.
+		 */
+
+		part = DISKPART(dev);
+		pmask = (1 << part);
+		if ((rs->sc_dkdev.dk_openmask & ~pmask) ||
+		    ((rs->sc_dkdev.dk_bopenmask & pmask) &&
+		    (rs->sc_dkdev.dk_copenmask & pmask))) {
+			raidunlock(rs);
+			return (EBUSY);
+		}
+		
+		/*
+		 * The intention here was to disallow shutdowns while
+		 * raidframe is mounted, but it doesn't work because the
+		 * shutdown ioctl calls rf_open.
+		 */
+		if (rf_pending_testaccs > 0) {
+			printf("RAIDFRAME: Can't shutdown because there are "
+			    "%d pending test accs\n",
+			    rf_pending_testaccs);
+			return (EINVAL);
+		}
+		if (rf_debugKernelAccess) {
+			printf("call shutdown\n");
+		}
+		raidPtrs[unit]->proc = p; /* XXX Necessary evil */
+		retcode = rf_Shutdown(raidPtrs[unit]);
+
+		db1_printf(("Done main shutdown\n"));
+
+		/* It's no longer initialized... */
+		rs->sc_flags &= ~RAIDF_INITED;
+
+		/* Detach the disk. */
+		disk_detach(&rs->sc_dkdev);
+
+		raidunlock(rs);
+
+		return (retcode);
+		
+	case RAIDFRAME_REWRITEPARITY:
+		/* initialize all parity */
+
+		if (raidPtrs[unit]->Layout.map->faultsTolerated == 0)
+			return (EINVAL);
+		/* borrow the thread of the requesting process */
+		raidPtrs[unit]->proc = p; /* Blah... :-p GO */
+		retcode = rf_RewriteParity(raidPtrs[unit]);
+		/* return I/O Error if the parity rewrite fails */
+
+		if (retcode)
+			retcode = EIO;		
+		return (retcode);
+
+#if 0 /* XXX not supported yet (ever?) */
+	case RAIDFRAME_TUR:
+		/*
+		 * Issue a test-unit-ready through raidframe to the
+		 * indicated device.
+		 */
+
+		/* debug only */
+		retcode = rf_SCSI_DoTUR(0, 0, 0, 0, *(dev_t *)data);
+		return (retcode);
+#endif
+
+	case RAIDFRAME_GET_INFO:
+		{
+			RF_Raid_t *raid = raidPtrs[unit];
+			RF_DeviceConfig_t *cfg, **ucfgp;
+			int i, j, d;
+			
+			if (!raid->valid)
+				return (ENODEV);
+			ucfgp = (RF_DeviceConfig_t **)data;
+			RF_Malloc(cfg,sizeof(RF_DeviceConfig_t),
+				  (RF_DeviceConfig_t *));
+			if (cfg == NULL)
+				return (ENOMEM);
+			bzero((char *)cfg, sizeof(RF_DeviceConfig_t));
+			cfg->rows = raid->numRow;
+			cfg->cols = raid->numCol;
+			cfg->ndevs = raid->numRow * raid->numCol;
+			if (cfg->ndevs >= RF_MAX_DISKS) {
+				cfg->ndevs = 0;
+				return (ENOMEM);
+			}
+			cfg->nspares = raid->numSpare;
+			if (cfg->nspares >= RF_MAX_DISKS) {
+				cfg->nspares = 0;
+				return (ENOMEM);
+			}
+			cfg->maxqdepth = raid->maxQueueDepth;
+			d = 0;
+			for(i=0;i<cfg->rows;i++) {
+				for(j=0;j<cfg->cols;j++) {
+					cfg->devs[d] = raid->Disks[i][j];
+					d++;
+				}
+			}
+			for(j=cfg->cols,i=0;i<cfg->nspares;i++,j++) {
+				cfg->spares[i] = raid->Disks[0][j];
+			}
+			retcode = copyout((caddr_t)cfg, (caddr_t)*ucfgp,
+					  sizeof(RF_DeviceConfig_t));
+			RF_Free(cfg,sizeof(RF_DeviceConfig_t));
+			
+			return (retcode);
+		}
+	break;
+	
+	case RAIDFRAME_RESET_ACCTOTALS:
+		{
+			RF_Raid_t *raid = raidPtrs[unit];
+			
+			bzero(&raid->acc_totals, sizeof(raid->acc_totals));
+			return (0);
+		}
+	break;
+	
+	case RAIDFRAME_GET_ACCTOTALS:
+		{
+			RF_AccTotals_t *totals = (RF_AccTotals_t *)data;
+			RF_Raid_t *raid = raidPtrs[unit];
+			
+			*totals = raid->acc_totals;
+			return (0);
+		}
+	break;
+	
+	case RAIDFRAME_KEEP_ACCTOTALS:
+		{
+			RF_Raid_t *raid = raidPtrs[unit];
+			int *keep = (int *)data;
+			
+			raid->keep_acc_totals = *keep;
+			return (0);
+		}
+	break;
+	
+	case RAIDFRAME_GET_SIZE:
+		*(int *) data = raidPtrs[unit]->totalSectors;
+		return (0);
+
+#define RAIDFRAME_RECON 1
+		/* XXX The above should probably be set somewhere else!! GO */
+#if RAIDFRAME_RECON > 0
+
+		/* fail a disk & optionally start reconstruction */
+	case RAIDFRAME_FAIL_DISK:
+		rr = (struct rf_recon_req *) data;
+		
+		if (rr->row < 0 || rr->row >= raidPtrs[unit]->numRow
+		    || rr->col < 0 || rr->col >= raidPtrs[unit]->numCol)
+			return (EINVAL);
+
+		printf("Failing the disk: row: %d col: %d\n",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 *));
+		bcopy(rr, rrcopy, sizeof(*rr));
+		rrcopy->raidPtr = (void *) raidPtrs[unit];
+
+		LOCK_RECON_Q_MUTEX();
+		rrcopy->next = recon_queue;
+		recon_queue = rrcopy;
+		wakeup(&recon_queue);
+		UNLOCK_RECON_Q_MUTEX();
+		
+		return (0);
+		
+		/*
+		 * Invoke a copyback operation after recon on whatever
+		 * disk needs it, if any.
+		 */
+	case RAIDFRAME_COPYBACK:		
+		/* Borrow the current thread to get this done */
+		raidPtrs[unit]->proc = p; /* ICK.. but needed :-p  GO */
+		rf_CopybackReconstructedData(raidPtrs[unit]);
+		return (0);
+		
+		/* Return the percentage completion of reconstruction */
+	case RAIDFRAME_CHECKRECON:
+		row = *(int *)data;
+		if (row < 0 || row >= raidPtrs[unit]->numRow)
+			return (EINVAL);
+		if (raidPtrs[unit]->status[row] != rf_rs_reconstructing)
+			*(int *)data = 100;
+		else
+			*(int *)data =
+			    raidPtrs[unit]->reconControl[row]->percentComplete;
+		return (0);
+		
+#if 0
+	case RAIDFRAME_SPARET_WAIT:
+		/*
+		 * 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
+		 */
+		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);
+		
+		*((RF_SparetWait_t *)data) = *waitreq;
+		
+		RF_Free(waitreq, sizeof *waitreq);
+		return (0);
+		
+	case RAIDFRAME_ABORT_SPARET_WAIT:
+		/*
+		 * Wakes up a process waiting on SPARET_WAIT and puts an
+		 * error code in it that will cause the dameon to exit.
+		 */
+		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);
+
+	case RAIDFRAME_SEND_SPARET:
+		/*
+		 * Used by the spare table daemon to deliver a spare table
+		 * into the kernel
+		 */
+		
+		/* Install the spare table */
+		retcode = rf_SetSpareTable(raidPtrs[unit],*(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
+#endif	 /* RAIDFRAME_RECON > 0 */
+
+	default:
+		/* fall through to the os-specific code below */
+		break;
+	}
+	
+	if (!raidPtrs[unit]->valid)
+		return (EINVAL);
+	
+	/*
+	 * Add support for "regular" device ioctls here.
+	 */
+	switch (cmd) {
+	case DIOCGDINFO:
+		db1_printf(
+		    ("DIOCGDINFO %d %d\n", (int)dev, (int)DISKPART(dev)));
+		*(struct disklabel *)data = *(rs->sc_dkdev.dk_label);
+		break;
+
+	case DIOCGPART:
+		db1_printf(
+		    ("DIOCGPART: %d %d\n", (int)dev, (int)DISKPART(dev)));
+		((struct partinfo *)data)->disklab = rs->sc_dkdev.dk_label;
+		((struct partinfo *)data)->part =
+		    &rs->sc_dkdev.dk_label->d_partitions[DISKPART(dev)];
+		break;
+
+	case DIOCWDINFO:
+		db1_printf(("DIOCWDINFO\n"));
+	case DIOCSDINFO:
+		db1_printf(("DIOCSDINFO\n"));
+		if ((error = raidlock(rs)) != 0)
+			return (error);
+
+		rs->sc_flags |= RAIDF_LABELLING;
+
+		error = setdisklabel(rs->sc_dkdev.dk_label,
+		    (struct disklabel *)data, 0, rs->sc_dkdev.dk_cpulabel);
+		if (error == 0) {
+			if (cmd == DIOCWDINFO)
+				error = writedisklabel(RAIDLABELDEV(dev),
+				    raidstrategy, rs->sc_dkdev.dk_label,
+				    rs->sc_dkdev.dk_cpulabel);
+		}
+
+		rs->sc_flags &= ~RAIDF_LABELLING;
+
+		raidunlock(rs);
+
+		if (error)
+			return (error);
+		break;
+
+	case DIOCWLABEL:
+		db1_printf(("DIOCWLABEL\n"));
+		if (*(int *)data != 0)
+			rs->sc_flags |= RAIDF_WLABEL;
+		else
+			rs->sc_flags &= ~RAIDF_WLABEL;
+		break;
+
+	default:
+		retcode = ENOTTY; /* XXXX ?? OR EINVAL ? */
+	}
+	return (retcode);
+}
+
+/*
+ * raidinit -- complete the rest of the initialization for the
+ * RAIDframe device.
+ */
+int
+raidinit(dev, raidPtr, unit)
+	dev_t dev;
+	RF_Raid_t *raidPtr;
+	int unit;
+{
+	int retcode;
+	/*	int ix; */
+	/*	struct raidbuf *raidbp; */
+	struct raid_softc *rs;
+
+	retcode = 0;
+
+	rs = &raid_softc[unit];
+	
+	/* XXX should check return code first... */
+	rs->sc_flags |= RAIDF_INITED;
+
+	/* XXX doesn't check bounds.*/
+	sprintf(rs->sc_xname, "raid%d", unit);
+
+	rs->sc_dkdev.dk_name = rs->sc_xname;	
+
+	/*
+	 * disk_attach actually creates space for the CPU disklabel, among
+	 * other things, so it's critical to call this *BEFORE* we
+	 * try putzing with disklabels.
+	 */
+	disk_attach(&rs->sc_dkdev);
+
+	/*
+	 * XXX There may be a weird interaction here between this, and
+	 * protectedSectors, as used in RAIDframe.
+	 */
+	rs->sc_size = raidPtr->totalSectors;
+	rs->sc_dev = dev;
+	return (retcode);
+}
+
+/*********************************************************
+ *
+ * initialization code called at boot time (startup.c)
+ *
+ ********************************************************/
+int
+rf_boot()
+{
+	int i, rc;
+
+	rc = rf_mutex_init(&rf_sparet_wait_mutex);
+	if (rc) {
+		RF_PANIC();
+	}
+	rc = rf_mutex_init(&rf_async_done_q_mutex);
+	if (rc) {
+		RF_PANIC();
+	}
+	rf_sparet_wait_queue = rf_sparet_resp_queue = NULL;
+	recon_queue = NULL;
+	rf_async_done_qh = rf_async_done_qt = NULL;
+	for (i=0; i<numraid; i++)
+		raidPtrs[i] = NULL;
+	rc = rf_BootRaidframe();
+	if (rc == 0)
+		printf("Kernelized RAIDframe activated\n");
+	else
+		rf_kbooted = RFK_BOOT_BAD;
+	return (rc);
+}
+
+/*
+ * This kernel thread never exits.  It is created once, and persists
+ * until the system reboots.
+ */
+void
+rf_ReconKernelThread()
+{
+	struct rf_recon_req *req;
+	int s;
+
+	/*
+	 * XXX not sure what spl() level we should be at here...
+	 * probably splbio()
+	 */
+	s = splbio();
+
+	while (1) {
+		/* grab the next reconstruction request from the queue */
+		LOCK_RECON_Q_MUTEX();
+		while (!recon_queue) {
+		  UNLOCK_RECON_Q_MUTEX();
+		  tsleep(&recon_queue, PRIBIO | PCATCH, "raidframe recon", 0);
+		  LOCK_RECON_Q_MUTEX();
+		}
+		req = recon_queue;
+		recon_queue = recon_queue->next;
+		UNLOCK_RECON_Q_MUTEX();
+
+		/*
+		 * If flags specifies that we should start recon, this call
+		 * will not return until reconstruction completes, fails, or
+		 * is aborted.
+		 */
+		rf_FailDisk((RF_Raid_t *) req->raidPtr, req->row, req->col,
+		    ((req->flags&RF_FDFLAGS_RECON) ? 1 : 0));
+
+		RF_Free(req, sizeof(*req));
+	}
+}
+
+/*
+ * 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
+ */
+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 | PCATCH,
+		    "raidframe getsparetable", 0);
+#if 0
+		mpsleep(&rf_sparet_resp_queue, PZERO, "sparet resp", 0,
+		    (void *) simple_lock_addr(rf_sparet_wait_mutex),
+		    MS_LOCK_SIMPLE);
+#endif
+	}
+	req = rf_sparet_resp_queue;
+	rf_sparet_resp_queue = req->next;
+	RF_UNLOCK_MUTEX(rf_sparet_wait_mutex);
+
+	retcode = req->fcol;
+	/* this is not the same req as we alloc'd */
+	RF_Free(req, sizeof(*req));
+	return (retcode);
+}
+
+/*
+ * A wrapper around rf_DoAccess that extracts appropriate info from the
+ * bp & passes it down.
+ * Any calls originating in the kernel must use non-blocking I/O
+ * do some extra sanity checking to return "appropriate" error values for
+ * certain conditions (to make some standard utilities work)
+ */
+int
+rf_DoAccessKernel(raidPtr, bp, flags, cbFunc, cbArg)
+	RF_Raid_t	       *raidPtr;
+	struct buf	       *bp;
+	RF_RaidAccessFlags_t	flags;
+	void		      (*cbFunc)(struct buf *);
+	void		       *cbArg;
+{
+	RF_SectorCount_t num_blocks, pb, sum;
+	RF_RaidAddr_t raid_addr;
+	int retcode;
+	struct partition *pp;
+	daddr_t blocknum;	
+	int unit;
+	struct raid_softc *rs;
+
+	/* XXX The dev_t used here should be for /dev/[r]raid* !!! */
+
+	unit = raidPtr->raidid;
+	rs = &raid_softc[unit];
+
+	/*
+	 * 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->b_blkno;
+	if (DISKPART(bp->b_dev) != RAW_PART) {
+		pp = &rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)];
+		blocknum += pp->p_offset;
+		db1_printf(
+		    ("updated: %d %d\n", DISKPART(bp->b_dev), pp->p_offset));
+	} else {
+		db1_printf(("Is raw..\n"));
+	}
+	db1_printf(("Blocks: %d, %d\n", (int)bp->b_blkno, (int)blocknum));
+	db1_printf(("bp->b_bcount = %d\n", (int)bp->b_bcount));
+	db1_printf(("bp->b_resid = %d\n", (int)bp->b_resid));
+
+	/*
+	 * *THIS* is where we adjust what block we're going to... but
+	 * DO NOT TOUCH bp->b_blkno!!!
+	 */
+	raid_addr = blocknum;
+	
+	num_blocks = bp->b_bcount >> raidPtr->logBytesPerSector;
+	pb = (bp->b_bcount&raidPtr->sectorMask) ? 1 : 0;
+	sum = raid_addr + num_blocks + pb;
+	if (1 || rf_debugKernelAccess) {
+		db1_printf(("raid_addr=%d sum=%d num_blocks=%d(+%d) (%d)\n",
+		    (int)raid_addr, (int)sum, (int)num_blocks, (int)pb,
+		    (int)bp->b_resid));
+	}
+	
+
+	if ((sum > raidPtr->totalSectors) || (sum < raid_addr) ||
+	    (sum < num_blocks) || (sum < pb)) {
+		bp->b_error = ENOSPC;
+		bp->b_flags |= B_ERROR;
+		bp->b_resid = bp->b_bcount;
+		biodone(bp);
+		return (bp->b_error);
+	}
+
+	/*
+	 * XXX rf_DoAccess() should do this, not just DoAccessKernel()
+	 */
+	if (bp->b_bcount & raidPtr->sectorMask) {
+		bp->b_error = EINVAL;
+		bp->b_flags |= B_ERROR;
+		bp->b_resid = bp->b_bcount;
+		biodone(bp);
+		return (bp->b_error);
+	}
+	db1_printf(("Calling DoAccess..\n"));
+
+	/*
+	 * Don't ever condition on bp->b_flags & B_WRITE.
+	 * always condition on B_READ instead.
+	 */
+	retcode = rf_DoAccess(raidPtr,
+	    (bp->b_flags & B_READ) ? RF_IO_TYPE_READ : RF_IO_TYPE_WRITE,
+	    0, raid_addr, num_blocks, bp->b_un.b_addr, bp, NULL, NULL,
+	    RF_DAG_NONBLOCKING_IO|flags, NULL, cbFunc, cbArg);
+	db1_printf(("After call to DoAccess: 0x%x 0x%x %d\n", bp, bp->b_data,
+	    (int)bp->b_resid));
+	return (retcode);
+}
+
+/* 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) ? B_READ : B_WRITE;
+	struct buf *bp;
+	struct raidbuf *raidbp = NULL;
+	struct raid_softc *rs;
+	int unit;
+	
+	/*
+	 * XXX along with the vnode, we also need the softc associated with
+	 * this device..
+	 */
+	req->queue = queue;
+	
+	unit = queue->raidPtr->raidid;
+
+	db1_printf(("DispatchKernelIO unit: %d\n", unit));
+
+	if (unit >= numraid) {
+		printf("Invalid unit number: %d %d\n", unit, numraid);
+		panic("Invalid Unit number in rf_DispatchKernelIO\n");
+	}
+
+	rs = &raid_softc[unit];
+
+	/* XXX is this the right place? */
+	disk_busy(&rs->sc_dkdev);
+
+	bp = req->bp;
+
+	/*
+	 * 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->b_flags & B_ERROR) {
+		bp->b_flags &= ~B_ERROR;
+	}
+	if (bp->b_error!=0) {
+		bp->b_error = 0;
+	}
+
+	raidbp = RAIDGETBUF();
+
+	raidbp->rf_flags = 0; /* XXX not really used anywhere... */
+
+	/*
+	 * context for raidiodone
+	 */
+	raidbp->rf_obp = bp;
+	raidbp->req = req;
+
+	switch (req->type) {
+	case RF_IO_TYPE_NOP:
+		/* Used primarily to unlock a locked queue. */
+
+		db1_printf(("rf_DispatchKernelIO: NOP to r %d c %d\n",
+		    queue->row, queue->col));
+
+		/* 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
+		 */
+		printf(("WAKEUP CALLED\n"));
+		queue->numOutstanding++;
+
+		/* XXX need to glue the original buffer into this??  */
+
+		rf_KernelWakeupFunc(&raidbp->rf_buf);
+		break;
+		
+	case RF_IO_TYPE_READ:
+	case RF_IO_TYPE_WRITE:
+		if (req->tracerec) {
+			RF_ETIMER_START(req->tracerec->timer);
+		}
+
+		rf_InitBP(&raidbp->rf_buf, queue->rf_cinfo->ci_vp,
+		    op | bp->b_flags, queue->rf_cinfo->ci_dev,
+		    req->sectorOffset, req->numSector,
+		    req->buf, rf_KernelWakeupFunc, (void *)req,	
+		    queue->raidPtr->logBytesPerSector, req->b_proc);
+
+		if (rf_debugKernelAccess) {
+			db1_printf(("dispatch: bp->b_blkno = %ld\n",
+			    (long)bp->b_blkno));
+		}
+		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;
+
+		db1_printf(("Going for %c to unit %d row %d col %d\n",
+		    req->type, unit, queue->row, queue->col));
+		db1_printf(("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 ((raidbp->rf_buf.b_flags & B_READ) == 0) {
+			raidbp->rf_buf.b_vp->v_numoutput++;
+		}
+
+		VOP_STRATEGY(&raidbp->rf_buf);
+		break;
+		
+	default:
+		panic("bad req->type in rf_DispatchKernelIO");
+	}
+	db1_printf(("Exiting from DispatchKernelIO\n"));
+	return (0);
+}
+
+/*
+ * This is the callback function associated with a I/O invoked from
+ * kernel code.
+ */
+void
+rf_KernelWakeupFunc(vbp)
+	struct buf *vbp;
+{
+	RF_DiskQueueData_t *req = NULL;
+	RF_DiskQueue_t *queue;
+	struct raidbuf *raidbp = (struct raidbuf *)vbp;
+	struct buf *bp;
+	struct raid_softc *rs;
+	int unit;
+	int s;
+
+	s = splbio(); /* XXX */
+	db1_printf(("recovering the request queue:\n"));
+	req = raidbp->req;
+
+	bp = raidbp->rf_obp;
+	db1_printf(("bp=0x%x\n", bp));
+
+	queue = (RF_DiskQueue_t *)req->queue;
+
+	if (raidbp->rf_buf.b_flags & B_ERROR) {
+		db1_printf(
+		    ("Setting bp->b_flags!!! %d\n", raidbp->rf_buf.b_error));
+		bp->b_flags |= B_ERROR;
+		bp->b_error =
+		    raidbp->rf_buf.b_error ? raidbp->rf_buf.b_error : EIO;
+	}
+
+	db1_printf(("raidbp->rf_buf.b_bcount=%d\n",
+	    (int)raidbp->rf_buf.b_bcount));
+	db1_printf(("raidbp->rf_buf.b_bufsize=%d\n",
+	    (int)raidbp->rf_buf.b_bufsize));
+	db1_printf(("raidbp->rf_buf.b_resid=%d\n",
+	    (int)raidbp->rf_buf.b_resid));
+	db1_printf(("raidbp->rf_buf.b_data=0x%x\n", raidbp->rf_buf.b_data));
+
+#if 1
+	/* XXX Methinks this could be wrong... */
+	bp->b_resid = raidbp->rf_buf.b_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->b_bcount = raidbp->rf_buf.b_bcount;/* XXXX ?? */
+
+	unit = queue->raidPtr->raidid; /* *Much* simpler :-> */
+
+#if 1
+	/*
+	 * XXX Ok, let's get aggressive... If B_ERROR is set, let's go
+	 * ballistic, and mark the component as hosed...
+	 */
+	if (bp->b_flags & B_ERROR) {
+		/* Mark the disk as dead but only mark it once... */
+		if (queue->raidPtr->Disks[queue->row][queue->col].status ==
+		    rf_ds_optimal) {
+			printf("raid%d: IO Error.  Marking %s as failed.\n",
+			    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++;
+		} else {
+			/* Disk is already dead... */
+			/* printf("Disk already marked as dead!\n"); */
+		}
+	}
+#endif
+
+	rs = &raid_softc[unit];
+	RAIDPUTBUF(raidbp);
+
+	if (bp->b_resid==0) {
+		db1_printf((
+		    "Disk is no longer busy for this buffer... %d %ld %ld\n",
+		    unit, bp->b_resid, bp->b_bcount));
+		/* XXX is this the right place for a disk_unbusy()??!??!?!? */
+		disk_unbusy(&rs->sc_dkdev, (bp->b_bcount - bp->b_resid));
+	} else {
+		db1_printf(("b_resid is still %ld\n", bp->b_resid));
+	}
+
+	rf_DiskIOComplete(queue, req, (bp->b_flags & B_ERROR) ? 1 : 0);
+	(req->CompleteFunc)(req->argument, (bp->b_flags & B_ERROR) ? 1 : 0);
+	/* printf("Exiting rf_KernelWakeupFunc\n"); */
+
+	splx(s); /* XXX */
+}
+
+/*
+ * Initialize a buf structure for doing an I/O in the kernel.
+ */
+void
+rf_InitBP(bp, b_vp, rw_flag, dev, startSect, numSect, buf, cbFunc, cbArg,
+    logBytesPerSector, b_proc)
+	struct buf *bp;
+	struct vnode *b_vp;
+	unsigned rw_flag;
+	dev_t dev;
+	RF_SectorNum_t startSect;
+	RF_SectorCount_t numSect;
+	caddr_t buf;
+	void (*cbFunc)(struct buf *);
+	void *cbArg;
+	int logBytesPerSector;
+	struct proc *b_proc;
+{
+	/* bp->b_flags = B_PHYS | rw_flag; */
+	bp->b_flags = B_CALL | rw_flag; /* XXX need B_PHYS here too??? */
+	bp->b_bcount = numSect << logBytesPerSector;
+	bp->b_bufsize = bp->b_bcount;
+	bp->b_error = 0;
+	bp->b_dev = dev;
+	db1_printf(("bp->b_dev is %d\n", dev));
+	bp->b_un.b_addr = buf;
+	db1_printf(("bp->b_data=0x%x\n", bp->b_data));
+
+	bp->b_blkno = startSect;
+	bp->b_resid = bp->b_bcount; /* XXX is this right!??!?!! */
+	db1_printf(("b_bcount is: %d\n", (int)bp->b_bcount));
+	if (bp->b_bcount == 0) {
+		panic("bp->b_bcount is zero in rf_InitBP!!\n");
+	}
+	bp->b_proc = b_proc;
+	bp->b_iodone = cbFunc;
+	bp->b_vp = b_vp;
+}
+#endif /* KERNEL */
+
+/* Extras... */
+
+unsigned int
+rpcc()
+{
+	/* XXX no clue what this is supposed to do.. my guess is
+	   that it's supposed to read the CPU cycle counter... */
+	/*	db1_printf("this is supposed to do something useful too!??\n"); */
+	return (0);
+}
+
+#if 0
+int
+rf_GetSpareTableFromDaemon(req)
+	RF_SparetWait_t	 *req;
+{
+	int retcode=1;
+	printf("This is supposed to do something useful!!\n"); /* XXX */
+
+	return (retcode);
+}
+#endif
+
+void
+raidgetdefaultlabel(raidPtr, rs, lp)
+	RF_Raid_t *raidPtr;
+	struct raid_softc *rs;
+	struct disklabel *lp;
+{
+	db1_printf(("Building a default label...\n"));
+	bzero(lp, sizeof(*lp));
+
+	/* fabricate a label... */
+	lp->d_secperunit = raidPtr->totalSectors;
+	lp->d_secsize = raidPtr->bytesPerSector;
+	lp->d_nsectors = 1024 * (1024 / raidPtr->bytesPerSector);
+	lp->d_ntracks = 1;
+	lp->d_ncylinders = raidPtr->totalSectors / lp->d_nsectors;
+	lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
+
+	strncpy(lp->d_typename, "raid", sizeof(lp->d_typename));
+	lp->d_type = DTYPE_RAID;
+	strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
+	lp->d_rpm = 3600;
+	lp->d_interleave = 1;
+	lp->d_flags = 0;
+
+	lp->d_partitions[RAW_PART].p_offset = 0;
+	lp->d_partitions[RAW_PART].p_size = raidPtr->totalSectors;
+	lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
+	lp->d_npartitions = RAW_PART + 1;
+
+	lp->d_magic = DISKMAGIC;
+	lp->d_magic2 = DISKMAGIC;
+	lp->d_checksum = dkcksum(rs->sc_dkdev.dk_label);
+
+}
+
+/*
+ * Read the disklabel from the raid device.  If one is not present, fake one
+ * up.
+ */
+void
+raidgetdisklabel(dev)
+	dev_t dev;
+{
+	int unit = raidunit(dev);
+	struct raid_softc *rs = &raid_softc[unit];
+	char *errstring;
+	struct disklabel *lp = rs->sc_dkdev.dk_label;
+	struct cpu_disklabel *clp = rs->sc_dkdev.dk_cpulabel;
+	RF_Raid_t *raidPtr;
+
+	db1_printf(("Getting the disklabel...\n"));
+
+	bzero(clp, sizeof(*clp));
+
+	raidPtr = raidPtrs[unit];
+
+	raidgetdefaultlabel(raidPtr, rs, lp);
+
+	/*
+	 * Call the generic disklabel extraction routine.
+	 */
+	errstring = readdisklabel(RAIDLABELDEV(dev), raidstrategy,
+	    rs->sc_dkdev.dk_label, rs->sc_dkdev.dk_cpulabel, 0);
+	if (errstring)
+		raidmakedisklabel(rs);
+	else {
+		int i;
+		struct partition *pp;
+
+		/*
+		 * Sanity check whether the found disklabel is valid.
+		 *
+		 * This is necessary since total size of the raid device
+		 * may vary when an interleave is changed even though exactly
+		 * same componets are used, and old disklabel may used
+		 * if that is found.
+		 */
+		if (lp->d_secperunit != rs->sc_size)
+			printf("WARNING: %s: "
+			    "total sector size in disklabel (%d) != "
+			    "the size of raid (%d)\n", rs->sc_xname,
+			    lp->d_secperunit, rs->sc_size);
+		for (i = 0; i < lp->d_npartitions; i++) {
+			pp = &lp->d_partitions[i];
+			if (pp->p_offset + pp->p_size > rs->sc_size)
+				printf("WARNING: %s: end of partition `%c' "
+				    "exceeds the size of raid (%d)\n",
+				    rs->sc_xname, 'a' + i, rs->sc_size);
+		}
+	}
+}
+
+/*
+ * Take care of things one might want to take care of in the event
+ * that a disklabel isn't present.
+ */
+void
+raidmakedisklabel(rs)
+	struct raid_softc *rs;
+{
+	struct disklabel *lp = rs->sc_dkdev.dk_label;
+	db1_printf(("Making a label..\n"));
+
+	/*
+	 * For historical reasons, if there's no disklabel present
+	 * the raw partition must be marked FS_BSDFFS.
+	 */
+
+	lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS;
+
+	strncpy(lp->d_packname, "default label", sizeof(lp->d_packname));
+
+	lp->d_checksum = dkcksum(lp);
+}
+
+/*
+ * 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, p, vpp)
+	char *path;
+	struct proc *p;
+	struct vnode **vpp;	/* result */
+{
+	struct nameidata nd;
+	struct vnode *vp;
+	struct vattr va;
+	int error;
+
+	NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, p);
+	if ((error = vn_open(&nd, FREAD|FWRITE, 0)) != 0) {
+		db1_printf(("RAIDframe: vn_open returned %d\n", error));
+		return (error);
+	}
+	vp = nd.ni_vp;
+	if (vp->v_usecount > 1) {
+		VOP_UNLOCK(vp, 0, p);
+		(void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
+		return (EBUSY);
+	}
+	if ((error = VOP_GETATTR(vp, &va, p->p_ucred, p)) != 0) {
+		VOP_UNLOCK(vp, 0, p);
+		(void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
+		return (error);
+	}
+	/* XXX: eventually we should handle VREG, too. */
+	if (va.va_type != VBLK) {
+		VOP_UNLOCK(vp, 0, p);
+		(void)vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
+		return (ENOTBLK);
+	}
+	VOP_UNLOCK(vp, 0, p);
+	*vpp = vp;
+	return (0);
+}
+
+/*
+ * 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 )
+ */
+int
+raidlock(rs)
+	struct raid_softc *rs;
+{
+	int error;
+
+	while ((rs->sc_flags & RAIDF_LOCKED) != 0) {
+		rs->sc_flags |= RAIDF_WANTED;
+		if ((error = tsleep(rs, PRIBIO | PCATCH, "raidlck", 0)) != 0)
+			return (error);
+	}
+	rs->sc_flags |= RAIDF_LOCKED;
+	return (0);
+}
+
+/*
+ * Unlock and wake up any waiters.
+ */
+void
+raidunlock(rs)
+	struct raid_softc *rs;
+{
+	rs->sc_flags &= ~RAIDF_LOCKED;
+	if ((rs->sc_flags & RAIDF_WANTED) != 0) {
+		rs->sc_flags &= ~RAIDF_WANTED;
+		wakeup(rs);
+	}
+}