If I've done this right, revive the vinum code in it's now home after it

was savaged in the blood bath a few hours ago.

23 files changed, 8492 insertions, 0 deletions

diff --git a/sys/dev/vinum/COPYRIGHT b/sys/dev/vinum/COPYRIGHT
new file mode 100644
index 0000000..ed43ff1
--- /dev/null
+++ b/sys/dev/vinum/COPYRIGHT
@@ -0,0 +1,37 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: COPYRIGHT,v 1.1.1.1 1998/09/16 05:56:21 grog Exp $
+ */
diff --git a/sys/dev/vinum/Makefile b/sys/dev/vinum/Makefile
new file mode 100644
index 0000000..28e6429
--- /dev/null
+++ b/sys/dev/vinum/Makefile
@@ -0,0 +1,26 @@
+#       $Id: Makefile,v 1.2 1998/09/28 04:21:20 grog Exp $ 
+
+.PATH:  ${.CURDIR}/../../sys/dev/ccd
+KMOD=   vinum_mod
+SRCS=   vinum.c vinum.h vnode_if.h parser.c config.c io.c util.c vinumhdr.h request.h \
+	state.c memory.c request.c lock.c vinumext.h vinumio.h vinumkw.h \
+	vinumstate.h vinumvar.h revive.c vinumioctl.c interrupt.c
+NOMAN=
+PSEUDO_LKM=
+CFLAGS = -I${.CURDIR} -O -g -I/usr/include/machine -DDEBUG -Wall -Wno-unused -Wno-parentheses
+
+CLEANFILES+=    vinum.h vnode_if.h vnode_if.c
+
+all:
+
+# We don't need this, but the Makefile wants it
+vinum.h:
+	touch $@
+
+state.h:  maketabs vinumstate.h
+	./maketabs >state.h
+
+maketabs: maketabs.c
+	${CC} -g -o maketabs maketabs.c
+
+.include <bsd.kmod.mk>
diff --git a/sys/dev/vinum/makestatetext b/sys/dev/vinum/makestatetext
new file mode 100755
index 0000000..3c39dd0
--- /dev/null
+++ b/sys/dev/vinum/makestatetext
@@ -0,0 +1,40 @@
+#!/bin/sh
+# Make statetexts.h from vinumstate.h
+# $Id: makestatetext,v 1.1.1.1 1998/09/16 05:56:21 grog Exp $
+infile=vinumstate.h
+ofile=statetexts.h
+cat <COPYRIGHT > $ofile
+
+echo >>$ofile "/* Created by $0 on" `date`.  "Do not edit */"
+echo >>$ofile
+echo >>$ofile "/* Drive state texts */"
+echo >>$ofile "char *drivestatetext [] = 
+  { "
+egrep  -e 'drive_[A-z0-9]*,'  <$infile | grep -v = | sed 's: *drive_\([^,]*\).*:  \"\1\",:' >>$ofile
+cat <<FOO >> $ofile
+  };
+
+/* Subdisk state texts */
+char *sdstatetext [] =
+  { 
+FOO
+egrep  -e 'sd_[A-z0-9]*,' $infile | grep -v = | sed 's: *sd_\([^,]*\).*:  \"\1\",:' >>$ofile
+cat <<FOO >> $ofile
+  };
+
+/* Plex state texts */
+char *plexstatetext [] =
+  { 
+FOO
+egrep  -e 'plex_[A-z0-9]*,' $infile | grep -v = | sed 's: *plex_\([^,]*\).*:  \"\1\",:' >>$ofile
+cat <<FOO >> $ofile
+  };
+
+/* Volume state texts */
+char *volstatetext [] =
+  { 
+FOO
+egrep  -e 'volume_[A-z0-9]*,' $infile | grep -v = | sed 's: *volume_\([^,]*\).*:  \"\1\",:' >>$ofile
+cat <<FOO >> $ofile
+  };
+FOO
diff --git a/sys/dev/vinum/request.h b/sys/dev/vinum/request.h
new file mode 100644
index 0000000..81fafd2
--- /dev/null
+++ b/sys/dev/vinum/request.h
@@ -0,0 +1,191 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: request.h,v 1.2 1998/10/21 08:32:32 grog Exp $
+ */
+
+/* Information needed to set up a transfer */
+
+/* struct buf is surprisingly big (about 300
+ * bytes), and it's part of the request, so this
+ * value is really important.  Most requests
+ * don't need more than 2 subrequests per
+ * plex. The table is automatically extended if
+ * this value is too small. */
+#define RQELTS 2					    /* default of 2 requests per transfer */
+
+enum xferinfo {
+    XFR_NORMAL_READ = 1,
+    XFR_NORMAL_WRITE = 2,				    /* write request in normal mode */
+    XFR_RECOVERY_READ = 4,
+    XFR_DEGRADED_WRITE = 8,
+    XFR_PARITYLESS_WRITE = 0x10,
+    XFR_NO_PARITY_STRIPE = 0x20,			    /* parity stripe is not available */
+    XFR_DATA_BLOCK = 0x40,				    /* data block in request */
+    XFR_PARITY_BLOCK = 0x80,				    /* parity block in request */
+    XFR_BAD_SUBDISK = 0x100,				    /* this subdisk is dead */
+    XFR_MALLOCED = 0x200,				    /* this buffer is malloced */
+#if DEBUG
+    XFR_PHASE2 = 0x800,					    /* documentation only: 2nd phase write */
+#endif
+    XFR_REVIVECONFLICT = 0x1000,			    /* possible conflict with a revive operation */
+    /* operations that need a parity block */
+    XFR_PARITYOP = (XFR_NORMAL_WRITE | XFR_RECOVERY_READ | XFR_DEGRADED_WRITE),
+    /* operations that use the group parameters */
+    XFR_GROUPOP = (XFR_DEGRADED_WRITE | XFR_RECOVERY_READ),
+    /* operations that that use the data parameters */
+    XFR_DATAOP = (XFR_NORMAL_READ | XFR_NORMAL_WRITE | XFR_PARITYLESS_WRITE),
+    /* operations requiring read before write */
+    XFR_RBW = (XFR_NORMAL_WRITE | XFR_DEGRADED_WRITE),
+    /* operations that need a malloced buffer */
+    XFR_NEEDS_MALLOC = (XFR_NORMAL_WRITE | XFR_RECOVERY_READ | XFR_DEGRADED_WRITE)
+};
+
+/* Describe one low-level request, part
+ * of a high-level request.  This is an
+ * extended struct buf buffer, and the first
+ * element *must* be a struct buf.  We pass this structure
+ * to the I/O routines instead of a struct buf in oder
+ * to be able to locate the high-level request when it
+ * completes.
+ *
+ * All offsets and lengths are in "blocks", i.e. sectors */
+struct rqelement {
+    struct buf b;					    /* buf structure */
+    struct rqgroup *rqg;				    /* pointer to our group */
+    /* Information about the transfer */
+    daddr_t sdoffset;					    /* offset in subdisk */
+    int useroffset;					    /* offset in user buffer of normal data */
+    /* dataoffset and datalen refer to "individual"
+     * data transfers (normal read, parityless write)
+     * and also degraded write.
+     *
+     * groupoffset and grouplen refer to the other
+     * "group" operations (normal write, recovery read)
+     * Both the offsets are relative to the start of the
+     * local buffer */
+    int dataoffset;					    /* offset in buffer of the normal data */
+    int groupoffset;					    /* offset in buffer of group data */
+    short datalen;					    /* length of normal data (sectors) */
+    short grouplen;					    /* length of group data (sectors) */
+    short buflen;					    /* total buffer length to allocate */
+    short flags;					    /* really enum xferinfo (see above) */
+    /* Ways to find other components */
+    short sdno;						    /* subdisk number */
+    short driveno;					    /* drive number */
+};
+
+/* A group of requests built to satisfy a certain
+ * component of a user request */
+struct rqgroup {
+    struct rqgroup *next;				    /* pointer to next group */
+    struct request *rq;					    /* pointer to the request */
+    short count;					    /* number of requests in this group */
+    short active;					    /* and number active */
+    short plexno;					    /* index of plex */
+    int badsdno;					    /* index of bad subdisk or -1 */
+    enum xferinfo flags;				    /* description of transfer */
+    struct rqelement rqe[0];				    /* and the elements of this request */
+};
+
+/* Describe one high-level request and the
+ * work we have to do to satisfy it */
+struct request {
+    struct buf *bp;					    /* pointer to the high-level request */
+    int flags;
+    union {
+	int volno;					    /* volume index */
+	int plexno;					    /* or plex index */
+    } volplex;
+    int error;						    /* current error indication */
+    short isplex;					    /* set if this is a plex request */
+    short active;					    /* number of subrequests still active */
+    struct rqgroup *rqg;				    /* pointer to the first group of requests */
+    struct rqgroup *lrqg;				    /* and to the first group of requests */
+    struct request *next;				    /* link of waiting requests */
+};
+
+/* Extended buffer header for subdisk I/O.  Includes
+ * a pointer to the user I/O request. */
+struct sdbuf {
+    struct buf b;					    /* our buffer */
+    struct buf *bp;					    /* and pointer to parent */
+    short driveno;					    /* drive index */
+    short sdno;						    /* and subdisk index */
+};
+
+/* Values returned by rqe and friends.
+ * Be careful with these: they are in order of increasing
+ * seriousness.  Some routines check for > REQUEST_RECOVERED
+ * to indicate a completely failed request. */
+enum requeststatus {
+    REQUEST_OK,						    /* request built OK */
+    REQUEST_RECOVERED,					    /* request OK, but involves RAID5 recovery */
+    REQUEST_EOF,					    /* request failed: outside plex */
+    REQUEST_DOWN,					    /* request failed: subdisk down  */
+    REQUEST_ENOMEM					    /* ran out of memory */
+};
+
+#ifdef DEBUG
+/* Trace entry for request info (DEBUG_LASTREQS) */
+enum rqinfo_type {
+    loginfo_unused,					    /* never been used */
+    loginfo_user_bp,					    /* this is the bp when strategy is called */
+    loginfo_user_bpl,					    /* and this is the bp at launch time */
+    loginfo_rqe,					    /* user RQE */
+    loginfo_iodone,					    /* iodone */
+    loginfo_raid5_data,					    /* write RAID-5 data block */
+    loginfo_raid5_parity				    /* write RAID-5 parity block */
+};
+
+union rqinfou {						    /* info to pass to logrq */
+    struct buf *bp;
+    struct rqelement *rqe;				    /* address of request, for correlation */
+};
+
+struct rqinfo {
+    enum rqinfo_type type;				    /* kind of event */
+    struct timeval timestamp;				    /* time it happened */
+    struct buf *bp;					    /* point to user buffer */
+    union {
+	struct buf b;					    /* yup, the *whole* buffer header */
+	struct rqelement rqe;				    /* and the whole rqe */
+    } info;
+};
+
+#define RQINFO_SIZE 64					    /* number of info slots in buffer */
+
+void logrq(enum rqinfo_type type, union rqinfou info, struct buf *ubp);
+#endif
diff --git a/sys/dev/vinum/statetexts.h b/sys/dev/vinum/statetexts.h
new file mode 100644
index 0000000..8205e96
--- /dev/null
+++ b/sys/dev/vinum/statetexts.h
@@ -0,0 +1,88 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: statetexts.h,v 1.1.1.1 1998/09/16 05:56:21 grog Exp $
+ */
+/* Created by ./makestatetext on Tue 4 Aug 15:53:16 CST 1998. Do not edit */
+
+/* Drive state texts */
+char *drivestatetext[] =
+{
+    "unallocated",
+    "uninit",
+    "down",
+    "coming_up",
+    "up",
+};
+
+/* Subdisk state texts */
+char *sdstatetext[] =
+{
+    "unallocated",
+    "uninit",
+    "init",
+    "initializing",
+    "empty",
+    "obsolete",
+    "stale",
+    "crashed",
+    "down",
+    "reborn",
+    "up",
+};
+
+/* Plex state texts */
+char *plexstatetext[] =
+{
+    "unallocated",
+    "init",
+    "faulty",
+    "down",
+    "reviving",
+    "initializing",
+    "corrupt",
+    "degraded",
+    "flaky",
+    "up",
+};
+
+/* Volume state texts */
+char *volstatetext[] =
+{
+    "unallocated",
+    "uninit",
+    "down",
+    "up",
+};
diff --git a/sys/dev/vinum/vinum.c b/sys/dev/vinum/vinum.c
new file mode 100644
index 0000000..49a60de
--- /dev/null
+++ b/sys/dev/vinum/vinum.c
@@ -0,0 +1,544 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: vinum.c,v 1.3 1998/11/03 06:38:58 grog Exp $
+ */
+
+#define STATIC						    /* nothing while we're testing XXX */
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+#include "sys/sysproto.h"				    /* for sync(2) */
+#ifdef DEBUG
+#include <sys/reboot.h>
+int debug = 0;
+#endif
+
+/* pointer to ioctl p parameter, to save passing it around */
+struct proc *myproc;
+
+#if __FreeBSD__ < 3
+STATIC struct cdevsw vinum_cdevsw;
+STATIC struct bdevsw vinum_bdevsw =
+{
+    vinumopen, vinumclose, vinumstrategy, vinumioctl,
+    vinumdump, vinumsize, 0,
+    "vinum", &vinum_cdevsw, -1
+};
+#else /* goodbye, bdevsw */
+STATIC struct cdevsw vinum_cdevsw =
+{
+    vinumopen, vinumclose, vinumread, vinumwrite,
+    vinumioctl, nostop, nullreset, nodevtotty,
+    seltrue, nommap, vinumstrategy, "vinum",
+    NULL, -1, vinumdump, vinumsize,
+    D_DISK, 0, -1
+};
+#endif
+
+/* Called by main() during pseudo-device attachment. */
+STATIC void vinumattach(void *);
+
+STATIC void vinumgetdisklabel(dev_t);
+void vinum_scandisk(void);
+int vinum_inactive(void);
+void free_vinum(int);
+
+#ifndef ACTUALLY_LKM_NOT_KERNEL
+STATIC int vinum_modevent(module_t mod, modeventtype_t type, void *unused);
+#endif
+
+#if __FreeBSD__ >= 3
+/* Why aren't these declared anywhere? XXX */
+int setjmp(jmp_buf);
+void longjmp(jmp_buf, int);
+#endif
+
+extern jmp_buf command_fail;				    /* return here if config fails */
+
+struct _vinum_conf vinum_conf;				    /* configuration information */
+
+STATIC int vinum_devsw_installed = 0;
+
+/*
+ * Called by main() during pseudo-device attachment.  All we need
+ * to do is allocate enough space for devices to be configured later, and
+ * add devsw entries.
+ */
+void
+vinumattach(void *dummy)
+{
+    BROKEN_GDB;
+    char *buf;						    /* pointer to temporary buffer */
+    struct _ioctl_reply *ioctl_reply;			    /* struct to return */
+    struct uio uio;
+    struct iovec iovec;
+
+    /* modload should prevent multiple loads, so this is worth a panic */
+    if ((vinum_conf.flags & VF_LOADED) != NULL)
+	panic("vinum: already loaded");
+
+    printf("vinum: loaded\n");
+    vinum_conf.flags |= VF_LOADED;			    /* we're loaded now */
+
+    /* We don't have a p pointer here, so take it from curproc */
+    myproc = curproc;
+#if __FreeBSD__ < 3
+    bdevsw_add_generic(BDEV_MAJOR, CDEV_MAJOR, &vinum_bdevsw);
+#else
+    cdevsw_add_generic(BDEV_MAJOR, CDEV_MAJOR, &vinum_cdevsw);
+#endif
+#ifdef DEVFS
+#error DEVFS not finished yet
+#endif
+
+    uio.uio_iov = &iovec;
+    uio.uio_iovcnt = 1;					    /* just one buffer */
+    uio.uio_offset = 0;					    /* start at the beginning */
+    uio.uio_resid = 512;				    /* one sector */
+    uio.uio_segflg = UIO_SYSSPACE;			    /* we're in system space */
+    uio.uio_rw = UIO_READ;				    /* do we need this? */
+    uio.uio_procp = curproc;				    /* do it for our own process */
+
+    iovec.iov_len = 512;
+    buf = (char *) Malloc(iovec.iov_len);		    /* get a buffer */
+    CHECKALLOC(buf, "vinum: no memory\n");		    /* can't get 512 bytes? */
+    iovec.iov_base = buf;				    /* read into buf */
+
+    /* allocate space: drives... */
+    DRIVE = (struct drive *) Malloc(sizeof(struct drive) * INITIAL_DRIVES);
+    CHECKALLOC(DRIVE, "vinum: no memory\n");
+    vinum_conf.drives_allocated = INITIAL_DRIVES;	    /* number of drive slots allocated */
+    vinum_conf.drives_used = 0;				    /* and number in use */
+
+    /* volumes, ... */
+    VOL = (struct volume *) Malloc(sizeof(struct volume) * INITIAL_VOLUMES);
+    CHECKALLOC(VOL, "vinum: no memory\n");
+    vinum_conf.volumes_allocated = INITIAL_VOLUMES;	    /* number of volume slots allocated */
+    vinum_conf.volumes_used = 0;			    /* and number in use */
+
+    /* plexes, ... */
+    PLEX = (struct plex *) Malloc(sizeof(struct plex) * INITIAL_PLEXES);
+    CHECKALLOC(PLEX, "vinum: no memory\n");
+    vinum_conf.plexes_allocated = INITIAL_PLEXES;	    /* number of plex slots allocated */
+    vinum_conf.plexes_used = 0;				    /* and number in use */
+
+    /* and subdisks */
+    SD = (struct sd *) Malloc(sizeof(struct sd) * INITIAL_SUBDISKS);
+    CHECKALLOC(SD, "vinum: no memory\n");
+    vinum_conf.subdisks_allocated = INITIAL_SUBDISKS;	    /* number of sd slots allocated */
+    vinum_conf.subdisks_used = 0;			    /* and number in use */
+
+    ioctl_reply = NULL;					    /* no reply on longjmp */
+}
+
+/* Check if we have anything open.  If so, return 0 (not inactive),
+ * otherwise 1 (inactive) */
+int 
+vinum_inactive(void)
+{
+    BROKEN_GDB;
+    int i;
+    int can_do = 1;					    /* assume we can do it */
+
+    lock_config();
+    for (i = 0; i < vinum_conf.volumes_used; i++) {
+	if (VOL[i].pid != NULL) {			    /* volume is open */
+	    can_do = 0;
+	    break;
+	}
+    }
+    unlock_config();
+    return can_do;
+}
+
+/* Free all structures.
+ * If cleardrive is 0, save the configuration; otherwise
+ * remove the configuration from the drive.
+ *
+ * Before coming here, ensure that no volumes are open.
+ */
+void 
+free_vinum(int cleardrive)
+{
+    BROKEN_GDB;
+    int i;
+
+    if (cleardrive) {
+	for (i = 0; i < vinum_conf.drives_used; i++)
+	    remove_drive(i);				    /* remove the drive */
+    } else {						    /* keep the config */
+	save_config();
+	if (DRIVE != NULL) {
+	    for (i = 0; i < vinum_conf.drives_used; i++)
+		free_drive(&DRIVE[i]);			    /* close files and things */
+	    Free(DRIVE);
+	}
+    }
+    if (SD != NULL)
+	Free(SD);
+    if (PLEX != NULL) {
+	for (i = 0; i < vinum_conf.plexes_used; i++) {
+	    struct plex *plex = &vinum_conf.plex[i];
+
+	    if (plex->state != plex_unallocated) {	    /* we have real data there */
+		if (plex->sdnos)
+		    Free(plex->sdnos);
+		if (plex->unmapped_regions)
+		    Free(plex->unmapped_region);
+		if (plex->defective_regions)
+		    Free(plex->defective_region);
+	    }
+	}
+	Free(PLEX);
+    }
+    if (VOL != NULL)
+	Free(VOL);
+    bzero(&vinum_conf, sizeof(vinum_conf));
+}
+
+#ifdef ACTUALLY_LKM_NOT_KERNEL				    /* stuff for LKMs */
+
+MOD_MISC(vinum);
+
+/*
+ * Function called when loading the driver.
+ */
+
+STATIC int 
+vinum_load(struct lkm_table *lkmtp, int cmd)
+{
+    BROKEN_GDB;
+    vinumattach(NULL);
+    return 0;						    /* OK */
+}
+
+/*
+ * Function called when unloading the driver.
+ */
+STATIC int 
+vinum_unload(struct lkm_table *lkmtp, int cmd)
+{
+    BROKEN_GDB;
+    if (vinum_inactive()) {				    /* is anything open? */
+	struct sync_args dummyarg =
+	{0};
+#if __FreeBSD__ < 3
+	int retval;
+#endif
+
+	printf("vinum: unloaded\n");
+#if __FreeBSD__ < 3
+	sync(curproc, &dummyarg, &retval);		    /* write out buffers */
+#else
+	sync(curproc, &dummyarg);			    /* write out buffers */
+#endif
+	free_vinum(0);					    /* no: clean up */
+#if __FreeBSD__ < 3
+	bdevsw[BDEV_MAJOR] = NULL;			    /* clear bdevsw */
+#endif
+	cdevsw[CDEV_MAJOR] = NULL;			    /* and cdevsw */
+	return 0;
+    } else
+	return EBUSY;
+}
+
+/*
+ * Dispatcher function for the module (load/unload/stat).
+ */
+int 
+vinum_mod(struct lkm_table *lkmtp, int cmd, int ver)
+{
+    BROKEN_GDB;
+    MOD_DISPATCH(vinum,					    /* module name */
+	lkmtp,						    /* LKM table */
+	cmd,						    /* command */
+	ver,
+	vinum_load,					    /* load with this function */
+	vinum_unload,					    /* and unload with this */
+	lkm_nullcmd);
+}
+
+#else /* not LKM */
+
+STATIC int 
+vinum_modevent(module_t mod, modeventtype_t type, void *unused)
+{
+    struct sync_args dummyarg =
+    {0};
+
+    BROKEN_GDB;
+    switch (type) {
+    case MOD_LOAD:
+	vinumattach(NULL);
+	return 0;					    /* OK */
+    case MOD_UNLOAD:
+	if (!vinum_inactive())				    /* is anything open? */
+	    return EBUSY;
+	sync(curproc, &dummyarg);			    /* write out buffers */
+	free_vinum(0);					    /* no: clean up */
+	cdevsw[CDEV_MAJOR] = NULL;			    /* and cdevsw */
+	return 0;
+    default:
+	break;
+    }
+    return 0;
+}
+
+moduledata_t vinum_mod =
+{
+    "vinum",
+    vinum_modevent,
+    0
+};
+DECLARE_MODULE(vinum, vinum_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE);
+
+#endif /* LKM */
+
+/* ARGSUSED */
+/* Open a vinum object
+ * At the moment, we only open volumes and the
+ * super device.  It's a nice concept to be
+ * able to open drives, subdisks and plexes, but
+ * I can't think what good it could be */
+int 
+vinumopen(dev_t dev,
+    int flags,
+    int fmt,
+    struct proc *p)
+{
+    BROKEN_GDB;
+    int s;						    /* spl */
+    int error;
+    unsigned int index;
+    struct volume *vol;
+    struct plex *plex;
+    struct sd *sd;
+    struct devcode *device;
+
+    device = (struct devcode *) &dev;
+
+    error = 0;
+    /* First, decide what we're looking at */
+    switch (device->type) {
+    case VINUM_VOLUME_TYPE:
+	index = VOLNO(dev);
+	if (index >= vinum_conf.volumes_used)
+	    return ENXIO;				    /* no such device */
+	vol = &VOL[index];
+
+	switch (vol->state) {
+	case volume_unallocated:
+	case volume_uninit:
+	    return ENXIO;
+
+	case volume_up:
+	    s = splhigh();				    /* quick lock */
+	    if (error)
+		return error;
+	    if (vol->opencount == 0)
+		vol->openflags = flags;			    /* set our flags */
+	    vol->opencount++;
+	    vol->pid = p->p_pid;			    /* and say who we are (do we need this? XXX) */
+	    splx(s);
+	    return 0;
+
+	case volume_down:
+	    return EIO;
+
+	default:
+	    return EINVAL;
+	}
+
+    case VINUM_PLEX_TYPE:
+	if (VOLNO(dev) >= vinum_conf.volumes_used)
+	    return ENXIO;
+	index = PLEXNO(dev);				    /* get plex index in vinum_conf */
+	if (index >= vinum_conf.plexes_used)
+	    return ENXIO;				    /* no such device */
+	plex = &PLEX[index];
+
+	switch (plex->state) {
+	case plex_unallocated:
+	    return EINVAL;
+
+	default:
+	    s = splhigh();
+	    if (plex->pid				    /* it's open already */
+		&& (plex->pid != p->p_pid)) {		    /* and not by us, */
+		splx(s);
+		return EBUSY;				    /* one at a time, please */
+	    }
+	    plex->pid = p->p_pid;			    /* and say who we are (do we need this? XXX) */
+	    splx(s);
+	    return 0;
+	}
+
+    case VINUM_SD_TYPE:
+	if ((VOLNO(dev) >= vinum_conf.volumes_used) ||	    /* no such volume */
+	    (PLEXNO(dev) >= vinum_conf.plexes_used))	    /* or no such plex */
+	    return ENXIO;				    /* no such device */
+	index = SDNO(dev);				    /* get the subdisk number */
+	if (index >= vinum_conf.subdisks_used)
+	    return ENXIO;				    /* no such device */
+	sd = &SD[index];
+
+	/* Opening a subdisk is always a special operation, so we 
+	 * ignore the state as long as it represents a real subdisk */
+	switch (sd->state) {
+	case sd_unallocated:
+	case sd_uninit:
+	    return EINVAL;
+
+	default:
+	    s = splhigh();
+	    if (sd->pid					    /* it's open already */
+		&& (sd->pid != p->p_pid)) {		    /* and not by us, */
+		splx(s);
+		return EBUSY;				    /* one at a time, please */
+	    }
+	    sd->pid = p->p_pid;				    /* and say who we are (do we need this? XXX) */
+	    splx(s);
+	    return 0;
+	}
+
+    case VINUM_DRIVE_TYPE:
+    default:
+	return ENODEV;					    /* don't know what to do with these */
+
+    case VINUM_SUPERDEV_TYPE:
+	if (p->p_ucred->cr_uid == 0) {			    /* root calling, */
+	    vinum_conf.opencount++;			    /* one more opener */
+	    return 0;					    /* no worries opening super dev */
+	} else
+	    return EPERM;				    /* you can't do that! */
+    }
+}
+
+/* ARGSUSED */
+int 
+vinumclose(dev_t dev,
+    int flags,
+    int fmt,
+    struct proc *p)
+{
+    BROKEN_GDB;
+    unsigned int index;
+    struct volume *vol;
+    struct plex *plex;
+    struct sd *sd;
+    struct devcode *device = (struct devcode *) &dev;
+
+    index = VOLNO(dev);
+    /* First, decide what we're looking at */
+    switch (device->type) {
+    case VINUM_VOLUME_TYPE:
+	if (index >= vinum_conf.volumes_used)
+	    return ENXIO;				    /* no such device */
+	vol = &VOL[index];
+
+	switch (vol->state) {
+	case volume_unallocated:
+	case volume_uninit:
+	    return ENXIO;
+
+	case volume_up:
+	    vol->opencount = 0;				    /* reset our flags */
+	    vol->pid = NULL;				    /* and forget who owned us */
+	    return 0;
+
+	case volume_down:
+	    return EIO;
+
+	default:
+	    return EINVAL;
+	}
+
+    case VINUM_PLEX_TYPE:
+	if (VOLNO(dev) >= vinum_conf.volumes_used)
+	    return ENXIO;
+	index = PLEXNO(dev);				    /* get plex index in vinum_conf */
+	if (index >= vinum_conf.plexes_used)
+	    return ENXIO;				    /* no such device */
+	plex = &PLEX[index];
+	plex->pid = 0;
+	return 0;
+
+    case VINUM_SD_TYPE:
+	if ((VOLNO(dev) >= vinum_conf.volumes_used) ||	    /* no such volume */
+	    (PLEXNO(dev) >= vinum_conf.plexes_used))	    /* or no such plex */
+	    return ENXIO;				    /* no such device */
+	index = SDNO(dev);				    /* get the subdisk number */
+	if (index >= vinum_conf.subdisks_used)
+	    return ENXIO;				    /* no such device */
+	sd = &SD[index];
+	sd->pid = 0;
+	return 0;
+
+    case VINUM_SUPERDEV_TYPE:
+	if (p->p_ucred->cr_uid == 0)			    /* root calling, */
+	    vinum_conf.opencount--;			    /* one less opener */
+	return 0;					    /* no worries closing super dev */
+
+    case VINUM_DRIVE_TYPE:
+    default:
+	return ENODEV;					    /* don't know what to do with these */
+    }
+}
+
+/* size routine */
+int 
+vinumsize(dev_t dev)
+{
+    BROKEN_GDB;
+    struct volume *vol;
+    int size;
+
+    vol = &VOL[VOLNO(dev)];
+
+    if (vol->state == volume_up)
+	size = vol->size;
+    else
+	return 0;					    /* err on the size of conservatism */
+
+    return size;
+}
+
+int 
+vinumdump(dev_t dev)
+{
+    /* Not implemented. */
+    return ENXIO;
+}
diff --git a/sys/dev/vinum/vinumconfig.c b/sys/dev/vinum/vinumconfig.c
new file mode 100644
index 0000000..5b9abc3
--- /dev/null
+++ b/sys/dev/vinum/vinumconfig.c
@@ -0,0 +1,1723 @@
+/* To do:
+
+ * Don't store drive configuration on the config DB: read each drive's header
+ * to decide where it is.
+ *
+ * Accept any old crap in the config_<foo> functions, and complain when
+ * we try to bring it up.
+ *
+ * When trying to bring volumes up, check that the complete address range
+ * is covered.
+ */
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: config.c,v 1.4 1998/11/03 06:37:14 grog Exp $
+ */
+
+#define STATIC						    /* nothing while we're testing XXX */
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+
+extern jmp_buf command_fail;				    /* return on a failed command */
+
+#if __FreeBSD__ >= 3
+/* Why aren't these declared anywhere? XXX */
+void longjmp(jmp_buf, int);
+#endif
+
+#define MAXTOKEN 64					    /* maximum number of tokens in a line */
+
+/* We can afford the luxury of global variables here,
+ * since start_config ensures that these functions
+ * are single-threaded. */
+
+/* These are indices in vinum_conf of the last-mentioned of each kind of object */
+static int current_drive = -1;				    /* note the last drive we mention, for
+							    * some defaults */
+static int current_plex = -1;				    /* and the same for the last plex */
+static int current_volume = -1;				    /* and the last volme */
+static struct _ioctl_reply *ioctl_reply;		    /* struct to return via ioctl */
+
+
+/* These values are used by most of these routines, so set them as globals */
+static char *token[MAXTOKEN];				    /* pointers to individual tokens */
+static int tokens;					    /* number of tokens */
+
+#define TOCONS	0x01
+#define TOTTY	0x02
+#define TOLOG	0x04
+
+struct putchar_arg {
+    int flags;
+    struct tty *tty;
+};
+
+#define MSG_MAX 1024					    /* maximum length of a formatted message */
+/* Format an error message and return to the user in the reply.
+ * CARE: This routine is designed to be called only from the
+ * configuration routines, so it assumes it's the owner of
+ * the configuration lock, and unlocks it on exit */
+void 
+throw_rude_remark(int error, char *msg,...)
+{
+    BROKEN_GDB;
+    int retval;
+    va_list ap;
+    char *text;
+    static int finishing;				    /* don't recurse */
+    int was_finishing;
+
+    va_start(ap, msg);
+    if ((ioctl_reply != NULL)				    /* we're called from the user */
+    &&(!(vinum_conf.flags & VF_KERNELOP))) {		    /* and we're not doing kernel things: return msg */
+	/* XXX We can't just format to ioctl_reply, since it
+	 * may contain our input parameters */
+	text = Malloc(MSG_MAX);
+	if (text == NULL) {
+	    printf("vinum: can't allocate error message buffer");
+	    printf("vinum: ");
+	    vprintf(msg, ap);				    /* print to the console */
+	    printf("\n");
+	} else {
+	    retval = kvprintf(msg, NULL, (void *) text, 10, ap);
+	    text[retval] = '\0';			    /* delimit */
+	    strcpy(ioctl_reply->msg, text);
+	    ioctl_reply->error = error;			    /* first byte is the error number */
+	    Free(text);
+	}
+    } else {
+	printf("vinum: ");
+	vprintf(msg, ap);				    /* print to the console */
+	printf("\n");
+    }
+    va_end(ap);
+
+    if (vinum_conf.flags & VF_READING_CONFIG)		    /* go through to the bitter end, */
+	return;
+    /* We have a problem here: we want to unlock the
+     * configuration, which implies tidying up, but
+     * if we find an error while tidying up, we could
+     * recurse for ever.  Use this kludge to only try
+     * once */
+    was_finishing = finishing;
+    finishing = 1;
+    finish_config(was_finishing);			    /* unlock anything we may be holding */
+    finishing = was_finishing;
+    longjmp(command_fail, error);
+}
+
+/* Function declarations */
+int atoi(char *);					    /* no atoi in the kernel */
+
+/* Minimal version of atoi */
+int 
+atoi(char *s)
+{							    /* no atoi in the kernel */
+    BROKEN_GDB;
+    int r = 0;
+    int sign = 1;
+
+    while (((*s >= '0') && (*s <= '9')) || (*s == '-')) {
+	if (*s == '-')
+	    sign = -sign;
+	else
+	    r = r * 10 + (*s - '0');
+    }
+    return r;
+}
+
+/* Find index of volume in vinum_conf.  Return the index
+ * if found, or -1 if not */
+int 
+volume_index(struct volume *vol)
+{
+    BROKEN_GDB;
+    int i;
+
+    for (i = 0; i < vinum_conf.volumes_used; i++)
+	if (&VOL[i] == vol)
+	    return i;
+    return -1;
+}
+
+/* Find index of plex in vinum_conf.  Return the index
+ * if found, or -1 if not */
+int 
+plex_index(struct plex *plex)
+{
+    BROKEN_GDB;
+    int i;
+
+    for (i = 0; i < vinum_conf.plexes_used; i++)
+	if (&PLEX[i] == plex)
+	    return i;
+    return -1;
+}
+
+/* Find index of subdisk in vinum_conf.  Return the index
+ * if found, or -1 if not */
+int 
+sd_index(struct sd *sd)
+{
+    BROKEN_GDB;
+    int i;
+
+    for (i = 0; i < vinum_conf.subdisks_used; i++)
+	if (&SD[i] == sd)
+	    return i;
+    return -1;
+}
+
+/* Find index of drive in vinum_conf.  Return the index
+ * if found, or -1 if not */
+int 
+drive_index(struct drive *drive)
+{
+    BROKEN_GDB;
+    int i;
+
+    for (i = 0; i < vinum_conf.drives_used; i++)
+	if (&DRIVE[i] == drive)
+	    return i;
+    return -1;
+}
+
+/* Check a volume to see if the plex is already assigned to it.
+ * Return index in volume->plex, or -1 if not assigned */
+int 
+my_plex(int volno, int plexno)
+{
+    BROKEN_GDB;
+    int i;
+    struct volume *vol;
+
+    vol = &VOL[volno];					    /* point to volno */
+    for (i = 0; i < vol->plexes; i++)
+	if (vol->plex[i] == plexno)
+	    return i;
+    return -1;						    /* not found */
+}
+
+/* Check a plex to see if the subdisk is already assigned to it.
+ * Return index in plex->sd, or -1 if not assigned */
+int 
+my_sd(int plexno, int sdno)
+{
+    BROKEN_GDB;
+    int i;
+    struct plex *plex;
+
+    plex = &PLEX[plexno];
+    for (i = 0; i < plex->subdisks; i++)
+	if (plex->sdnos[i] == sdno)
+	    return i;
+    return -1;						    /* not found */
+}
+
+/* Check that this operation is being done in the kernel.
+ * longjmp out if not.  op the name of the operation. */
+void 
+checkkernel(char *op)
+{
+    BROKEN_GDB;
+    if (vinum_conf.flags & VF_KERNELOP == 0)
+	throw_rude_remark(EPERM, "Can't perform '%s' from user space", op);
+}
+
+/* Add plex to the volume if possible */
+int 
+give_plex_to_volume(int volno, int plexno)
+{
+    BROKEN_GDB;
+    struct volume *vol;
+
+    /* XXX It's not an error for the plex to already
+     * belong to the volume, but we need to check a
+     * number of things to make sure it's done right.
+     * Some day. */
+    if (my_plex(volno, plexno) >= 0)
+	return plexno;					    /* that's it */
+
+    vol = &VOL[volno];					    /* point to volume */
+    if (vol->plexes == MAXPLEX)				    /* all plexes allocated */
+	throw_rude_remark(ENOSPC,
+	    "Too many plexes for volume %s",
+	    vol->name);
+    vol->plex[vol->plexes] = plexno;			    /* this one */
+    vol->plexes++;					    /* add another plex */
+    PLEX[plexno].volno = volno;				    /* note the number of our volume */
+
+    return vol->plexes - 1;				    /* and return its index */
+}
+
+/* Add subdisk to a plex if possible */
+int 
+give_sd_to_plex(int plexno, int sdno)
+{
+    BROKEN_GDB;
+    int i;
+    struct plex *plex;
+    struct sd *sd;
+
+    /* XXX It's not an error for the sd to already
+     * belong to the plex, but we need to check a
+     * number of things to make sure it's done right.
+     * Some day. */
+    i = my_sd(plexno, sdno);
+    if (i >= 0)						    /* does it already belong to us? */
+	return i;					    /* that's it */
+
+    plex = &PLEX[plexno];				    /* point to the plex */
+    sd = &SD[sdno];					    /* and the subdisk */
+
+    /* Do we have an offset?  Otherwise put it after the last one */
+    if (sd->plexoffset < 0) {				    /* no offset specified */
+	if (plex->subdisks > 0) {
+	    struct sd *lastsd = &SD[plex->sdnos[plex->subdisks - 1]]; /* last subdisk */
+	    sd->plexoffset = lastsd->sectors + lastsd->plexoffset; /* take it */
+	} else						    /* first subdisk */
+	    sd->plexoffset = 0;				    /* start at the beginning */
+    }
+    if (plex->subdisks == MAXSD)			    /* we already have our maximum */
+	throw_rude_remark(ENOSPC,			    /* crap out */
+	    "Can't add %s to %s: plex full\n",
+	    sd->name,
+	    plex->name);
+
+    plex->subdisks++;					    /* another entry */
+    if (plex->subdisks >= plex->subdisks_allocated)	    /* need more space */
+	EXPAND(plex->sdnos, int, plex->subdisks_allocated, INITIAL_SUBDISKS_IN_PLEX);
+
+    /* XXX I'm not sure this makes any sense
+     * for anything except concatenated plexes,
+     * and it comes up with the wrong answer for
+     * RAID-5 plexes, but it's currently needed
+     * for the calculations.  We'll adjust for
+     * RAID-5 in config_plex */
+    if ((sd->sectors + sd->plexoffset) > plex->length) {    /* gone beyond the end of the plex */
+	plex->length = sd->sectors + sd->plexoffset;	    /* adjust the length */
+
+	if ((plex->volno >= 0)				    /* we have a volume */
+	&&(plex->length > VOL[plex->volno].size))	    /* and we're now the longest plex */
+	    VOL[plex->volno].size = plex->length;	    /* increase the size of the volume */
+    }
+    /* We need to check that the subdisks don't overlap,
+     * but we can't do that until a point where we *must*
+     * know the size of all the subdisks.  That's not
+     * here.  But we need to sort them by offset */
+    for (i = 0; i < plex->subdisks - 1; i++) {
+	if (sd->plexoffset < SD[plex->sdnos[i]].plexoffset) { /* it fits before this one */
+	    /* First move any remaining subdisks by one */
+	    int j;
+
+	    for (j = plex->subdisks - 1; j > i; j--)	    /* move up one at a time */
+		plex->sdnos[j] = plex->sdnos[j - 1];
+	    plex->sdnos[i] = sdno;
+	    return i;
+	}
+    }
+
+    /* The plex doesn't have any subdisk with a larger
+     * offset.  Insert it */
+    plex->sdnos[i] = sdno;
+    return i;
+}
+
+/* Add a subdisk to drive if possible.  The pointer to the drive
+ * must already be stored in the sd structure, but the drive
+ * doesn't know about the subdisk yet.  */
+static void 
+give_sd_to_drive(int sdno)
+{
+    BROKEN_GDB;
+    struct sd *sd;					    /* pointer to subdisk */
+    struct drive *drive;				    /* and drive */
+    int fe;						    /* index in free list */
+
+    sd = &SD[sdno];					    /* point to sd */
+    drive = &DRIVE[sd->driveno];			    /* and drive */
+
+    if (drive->state != drive_up)			    /* not up */
+	throw_rude_remark(EIO, "Drive %s is not accessible", drive->label.name);
+    else if (sd->sectors > drive->sectors_available) {	    /* too big, */
+	sd->driveoffset = -1;				    /* don't be confusing */
+	throw_rude_remark(ENOSPC, "No space for %s on %s", sd->name, drive->label.name);
+    }
+    drive->subdisks_used++;				    /* one more subdisk */
+
+    /* no offset specified, find one */
+    if (sd->driveoffset < 0) {
+	for (fe = 0; fe < drive->freelist_entries; fe++) {
+	    if (drive->freelist[fe].sectors >= sd->sectors) { /* it'll fit here */
+		sd->driveoffset = drive->freelist[fe].offset;
+		if (sd->sectors == drive->freelist[fe].sectors) { /* used up the entire entry */
+		    if (fe < (drive->freelist_entries - 1)) /* not the last one, */
+			bcopy(&drive->freelist[fe + 1],
+			    &drive->freelist[fe],
+			    (drive->freelist_entries - fe) * sizeof(struct drive_freelist));
+		    drive->freelist_entries--;		    /* one less entry */
+		} else {
+		    drive->freelist[fe].sectors -= sd->sectors;	/* this much less space */
+		    drive->freelist[fe].offset += sd->sectors; /* this much further on */
+		}
+		drive->sectors_available -= sd->sectors;    /* and note how much less space we have */
+		break;
+	    }
+	}
+	if (fe == drive->freelist_entries)
+	    /* Didn't find anything.  Although the drive has
+	     * enough space, it's too fragmented */
+	{
+	    sd->driveoffset = -1;			    /* don't be confusing */
+	    throw_rude_remark(ENOSPC, "No space for %s on %s", sd->name, drive->label.name);
+	}
+    } else {						    /* specific offset */
+	/* For a specific offset to work, the space must be
+	 * entirely in a single freelist entry.  Look for it. */
+	u_int64_t sdend = sd->driveoffset + sd->sectors;    /* end of our subdisk */
+	for (fe = 0; fe < drive->freelist_entries; fe++) {
+	    u_int64_t dend = drive->freelist[fe].offset + drive->freelist[fe].sectors; /* end of entry */
+	    if (dend >= sdend) {			    /* fits before here */
+		if (drive->freelist[fe].offset > sd->driveoffset) /* starts after the beginning of sd area */
+		    throw_rude_remark(ENOSPC,
+			"No space for subdisk %s on drive %s at offset %qd\n",
+			sd->name,
+			drive->label.name);
+
+		/* We've found the space, and we can allocate it.
+		 * We don't need to say that to the subdisk, which
+		 * already knows about it.  We need to tell it to
+		 * the free list, though.  We have four possibilities:
+		 *
+		 * 1.  The subdisk exactly eats up the entry.  That's the
+		 *     same as above.
+		 * 2.  The subdisk starts at the beginning and leaves space
+		 *     at the end.
+		 * 3.  The subdisk starts after the beginning and leaves
+		 *     space at the end as well: we end up with another
+		 *     fragment.
+		 * 4.  The subdisk leaves space at the beginning and finishes
+		 *     at the end.
+		 */
+		drive->sectors_available -= sd->sectors;    /* note how much less space we have */
+		if (sd->driveoffset == drive->freelist[fe].offset) { /* 1 or 2 */
+		    if (sd->sectors == drive->freelist[fe].sectors) { /* 1: used up the entire entry */
+			if (fe < (drive->freelist_entries - 1))	/* not the last one, */
+			    bcopy(&drive->freelist[fe + 1],
+				&drive->freelist[fe],
+				(drive->freelist_entries - fe) * sizeof(struct drive_freelist));
+			drive->freelist_entries--;	    /* one less entry */
+		    } else {				    /* 2: space at the end */
+			drive->freelist[fe].sectors -= sd->sectors; /* this much less space */
+			drive->freelist[fe].offset += sd->sectors; /* this much further on */
+		    }
+		} else {				    /* 3 or 4 */
+		    drive->freelist[fe].sectors = sd->driveoffset - drive->freelist[fe].offset;
+		    if (dend > sdend) {			    /* 3: space at the end as well */
+			if (fe < (drive->freelist_entries - 1))	/* not the last one */
+			    bcopy(&drive->freelist[fe],	    /* move the rest down */
+				&drive->freelist[fe + 1],
+				(drive->freelist_entries - fe) * sizeof(struct drive_freelist));
+			drive->freelist_entries++;	    /* one less entry */
+			drive->freelist[fe + 1].offset = sdend;	/* second entry starts after sd */
+			drive->freelist[fe + 1].sectors = dend - sdend;	/* and is this long */
+		    }
+		}
+		break;
+	    }
+	}
+    }
+    drive->opencount++;					    /* one more subdisk attached */
+}
+
+/* Get an empty drive entry from the drive table */
+int 
+get_empty_drive(void)
+{
+    BROKEN_GDB;
+    int driveno;
+    struct drive *drive;
+
+    /* first see if we have one which has been deallocated */
+    for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) {
+	if (DRIVE[driveno].state == drive_unallocated)	    /* bingo */
+	    break;
+    }
+
+    if (driveno >= vinum_conf.drives_used)
+	/* Couldn't find a deallocated drive.  Allocate a new one */
+    {
+	vinum_conf.drives_used++;
+	if (vinum_conf.drives_used > vinum_conf.drives_allocated) /* we've used all our allocation */
+	    EXPAND(DRIVE, struct drive, vinum_conf.drives_allocated, INITIAL_DRIVES);
+    }
+    /* got a drive entry.  Make it pretty */
+    drive = &DRIVE[driveno];
+    bzero(drive, sizeof(struct drive));
+    drive->driveno = driveno;				    /* put number in structure */
+    return driveno;					    /* return the index */
+}
+
+/* Find the named drive in vinum_conf.drive, return a pointer
+ * return the index in vinum_conf.drive.
+ * Don't mark the drive as allocated (XXX SMP)
+ * If create != 0, create an entry if it doesn't exist
+ */
+/* XXX check if we have it open from attach */
+int 
+find_drive(const char *name, int create)
+{
+    BROKEN_GDB;
+    int driveno;
+    struct drive *drive;
+
+    if (name != NULL) {
+	for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) {
+	    drive = &DRIVE[driveno];			    /* point to drive */
+	    if ((drive->label.name[0] != '\0')		    /* it has a name */
+	    &&(strcmp(drive->label.name, name) == 0))	    /* and it's this one: found */
+		return driveno;
+	}
+    }
+    /* the drive isn't in the list.  Add it if he wants */
+    if (create == 0)					    /* don't want to create */
+	return -1;					    /* give up */
+
+    driveno = get_empty_drive();
+    drive = &DRIVE[driveno];
+    if (name != NULL)
+	bcopy(name,					    /* put in its name */
+	    drive->label.name,
+	    min(sizeof(drive->label.name),
+		strlen(name)));
+    drive->state = drive_uninit;			    /* in use, nothing worthwhile there */
+    return driveno;					    /* return the index */
+}
+
+/* Find a drive given its device name.
+ * devname must be valid.
+ * Otherwise the same as find_drive above */
+int 
+find_drive_by_dev(const char *devname, int create)
+{
+    BROKEN_GDB;
+    int driveno;
+    struct drive *drive;
+
+    for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) {
+	drive = &DRIVE[driveno];			    /* point to drive */
+	if ((drive->label.name[0] != '\0')		    /* it has a name */
+	&&(strcmp(drive->label.name, devname) == 0))	    /* and it's this one: found */
+	    return driveno;
+    }
+
+    /* the drive isn't in the list.  Add it if he wants */
+    if (create == 0)					    /* don't want to create */
+	return -1;					    /* give up */
+
+    driveno = get_empty_drive();
+    drive = &DRIVE[driveno];
+    bcopy(devname,					    /* put in its name */
+	drive->devicename,
+	min(sizeof(drive->devicename),
+	    strlen(devname)));
+    drive->state = drive_uninit;			    /* in use, nothing worthwhile there */
+    return driveno;					    /* return the index */
+}
+
+/* Find an empty subdisk in the subdisk table */
+int 
+get_empty_sd(void)
+{
+    BROKEN_GDB;
+    int sdno;
+    struct sd *sd;
+
+    /* first see if we have one which has been deallocated */
+    for (sdno = 0; sdno < vinum_conf.subdisks_used; sdno++) {
+	if (SD[sdno].state == sd_unallocated)		    /* bingo */
+	    break;
+    }
+
+    if (sdno >= vinum_conf.subdisks_used) {		    /* No unused sd found.  Allocate a new one */
+	vinum_conf.subdisks_used++;
+	if (vinum_conf.subdisks_used > vinum_conf.subdisks_allocated)
+	    EXPAND(SD, struct sd, vinum_conf.subdisks_allocated, INITIAL_SUBDISKS);
+    }
+    /* initialize some things */
+    sd = &SD[sdno];					    /* point to it */
+    bzero(sd, sizeof(struct sd));			    /* initialize */
+    sd->plexno = -1;					    /* no plex */
+    sd->driveno = -1;					    /* and no drive */
+    sd->plexoffset = -1;				    /* and no offsets */
+    sd->driveoffset = -1;
+    return sdno;					    /* return the index */
+}
+
+/* return a drive to the free pool */
+void 
+free_drive(struct drive *drive)
+{
+    BROKEN_GDB;
+    if (drive->vp != NULL)				    /* device open */
+	vn_close(drive->vp, FREAD | FWRITE, FSCRED, drive->p);
+    bzero(drive, sizeof(struct drive));			    /* this also sets drive_unallocated */
+    vinum_conf.drives_used--;				    /* one less drive */
+}
+
+/* Find the named subdisk in vinum_conf.sd.
+
+ * If create != 0, create an entry if it doesn't exist
+ *
+ * Return index in vinum_conf.sd
+ */
+int 
+find_subdisk(const char *name, int create)
+{
+    BROKEN_GDB;
+    int sdno;
+    struct sd *sd;
+
+    for (sdno = 0; sdno < vinum_conf.subdisks_allocated; sdno++) {
+	if (strcmp(SD[sdno].name, name) == 0)		    /* found it */
+	    return sdno;
+    }
+
+    /* the subdisk isn't in the list.  Add it if he wants */
+    if (create == 0)					    /* don't want to create */
+	return -1;					    /* give up */
+
+    /* Allocate one and insert the name */
+    sdno = get_empty_sd();
+    sd = &SD[sdno];
+    bcopy(name, sd->name, min(sizeof(sd->name), strlen(name)));	/* put in its name */
+    return sdno;					    /* return the pointer */
+}
+
+/* Free an allocated sd entry
+ * This performs memory management only.  remove()
+ * is responsible for checking relationships.
+ */
+void 
+free_sd(int sdno)
+{
+    BROKEN_GDB;
+    struct sd *sd;
+    struct drive *drive;
+    int fe;						    /* free list entry */
+    u_int64_t sdend;					    /* end of our subdisk */
+    u_int64_t dend;					    /* end of our freelist entry */
+
+    sd = &SD[sdno];
+    if ((sd->driveno >= 0)				    /* we have a drive, */
+    &&(sd->sectors > 0)) {				    /* and some space on it */
+	drive = &DRIVE[sd->driveno];
+	sdend = sd->driveoffset + sd->sectors;		    /* end of our subdisk */
+
+	/* Look for where to return the sd address space */
+	for (fe = 0;
+	    (fe < drive->freelist_entries) && (drive->freelist[fe].offset < sd->driveoffset);
+	    fe++);
+	/* Now we are pointing to the last entry, the first
+	 * with a higher offset than the subdisk, or both. */
+	if ((fe > 1)					    /* not the first entry */
+	&&((fe == drive->freelist_entries)		    /* gone past the end */
+	||(drive->freelist[fe].offset > sd->driveoffset)))  /* or past the block were looking for */
+	    fe--;					    /* point to the block before */
+	dend = drive->freelist[fe].offset + drive->freelist[fe].sectors; /* end of the entry */
+
+	/* At this point, we are pointing to the correct
+	 * place in the free list.  A number of possibilities
+	 * exist:
+	 *
+	 * 1.  The block to be freed immediately follows
+	 *     the block to which we are pointing.  Just
+	 *     enlarge it.
+	 * 2.  The block to be freed starts at the end of
+	 *     the current block and ends at the beginning
+	 *     of the following block.  Merge the three
+	 *     areas into a single block.
+	 * 3.  The block to be freed starts after the end
+	 *     of the block and ends before the start of
+	 *     the following block.  Create a new free block.
+	 * 4.  The block to be freed starts after the end
+	 *     of the block, but ends at the start of the
+	 *     following block.  Enlarge the following block
+	 *     downwards.
+	 *
+	 */
+	if (sd->driveoffset == dend) {			    /* it starts after the end of this block */
+	    if ((fe < drive->freelist_entries - 1)	    /* we're not the last block in the free list */
+	    &&(sdend == drive->freelist[fe + 1].offset)) {  /* and the subdisk ends at the start of the
+																			   * next block */
+		drive->freelist[fe].sectors = drive->freelist[fe + 1].sectors; /* 2: merge all three blocks */
+		if (fe < drive->freelist_entries - 2)	    /* still more blocks after next */
+		    bcopy(&drive->freelist[fe + 2],	    /* move down one */
+			&drive->freelist[fe + 1],
+			(drive->freelist_entries - 2 - fe) * sizeof(struct drive_freelist));
+		drive->freelist_entries--;		    /* one less entry in the free list */
+	    } else					    /* 1: just enlarge this block */
+		drive->freelist[fe].sectors += sd->sectors;
+	} else {
+	    if (sd->driveoffset > dend)			    /* it starts after this block */
+		fe++;					    /* so look at the next block */
+	    if ((fe < drive->freelist_entries)		    /* we're not the last block in the free list */
+	    &&(sdend == drive->freelist[fe].offset)) {	    /* and the subdisk ends at the start of
+																		   * this block: case 4 */
+		drive->freelist[fe].offset = sd->driveoffset; /* it starts where the sd was */
+		drive->freelist[fe].sectors += sd->sectors; /* and it's this much bigger */
+	    } else {					    /* case 3: non-contiguous */
+		if (fe < drive->freelist_entries)	    /* not after the last block, */
+		    bcopy(&drive->freelist[fe],		    /* move the rest up one entry */
+			&drive->freelist[fe + 1],
+			(drive->freelist_entries - fe) * sizeof(struct drive_freelist));
+		drive->freelist_entries++;		    /* one less entry */
+		drive->freelist[fe].offset = sd->driveoffset; /* this entry represents the sd */
+		drive->freelist[fe].sectors = sd->sectors;
+	    }
+	}
+	drive->opencount--;				    /* one less subdisk attached */
+    }
+    bzero(sd, sizeof(struct sd));			    /* and clear it out */
+    sd->state = sd_unallocated;
+    vinum_conf.subdisks_used--;				    /* one less sd */
+}
+
+/* Find an empty plex in the plex table */
+int 
+get_empty_plex(void)
+{
+    BROKEN_GDB;
+    int plexno;
+    struct plex *plex;					    /* if we allocate one */
+
+    /* first see if we have one which has been deallocated */
+    for (plexno = 0; plexno < vinum_conf.plexes_used; plexno++) {
+	if (PLEX[plexno].state == plex_unallocated)	    /* bingo */
+	    break;					    /* and get out of here */
+    }
+
+    if (plexno >= vinum_conf.plexes_used) {
+	/* Couldn't find a deallocated plex.  Allocate a new one */
+	vinum_conf.plexes_used++;
+	if (vinum_conf.plexes_used > vinum_conf.plexes_allocated)
+	    EXPAND(PLEX, struct plex, vinum_conf.plexes_allocated, INITIAL_PLEXES);
+    }
+    /* Found a plex.  Give it an sd structure */
+    plex = &PLEX[plexno];				    /* this one is ours */
+    bzero(plex, sizeof(struct plex));			    /* polish it up */
+    plex->sdnos = (int *) Malloc(sizeof(int) * INITIAL_SUBDISKS_IN_PLEX); /* allocate sd table */
+    CHECKALLOC(plex->sdnos, "vinum: Can't allocate plex subdisk table");
+    bzero(plex->sdnos, (sizeof(int) * INITIAL_SUBDISKS_IN_PLEX)); /* do we need this? */
+    plex->subdisks = 0;					    /* no subdisks in use */
+    plex->subdisks_allocated = INITIAL_SUBDISKS_IN_PLEX;    /* and we have space for this many */
+    plex->organization = plex_disorg;			    /* and it's not organized */
+    plex->volno = -1;					    /* no volume yet */
+    return plexno;					    /* return the index */
+}
+
+/* Find the named plex in vinum_conf.plex
+
+ * If create != 0, create an entry if it doesn't exist
+ * return index in vinum_conf.plex
+ */
+int 
+find_plex(const char *name, int create)
+{
+    BROKEN_GDB;
+    int plexno;
+    struct plex *plex;
+
+    for (plexno = 0; plexno < vinum_conf.plexes_allocated; plexno++) {
+	if (strcmp(PLEX[plexno].name, name) == 0)	    /* found it */
+	    return plexno;
+    }
+
+    /* the plex isn't in the list.  Add it if he wants */
+    if (create == 0)					    /* don't want to create */
+	return -1;					    /* give up */
+
+    /* Allocate one and insert the name */
+    plexno = get_empty_plex();
+    plex = &PLEX[plexno];				    /* point to it */
+    bcopy(name, plex->name, min(sizeof(plex->name), strlen(name))); /* put in its name */
+    return plexno;					    /* return the pointer */
+}
+
+/* Free an allocated plex entry
+ * and its associated memory areas */
+void 
+free_plex(int plexno)
+{
+    BROKEN_GDB;
+    struct plex *plex;
+
+    plex = &PLEX[plexno];
+    if (plex->sdnos)
+	Free(plex->sdnos);
+    if (plex->lock)
+	Free(plex->lock);
+    if (plex->defective_region)
+	Free(plex->defective_region);
+    if (plex->unmapped_region)
+	Free(plex->unmapped_region);
+    bzero(plex, sizeof(struct plex));			    /* and clear it out */
+    plex->state = plex_unallocated;
+    vinum_conf.plexes_used--;				    /* one less plex */
+}
+
+/* Find an empty volume in the volume table */
+int 
+get_empty_volume(void)
+{
+    BROKEN_GDB;
+    int volno;
+    struct volume *vol;
+
+    /* first see if we have one which has been deallocated */
+    for (volno = 0; volno < vinum_conf.volumes_used; volno++) {
+	if (VOL[volno].state == volume_unallocated)	    /* bingo */
+	    break;
+    }
+
+    if (volno >= vinum_conf.volumes_used)
+	/* Couldn't find a deallocated volume.  Allocate a new one */
+    {
+	vinum_conf.volumes_used++;
+	if (vinum_conf.volumes_used > vinum_conf.volumes_allocated)
+	    EXPAND(VOL, struct volume, vinum_conf.volumes_allocated, INITIAL_VOLUMES);
+    }
+    /* Now initialize fields */
+    vol = &VOL[volno];
+    bzero(vol, sizeof(struct volume));
+    vol->preferred_plex = -1;				    /* default to round robin */
+    vol->preferred_plex = ROUND_ROBIN_READPOL;		    /* round robin */
+
+    return volno;					    /* return the index */
+}
+
+/* Find the named volume in vinum_conf.volume.
+
+ * If create != 0, create an entry if it doesn't exist
+ * return the index in vinum_conf
+ */
+int 
+find_volume(const char *name, int create)
+{
+    BROKEN_GDB;
+    int volno;
+    struct volume *vol;
+
+    for (volno = 0; volno < vinum_conf.volumes_used; volno++) {
+	if (strcmp(VOL[volno].name, name) == 0)		    /* found it */
+	    return volno;
+    }
+
+    /* the volume isn't in the list.  Add it if he wants */
+    if (create == 0)					    /* don't want to create */
+	return -1;					    /* give up */
+
+    /* Allocate one and insert the name */
+    volno = get_empty_volume();
+    vol = &VOL[volno];
+    bcopy(name, vol->name, min(sizeof(vol->name), strlen(name))); /* put in its name */
+    vol->blocksize = DEV_BSIZE;				    /* block size of this volume */
+    return volno;					    /* return the pointer */
+}
+
+/* Free an allocated volume entry
+ * and its associated memory areas */
+void 
+free_volume(int volno)
+{
+    BROKEN_GDB;
+    struct volume *vol;
+
+    vol = &VOL[volno];
+    bzero(vol, sizeof(struct volume));			    /* and clear it out */
+    vol->state = volume_unallocated;
+    vinum_conf.volumes_used--;				    /* one less volume */
+}
+
+/* Handle a drive definition.  We store the information in the global variable
+ * drive, so we don't need to allocate.
+ *
+ * If we find an error, print a message and return
+ */
+void 
+config_drive(void)
+{
+    BROKEN_GDB;
+    enum drive_label_info partition_status;		    /* info about the partition */
+    int parameter;
+    int driveno;					    /* index of drive in vinum_conf */
+    struct drive *drive;				    /* and pointer to it */
+
+    if (tokens < 2)					    /* not enough tokens */
+	throw_rude_remark(EINVAL, "Drive has no name");
+    driveno = find_drive(token[1], 1);			    /* allocate a drive to initialize */
+    drive = &DRIVE[driveno];				    /* and get a pointer */
+
+    if (drive->state != drive_uninit) {			    /* we already know this drive */
+	/* XXX Check which definition is more up-to-date.  Give
+	 * preference for the definition on its own drive */
+	return;						    /* XXX */
+    }
+    for (parameter = 2; parameter < tokens; parameter++) {  /* look at the other tokens */
+	switch (get_keyword(token[parameter], &keyword_set)) {
+	case kw_device:
+	    parameter++;
+	    if (drive->devicename[0] != '\0') {		    /* we know this drive... */
+		if (strcmp(drive->devicename, token[parameter])) /* different name */
+		    close_drive(drive);			    /* close it if it's open */
+		else					    /* no change */
+		    break;
+	    }
+	    bcopy(token[parameter],			    /* insert device information */
+		drive->devicename,
+		min(sizeof(drive->devicename),
+		    strlen(token[parameter])));
+	    /* open the device and get the configuration */
+	    partition_status = read_drive_label(drive);
+	    if (partition_status == DL_CANT_OPEN) {	    /* not our kind */
+		close_drive(drive);
+		if (drive->lasterror == EFTYPE)		    /* wrong kind of partition */
+		    throw_rude_remark(drive->lasterror,
+			"Drive %s has invalid partition type",
+			drive->label.name);
+		else					    /* I/O error of some kind */
+		    throw_rude_remark(drive->lasterror,
+			"Can't initialize drive %s",
+			drive->label.name);
+	    } else if (partition_status == DL_WRONG_DRIVE) { /* valid drive, not ours */
+		close_drive(drive);
+		throw_rude_remark(drive->lasterror,
+		    "Incorrect drive name %s specified for drive %s",
+		    token[1],
+		    drive->label.name);
+	    }
+	    break;
+
+	case kw_state:
+	    checkkernel(token[++parameter]);		    /* must be a kernel user */
+	    drive->state = DriveState(token[parameter]);    /* set the state */
+	    break;
+
+	default:
+	    close_drive(drive);
+	    throw_rude_remark(EINVAL,
+		"Drive %s, invalid keyword: %s",
+		token[1],
+		token[parameter]);
+	}
+    }
+
+    if (drive->devicename[0] == '\0') {
+	drive->state = drive_unallocated;		    /* deallocate the drive */
+	throw_rude_remark(EINVAL, "No device name for %s", drive->label.name);
+    }
+}
+
+/* Handle a subdisk definition.  We store the information in the global variable
+ * sd, so we don't need to allocate.
+ *
+ * If we find an error, print a message and return
+ */
+void 
+config_subdisk(void)
+{
+    BROKEN_GDB;
+    int parameter;
+    int sdno;						    /* index of sd in vinum_conf */
+    struct sd *sd;					    /* and pointer to it */
+    u_int64_t size;
+    int sectors;					    /* sector offset value */
+    int detached = 0;					    /* set to 1 if this is a detached subdisk */
+    int sdindex = -1;					    /* index in plexes subdisk table */
+    int namedsdno;
+
+    sdno = get_empty_sd();				    /* allocate an SD to initialize */
+    sd = &SD[sdno];					    /* and get a pointer */
+    for (parameter = 1; parameter < tokens; parameter++) {  /* look at the other tokens */
+	switch (get_keyword(token[parameter], &keyword_set)) {
+	case kw_detached:
+	    detached = 1;
+	    break;
+
+	case kw_plexoffset:
+	    size = sizespec(token[++parameter]);
+	    if ((size % DEV_BSIZE) != 0)
+		throw_rude_remark(EINVAL, "sd %s, bad plex offset alignment: %qd", sd->name, size);
+	    else
+		sd->plexoffset = size / DEV_BSIZE;
+	    break;
+
+	case kw_driveoffset:
+	    size = sizespec(token[++parameter]);
+	    if ((size % DEV_BSIZE) != 0)
+		throw_rude_remark(EINVAL, "sd %s, bad drive offset alignment: %qd", sd->name, size);
+	    else
+		sd->driveoffset = size / DEV_BSIZE;
+	    break;
+
+	case kw_name:
+	    namedsdno = find_subdisk(token[++parameter], 0); /* find an existing sd with this name */
+	    if (namedsdno >= 0)
+		throw_rude_remark(EINVAL, "Duplicate subdisk %s", token[parameter]);
+	    bcopy(token[parameter],
+		sd->name,
+		min(sizeof(sd->name), strlen(token[parameter])));
+	    break;
+
+	case kw_len:
+	    size = sizespec(token[++parameter]);
+	    if ((size % DEV_BSIZE) != 0)
+		throw_rude_remark(EINVAL, "sd %s, length %d not multiple of sector size", sd->name, size);
+	    else
+		sd->sectors = size / DEV_BSIZE;
+	    break;
+
+	case kw_drive:
+	    sd->driveno = find_drive(token[++parameter], 1); /* insert drive information */
+	    break;
+
+	case kw_plex:
+	    sd->plexno = find_plex(token[++parameter], 1);  /* insert plex information */
+	    break;
+
+	case kw_state:
+	    checkkernel(token[++parameter]);		    /* must be a kernel user */
+	    sd->state = SdState(token[parameter]);	    /* set the state */
+	    break;
+
+	default:
+	    throw_rude_remark(EINVAL, "sd %s, invalid keyword: %s", sd->name, token[parameter]);
+	}
+    }
+
+    /* Check we have a drive name */
+    if (sd->driveno < 0) {				    /* didn't specify a drive */
+	sd->driveno = current_drive;			    /* set to the current drive */
+	if (sd->driveno < 0)				    /* no current drive? */
+	    throw_rude_remark(EINVAL, "Subdisk %s is not associated with a drive", sd->name);
+    }
+    /*  Check for a plex name */
+    if ((sd->plexno < 0)				    /* didn't specify a plex */
+    &&(!detached))					    /* and didn't say not to, */
+	sd->plexno = current_plex;			    /* set to the current plex */
+
+    if (sd->plexno >= 0)
+	sdindex = give_sd_to_plex(sd->plexno, sdno);	    /* now tell the plex that it has this sd */
+
+    sd->sdno = sdno;					    /* point to our entry in the table */
+
+    /* Does the subdisk have a name?  If not, give it one */
+    if (sd->name[0] == '\0') {				    /* no name */
+	char sdsuffix[8];				    /* form sd name suffix here */
+
+	/* Do we have a plex name? */
+	if (sdindex >= 0)				    /* we have a plex */
+	    strcpy(sd->name, PLEX[sd->plexno].name);	    /* take it from there */
+	else						    /* no way */
+	    throw_rude_remark(EINVAL, "Unnamed sd is not associated with a plex");
+	sprintf(sdsuffix, ".s%d", sdindex);		    /* form the suffix */
+	strcat(sd->name, sdsuffix);			    /* and add it to the name */
+    }
+    /* do we have complete info for this subdisk? */
+    if (sd->sectors == 0)
+	throw_rude_remark(EINVAL, "sd %s has no length spec", sd->name);
+
+    if (sd->state == sd_unallocated)			    /* no state decided, */
+	sd->state = sd_init;				    /* at least we're in the game */
+
+    /* register the subdisk with the drive.  This action
+     * will have the side effect of setting the offset if
+     * we haven't specified one, and causing an error
+     * message if it overlaps with another subdisk. */
+    give_sd_to_drive(sdno);
+}
+
+/* Handle a plex definition.
+ * If we find an error, print a message, deallocate the nascent plex, and return
+ */
+void 
+config_plex(void)
+{
+    BROKEN_GDB;
+    int parameter;
+    int plexno;						    /* index of plex in vinum_conf */
+    struct plex *plex;					    /* and pointer to it */
+    int pindex = MAXPLEX;				    /* index in volume's plex list */
+    int detached = 0;					    /* don't give it to a volume */
+    int namedplexno;
+
+    current_plex = -1;					    /* forget the previous plex */
+    plexno = get_empty_plex();				    /* allocate a plex */
+    plex = &PLEX[plexno];				    /* and point to it */
+    plex->plexno = plexno;				    /* and back to the config */
+    for (parameter = 1; parameter < tokens; parameter++) {  /* look at the other tokens */
+	switch (get_keyword(token[parameter], &keyword_set)) {
+	case kw_detached:
+	    detached = 1;
+	    break;
+
+	case kw_name:
+	    namedplexno = find_plex(token[++parameter], 0); /* find an existing plex with this name */
+	    if (namedplexno >= 0)
+		throw_rude_remark(EINVAL, "Duplicate plex %s", token[parameter]);
+	    bcopy(token[parameter],			    /* put in the name */
+		plex->name,
+		min(MAXPLEXNAME, strlen(token[parameter])));
+	    break;
+
+	case kw_org:					    /* plex organization */
+	    switch (get_keyword(token[++parameter], &keyword_set)) {
+	    case kw_concat:
+		plex->organization = plex_concat;
+		break;
+
+	    case kw_striped:
+		{
+		    int stripesize = sizespec(token[++parameter]);
+
+		    plex->organization = plex_striped;
+		    if (stripesize % DEV_BSIZE != 0)	    /* not a multiple of block size, */
+			throw_rude_remark(EINVAL, "plex %s: stripe size %d not a multiple of sector size",
+			    plex->name,
+			    stripesize);
+		    else
+			plex->stripesize = stripesize / DEV_BSIZE;
+		    break;
+		}
+
+
+	    default:
+		throw_rude_remark(EINVAL, "Invalid plex organization");
+	    }
+	    if (((plex->organization == plex_striped)
+		)
+		&& (plex->stripesize == 0))		    /* didn't specify a valid stripe size */
+		throw_rude_remark(EINVAL, "Need a stripe size parameter");
+	    break;
+
+	case kw_volume:
+	    plex->volno = find_volume(token[++parameter], 1); /* insert a pointer to the volume */
+	    break;
+
+	case kw_sd:					    /* add a subdisk */
+	    {
+		int sdno;
+
+		sdno = find_subdisk(token[++parameter], 1); /* find a subdisk */
+		SD[sdno].plexoffset = sizespec(token[++parameter]); /* get the offset */
+		give_sd_to_plex(plexno, sdno);		    /* and insert it there */
+		break;
+	    }
+
+	case kw_state:
+	    checkkernel(token[++parameter]);		    /* only for kernel use */
+	    plex->state = PlexState(token[parameter]);	    /* set the state */
+	    break;
+
+	default:
+	    throw_rude_remark(EINVAL, "plex %s, invalid keyword: %s",
+		plex->name,
+		token[parameter]);
+	}
+    }
+
+    if ((plex->volno < 0)				    /* we don't have a volume */
+    &&(!detached))					    /* and we wouldn't object */
+	plex->volno = current_volume;
+
+    if (plex->volno >= 0)
+	pindex = give_plex_to_volume(plex->volno, plexno);  /* Now tell the volume that it has this plex */
+
+    /* Does the plex have a name?  If not, give it one */
+    if (plex->name[0] == '\0') {			    /* no name */
+	char plexsuffix[8];				    /* form plex name suffix here */
+	/* Do we have a volume name? */
+	if (plex->volno >= 0)				    /* we have a volume */
+	    strcpy(plex->name,				    /* take it from there */
+		VOL[plex->volno].name);
+	else						    /* no way */
+	    throw_rude_remark(EINVAL, "Unnamed plex is not associated with a volume");
+	sprintf(plexsuffix, ".p%d", pindex);		    /* form the suffix */
+	strcat(plex->name, plexsuffix);			    /* and add it to the name */
+    }
+    /* Note the last plex we configured */
+    current_plex = plexno;
+    if (plex->state == plex_unallocated)		    /* we haven't changed the state, */
+	plex->state = plex_init;			    /* we're initialized now */
+}
+
+/* Handle a volume definition.
+ * If we find an error, print a message, deallocate the nascent volume, and return
+ */
+void 
+config_volume(void)
+{
+    BROKEN_GDB;
+    int parameter;
+    int volno;
+    struct volume *vol;					    /* collect volume info here */
+    int i;
+
+    if (tokens < 2)					    /* not enough tokens */
+	throw_rude_remark(EINVAL, "Volume has no name");
+    current_volume = -1;				    /* forget the previous volume */
+    volno = find_volume(token[1], 1);			    /* allocate a volume to initialize */
+    vol = &VOL[volno];					    /* and get a pointer */
+
+    for (parameter = 2; parameter < tokens; parameter++) {  /* look at all tokens */
+	switch (get_keyword(token[parameter], &keyword_set)) {
+	case kw_plex:
+	    {
+		int plexno;				    /* index of this plex */
+
+		plexno = find_plex(token[++parameter], 1);  /* find a plex */
+		if (plexno < 0)				    /* couldn't */
+		    break;				    /* we've already had an error message */
+		plexno = my_plex(volno, plexno);	    /* does it already belong to us? */
+		if (plexno > 0)				    /* yes, shouldn't get it again */
+		    throw_rude_remark(EINVAL,
+			"Plex %s already belongs to volume %s",
+			token[parameter],
+			vol->name);
+		else if (++vol->plexes > 8)		    /* another entry */
+		    throw_rude_remark(EINVAL,
+			"Too many plexes for volume %s",
+			vol->name);
+		vol->plex[vol->plexes - 1] = plexno;
+	    }
+	    break;
+
+	case kw_readpol:
+	    switch (get_keyword(token[++parameter], &keyword_set)) { /* decide what to do */
+	    case kw_round:
+		vol->preferred_plex = ROUND_ROBIN_READPOL;  /* default */
+		break;
+
+	    case kw_prefer:
+		{
+		    int myplexno;			    /* index of this plex */
+
+		    myplexno = find_plex(token[++parameter], 1); /* find a plex */
+		    if (myplexno < 0)			    /* couldn't */
+			break;				    /* we've already had an error message */
+		    myplexno = my_plex(volno, myplexno);    /* does it already belong to us? */
+		    if (myplexno > 0)			    /* yes */
+			vol->preferred_plex = myplexno;	    /* just note the index */
+		    else if (++vol->plexes > 8)		    /* another entry */
+			throw_rude_remark(EINVAL, "Too many plexes");
+		    else {				    /* space for the new plex */
+			vol->plex[vol->plexes - 1] = myplexno; /* add it to our list */
+			vol->preferred_plex = vol->plexes - 1; /* and note the index */
+		    }
+		}
+		break;
+
+	    default:
+		throw_rude_remark(EINVAL, "Invalid read policy");
+	    }
+
+	case kw_setupstate:
+	    vol->flags |= VF_CONFIG_SETUPSTATE;		    /* set the volume up later on */
+	    break;
+
+	case kw_state:
+	    checkkernel(token[++parameter]);		    /* must be a kernel user */
+	    vol->state = VolState(token[parameter]);	    /* set the state */
+	    break;
+
+	    /* XXX experimental ideas.  These are not
+	     * documented, and will not be until I
+	     * decide they're worth keeping */
+	case kw_writethrough:				    /* set writethrough mode */
+	    vol->flags |= VF_WRITETHROUGH;
+	    break;
+
+	case kw_writeback:				    /* set writeback mode */
+	    vol->flags &= ~VF_WRITETHROUGH;
+	    break;
+
+	case kw_raw:
+	    vol->flags |= VF_RAW;			    /* raw volume (no label) */
+	    break;
+
+	default:
+	    throw_rude_remark(EINVAL, "volume %s, invalid keyword: %s",
+		vol->name,
+		token[parameter]);
+	}
+    }
+
+    current_volume = volno;				    /* note last referred volume */
+    vol->devno = VINUMBDEV(volno, 0, 0, VINUM_VOLUME_TYPE); /* also note device number */
+
+    /* Before we can actually use the volume, we need
+     * a volume label.  We could start to fake one here,
+     * but it will be a lot easier when we have some
+     * to copy from the drives, so defer it until we
+     * set up the configuration. XXX */
+    if (vol->state == volume_unallocated)
+	vol->state = volume_down;			    /* now ready to bring up at the end */
+
+    /* Find out how big our volume is */
+    for (i = 0; i < vol->plexes; i++)
+	vol->size = max(vol->size, PLEX[vol->plex[i]].length);
+}
+
+/* Parse a config entry.  CARE!  This destroys the original contents of the
+ * config entry, which we don't really need after this.  More specifically, it
+ * places \0 characters at the end of each token.
+ *
+ * Return 0 if all is well, otherwise EINVAL */
+int 
+parse_config(char *cptr, struct keywordset *keyset)
+{
+    BROKEN_GDB;
+    int status;
+
+    status = 0;						    /* until proven otherwise */
+    tokens = tokenize(cptr, token);			    /* chop up into tokens */
+
+    if (tokens <= 0)					    /* screwed up or empty line */
+	return tokens;					    /* give up */
+
+    if (token[0][0] == '#')				    /* comment line */
+	return 0;
+
+    switch (get_keyword(token[0], keyset)) {		    /* decide what to do */
+    case kw_read:					    /* read config from a specified drive */
+	vinum_conf.flags |= VF_KERNELOP | VF_READING_CONFIG; /* kernel operation: reading config */
+	status = check_drive(token[1]);			    /* check the drive info */
+	vinum_conf.flags &= ~(VF_KERNELOP | VF_READING_CONFIG);
+	if (status != 0) {
+	    char *msg = "Can't read configuration from %s";
+	    if (status == ENODEV)
+		msg = "No vinum configuration on %s";
+	    throw_rude_remark(status, msg, token[1]);
+	}
+	updateconfig(VF_KERNELOP);			    /* update from kernel space */
+	break;
+
+    case kw_drive:
+	config_drive();
+	break;
+
+    case kw_subdisk:
+	config_subdisk();
+	break;
+
+    case kw_plex:
+	config_plex();
+	break;
+
+    case kw_volume:
+	config_volume();
+	break;
+
+	/* Anything else is invalid in this context */
+    default:
+	throw_rude_remark(EINVAL,			    /* should we die? */
+	    "Invalid configuration information: %s",
+	    token[0]);
+    }
+    return status;
+}
+
+/* parse a line handed in from userland via ioctl.
+ * This differs only by the error reporting mechanism:
+ * we return the error indication in the reply to the
+ * ioctl, so we need to set a global static pointer in
+ * this file.  This technique works because we have
+ * ensured that configuration is performed in a single-
+ * threaded manner */
+int 
+parse_user_config(char *cptr, struct keywordset *keyset)
+{
+    BROKEN_GDB;
+    int status;
+
+    ioctl_reply = (struct _ioctl_reply *) cptr;
+    status = parse_config(cptr, keyset);
+    ioctl_reply = NULL;					    /* don't do this again */
+    return status;
+}
+
+/* Remove an object */
+void 
+remove(struct vinum_ioctl_msg *msg)
+{
+    struct vinum_ioctl_msg message = *msg;		    /* make a copy to hand on */
+
+    ioctl_reply = (struct _ioctl_reply *) msg;		    /* reinstate the address to reply to */
+    ioctl_reply->error = 0;				    /* no error, */
+    ioctl_reply->msg[0] = '\0';				    /* no message */
+
+    switch (message.type) {
+    case drive_object:
+	remove_drive_entry(message.index, message.force, message.recurse);
+	updateconfig(0);
+	return;
+
+    case sd_object:
+	remove_sd_entry(message.index, message.force, message.recurse);
+	updateconfig(0);
+	return;
+
+    case plex_object:
+	remove_plex_entry(message.index, message.force, message.recurse);
+	updateconfig(0);
+	return;
+
+    case volume_object:
+	remove_volume_entry(message.index, message.force, message.recurse);
+	updateconfig(0);
+	return;
+
+    default:
+	ioctl_reply->error = EINVAL;
+	strcpy(ioctl_reply->msg, "Invalid object type");
+    }
+}
+
+/* Remove a drive.  */
+void 
+remove_drive_entry(int driveno, int force, int recurse)
+{
+    struct drive *drive = &DRIVE[driveno];
+
+    if ((driveno > vinum_conf.drives_used)		    /* not a valid drive */
+    ||(drive->state == drive_unallocated)) {		    /* or nothing there */
+	ioctl_reply->error = EINVAL;
+	strcpy(ioctl_reply->msg, "No such drive");
+    } else if (drive->opencount > 0) {			    /* we have subdisks */
+	if (force) {					    /* do it at any cost */
+	    int sdno;
+	    struct vinum_ioctl_msg sdmsg;
+
+	    for (sdno = 0; sdno < vinum_conf.subdisks_used; sdno++) {
+		if ((SD[sdno].state != sd_unallocated)	    /* subdisk is allocated */
+		&&(SD[sdno].driveno == driveno)) {	    /* and it belongs to this drive */
+		    sdmsg.type = sd_object;
+		    sdmsg.recurse = 1;
+		    sdmsg.force = force;
+		    remove(&sdmsg);			    /* remove the subdisk by force */
+		}
+	    }
+	    remove_drive(driveno);			    /* now remove it */
+	} else
+	    ioctl_reply->error = EBUSY;			    /* can't do that */
+    } else
+	remove_drive(driveno);				    /* just remove it */
+}
+
+/* remove a subdisk */
+void 
+remove_sd_entry(int sdno, int force, int recurse)
+{
+    struct sd *sd = &SD[sdno];
+
+    if ((sdno > vinum_conf.subdisks_used)		    /* not a valid sd */
+    ||(sd->state == sd_unallocated)) {			    /* or nothing there */
+	ioctl_reply->error = EINVAL;
+	strcpy(ioctl_reply->msg, "No such subdisk");
+    } else if (sd->plexno >= 0) {			    /* we have a plex */
+	if (force) {					    /* do it at any cost */
+	    struct plex *plex = &PLEX[sd->plexno];	    /* point to our plex */
+	    int mysdno;
+
+	    for (mysdno = 0;				    /* look for ourselves */
+		mysdno < plex->subdisks && &SD[plex->sdnos[mysdno]] != sd;
+		mysdno++);
+	    if (mysdno == plex->subdisks)		    /* didn't find it */
+		throw_rude_remark(ENOENT, "plex %s does not contain subdisk %s", plex->name, sd->name);
+	    if (mysdno < (plex->subdisks - 1))		    /* not the last subdisk */
+		bcopy(&plex->sdnos[mysdno + 1],
+		    &plex->sdnos[mysdno],
+		    (plex->subdisks - 1 - mysdno) * sizeof(int));
+	    plex->subdisks--;
+	    /* removing a subdisk from a striped or
+	     * RAID-5 plex really tears the hell out
+	     * of the structure, and it needs to be
+	     * reinitialized */
+	    if (plex->organization != plex_concat)	    /* not concatenated, */
+		set_plex_state(plex->plexno, plex_faulty, setstate_force); /* need to reinitialize */
+	    rebuild_plex_unmappedlist(plex);		    /* and see what remains */
+	    free_sd(sdno);
+	} else
+	    ioctl_reply->error = EBUSY;			    /* can't do that */
+    } else
+	free_sd(sdno);
+}
+
+/* remove a plex */
+void 
+remove_plex_entry(int plexno, int force, int recurse)
+{
+    struct plex *plex = &PLEX[plexno];
+    int sdno;
+
+    if ((plexno > vinum_conf.plexes_used)		    /* not a valid plex */
+    ||(plex->state == plex_unallocated)) {		    /* or nothing there */
+	ioctl_reply->error = EINVAL;
+	strcpy(ioctl_reply->msg, "No such plex");
+    } else if (plex->pid) {				    /* we're open */
+	ioctl_reply->error = EBUSY;			    /* no getting around that */
+	return;
+    }
+    if (plex->subdisks) {
+	if (force) {					    /* do it anyway */
+	    if (recurse) {				    /* remove all below */
+		for (sdno = 0; sdno < plex->subdisks; sdno++)
+		    free_sd(plex->sdnos[sdno]);		    /* free all subdisks */
+	    } else {					    /* just tear them out */
+		for (sdno = 0; sdno < plex->subdisks; sdno++)
+		    SD[plex->sdnos[sdno]].plexno = -1;	    /* no plex any more */
+	    }
+	} else {					    /* can't do it without force */
+	    ioctl_reply->error = EBUSY;			    /* can't do that */
+	    return;
+	}
+    }
+    if (plex->volno >= 0) {				    /* we are part of a volume */
+	/* XXX This should be more intelligent.  We should
+	 * be able to remove a plex as long as the volume
+	 * does not lose any data, which is normally the
+	 * case when it has more than one plex.  To do it
+	 * right we must compare the completeness of the
+	 * mapping of all the plexes in the volume */
+	if (force) {					    /* do it at any cost */
+	    struct volume *vol = &VOL[plex->volno];
+	    int myplexno;
+
+	    for (myplexno = 0; myplexno < vol->plexes; myplexno++)
+		if (vol->plex[myplexno] == plexno)	    /* found it */
+		    break;
+	    if (myplexno == vol->plexes)		    /* didn't find it.  Huh? */
+		throw_rude_remark(ENOENT, "volume %s does not contain plex %s", vol->name, plex->name);
+	    if (myplexno < (vol->plexes - 1))		    /* not the last plex in the list */
+		bcopy(&vol->plex[myplexno + 1], &vol->plex[myplexno], vol->plexes - 1 - myplexno);
+	    vol->plexes--;
+	} else {
+	    ioctl_reply->error = EBUSY;			    /* can't do that */
+	    return;
+	}
+    }
+    free_plex(plexno);
+}
+
+/* remove a volume */
+void 
+remove_volume_entry(int volno, int force, int recurse)
+{
+    struct volume *vol = &VOL[volno];
+    int plexno;
+
+    if ((volno > vinum_conf.volumes_used)		    /* not a valid volume */
+    ||(vol->state == volume_unallocated)) {		    /* or nothing there */
+	ioctl_reply->error = EINVAL;
+	strcpy(ioctl_reply->msg, "No such volume");
+    } else if (vol->opencount)				    /* we're open */
+	ioctl_reply->error = EBUSY;			    /* no getting around that */
+    else if (vol->plexes) {
+	if (recurse && force) {				    /* remove all below */
+	    struct vinum_ioctl_msg plexmsg;
+
+	    plexmsg.type = plex_object;
+	    plexmsg.recurse = 1;
+	    plexmsg.force = force;
+	    for (plexno = 0; plexno < vol->plexes; plexno++) {
+		plexmsg.index = vol->plex[plexno];	    /* plex number */
+		remove(&plexmsg);
+	    }
+	    free_volume(volno);
+	} else
+	    ioctl_reply->error = EBUSY;			    /* can't do that */
+    } else
+	free_volume(volno);
+}
+
+void 
+update_sd_config(int sdno, int kernelstate)
+{
+    if (!kernelstate)
+	set_sd_state(sdno, sd_up, setstate_configuring | setstate_norecurse);
+}
+
+void 
+update_plex_config(int plexno, int kernelstate)
+{
+    int error = 0;
+    int size;
+    int sdno;
+    struct plex *plex = &PLEX[plexno];
+    enum plexstate state = plex_up;			    /* state we want the plex in */
+
+    /* XXX Insert checks here for sparse plexes and volumes */
+
+    /* Check that our subdisks make sense.  For
+     * striped and RAID5 plexes, we need at least
+     * two subdisks, and they must all be the same
+     * size */
+    if (((plex->organization == plex_striped)
+	)
+	&& (plex->subdisks < 2)) {
+	error = 1;
+	printf("vinum: plex %s does not have at least 2 subdisks\n", plex->name);
+	if (!kernelstate)
+	    set_plex_state(plexno, plex_down, setstate_force | setstate_configuring | setstate_norecurse);
+    }
+    size = 0;
+    for (sdno = 0; sdno < plex->subdisks; sdno++) {
+	if (((plex->organization == plex_striped)
+	    )
+	    && (sdno > 0)
+	    && (SD[plex->sdnos[sdno]].sectors != SD[plex->sdnos[sdno - 1]].sectors)) {
+	    error = 1;
+	    printf("vinum: plex %s must have equal sized subdisks\n", plex->name);
+	    set_plex_state(plexno, plex_down, setstate_force | setstate_configuring | setstate_norecurse);
+	}
+	size += SD[plex->sdnos[sdno]].sectors;
+    }
+
+    if (plex->subdisks) {				    /* plex has subdisks, calculate size */
+	rebuild_plex_unmappedlist(plex);		    /* rebuild the unmapped list first */
+
+	plex->length = size;
+    } else {						    /* no subdisks, */
+	plex->length = 0;				    /* no size */
+	state = plex_down;				    /* take it down */
+    }
+    if (!(kernelstate || error))
+	set_plex_state(plexno, state, setstate_none | setstate_configuring | setstate_norecurse);
+}
+
+void 
+update_volume_config(int volno, int kernelstate)
+{
+    struct volume *vol = &VOL[volno];
+    struct plex *plex;
+    int plexno;
+
+    if (vol->state != volume_unallocated)
+	/* Recalculate the size of the volume */
+    {
+	vol->size = 0;
+	for (plexno = 0; plexno < vol->plexes; plexno++) {
+	    plex = &PLEX[vol->plex[plexno]];
+	    vol->size = max(plex->length, vol->size);	    /* maximum size */
+	    plex->volplexno = plexno;			    /* note it in the plex */
+	}
+    }
+    if (!kernelstate)					    /* try to bring it up */
+	set_volume_state(volno, volume_up, setstate_configuring | setstate_norecurse);
+}
+
+/* Update the global configuration.
+ * kernelstate is != 0 if we're reading in a config
+ * from disk.  In this case, we don't try to
+ * bring the devices up, though we will bring
+ * them down if there's some error which got
+ * missed when writing to disk.
+ */
+void 
+updateconfig(int kernelstate)
+{
+    BROKEN_GDB;
+    int sdno;
+    int plexno;
+    int volno;
+    struct volume *vol;
+    struct plex *plex;
+
+    for (sdno = 0; sdno < vinum_conf.subdisks_used; sdno++)
+	update_sd_config(sdno, kernelstate);
+
+    for (plexno = 0; plexno < vinum_conf.plexes_used; plexno++)
+	update_plex_config(plexno, kernelstate);
+
+    for (volno = 0; volno < vinum_conf.volumes_used; volno++)
+	update_volume_config(volno, kernelstate);
+    save_config();
+}
+
+/* Start manual changes to the configuration and lock out
+ * others who may wish to do so.
+ * XXX why do we need this and lock_config too? */
+int 
+start_config(void)
+{
+    int error;
+
+    while ((vinum_conf.flags & VF_CONFIGURING) != 0) {
+	vinum_conf.flags |= VF_WILL_CONFIGURE;
+	if ((error = tsleep(&vinum_conf, PRIBIO | PCATCH, "vincfg", 0)) != 0)
+	    return error;
+    }
+    /* We need two flags here: VF_CONFIGURING
+     * tells other processes to hold off (this 
+     * function), and VF_CONFIG_INCOMPLETE
+     * tells the state change routines not to
+     * propagate incrememntal state changes */
+    vinum_conf.flags |= VF_CONFIGURING | VF_CONFIG_INCOMPLETE;
+    current_drive = -1;					    /* reset the defaults */
+    current_plex = -1;					    /* and the same for the last plex */
+    current_volume = -1;				    /* and the last volme */
+    return 0;
+}
+
+/* Update the config if update is 1, and unlock
+ * it.  We won't update the configuration if we
+ * are called in a recursive loop via throw_rude_remark.
+ */
+void 
+finish_config(int update)
+{
+    vinum_conf.flags &= ~VF_CONFIG_INCOMPLETE;		    /* we've finished our config */
+    if (update)
+	updateconfig(0);				    /* so update things */
+    else
+	updateconfig(1);				    /* do some updates only */
+    vinum_conf.flags &= ~VF_CONFIGURING;		    /* and now other people can take a turn */
+    if ((vinum_conf.flags & VF_WILL_CONFIGURE) != 0) {
+	vinum_conf.flags &= ~VF_WILL_CONFIGURE;
+	wakeup(&vinum_conf);
+    }
+}
diff --git a/sys/dev/vinum/vinumext.h b/sys/dev/vinum/vinumext.h
new file mode 100644
index 0000000..ab1d143
--- /dev/null
+++ b/sys/dev/vinum/vinumext.h
@@ -0,0 +1,204 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: vinumext.h,v 1.2 1998/10/21 08:32:32 grog Exp $
+ */
+
+/* vinumext.h: external definitions */
+
+extern struct _vinum_conf vinum_conf;			    /* configuration information */
+
+#ifdef DEBUG
+extern debug;						    /* debug flags */
+#endif
+
+#define CHECKALLOC(ptr, msg) \
+  if (ptr == NULL) \
+    { \
+    printf (msg); \
+    longjmp (command_fail, -1); \
+    }
+#ifndef KERNEL
+struct vnode;
+struct proc;
+#endif
+
+#ifdef KERNEL
+int give_sd_to_plex(int plexno, int sdno);
+int give_plex_to_volume(int volno, int plexno);
+int check_drive(char *);
+enum drive_label_info read_drive_label(struct drive *drive);
+int parse_config(char *, struct keywordset *);
+int parse_user_config(char *cptr, struct keywordset *keyset);
+u_int64_t sizespec(char *spec);
+int volume_index(struct volume *volume);
+int plex_index(struct plex *plex);
+int sd_index(struct sd *sd);
+int drive_index(struct drive *drive);
+int my_plex(int volno, int plexno);
+int my_sd(int plexno, int sdno);
+int get_empty_drive(void);
+int find_drive(const char *name, int create);
+int find_drive_by_dev(const char *devname, int create);
+int get_empty_sd(void);
+int find_subdisk(const char *name, int create);
+void free_sd(int sdno);
+void free_volume(int volno);
+int get_empty_plex(void);
+int find_plex(const char *name, int create);
+void free_plex(int plexno);
+int get_empty_volume(void);
+int find_volume(const char *name, int create);
+void config_subdisk(void);
+void config_plex(void);
+void config_volume(void);
+void config_drive(void);
+void updateconfig(int);
+void update_sd_config(int sdno, int kernelstate);
+void update_plex_config(int plexno, int kernelstate);
+void update_volume_config(int volno, int kernelstate);
+void update_config(void);
+void drive_io_done(struct buf *);
+int save_config(void);
+void write_config(char *, int);
+int start_config(void);
+void finish_config(int);
+void remove(struct vinum_ioctl_msg *msg);
+void remove_drive_entry(int driveno, int force, int recurse);
+void remove_sd_entry(int sdno, int force, int recurse);
+void remove_plex_entry(int plexno, int force, int recurse);
+void remove_volume_entry(int volno, int force, int recurse);
+
+void checkernel(char *);
+int open_drive(struct drive *, struct proc *);
+void close_drive(struct drive *drive);
+int driveio(struct drive *, void *, size_t, off_t, int);
+/* #define read_drive(a, b, c, d) driveio (a, b, c, d, B_READ)
+   #define write_drive(a, b, c, d) driveio (a, b, c, d, B_WRITE) */
+int set_drive_parms(struct drive *drive);
+int init_drive(struct drive *);
+/* void throw_rude_remark (int, struct _ioctl_reply *, char *, ...); XXX */
+void throw_rude_remark(int, char *,...);
+
+int read_drive(struct drive *drive, void *buf, size_t length, off_t offset);
+int write_drive(struct drive *drive, void *buf, size_t length, off_t offset);
+void format_config(char *config, int len);
+void checkkernel(char *op);
+void free_drive(struct drive *drive);
+void down_drive(struct drive *drive);
+void remove_drive(int driveno);
+
+/* I/O */
+d_open_t vinumopen;
+d_close_t vinumclose;
+d_strategy_t vinumstrategy;
+d_ioctl_t vinumioctl;
+d_dump_t vinumdump;
+d_psize_t vinumsize;
+d_read_t vinumread;
+d_write_t vinumwrite;
+
+int vinumstart(struct buf *bp, int reviveok);
+int launch_requests(struct request *rq, int reviveok);
+
+/* XXX Do we need this? */
+int vinumpart(dev_t);
+
+#ifdef DEBUG
+/* Memory allocation and request tracing */
+void vinum_meminfo(caddr_t data);
+int vinum_mallocinfo(caddr_t data);
+int vinum_rqinfo(caddr_t data);
+#endif
+
+void expand_table(void **, int, int);
+
+void add_defective_region(struct plex *plex, off_t offset, size_t length);
+void add_unmapped_region(struct plex *plex, off_t offset, size_t length);
+void rebuild_plex_unmappedlist(struct plex *plex);
+struct request;
+struct rqgroup *allocrqg(struct request *rq, int elements);
+void deallocrqg(struct rqgroup *rqg);
+
+/* State transitions */
+int set_drive_state(int driveno, enum drivestate state, int force);
+int set_sd_state(int sdno, enum sdstate state, enum setstateflags flags);
+enum requeststatus checksdstate(struct sd *sd, struct request *rq, daddr_t diskaddr, daddr_t diskend);
+int set_plex_state(int plexno, enum plexstate state, enum setstateflags flags);
+int set_volume_state(int volumeno, enum volumestate state, enum setstateflags flags);
+void get_volume_label(struct volume *vol, struct disklabel *lp);
+int write_volume_label(int);
+void start_object(struct vinum_ioctl_msg *);
+void stop_object(struct vinum_ioctl_msg *);
+void setstate(struct vinum_ioctl_msg *msg);
+void vinum_label(int);
+int vinum_writedisklabel(struct volume *, struct disklabel *);
+int initsd(int);
+
+int restart_plex(int plexno);
+int revive_block(int plexno);
+
+/* Auxiliary functions */
+enum sdstates sdstatemap(struct plex *plex, int *sddowncount);
+enum volplexstate vpstate(struct plex *plex);
+#endif
+
+enum keyword get_keyword(char *, struct keywordset *);
+void listconfig(void);
+char *drive_state(enum drivestate);
+char *volume_state(enum volumestate);
+char *plex_state(enum plexstate);
+char *plex_org(enum plexorg);
+char *sd_state(enum sdstate);
+enum drivestate DriveState(char *text);
+enum sdstate SdState(char *text);
+enum plexstate PlexState(char *text);
+enum volumestate VolState(char *text);
+struct drive *validdrive(int driveno, struct _ioctl_reply *);
+struct sd *validsd(int sdno, struct _ioctl_reply *);
+struct plex *validplex(int plexno, struct _ioctl_reply *);
+struct volume *validvol(int volno, struct _ioctl_reply *);
+int tokenize(char *, char *[]);
+void resetstats(struct vinum_ioctl_msg *msg);
+
+/* Locking */
+int lockvol(struct volume *vol);
+void unlockvol(struct volume *vol);
+int lockplex(struct plex *plex);
+void unlockplex(struct plex *plex);
+int lockrange(struct plex *plex, off_t first, off_t last);
+void unlockrange(struct plex *plex, off_t first, off_t last);
+int lock_config(void);
+void unlock_config(void);
diff --git a/sys/dev/vinum/vinumhdr.h b/sys/dev/vinum/vinumhdr.h
new file mode 100644
index 0000000..af86c61
--- /dev/null
+++ b/sys/dev/vinum/vinumhdr.h
@@ -0,0 +1,103 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ */
+
+/* Header files used by all modules */
+/* $Id: vinumhdr.h,v 1.2 1998/11/06 01:34:06 peter Exp $ */
+
+#ifdef KERNEL
+#define REALLYKERNEL
+#endif
+#include <sys/param.h>
+#ifdef REALLYKERNEL
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#endif
+#ifdef DEVFS
+#error "DEVFS code not complete yet"
+#include <sys/devfsext.h>
+#endif /*DEVFS */
+#include <sys/proc.h>
+#include <sys/errno.h>
+#include <sys/dkstat.h>
+#include <sys/buf.h>
+#include <sys/malloc.h>
+#include <sys/uio.h>
+#include <sys/namei.h>
+#include <sys/conf.h>
+#include <sys/stat.h>
+#include <sys/disklabel.h>
+#include <ufs/ffs/fs.h>
+#include <sys/mount.h>
+#include <sys/device.h>
+#undef KERNEL						    /* XXX */
+#include <sys/disk.h>
+#ifdef REALLYKERNEL
+#define KERNEL
+#endif
+#include <sys/syslog.h>
+#include <sys/fcntl.h>
+#include <sys/vnode.h>
+#include <sys/dkbad.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <vm/vm.h>
+#ifdef USES_VM
+/* XXX Do we need this? */
+#include <vm/vm_extern.h>
+#include <vm/vm_kern.h>
+#include <vm/vm_object.h>
+#include <vm/vm_prot.h>
+/* #include <vm/vm_page.h> */
+#include <sys/vmmeter.h>
+/* #include <machine/pmap.h> */
+#endif							    /* USES_VM */
+#include <vinumvar.h>
+#include <vinumio.h>
+#include "vinumkw.h"
+#include "vinumext.h"
+
+#undef Free						    /* defined in some funny net stuff */
+#ifdef REALLYKERNEL
+#define Malloc(x)  MMalloc ((x), __FILE__, __LINE__)	    /* show where we came from */
+#define Free(x)	   FFree ((x), __FILE__, __LINE__)	    /* show where we came from */
+caddr_t MMalloc (int size, char *, int);
+void FFree (void *mem, char *, int);
+#else
+#define Malloc(x)  malloc ((x))				    /* just the size */
+#define Free(x)	   free ((x))				    /* just the address */
+#endif
+
diff --git a/sys/dev/vinum/vinuminterrupt.c b/sys/dev/vinum/vinuminterrupt.c
new file mode 100644
index 0000000..b97ec3e
--- /dev/null
+++ b/sys/dev/vinum/vinuminterrupt.c
@@ -0,0 +1,198 @@
+/* interrupt.c: bottom half of the driver */
+
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: interrupt.c,v 1.3 1998/11/03 06:37:57 grog Exp $
+ */
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+#include "request.h"
+#include <miscfs/specfs/specdev.h>
+#include <sys/resourcevar.h>
+
+void complete_raid5_write(struct rqelement *);
+void freerq(struct request *rq);
+void free_rqg(struct rqgroup *rqg);
+void complete_rqe(struct buf *bp);
+void sdio_done(struct buf *bp);
+
+/* Take a completed buffer, transfer the data back if
+ * it's a read, and complete the high-level request
+ * if this is the last subrequest.
+ *
+ * The bp parameter is in fact a struct rqelement, which
+ * includes a couple of extras at the end.
+ */
+void 
+complete_rqe(struct buf *bp)
+{
+    BROKEN_GDB;
+    struct rqelement *rqe;
+    struct request *rq;
+    struct rqgroup *rqg;
+    struct buf *ubp;					    /* user buffer */
+
+    rqe = (struct rqelement *) bp;			    /* point to the element element that completed */
+    rqg = rqe->rqg;					    /* and the request group */
+    rq = rqg->rq;					    /* and the complete request */
+    ubp = rq->bp;					    /* user buffer */
+
+#ifdef DEBUG
+    if (debug & DEBUG_LASTREQS)
+	logrq(loginfo_iodone, rqe, ubp);
+#endif
+    if ((bp->b_flags & B_ERROR) != 0) {			    /* transfer in error */
+	if (bp->b_error != 0)				    /* did it return a number? */
+	    rq->error = bp->b_error;			    /* yes, put it in. */
+	else if (rq->error == 0)			    /* no: do we have one already? */
+	    rq->error = EIO;				    /* no: catchall "I/O error" */
+	if (rq->error == EIO)				    /* I/O error, */
+	    set_sd_state(rqe->sdno, sd_crashed, setstate_force | setstate_noupdate); /* take the subdisk down */
+	else if (rq->error = ENXIO)			    /* or "not configured" (drive down) */
+	    set_drive_state(rqe->driveno,		    /* take the drive down */
+		drive_down,
+		setstate_force | setstate_noupdate);
+    }
+    /* Now update the statistics */
+    if (bp->b_flags & B_READ) {				    /* read operation */
+	DRIVE[rqe->driveno].reads++;
+	DRIVE[rqe->driveno].bytes_read += bp->b_bcount;
+	SD[rqe->sdno].reads++;
+	SD[rqe->sdno].bytes_read += bp->b_bcount;
+	PLEX[rqe->rqg->plexno].reads++;
+	PLEX[rqe->rqg->plexno].bytes_read += bp->b_bcount;
+    } else {						    /* write operation */
+	DRIVE[rqe->driveno].writes++;
+	DRIVE[rqe->driveno].bytes_written += bp->b_bcount;
+	SD[rqe->sdno].writes++;
+	SD[rqe->sdno].bytes_written += bp->b_bcount;
+	PLEX[rqe->rqg->plexno].writes++;
+	PLEX[rqe->rqg->plexno].bytes_written += bp->b_bcount;
+    }
+    rqg->active--;					    /* one less request active */
+    if (rqg->active == 0)				    /* request group finished, */
+	rq->active--;					    /* one less */
+    if (rq->active == 0) {				    /* request finished, */
+#if DEBUG
+	if (debug & DEBUG_RESID) {
+	    if (ubp->b_resid != 0)			    /* still something to transfer? */
+		Debugger("resid");
+
+	    {
+		int i;
+		for (i = 0; i < ubp->b_bcount; i += 512)    /* XXX debug */
+		    if (((char *) ubp->b_data)[i] != '<') { /* and not what we expected */
+			printf("At 0x%x (offset 0x%x): '%c' (0x%x)\n",
+			    (int) (&((char *) ubp->b_data)[i]),
+			    i,
+			    ((char *) ubp->b_data)[i],
+			    ((char *) ubp->b_data)[i]);
+			Debugger("complete_request checksum");
+		    }
+	    }
+	}
+#endif
+
+	if (rq->error) {				    /* did we have an error? */
+	    ubp->b_flags |= B_ERROR;			    /* yes, propagate to user */
+	    ubp->b_error = rq->error;
+	} else
+	    ubp->b_resid = 0;				    /* completed our transfer */
+	if (rq->isplex == 0)				    /* volume request, */
+	    VOL[rq->volplex.volno].active--;		    /* another request finished */
+	biodone(ubp);					    /* top level buffer completed */
+	freerq(rq);					    /* return the request storage */
+    }
+}
+
+
+/* Free a request block and anything hanging off it */
+void 
+freerq(struct request *rq)
+{
+    BROKEN_GDB;
+    struct rqgroup *rqg;
+    struct rqgroup *nrqg;				    /* next in chain */
+    int rqno;
+
+    for (rqg = rq->rqg; rqg != NULL; rqg = nrqg) {	    /* through the whole request chain */
+	for (rqno = 0; rqno < rqg->count; rqno++)
+	    if ((rqg->rqe[rqno].flags & XFR_MALLOCED)	    /* data buffer was malloced, */
+	    &&rqg->rqe[rqno].b.b_data)			    /* and the allocation succeeded */
+		Free(rqg->rqe[rqno].b.b_data);		    /* free it */
+	nrqg = rqg->next;				    /* note the next one */
+	Free(rqg);					    /* and free this one */
+    }
+    Free(rq);						    /* free the request itself */
+}
+
+void 
+free_rqg(struct rqgroup *rqg)
+{
+    if ((rqg->flags & XFR_GROUPOP)			    /* RAID 5 request */
+    &&(rqg->rqe) /* got a buffer structure */
+    &&(rqg->rqe->b.b_data))				    /* and it has a buffer allocated */
+	Free(rqg->rqe->b.b_data);			    /* free it */
+}
+
+/* I/O on subdisk completed */
+void 
+sdio_done(struct buf *bp)
+{
+    struct sdbuf *sbp;
+
+    sbp = (struct sdbuf *) bp;
+    if (sbp->b.b_flags & B_ERROR) {			    /* had an error */
+	bp->b_flags |= B_ERROR;
+	bp->b_error = sbp->b.b_error;
+    }
+    bp->b_resid = sbp->b.b_resid;
+    biodone(sbp->bp);					    /* complete the caller's I/O */
+    /* Now update the statistics */
+    if (bp->b_flags & B_READ) {				    /* read operation */
+	DRIVE[sbp->driveno].reads++;
+	DRIVE[sbp->driveno].bytes_read += bp->b_bcount;
+	SD[sbp->sdno].reads++;
+	SD[sbp->sdno].bytes_read += bp->b_bcount;
+    } else {						    /* write operation */
+	DRIVE[sbp->driveno].writes++;
+	DRIVE[sbp->driveno].bytes_written += bp->b_bcount;
+	SD[sbp->sdno].writes++;
+	SD[sbp->sdno].bytes_written += bp->b_bcount;
+    }
+    Free(sbp);
+}
diff --git a/sys/dev/vinum/vinumio.c b/sys/dev/vinum/vinumio.c
new file mode 100644
index 0000000..e61cf0c
--- /dev/null
+++ b/sys/dev/vinum/vinumio.c
@@ -0,0 +1,907 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: io.c,v 1.3 1998/11/03 06:38:26 grog Exp $
+ */
+
+#define STATIC						    /* nothing while we're testing XXX */
+
+#if __FreeBSD__ < 3					    /* this is in sys/disklabel.h in 3.0 and on */
+#define DTYPE_VINUM		12			    /* vinum volume */
+#endif
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+#include <miscfs/specfs/specdev.h>
+
+extern jmp_buf command_fail;				    /* return on a failed command */
+struct _ioctl_reply *ioctl_reply;			    /* data pointer, for returning error messages */
+
+#if __FreeBSD__ >= 3
+/* Why aren't these declared anywhere? XXX */
+int setjmp(jmp_buf);
+void longjmp(jmp_buf, int);
+#endif
+
+/* pointer to ioctl p parameter, to save passing it around */
+extern struct proc *myproc;
+
+/* Open the device associated with the drive, and set drive's vp */
+int
+open_drive(struct drive *drive, struct proc *p)
+{
+    BROKEN_GDB;
+    struct nameidata nd;
+    struct vattr va;
+    int error;
+
+    if (drive->devicename[0] == '\0')			    /* no device name */
+	sprintf(drive->devicename, "/dev/%s", drive->label.name); /* get it from the drive name */
+    NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, drive->devicename, p);
+    error = vn_open(&nd, FREAD | FWRITE, 0);		    /* open the device */
+    if (error != 0) {					    /* can't open? */
+	set_drive_state(drive->driveno, drive_down, 1);
+	drive->lasterror = error;
+	printf("vinum open_drive %s: failed with error %d\n", drive->devicename, error); /* XXX */
+	return error;
+    }
+    drive->vp = nd.ni_vp;
+    drive->p = p;
+
+    if (drive->vp->v_usecount > 1) {			    /* already in use? */
+#if 1
+	printf("open_drive %s: use count %d, ignoring\n",   /* XXX where does this come from? */
+	    drive->devicename,
+	    drive->vp->v_usecount);
+	drive->vp->v_usecount = 1;			    /* will this work? */
+#else
+#if __FreeBSD__ == 2					    /* pre-4.4BSD Lite/2 parameters */
+	VOP_UNLOCK(drive->vp);
+#else
+	VOP_UNLOCK(drive->vp, 0, p);
+#endif
+	close_drive(drive);
+	set_drive_state(drive->driveno, drive_down, 1);
+	drive->lasterror = EBUSY;
+	printf("vinum open_drive %s: Drive in use\n", drive->devicename); /* XXX */
+	return EBUSY;
+#endif
+    }
+    error = VOP_GETATTR(drive->vp, &va, NOCRED, p);
+    if (error) {
+#if __FreeBSD__ == 2					    /* pre-4.4BSD Lite/2 parameters */
+	VOP_UNLOCK(drive->vp);
+#else
+	VOP_UNLOCK(drive->vp, 0, p);
+#endif
+	close_drive(drive);
+	set_drive_state(drive->driveno, drive_down, 1);
+	drive->lasterror = error;
+	printf("vinum open_drive %s: GETAATTR returns error %d\n", drive->devicename, error); /* XXX */
+	return error;
+    }
+    drive->dev = va.va_rdev;				    /* device */
+
+    if (va.va_type != VBLK) {				    /* only consider block devices */
+#if __FreeBSD__ == 2					    /* pre-4.4BSD Lite/2 parameters */
+	VOP_UNLOCK(drive->vp);
+#else
+	VOP_UNLOCK(drive->vp, 0, p);
+#endif
+	close_drive(drive);
+	set_drive_state(drive->driveno, drive_down, 1);	    /* this also closes the drive */
+	drive->lasterror = ENOTBLK;
+	printf("vinum open_drive %s: Not a block device\n", drive->devicename);	/* XXX */
+	return ENOTBLK;
+    }
+    drive->vp->v_numoutput = 0;
+#if __FreeBSD__ == 2					    /* pre-4.4BSD Lite/2 parameters */
+    VOP_UNLOCK(drive->vp);
+#else
+    VOP_UNLOCK(drive->vp, 0, p);
+#endif
+    return 0;
+}
+
+/* Set some variables in the drive struct
+ * in more convenient form.  Return error indication */
+int 
+set_drive_parms(struct drive *drive)
+{
+    drive->blocksize = BLKDEV_IOSIZE;			    /* XXX do we need this? */
+    drive->secsperblock = drive->blocksize		    /* number of sectors per block */
+	/ drive->partinfo.disklab->d_secsize;
+
+    /* Now update the label part */
+    bcopy(hostname, drive->label.sysname, VINUMHOSTNAMELEN); /* put in host name */
+#if __FreeBSD__ >= 3
+    getmicrotime(&drive->label.date_of_birth);		    /* and current time */
+#else
+    drive->label.date_of_birth = time;			    /* and current time */
+#endif
+    drive->label.drive_size = ((u_int64_t) drive->partinfo.part->p_size) /* size of the drive in bytes */
+    *((u_int64_t) drive->partinfo.disklab->d_secsize);
+
+    /* number of sectors available for subdisks */
+    drive->sectors_available = drive->label.drive_size / DEV_BSIZE - DATASTART;
+
+    /* XXX Bug in 3.0 as of January 1998: you can open
+     * non-existent slices.  They have a length of 0 */
+    if (drive->label.drive_size < MINVINUMSLICE) {	    /* too small to worry about */
+	set_drive_state(drive->driveno, drive_down, 1);
+	printf("vinum open_drive %s: Drive too small\n", drive->devicename); /* XXX */
+	drive->lasterror = ENOSPC;
+	return ENOSPC;
+    }
+    drive->freelist_size = INITIAL_DRIVE_FREELIST;	    /* initial number of entries */
+    drive->freelist = (struct drive_freelist *)
+	Malloc(INITIAL_DRIVE_FREELIST * sizeof(struct drive_freelist));
+    if (drive->freelist == NULL)			    /* can't malloc, dammit */
+	return ENOSPC;
+    drive->freelist_entries = 1;			    /* just (almost) the complete drive */
+    drive->freelist[0].offset = DATASTART;		    /* starts here */
+    drive->freelist[0].sectors = (drive->label.drive_size >> DEV_BSHIFT) - DATASTART; /* and it's this long */
+    set_drive_state(drive->driveno, drive_up, 1);	    /* our drive is accessible */
+    return 0;
+}
+
+/* Initialize a drive: open the device and add device
+ * information */
+int 
+init_drive(struct drive *drive)
+{
+    BROKEN_GDB;
+    int error;
+
+    if (drive->devicename[0] == '\0') {			    /* no device name yet, default to drive name */
+	drive->lasterror = EINVAL;
+	printf("vinum: Can't open drive without drive name\n");	/* XXX */
+	return EINVAL;
+    }
+    error = open_drive(drive, myproc);			    /* open the drive */
+    if (error)
+	return error;
+
+    error = VOP_IOCTL(drive->vp,			    /* get the partition information */
+	DIOCGPART,
+	(caddr_t) & drive->partinfo,
+	FREAD,
+	NOCRED,
+	myproc);
+    if (error) {
+	printf("vinum open_drive %s: Can't get partition information, error %d\n",
+	    drive->devicename,
+	    error);					    /* XXX */
+	close_drive(drive);
+	drive->lasterror = error;
+	set_drive_state(drive->driveno, drive_down, 1);
+	return error;
+    }
+    if (drive->partinfo.part->p_fstype != 0) {		    /* not plain */
+	drive->lasterror = EFTYPE;
+	printf("vinum open_drive %s: Wrong partition type for vinum\n", drive->devicename); /* XXX */
+	close_drive(drive);
+	set_drive_state(drive->driveno, drive_down, 1);
+	return EFTYPE;
+    }
+    return set_drive_parms(drive);			    /* set various odds and ends */
+}
+
+/* Close a drive if it's open.  No errors */
+void 
+close_drive(struct drive *drive)
+{
+    if (drive->vp) {
+	vn_close(drive->vp, FREAD | FWRITE, NOCRED, drive->p);
+	if (drive->vp->v_usecount) {			    /* XXX shouldn't happen */
+	    printf("close_drive %s: use count still %d\n", drive->devicename, drive->vp->v_usecount);
+	    drive->vp->v_usecount = 0;			    /* will this work? */
+	}
+	drive->vp = NULL;
+    }
+}
+
+/* Remove drive from the configuration.
+ * Caller must ensure that it isn't active
+ */
+void 
+remove_drive(int driveno)
+{
+    BROKEN_GDB;
+    struct drive *drive = &vinum_conf.drive[driveno];
+    long long int nomagic = VINUM_NOMAGIC;		    /* no magic number */
+
+    write_drive(drive,					    /* obliterate the magic, but leave a hint */
+	(char *) &nomagic,
+	8,
+	VINUM_LABEL_OFFSET);
+    close_drive(drive);					    /* and close it */
+    drive->state = drive_unallocated;			    /* and forget everything we knew about it */
+    save_config();					    /* and save the updated configuration */
+}
+
+/* Transfer drive data.  Usually called from one of these defines;
+ * #define read_drive(a, b, c, d) driveio (a, b, c, d, B_READ)
+ * #define write_drive(a, b, c, d) driveio (a, b, c, d, B_WRITE)
+ *
+ * Return error number
+ */
+int
+driveio(struct drive *drive, void *buf, size_t length, off_t offset, int flag)
+{
+    BROKEN_GDB;
+    int error;
+    struct buf *bp;
+    int spl;
+
+    error = 0;
+
+    /* Get a buffer */
+    bp = (struct buf *) Malloc(sizeof(struct buf));	    /* get a buffer */
+    CHECKALLOC(bp, "Can't allocate memory");
+
+    bzero(&buf, sizeof(buf));
+    bp->b_flags = B_BUSY | flag;			    /* tell us when it's done */
+    bp->b_iodone = drive_io_done;			    /* here */
+    bp->b_proc = myproc;				    /* process */
+    bp->b_dev = drive->vp->v_un.vu_specinfo->si_rdev;	    /* device */
+    if (offset & (drive->partinfo.disklab->d_secsize - 1))  /* not on a block boundary */
+	bp->b_blkno = offset / drive->partinfo.disklab->d_secsize; /* block number */
+    bp->b_data = buf;
+    bp->b_vp = drive->vp;				    /* vnode */
+    bp->b_bcount = length;
+    bp->b_bufsize = length;
+
+    (*bdevsw[major(bp->b_dev)]->d_strategy) (bp);	    /* initiate the transfer */
+
+    spl = splbio();
+    while ((bp->b_flags & B_DONE) == 0) {
+	bp->b_flags |= B_CALL;				    /* wake me again */
+	tsleep((caddr_t) bp, PRIBIO, "driveio", 0);	    /* and wait for it to complete */
+    }
+    splx(spl);
+    if (bp->b_flags & B_ERROR)				    /* didn't work */
+	error = bp->b_error;				    /* get the error return */
+    Free(bp);						    /* then return the buffer */
+    return error;
+}
+
+/* Read data from a drive
+
+ * Return error number
+ */
+int
+read_drive(struct drive *drive, void *buf, size_t length, off_t offset)
+{
+    BROKEN_GDB;
+    int error;
+    struct buf *bp;
+    daddr_t nextbn;
+    long bscale;
+
+    struct uio uio;
+    struct iovec iov;
+    daddr_t blocknum;					    /* block number */
+    int blockoff;					    /* offset in block */
+    int count;						    /* amount to transfer */
+
+    iov.iov_base = buf;
+    iov.iov_len = length;
+
+    uio.uio_iov = &iov;
+    uio.uio_iovcnt = length;
+    uio.uio_offset = offset;
+    uio.uio_resid = length;
+    uio.uio_segflg = UIO_SYSSPACE;
+    uio.uio_rw = UIO_READ;
+    uio.uio_procp = myproc;
+
+    bscale = btodb(drive->blocksize);			    /* mask off offset from block number */
+    do {
+	blocknum = btodb(uio.uio_offset) & ~(bscale - 1);   /* get the block number */
+	blockoff = uio.uio_offset % drive->blocksize;	    /* offset in block */
+	count = min((unsigned) (drive->blocksize - blockoff), /* amount to transfer in this block */
+	    uio.uio_resid);
+
+	/* XXX Check this.  I think the test is wrong */
+	if (drive->vp->v_lastr + bscale == blocknum) {	    /* did our last read finish in this block? */
+	    nextbn = blocknum + bscale;			    /* note the end of the transfer */
+	    error = breadn(drive->vp,			    /* and read with read-ahead */
+		blocknum,
+		(int) drive->blocksize,
+		&nextbn,
+		(int *) &drive->blocksize,
+		1,
+		NOCRED,
+		&bp);
+	} else						    /* random read: just read this block */
+	    error = bread(drive->vp, blocknum, (int) drive->blocksize, NOCRED, &bp);
+	drive->vp->v_lastr = blocknum;			    /* note the last block we read */
+	count = min(count, drive->blocksize - bp->b_resid);
+	if (error) {
+	    brelse(bp);
+	    return error;
+	}
+	error = uiomove((char *) bp->b_data + blockoff, count, &uio); /* move the data */
+	brelse(bp);
+    }
+    while (error == 0 && uio.uio_resid > 0 && count != 0);
+    return error;
+}
+
+/* Write data to a drive
+
+ * Return error number
+ */
+int 
+write_drive(struct drive *drive, void *buf, size_t length, off_t offset)
+{
+    BROKEN_GDB;
+    int error;
+    struct buf *bp;
+    struct uio uio;
+    struct iovec iov;
+    daddr_t blocknum;					    /* block number */
+    int blockoff;					    /* offset in block */
+    int count;						    /* amount to transfer */
+    int blockshift;
+
+    if (drive->state == drive_down)			    /* currently down */
+	return 0;					    /* ignore */
+    if (drive->vp == NULL) {
+	drive->lasterror = ENODEV;
+	return ENODEV;					    /* not configured yet */
+    }
+    iov.iov_base = buf;
+    iov.iov_len = length;
+
+    uio.uio_iov = &iov;
+    uio.uio_iovcnt = length;
+    uio.uio_offset = offset;
+    uio.uio_resid = length;
+    uio.uio_segflg = UIO_SYSSPACE;
+    uio.uio_rw = UIO_WRITE;
+    uio.uio_procp = myproc;
+
+    error = 0;
+    blockshift = btodb(drive->blocksize) - 1;		    /* amount to shift block number
+							    * to get sector number */
+    do {
+	blocknum = btodb(uio.uio_offset) & ~blockshift;	    /* get the block number */
+	blockoff = uio.uio_offset % drive->blocksize;	    /* offset in block */
+	count = min((unsigned) (drive->blocksize - blockoff), /* amount to transfer in this block */
+	    uio.uio_resid);
+	if (count == drive->blocksize)			    /* the whole block */
+	    bp = getblk(drive->vp, blocknum, drive->blocksize, 0, 0); /* just get it */
+	else						    /* partial block: */
+	    error = bread(drive->vp,			    /* read it first */
+		blocknum,
+		drive->blocksize,
+		NOCRED,
+		&bp);
+	count = min(count, drive->blocksize - bp->b_resid); /* how much will we transfer now? */
+	if (error == 0)
+	    error = uiomove((char *) bp->b_data + blockoff, /* move the data to the block */
+		count,
+		&uio);
+	if (error) {
+	    brelse(bp);
+	    drive->lasterror = error;
+	    switch (error) {
+	    case EIO:
+		set_drive_state(drive->driveno, drive_down, 1);
+		break;
+
+		/* XXX Add other possibilities here */
+	    default:
+	    }
+	    return error;
+	}
+	if (count + blockoff == drive->blocksize)
+	    /* The transfer goes to the end of the block.  There's
+	     * no need to wait for any more data to arrive. */
+	    bawrite(bp);				    /* start the write now */
+	else
+	    bdwrite(bp);				    /* do a delayed write */
+    }
+    while (error == 0 && uio.uio_resid > 0 && count != 0);
+    if (error)
+	drive->lasterror = error;
+    return error;					    /* OK */
+}
+
+/* Wake up on completion */
+void 
+drive_io_done(struct buf *bp)
+{
+    BROKEN_GDB;
+    wakeup((caddr_t) bp);				    /* Wachet auf! */
+    bp->b_flags &= ~B_CALL;				    /* don't do this again */
+}
+
+/* Check a drive for a vinum header.  If found, 
+ * update the drive information.  We come here
+ * with a partially populated drive structure
+ * which includes the device name.
+ *
+ * Return information on what we found
+ */
+enum drive_label_info 
+read_drive_label(struct drive *drive)
+{
+    BROKEN_GDB;
+    int error;
+    int result;						    /* result of our search */
+    struct vinum_hdr *vhdr;				    /* and as header */
+
+    error = init_drive(drive);				    /* find the drive */
+    if (error)						    /* find the drive */
+	return DL_CANT_OPEN;				    /* not ours */
+
+    vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN);	    /* allocate buffers */
+    CHECKALLOC(vhdr, "Can't allocate memory");
+
+    error = read_drive(drive, (void *) vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
+    if (vhdr->magic == VINUM_MAGIC) {			    /* ours! */
+	if (drive->label.name[0]			    /* we have a name for this drive */
+	&&(strcmp(drive->label.name, vhdr->label.name))) {  /* but it doesn't match the real name */
+	    drive->lasterror = EINVAL;
+	    result = DL_WRONG_DRIVE;			    /* it's the wrong drive */
+	} else {
+	    set_drive_parms(drive);			    /* and set other parameters */
+	    result = DL_OURS;
+	}
+	/* We copy the drive anyway so that we have
+	 * the correct name in the drive info.  This
+	 * may not be the name specified */
+	drive->label = vhdr->label;			    /* put in the label information */
+    } else if (vhdr->magic == VINUM_NOMAGIC)		    /* was ours, but we gave it away */
+	result = DL_DELETED_LABEL;
+    else
+	result = DL_NOT_OURS;				    /* we could have it, but we don't yet */
+    Free(vhdr);						    /* that's all. */
+    return result;
+}
+
+/* Check a drive for a vinum header.  If found, 
+ * read configuration information from the drive and
+ * incorporate the data into the configuration.
+ *
+ * Return error number
+ */
+int 
+check_drive(char *drivename)
+{
+    BROKEN_GDB;
+    int error;
+    struct nameidata nd;				    /* mount point credentials */
+    char *config_text;					    /* read the config info from disk into here */
+    volatile char *cptr;				    /* pointer into config information */
+    char *eptr;						    /* end pointer into config information */
+    int driveno;
+    struct drive *drive;
+    char *config_line;					    /* copy the config line to */
+
+    driveno = find_drive_by_dev(drivename, 1);		    /* doesn't exist, create it */
+    drive = &vinum_conf.drive[driveno];			    /* and get a pointer */
+    strcpy(drive->devicename, drivename);		    /* put in device name */
+
+    if (read_drive_label(drive) == DL_OURS) {		    /* ours! */
+	config_text = (char *) Malloc(MAXCONFIG * 2);	    /* allocate buffers */
+	CHECKALLOC(config_text, "Can't allocate memory");
+	config_line = (char *) Malloc(MAXCONFIGLINE * 2);   /* allocate buffers */
+	CHECKALLOC(config_line, "Can't allocate memory");
+
+	/* Read in both copies of the configuration information */
+	error = read_drive(drive, config_text, MAXCONFIG * 2, VINUM_CONFIG_OFFSET);
+
+	if (error != 0) {
+	    printf("vinum: Can't read device %s, error %d\n", drive->devicename, error);
+	    Free(config_text);
+	    Free(config_line);
+	    free_drive(drive);				    /* give it back */
+	    return error;
+	}
+	/* XXX At this point, check that the two copies are the same, and do something useful if not.
+	 * In particular, consider which is newer, and what this means for the integrity of the
+	 * data on the drive */
+
+	/* Parse the configuration, and add it to the global configuration */
+	for (cptr = config_text; *cptr != '\0';) {	    /* love this style(9) */
+	    volatile int parse_status;			    /* return value from parse_config */
+
+	    for (eptr = config_line; (*cptr != '\n') && (*cptr != '\0');) /* until the end of the line */
+		*eptr++ = *cptr++;
+	    *eptr = '\0';				    /* and delimit */
+	    if (setjmp(command_fail) == 0) {		    /* come back here on error and continue */
+		parse_status = parse_config(config_line, &keyword_set);	/* parse the config line */
+		if (parse_status < 0) {			    /* error in config */
+							    /* This config should have been parsed in user
+		       * space.  If we run into problems here, something
+		       * serious is afoot.  Complain and let the user
+		       * snarf the config to see what's wrong */
+		    printf("vinum: Config error on drive %s, aborting integration\n", nd.ni_dirp);
+		    Free(config_text);
+		    Free(config_line);
+		    free_drive(drive);			    /* give it back */
+		    return EINVAL;
+		}
+	    }
+	    while (*cptr == '\n')
+		cptr++;					    /* skip to next line */
+	}
+	Free(config_text);
+	if ((vinum_conf.flags & VF_READING_CONFIG) == 0)    /* not reading config */
+	    updateconfig(0);				    /* update object states */
+	printf("vinum: read configuration from %s\n", drivename);
+	return 0;					    /* it all worked */
+    } else {						    /* no vinum label found */
+	if (drive->lasterror) {
+	    set_drive_state(drive->driveno, drive_down, 1);
+	    return drive->lasterror;
+	} else
+	    return ENODEV;				    /* not our device */
+    }
+}
+
+/* Kludge: kernel printf doesn't handle longs correctly XXX */
+static char *lltoa(long long l, char *s);
+static char *sappend(char *txt, char *s);
+
+static char *
+lltoa(long long l, char *s)
+{
+    if (l < 0) {
+	*s++ = '-';
+	l = -l;
+    }
+    if (l > 9) {
+	s = lltoa(l / 10, s);
+	l %= 10;
+    }
+    *s++ = l + '0';
+    return s;
+}
+
+static char *
+sappend(char *txt, char *s)
+{
+    while (*s++ = *txt++);
+    return s - 1;
+}
+
+/* Format the configuration in text form into the buffer
+ * at config.  Don't go beyond len bytes
+ * XXX this stinks.  Fix soon. */
+void 
+format_config(char *config, int len)
+{
+    BROKEN_GDB;
+    int i;
+    int j;
+    char *s = config;
+
+    bzero(config, len);
+
+    /* First write the drive configuration */
+    for (i = 0; i < vinum_conf.drives_used; i++) {
+	struct drive *drive;
+
+	drive = &vinum_conf.drive[i];
+	if (drive->state != drive_unallocated) {
+	    sprintf(s,
+		"drive %s state %s device %s\n",
+		drive->label.name,
+		drive_state(drive->state),
+		drive->devicename);
+	    while (*s)
+		s++;					    /* find the end */
+	    if (s > &config[len - 80]) {
+		printf("vinum: configuration data overflow\n");
+		return;
+	    }
+	}
+    }
+
+    /* Then the volume configuration */
+    for (i = 0; i < vinum_conf.volumes_used; i++) {
+	struct volume *vol;
+
+	vol = &vinum_conf.volume[i];
+	if (vol->state != volume_unallocated) {
+	    if (vol->preferred_plex >= 0)		    /* preferences, */
+		sprintf(s,
+		    "volume %s state %s readpol prefer %s",
+		    vol->name,
+		    volume_state(vol->state),
+		    vinum_conf.plex[vol->preferred_plex].name);
+	    else					    /* default round-robin */
+		sprintf(s,
+		    "volume %s state %s",
+		    vol->name,
+		    volume_state(vol->state));
+	    while (*s)
+		s++;					    /* find the end */
+	    s = sappend("\n", s);
+	    if (s > &config[len - 80]) {
+		printf("vinum: configuration data overflow\n");
+		return;
+	    }
+	}
+    }
+
+    /* Then the plex configuration */
+    for (i = 0; i < vinum_conf.plexes_used; i++) {
+	struct plex *plex;
+
+	plex = &vinum_conf.plex[i];
+	if (plex->state != plex_unallocated) {
+	    sprintf(s, "plex name %s state %s org %s ",
+		plex->name,
+		plex_state(plex->state),
+		plex_org(plex->organization));
+	    while (*s)
+		s++;					    /* find the end */
+	    if ((plex->organization == plex_striped)
+		) {
+		sprintf(s, "%db ", (int) plex->stripesize);
+		while (*s)
+		    s++;				    /* find the end */
+	    }
+	    if (plex->volno >= 0)			    /* we have a volume */
+		sprintf(s, "vol %s ", vinum_conf.volume[plex->volno].name);
+	    while (*s)
+		s++;					    /* find the end */
+	    for (j = 0; j < plex->subdisks; j++) {
+		sprintf(s, " sd %s", vinum_conf.sd[plex->sdnos[j]].name);
+	    }
+	    s = sappend("\n", s);
+	    if (s > &config[len - 80]) {
+		printf("vinum: configuration data overflow\n");
+		return;
+	    }
+	}
+    }
+
+    /* And finally the subdisk configuration */
+    for (i = 0; i < vinum_conf.subdisks_used; i++) {
+	struct sd *sd = &vinum_conf.sd[i];		    /* XXX */
+	if (vinum_conf.sd[i].state != sd_unallocated) {
+	    sprintf(s,
+		"sd name %s drive %s plex %s state %s len ",
+		sd->name,
+		vinum_conf.drive[sd->driveno].label.name,
+		vinum_conf.plex[sd->plexno].name,
+		sd_state(sd->state));
+	    while (*s)
+		s++;					    /* find the end */
+	    s = lltoa(sd->sectors, s);
+	    s = sappend("b driveoffset ", s);
+	    s = lltoa(sd->driveoffset, s);
+	    s = sappend("b plexoffset ", s);
+	    s = lltoa(sd->plexoffset, s);
+	    s = sappend("b\n", s);
+	    if (s > &config[len - 80]) {
+		printf("vinum: configuration data overflow\n");
+		return;
+	    }
+	}
+    }
+}
+
+/* Write the configuration to all vinum slices */
+int
+save_config(void)
+{
+    BROKEN_GDB;
+    int error;
+    int written_config;					    /* set when we firstnwrite the config to disk */
+    int driveno;
+    struct drive *drive;				    /* point to current drive info */
+    struct vinum_hdr *vhdr;				    /* and as header */
+    char *config;					    /* point to config data */
+    int wlabel_on;					    /* to set writing label on/off */
+
+    /* don't save the configuration while we're still working on it */
+    if (vinum_conf.flags & VF_CONFIGURING)
+	return 0;
+    written_config = 0;					    /* no config written yet */
+    /* Build a volume header */
+    vhdr = (struct vinum_hdr *) Malloc(VINUMHEADERLEN);	    /* get space for the config data */
+    CHECKALLOC(vhdr, "Can't allocate config data");
+    vhdr->magic = VINUM_MAGIC;				    /* magic number */
+    vhdr->config_length = MAXCONFIG;			    /* length of following config info */
+
+    config = Malloc(MAXCONFIG);				    /* get space for the config data */
+    CHECKALLOC(config, "Can't allocate config data");
+
+    format_config(config, MAXCONFIG);
+    error = 0;						    /* no errors yet */
+    for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) {
+	drive = &vinum_conf.drive[driveno];		    /* point to drive */
+
+	if ((drive->devicename[0] == '\0')		    /* XXX we keep getting these nameless drives */
+	||(drive->label.name[0] == '\0')) {		    /* XXX we keep getting these nameless drives */
+	    printf("Removing incomplete drive, index %d\n", driveno);
+	    if (drive->vp)				    /* how can it be open without a name? */
+		close_drive(drive);
+	    free_drive(drive);				    /* get rid of it */
+	    break;
+	}
+	if ((drive->vp == NULL)				    /* drive not open */
+	&&(drive->state > drive_down))			    /* and it thinks it's not down */
+	    set_drive_state(driveno, drive_down, setstate_force | setstate_noupdate); /* tell it what's what */
+	if (drive->state != drive_down) {
+#if (__FreeBSD__ >= 3)
+	    getmicrotime(&drive->label.last_update);	    /* time of last update is now */
+#else
+	    drive->label.last_update = time;		    /* time of last update is now */
+#endif
+	    bcopy((char *) &drive->label,		    /* and the label info from the drive structure */
+		(char *) &vhdr->label,
+		sizeof(vhdr->label));
+	    if ((drive->state != drive_unallocated)
+		&& (drive->state != drive_uninit)) {
+		wlabel_on = 1;				    /* enable writing the label */
+		error = VOP_IOCTL(drive->vp,		    /* make the label writeable */
+		    DIOCWLABEL,
+		    (caddr_t) & wlabel_on,
+		    FWRITE,
+		    NOCRED,
+		    myproc);
+		if (error == 0)
+		    error = write_drive(drive, vhdr, VINUMHEADERLEN, VINUM_LABEL_OFFSET);
+		if (error == 0)
+		    error = write_drive(drive, config, MAXCONFIG, VINUM_CONFIG_OFFSET);
+		wlabel_on = 0;				    /* enable writing the label */
+		VOP_IOCTL(drive->vp,			    /* make the label non-writeable again */
+		    DIOCWLABEL,
+		    (caddr_t) & wlabel_on,
+		    FWRITE,
+		    NOCRED,
+		    myproc);
+		if (error) {
+		    printf("vinum: Can't write config to %s, error %d\n", drive->devicename, error);
+		    set_drive_state(drive->driveno, drive_down, 1);
+		} else
+		    written_config = 1;			    /* we've written it on at least one drive */
+	    }
+	}
+    }
+    Free(vhdr);
+    Free(config);
+    return written_config == 0;				    /* return 1 if we failed to write config */
+}
+
+/* Disk labels are a mess.  The correct way to access them
+ * is with the DIOC[GSW]DINFO ioctls, but some programs, such
+ * as newfs, access the disk directly, so we have to write
+ * things there.  We do this only on request.  If a user
+ * request tries to read it directly, we fake up one on the fly.
+ */
+
+/* get_volume_label returns a label structure to lp, which
+ * is allocated by the caller */
+void 
+get_volume_label(struct volume *vol, struct disklabel *lp)
+{
+    bzero(lp, sizeof(struct disklabel));
+
+    strncpy(lp->d_typename, "vinum", sizeof(lp->d_typename));
+    lp->d_type = DTYPE_VINUM;
+    strncpy(lp->d_packname, vol->name, min(sizeof(lp->d_packname), sizeof(vol->name)));
+    lp->d_rpm = 14400 * vol->plexes;			    /* to keep them guessing */
+    lp->d_interleave = 1;
+    lp->d_flags = 0;
+
+    /* Fitting unto the vine, a vinum has a single
+     *  track with all its sectors */
+    lp->d_secsize = DEV_BSIZE;				    /* bytes per sector */
+    lp->d_nsectors = vol->size;				    /* data sectors per track */
+    lp->d_ntracks = 1;					    /* tracks per cylinder */
+    lp->d_ncylinders = 1;				    /* data cylinders per unit */
+    lp->d_secpercyl = vol->size;			    /* data sectors per cylinder */
+    lp->d_secperunit = vol->size;			    /* data sectors per unit */
+
+    lp->d_bbsize = BBSIZE;
+    lp->d_sbsize = SBSIZE;
+
+    lp->d_magic = DISKMAGIC;
+    lp->d_magic2 = DISKMAGIC;
+
+    /* Set up partitions a, b and c to be identical
+     * and the size of the volume.  a is UFS, b is
+     * swap, c is nothing */
+    lp->d_partitions[0].p_size = vol->size;
+    lp->d_partitions[0].p_fsize = 1024;
+    lp->d_partitions[0].p_fstype = FS_BSDFFS;		    /* FreeBSD File System :-) */
+    lp->d_partitions[0].p_fsize = 1024;			    /* FS fragment size */
+    lp->d_partitions[0].p_frag = 8;			    /* and fragments per block */
+    lp->d_partitions[SWAP_PART].p_size = vol->size;
+    lp->d_partitions[SWAP_PART].p_fstype = FS_SWAP;	    /* swap partition */
+    lp->d_partitions[LABEL_PART].p_size = vol->size;
+    lp->d_npartitions = LABEL_PART + 1;
+    strncpy(lp->d_packname, vol->name, min(sizeof(lp->d_packname), sizeof(vol->name)));
+    lp->d_checksum = dkcksum(lp);
+}
+
+int 
+write_volume_label(int volno)
+{
+    struct disklabel *lp;
+    struct buf *bp;
+    struct disklabel *dlp;
+    struct volume *vol;
+    int error;
+
+    lp = (struct disklabel *) Malloc((sizeof(struct disklabel) + (DEV_BSIZE - 1)) & (DEV_BSIZE - 1));
+    if (lp == 0)
+	return ENOMEM;
+
+    if ((unsigned) (volno) >= (unsigned) vinum_conf.volumes_used) /* invalid volume */
+	return ENOENT;
+
+    vol = &VOL[volno];					    /* volume in question */
+    if (vol->state == volume_unallocated)		    /* nothing there */
+	return ENOENT;
+
+    get_volume_label(vol, lp);				    /* get the label */
+
+    /* Now write to disk.  This code is derived from the
+     * system writedisklabel (), which does silly things
+     * like reading the label and refusing to write
+     * unless it's already there. */
+    bp = geteblk((int) lp->d_secsize);			    /* get a buffer */
+    bp->b_dev = minor(vol->devno) | (CDEV_MAJOR << MAJORDEV_SHIFT); /* our own raw volume */
+    bp->b_blkno = LABELSECTOR * ((int) lp->d_secsize / DEV_BSIZE);
+    bp->b_bcount = lp->d_secsize;
+    bzero(bp->b_data, lp->d_secsize);
+    dlp = (struct disklabel *) bp->b_data;
+    *dlp = *lp;
+    bp->b_flags &= ~B_INVAL;
+    bp->b_flags |= B_BUSY | B_WRITE;
+    vinumstrategy(bp);					    /* write it out */
+    error = biowait(bp);
+    bp->b_flags |= B_INVAL | B_AGE;
+    brelse(bp);
+    return error;
+}
+
+/* Initialize a subdisk */
+int 
+initsd(int sdno)
+{
+    return 0;
+}
diff --git a/sys/dev/vinum/vinumio.h b/sys/dev/vinum/vinumio.h
new file mode 100644
index 0000000..3487192
--- /dev/null
+++ b/sys/dev/vinum/vinumio.h
@@ -0,0 +1,141 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: vinumio.h,v 1.2 1998/10/21 08:32:32 grog Exp $
+ */
+
+#ifdef DEBUG
+#define MAX_IOCTL_REPLY 4096
+#else
+#define MAX_IOCTL_REPLY 256
+#endif
+
+#define L 'F'						    /* ID letter of our ioctls */
+/* VINUM_CREATE returns a buffer of this kind */
+struct _ioctl_reply {
+    int error;
+    char msg[MAX_IOCTL_REPLY];
+};
+
+/* ioctl requests */
+#define BUFSIZE 1024					    /* size of buffer, including continuations */
+#define VINUM_CREATE		_IOC(IOC_IN | IOC_OUT, L, 64, BUFSIZE) /* configure vinum */
+#define VINUM_GETCONFIG		_IOR(L, 65, struct _vinum_conf)	/* get global config */
+#define VINUM_DRIVECONFIG	_IOWR(L, 66, struct drive)  /* get drive config */
+#define VINUM_SDCONFIG		_IOWR(L, 67, struct sd)	    /* get subdisk config */
+#define VINUM_PLEXCONFIG	_IOWR(L, 68, struct plex)   /* get plex config */
+#define VINUM_VOLCONFIG		_IOWR(L, 69, struct volume) /* get volume config */
+#define VINUM_PLEXSDCONFIG	_IOWR(L, 70, struct sd)	    /* get sd config for plex (plex, sdno) */
+#define VINUM_GETFREELIST	_IOWR(L, 71, struct drive_freelist) /* get freelist element (drive, fe) */
+#define VINUM_SAVECONFIG	_IOC(0, L, 72, 0)	    /* release locks, update, write config to disk */
+#define VINUM_RESETCONFIG	_IOC(0, L, 73, 0)	    /* trash config on disk */
+#define VINUM_INIT		_IOC(0, L, 74, 0)	    /* read config from disk */
+#ifdef DEBUG
+
+struct debuginfo {
+    int changeit;
+    int param;
+};
+
+#define VINUM_DEBUG		_IOWR(L, 75, struct debuginfo) /* call the debugger from ioctl () */
+#endif
+
+enum objecttype {
+    drive_object,
+    sd_object,
+    plex_object,
+    volume_object,
+    invalid_object
+};
+
+/* Start an object.  Pass two integers:
+ * msg [0] index in vinum_conf.<object>
+ * msg [1] type of object (see below)
+ *
+ * Return ioctl_reply
+ */
+#define VINUM_SETSTATE 		_IOC(IOC_IN | IOC_OUT, L, 76, MAX_IOCTL_REPLY) /* start an object */
+
+/* The state to set with VINUM_SETSTATE.  Since
+ * each object has a different set of states, we
+ * need to translate later */
+enum objectstate {
+    object_down,
+    object_initializing,
+    object_up
+};
+
+/* This structure is used for modifying objects
+ * (VINUM_SETSTATE, VINUM_REMOVE, VINUM_RESETSTATS, VINUM_ATTACH,
+ * VINUM_DETACH, VINUM_REPLACE
+ */
+struct vinum_ioctl_msg {
+    int index;
+    enum objecttype type;
+    enum objectstate state;				    /* state to set (VINUM_SETSTATE) */
+    int force;						    /* do it even if it doesn't make sense */
+    int recurse;					    /* recurse (VINUM_REMOVE) */
+    int otherobject;					    /* superordinate object (attach),
+							    * replacement object (replace) */
+    int rename;						    /* rename object (attach) */
+    int64_t offset;					    /* offset of subdisk (for attach) */
+};
+
+#define VINUM_RELEASECONFIG	_IOC(0, L, 77, 0)	    /* release locks and write config to disk */
+#define VINUM_STARTCONFIG	_IOC(0, L, 78, 0)	    /* start a configuration operation */
+#define VINUM_MEMINFO 		_IOR(L, 79, struct meminfo) /* get memory usage summary */
+#define VINUM_MALLOCINFO	_IOWR(L, 80, struct mc)	    /* get specific malloc information [i] */
+#define VINUM_LABEL 		_IOC(IOC_IN | IOC_OUT, L, 81, MAX_IOCTL_REPLY) /* label a volume */
+#define VINUM_INITSD 		_IOW(L, 82, int)	    /* initialize a subdisk */
+#define VINUM_REMOVE 		_IOC(IOC_IN | IOC_OUT, L, 83, MAX_IOCTL_REPLY) /* remove an object */
+#define VINUM_GETUNMAPPED	_IOWR(L, 84, struct plexregion)	/* get unmapped element (plex, re) */
+#define VINUM_GETDEFECTIVE	_IOWR(L, 85, struct plexregion)	/* get defective element (plex, re) */
+#define VINUM_RESETSTATS	_IOC(IOC_IN | IOC_OUT, L, 86, MAX_IOCTL_REPLY) /* reset object stats */
+#define VINUM_ATTACH		_IOC(IOC_IN | IOC_OUT, L, 87, MAX_IOCTL_REPLY) /* reset object stats */
+#define VINUM_DETACH		_IOC(IOC_IN | IOC_OUT, L, 88, MAX_IOCTL_REPLY) /* reset object stats */
+
+struct vinum_rename_msg {
+    int index;
+    int recurse;					    /* rename subordinate objects too */
+    enum objecttype type;
+    char newname[MAXNAME];				    /* new name to give to object */
+};
+
+#define VINUM_RENAME		_IOC(IOC_IN | IOC_OUT, L, 89, MAX_IOCTL_REPLY) /* reset object stats */
+#define VINUM_REPLACE		_IOC(IOC_IN | IOC_OUT, L, 90, MAX_IOCTL_REPLY) /* reset object stats */
+
+#ifdef DEBUG
+#define VINUM_RQINFO		_IOWR(L, 91, struct rqinfo) /* get request info [i] from trace buffer */
+#endif
diff --git a/sys/dev/vinum/vinumioctl.c b/sys/dev/vinum/vinumioctl.c
new file mode 100644
index 0000000..5c2d8ec
--- /dev/null
+++ b/sys/dev/vinum/vinumioctl.c
@@ -0,0 +1,795 @@
+/* XXX replace all the checks on object validity with
+   * calls to valid<object> */
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: vinumioctl.c,v 1.2 1998/10/21 08:32:32 grog Exp $
+ */
+
+#define STATIC						    /* nothing while we're testing XXX */
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+#include "sys/sysproto.h"				    /* for sync(2) */
+#ifdef DEBUG
+#include <sys/reboot.h>
+#include "request.h"
+#endif
+
+jmp_buf command_fail;					    /* return on a failed command */
+
+#if __FreeBSD__ >= 3
+/* Why aren't these declared anywhere? XXX */
+int setjmp(jmp_buf);
+void longjmp(jmp_buf, int);
+#endif
+
+/* pointer to ioctl p parameter, to save passing it around */
+struct proc *myproc;
+
+int vinum_inactive(void);
+void free_vinum(int);
+void attachobject(struct vinum_ioctl_msg *);
+void detachobject(struct vinum_ioctl_msg *);
+void renameobject(struct vinum_rename_msg *);
+void replaceobject(struct vinum_ioctl_msg *);
+
+/* ioctl routine */
+int 
+vinumioctl(dev_t dev,
+#if __FreeBSD__ >= 3
+    u_long cmd,
+#else
+    int cmd,
+#endif
+    caddr_t data,
+    int flag,
+    struct proc *p)
+{
+    BROKEN_GDB;
+    unsigned int objno;
+    int error = 0;
+    struct volume *vol;
+    unsigned int index;					    /* for transferring config info */
+    unsigned int sdno;					    /* for transferring config info */
+    int fe;						    /* free list element number */
+    struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) data; /* struct to return */
+
+    struct devcode *device = (struct devcode *) &dev;
+
+    /* First, decide what we're looking at */
+    switch (device->type) {
+    case VINUM_SUPERDEV_TYPE:
+	myproc = p;					    /* save pointer to process */
+	ioctl_reply = (struct _ioctl_reply *) data;	    /* save the address to reply to */
+	error = setjmp(command_fail);			    /* come back here on error */
+	if (error)					    /* bombed out */
+	    return 0;					    /* the reply will contain meaningful info */
+	switch (cmd) {
+#ifdef DEBUG
+	case VINUM_DEBUG:
+	    if (((struct debuginfo *) data)->changeit)	    /* change debug settings */
+		debug = (((struct debuginfo *) data)->param);
+	    else {
+		if (debug & DEBUG_REMOTEGDB)
+		    boothowto |= RB_GDB;		    /* serial debug line */
+		else
+		    boothowto &= ~RB_GDB;		    /* local ddb */
+		Debugger("vinum debug");
+	    }
+	    ioctl_reply = (struct _ioctl_reply *) data;	    /* reinstate the address to reply to */
+	    ioctl_reply->error = 0;
+	    return 0;
+#endif
+
+	case VINUM_CREATE:				    /* create a vinum object */
+	    error = lock_config();			    /* get the config for us alone */
+	    if (error)					    /* can't do it, */
+		return error;				    /* give up */
+	    error = setjmp(command_fail);		    /* come back here on error */
+	    if (error == 0) {				    /* first time, */
+		parse_user_config((char *) data, &keyword_set);	/* update the config */
+		ioctl_reply->error = 0;			    /* no error if we make it here */
+	    } else if (ioctl_reply->error == 0) {	    /* longjmp, but no error status */
+		ioctl_reply->error = EINVAL;		    /* note that something's up */
+		ioctl_reply->msg[0] = '\0';		    /* no message? */
+	    }
+	    unlock_config();
+	    return 0;					    /* must be 0 to return the real error info */
+
+	case VINUM_GETCONFIG:				    /* get the configuration information */
+	    bcopy(&vinum_conf, data, sizeof(vinum_conf));
+	    return 0;
+
+	    /* start configuring the subsystem */
+	case VINUM_STARTCONFIG:
+	    return start_config();			    /* just lock it */
+
+	    /* Move the individual parts of the config to user space.
+
+	     * Specify the index of the object in the first word of data,
+	     * and return the object there
+	     */
+	case VINUM_DRIVECONFIG:
+	    index = *(int *) data;			    /* get the index */
+	    if (index >= (unsigned) vinum_conf.drives_used) /* can't do it */
+		return EFAULT;				    /* bang */
+	    bcopy(&DRIVE[index], data, sizeof(struct drive)); /* copy the config item out */
+	    return 0;
+
+	case VINUM_SDCONFIG:
+	    index = *(int *) data;			    /* get the index */
+	    if (index >= (unsigned) vinum_conf.subdisks_used) /* can't do it */
+		return EFAULT;				    /* bang */
+	    bcopy(&SD[index], data, sizeof(struct sd));	    /* copy the config item out */
+	    return 0;
+
+	case VINUM_PLEXCONFIG:
+	    index = *(int *) data;			    /* get the index */
+	    if (index >= (unsigned) vinum_conf.plexes_used) /* can't do it */
+		return EFAULT;				    /* bang */
+	    bcopy(&PLEX[index], data, sizeof(struct plex)); /* copy the config item out */
+	    return 0;
+
+	case VINUM_VOLCONFIG:
+	    index = *(int *) data;			    /* get the index */
+	    if (index >= (unsigned) vinum_conf.volumes_used) /* can't do it */
+		return EFAULT;				    /* bang */
+	    bcopy(&VOL[index], data, sizeof(struct volume)); /* copy the config item out */
+	    return 0;
+
+	case VINUM_PLEXSDCONFIG:
+	    index = *(int *) data;			    /* get the plex index */
+	    sdno = ((int *) data)[1];			    /* and the sd index */
+	    if ((index >= (unsigned) vinum_conf.plexes_used) /* plex doesn't exist */
+	    ||(sdno >= PLEX[index].subdisks))		    /* or it doesn't have this many subdisks */
+		return EFAULT;				    /* bang */
+	    bcopy(&SD[PLEX[index].sdnos[sdno]],		    /* copy the config item out */
+		data,
+		sizeof(struct sd));
+	    return 0;
+
+	case VINUM_SAVECONFIG:
+	    if (VFLAGS & VF_CONFIGURING) {		    /* must be us, the others are asleep */
+		finish_config(1);			    /* finish the configuration and update it */
+		error = save_config();			    /* save configuration to disk */
+	    } else
+		error = EINVAL;				    /* queue up for this one, please */
+	    return error;
+
+	case VINUM_RELEASECONFIG:			    /* release the config */
+	    if (VFLAGS & VF_CONFIGURING) {		    /* must be us, the others are asleep */
+		finish_config(0);			    /* finish the configuration, don't change it */
+		error = save_config();			    /* save configuration to disk */
+	    } else
+		error = EINVAL;				    /* release what config? */
+	    return error;
+
+	case VINUM_INIT:
+	    ioctl_reply = (struct _ioctl_reply *) data;	    /* reinstate the address to reply to */
+	    ioctl_reply->error = 0;
+	    return 0;
+
+	case VINUM_RESETCONFIG:
+	    if (vinum_inactive() && (vinum_conf.opencount < 2)) { /* if we're not active */
+		/* Note the open count.  We may be called from v, so we'll be open.
+		 * Keep the count so we don't underflow */
+		int oc = vinum_conf.opencount;
+		free_vinum(1);				    /* clean up everything */
+		printf("vinum: CONFIGURATION OBLITERATED\n");
+		vinum_conf.opencount = oc;
+		ioctl_reply = (struct _ioctl_reply *) data; /* reinstate the address to reply to */
+		ioctl_reply->error = 0;
+		return 0;
+	    }
+	    return EBUSY;
+
+	case VINUM_SETSTATE:
+	    setstate((struct vinum_ioctl_msg *) data);	    /* set an object state */
+	    return 0;
+
+	case VINUM_MEMINFO:
+	    vinum_meminfo(data);
+	    return 0;
+
+	case VINUM_MALLOCINFO:
+	    return vinum_mallocinfo(data);
+
+	case VINUM_RQINFO:
+	    return vinum_rqinfo(data);
+
+	case VINUM_LABEL:				    /* label a volume */
+	    ioctl_reply->error = write_volume_label(*(int *) data); /* index of the volume to label */
+	    ioctl_reply->msg[0] = '\0';			    /* no message */
+	    return 0;
+
+	case VINUM_REMOVE:
+	    remove((struct vinum_ioctl_msg *) data);	    /* remove an object */
+	    return 0;
+
+	case VINUM_GETFREELIST:				    /* get a drive free list element */
+	    index = *(int *) data;			    /* get the drive index */
+	    fe = ((int *) data)[1];			    /* and the free list element */
+	    if ((index >= (unsigned) vinum_conf.drives_used) /* plex doesn't exist */
+	    ||(DRIVE[index].state == drive_unallocated))
+		return ENODEV;
+	    if (fe >= DRIVE[index].freelist_entries)	    /* no such entry */
+		return ENOENT;
+	    bcopy(&DRIVE[index].freelist[fe],
+		data,
+		sizeof(struct drive_freelist));
+	    return 0;
+
+	case VINUM_GETDEFECTIVE:			    /* get a plex defective area element */
+	    index = *(int *) data;			    /* get the plex index */
+	    fe = ((int *) data)[1];			    /* and the region number */
+	    if ((index >= (unsigned) vinum_conf.plexes_used) /* plex doesn't exist */
+	    ||(PLEX[index].state == plex_unallocated))
+		return ENODEV;
+	    if (fe >= PLEX[index].defective_regions)	    /* no such entry */
+		return ENOENT;
+	    bcopy(&PLEX[index].defective_region[fe],
+		data,
+		sizeof(struct plexregion));
+	    return 0;
+
+	case VINUM_GETUNMAPPED:				    /* get a plex unmapped area element */
+	    index = *(int *) data;			    /* get the plex index */
+	    fe = ((int *) data)[1];			    /* and the region number */
+	    if ((index >= (unsigned) vinum_conf.plexes_used) /* plex doesn't exist */
+	    ||(PLEX[index].state == plex_unallocated))
+		return ENODEV;
+	    if (fe >= PLEX[index].unmapped_regions)	    /* no such entry */
+		return ENOENT;
+	    bcopy(&PLEX[index].unmapped_region[fe],
+		data,
+		sizeof(struct plexregion));
+	    return 0;
+
+	case VINUM_RESETSTATS:
+	    resetstats((struct vinum_ioctl_msg *) data);    /* reset object stats */
+	    return 0;
+
+	    /* attach an object to a superordinate object */
+	case VINUM_ATTACH:
+	    attachobject((struct vinum_ioctl_msg *) data);
+	    return 0;
+
+	    /* detach an object from a superordinate object */
+	case VINUM_DETACH:
+	    detachobject((struct vinum_ioctl_msg *) data);
+	    return 0;
+
+	    /* rename an object */
+	case VINUM_RENAME:
+	    renameobject((struct vinum_rename_msg *) data);
+	    return 0;
+
+	    /* replace an object */
+	case VINUM_REPLACE:
+	    replaceobject((struct vinum_ioctl_msg *) data);
+	    return 0;
+
+	default:
+	    /* FALLTHROUGH */
+	}
+
+    default:
+#if __FreeBSD__>=3
+	printf("vinumioctl: type %d, sd %d, plex %d, major %x, volume %d, command %lx\n",
+	    device->type,
+	    device->sd,
+	    device->plex,
+	    device->major,
+	    device->volume,
+	    cmd);					    /* XXX */
+
+#else
+	printf("vinumioctl: type %d, sd %d, plex %d, major %x, volume %d, command %x\n",
+	    device->type,
+	    device->sd,
+	    device->plex,
+	    device->major,
+	    device->volume,
+	    cmd);					    /* XXX */
+
+#endif
+	return EINVAL;
+
+    case VINUM_DRIVE_TYPE:
+    case VINUM_PLEX_TYPE:
+	return EAGAIN;					    /* try again next week */
+
+    case VINUM_SD_TYPE:
+	objno = SDNO(dev);
+
+	switch (cmd) {
+	case VINUM_INITSD:				    /* initialize subdisk */
+	    return initsd(objno);
+
+	default:
+	    return EINVAL;
+	}
+	break;
+
+    case VINUM_VOLUME_TYPE:
+	objno = VOLNO(dev);
+
+	if ((unsigned) objno >= (unsigned) vinum_conf.volumes_used) /* not a valid volume */
+	    return ENXIO;
+	vol = &VOL[objno];
+	if (vol->state != volume_up)			    /* not up, */
+	    return EIO;					    /* I/O error */
+
+	switch (cmd) {
+	case DIOCGDINFO:				    /* get disk label */
+	    get_volume_label(vol, (struct disklabel *) data);
+	    break;
+
+	    /* Care!  DIOCGPART returns *pointers* to
+	     * the caller, so we need to store this crap as well.
+	     * And yes, we need it. */
+	case DIOCGPART:					    /* get partition information */
+	    get_volume_label(vol, &vol->label);
+	    ((struct partinfo *) data)->disklab = &vol->label;
+	    ((struct partinfo *) data)->part = &vol->label.d_partitions[0];
+	    break;
+
+	    /* We don't have this stuff on hardware,
+	     * so just pretend to do it so that
+	     * utilities don't get upset. */
+	case DIOCWDINFO:				    /* write partition info */
+	case DIOCSDINFO:				    /* set partition info */
+	    return 0;					    /* not a titty */
+
+	case DIOCWLABEL:				    /* set or reset label writeable */
+	    if ((flag & FWRITE) == 0)			    /* not writeable? */
+		return EACCES;				    /* no, die */
+	    if (*(int *) data != 0)			    /* set it? */
+		vol->flags |= VF_WLABEL;		    /* yes */
+	    else
+		vol->flags &= ~VF_WLABEL;		    /* no, reset */
+	    break;
+
+	default:
+	    return ENOTTY;				    /* not my kind of ioctl */
+	}
+	break;
+    }
+    return 0;						    /* XXX */
+}
+
+/* The following four functions check the supplied
+ * object index and return a pointer to the object
+ * if it exists.  Otherwise they longjump out via
+ * throw_rude_remark */
+struct drive *
+validdrive(int driveno, struct _ioctl_reply *reply)
+{
+    if ((driveno < vinum_conf.drives_used)
+	&& (DRIVE[driveno].state != drive_unallocated))
+	return &DRIVE[driveno];
+    strcpy(reply->msg, "No such drive");
+    reply->error = ENOENT;
+    return NULL;
+}
+
+struct sd *
+validsd(int sdno, struct _ioctl_reply *reply)
+{
+    if ((sdno < vinum_conf.subdisks_used)
+	&& (SD[sdno].state != sd_unallocated))
+	return &SD[sdno];
+    strcpy(reply->msg, "No such subdisk");
+    reply->error = ENOENT;
+    return NULL;
+}
+
+struct plex *
+validplex(int plexno, struct _ioctl_reply *reply)
+{
+    if ((plexno < vinum_conf.plexes_used)
+	&& (PLEX[plexno].state != plex_unallocated))
+	return &PLEX[plexno];
+    strcpy(reply->msg, "No such plex");
+    reply->error = ENOENT;
+    return NULL;
+}
+
+struct volume *
+validvol(int volno, struct _ioctl_reply *reply)
+{
+    if ((volno < vinum_conf.volumes_used)
+	&& (VOL[volno].state != volume_unallocated))
+	return &VOL[volno];
+    strcpy(reply->msg, "No such volume");
+    reply->error = ENOENT;
+    return NULL;
+}
+
+/* reset an object's stats */
+void 
+resetstats(struct vinum_ioctl_msg *msg)
+{
+    struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
+
+    switch (msg->type) {
+    case drive_object:
+	if (msg->index < vinum_conf.drives_used) {
+	    struct drive *drive = &DRIVE[msg->index];
+	    if (drive->state != drive_unallocated) {
+		drive->reads = 0;			    /* number of reads on this drive */
+		drive->writes = 0;			    /* number of writes on this drive */
+		drive->bytes_read = 0;			    /* number of bytes read */
+		drive->bytes_written = 0;		    /* number of bytes written */
+		reply->error = 0;
+		return;
+	    }
+	    reply->error = EINVAL;
+	    return;
+	}
+    case sd_object:
+	if (msg->index < vinum_conf.subdisks_used) {
+	    struct sd *sd = &SD[msg->index];
+	    if (sd->state != sd_unallocated) {
+		sd->reads = 0;				    /* number of reads on this subdisk */
+		sd->writes = 0;				    /* number of writes on this subdisk */
+		sd->bytes_read = 0;			    /* number of bytes read */
+		sd->bytes_written = 0;			    /* number of bytes written */
+		reply->error = 0;
+		return;
+	    }
+	    reply->error = EINVAL;
+	    return;
+	}
+	break;
+
+    case plex_object:
+	if (msg->index < vinum_conf.plexes_used) {
+	    struct plex *plex = &PLEX[msg->index];
+	    if (plex->state != plex_unallocated) {
+		plex->reads = 0;
+		plex->writes = 0;			    /* number of writes on this plex */
+		plex->bytes_read = 0;			    /* number of bytes read */
+		plex->bytes_written = 0;		    /* number of bytes written */
+		plex->multiblock = 0;			    /* requests that needed more than one block */
+		plex->multistripe = 0;			    /* requests that needed more than one stripe */
+		reply->error = 0;
+		return;
+	    }
+	    reply->error = EINVAL;
+	    return;
+	}
+	break;
+
+    case volume_object:
+	if (msg->index < vinum_conf.volumes_used) {
+	    struct volume *vol = &VOL[msg->index];
+	    if (vol->state != volume_unallocated) {
+		vol->bytes_read = 0;			    /* number of bytes read */
+		vol->bytes_written = 0;			    /* number of bytes written */
+		vol->reads = 0;				    /* number of reads on this volume */
+		vol->writes = 0;			    /* number of writes on this volume */
+		vol->recovered_reads = 0;		    /* reads recovered from another plex */
+		reply->error = 0;
+		return;
+	    }
+	    reply->error = EINVAL;
+	    return;
+	}
+    case invalid_object:				    /* can't get this */
+	reply->error = EINVAL;
+	return;
+    }
+}
+
+/* attach an object to a superior object */
+void 
+attachobject(struct vinum_ioctl_msg *msg)
+{
+    struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
+    struct sd *sd;
+    struct plex *plex;
+    struct volume *vol;
+
+    switch (msg->type) {
+    case drive_object:					    /* you can't attach a drive to anything */
+    case volume_object:					    /* nor a volume */
+    case invalid_object:				    /* "this can't happen" */
+	reply->error = EINVAL;
+	reply->msg[0] = '\0';				    /* vinum(8) doesn't do this */
+	return;
+
+    case sd_object:
+	sd = validsd(msg->index, reply);
+	if (sd == NULL)					    /* not a valid subdisk  */
+	    return;
+	plex = validplex(msg->otherobject, reply);
+	if (plex) {
+	    if (sd->plexno >= 0) {			    /* already belong to a plex */
+		reply->error = EBUSY;			    /* no message, the user should check */
+		reply->msg[0] = '\0';
+		return;
+	    }
+	    sd->plexoffset = msg->offset;		    /* this is where we want it */
+	    set_sd_state(sd->sdno, sd_stale, setstate_force); /* make sure it's stale */
+	    give_sd_to_plex(plex->plexno, sd->sdno);	    /* and give it to the plex */
+	    update_sd_config(sd->sdno, 0);
+	    save_config();
+	    reply->error = 0;
+	}
+	break;
+
+    case plex_object:
+	plex = validplex(msg->index, reply);		    /* get plex */
+	if (plex == NULL)
+	    return;
+	if (plex->organization != plex_concat) {	    /* can't attach to striped and raid-5 */
+	    reply->error = EINVAL;			    /* no message, the user should check */
+	    reply->msg[0] = '\0';
+	    return;
+	}
+	vol = validvol(msg->otherobject, reply);	    /* and volume information */
+	if (vol) {
+	    if ((vol->plexes == MAXPLEX)		    /* we have too many already */
+	    ||(plex->volno >= 0)) {			    /* or the plex has an owner */
+		reply->error = EINVAL;			    /* no message, the user should check */
+		reply->msg[0] = '\0';
+		return;
+	    }
+	    set_plex_state(plex->plexno, plex_down, setstate_force); /* make sure it's down */
+	    give_plex_to_volume(msg->otherobject, msg->index); /* and give it to the volume */
+	    update_plex_config(plex->plexno, 0);
+	    save_config();
+	    if (plex->state == plex_reviving)
+		reply->error = EAGAIN;			    /* need to revive it */
+	    else
+		reply->error = 0;
+	}
+    }
+}
+
+/* detach an object from a superior object */
+void 
+detachobject(struct vinum_ioctl_msg *msg)
+{
+    struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
+    struct sd *sd;
+    struct plex *plex;
+    struct volume *vol;
+    int sdno;
+    int plexno;
+
+    switch (msg->type) {
+    case drive_object:					    /* you can't attach a drive to anything */
+    case volume_object:					    /* nor a volume */
+    case invalid_object:				    /* "this can't happen" */
+	reply->error = EINVAL;
+	reply->msg[0] = '\0';				    /* vinum(8) doesn't do this */
+	return;
+
+    case sd_object:
+	sd = validsd(msg->index, reply);
+	if (sd == NULL)
+	    return;
+	if (sd->plexno < 0) {				    /* doesn't belong to a plex */
+	    reply->error = ENOENT;
+	    strcpy(reply->msg, "Subdisk is not attached");
+	    return;
+	} else {					    /* valid plex number */
+	    plex = &PLEX[sd->plexno];
+	    if ((!msg->force)				    /* don't force things */
+	    &&((plex->state == plex_up)			    /* and the plex is up */
+	    ||((plex->state == plex_flaky) && sd->state == sd_up))) { /* or flaky with this sd up */
+		reply->error = EBUSY;			    /* we need this sd */
+		reply->msg[0] = '\0';
+		return;
+	    }
+	    sd->plexno = -1;				    /* anonymous sd */
+	    if (plex->subdisks == 1) {			    /* this was the only subdisk */
+		Free(plex->sdnos);			    /* free the subdisk array */
+		plex->sdnos = NULL;			    /* and note the fact */
+		plex->subdisks_allocated = 0;		    /* no subdisk space */
+	    } else {
+		for (sdno = 0; sdno < plex->subdisks; sdno++) {
+		    if (plex->sdnos[sdno] == msg->index)    /* found our subdisk */
+			break;
+		}
+		if (sdno < (plex->subdisks - 1))	    /* not the last one, compact */
+		    bcopy(&plex->sdnos[sdno + 1],
+			&plex->sdnos[sdno],
+			(plex->subdisks - 1 - sdno) * sizeof(int));
+	    }
+	    plex->subdisks--;
+	    rebuild_plex_unmappedlist(plex);		    /* rebuild the unmapped list */
+	    if (!bcmp(plex->name, sd->name, strlen(plex->name))) { /* this subdisk is named after the plex */
+		bcopy(sd->name,
+		    &sd->name[3],
+		    min(strlen(sd->name), MAXSDNAME - 3));
+		bcopy("ex-", sd->name, 3);
+		sd->name[MAXSDNAME - 1] = '\0';
+	    }
+	    update_plex_config(plex->plexno, 0);
+	    if ((plex->organization == plex_striped)	    /* we've just mutilated our plex, */
+	    ||(plex->organization == plex_striped))	    /* the data no longer matches */
+		set_plex_state(plex->plexno,
+		    plex_down,
+		    setstate_force | setstate_configuring);
+	    update_sd_config(sd->sdno, 0);
+	    save_config();
+	    reply->error = 0;
+	}
+	return;
+
+    case plex_object:
+	plex = validplex(msg->index, reply);		    /* get plex */
+	if (plex == NULL)
+	    return;
+	if (plex->volno >= 0) {
+	    int volno = plex->volno;
+
+	    vol = &VOL[volno];
+	    if ((!msg->force)				    /* don't force things */
+	    &&((vol->state == volume_up)		    /* and the volume is up */
+	    &&(vol->plexes == 1))) {			    /* and this is the last plex */
+		/* XXX As elsewhere, check whether we will lose
+		   * mapping by removing this plex */
+		reply->error = EBUSY;			    /* we need this plex */
+		reply->msg[0] = '\0';
+		return;
+	    }
+	    plex->volno = -1;				    /* anonymous plex */
+	    for (plexno = 0; plexno < vol->plexes; plexno++) {
+		if (vol->plex[plexno] == msg->index)	    /* found our plex */
+		    break;
+	    }
+	    if (plexno < (vol->plexes - 1))		    /* not the last one, compact */
+		bcopy(&vol[plexno + 1], &vol[plexno], (vol->plexes - 1 - plexno) * sizeof(int));
+	    vol->plexes--;
+	    if (!bcmp(vol->name, plex->name, strlen(vol->name))) { /* this plex is named after the volume */
+		/* First, check if the subdisks are the same */
+		if (msg->recurse) {
+		    int sdno;
+
+		    for (sdno = 0; sdno < plex->subdisks; sdno++) {
+			struct sd *sd = &SD[plex->sdnos[sdno]];
+
+			if (!bcmp(plex->name, sd->name, strlen(plex->name))) { /* subdisk is named after the plex */
+			    bcopy(sd->name, &sd->name[3], min(strlen(sd->name), MAXSDNAME - 3));
+			    bcopy("ex-", sd->name, 3);
+			    sd->name[MAXSDNAME - 1] = '\0';
+			}
+		    }
+		}
+		bcopy(plex->name, &plex->name[3], min(strlen(plex->name), MAXPLEXNAME - 3));
+		bcopy("ex-", plex->name, 3);
+		plex->name[MAXPLEXNAME - 1] = '\0';
+	    }
+	    update_plex_config(plex->plexno, 0);
+	    update_volume_config(volno, 0);
+	    save_config();
+	    reply->error = 0;
+	} else {
+	    reply->error = ENOENT;
+	    strcpy(reply->msg, "Plex is not attached");
+	}
+    }
+}
+
+void 
+renameobject(struct vinum_rename_msg *msg)
+{
+    struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
+    struct drive *drive;
+    struct sd *sd;
+    struct plex *plex;
+    struct volume *vol;
+
+    switch (msg->type) {
+    case drive_object:					    /* you can't attach a drive to anything */
+	if (find_drive(msg->newname, 0) >= 0) {		    /* we have that name already, */
+	    reply->error = EEXIST;
+	    reply->msg[0] = '\0';
+	    return;
+	}
+	drive = validdrive(msg->index, reply);
+	if (drive) {
+	    bcopy(msg->newname, drive->label.name, MAXDRIVENAME);
+	    save_config();
+	    reply->error = 0;
+	}
+	return;
+
+    case sd_object:					    /* you can't attach a subdisk to anything */
+	if (find_subdisk(msg->newname, 0) >= 0) {	    /* we have that name already, */
+	    reply->error = EEXIST;
+	    reply->msg[0] = '\0';
+	    return;
+	}
+	sd = validsd(msg->index, reply);
+	if (sd) {
+	    bcopy(msg->newname, sd->name, MAXSDNAME);
+	    update_sd_config(sd->sdno, 0);
+	    save_config();
+	    reply->error = 0;
+	}
+	return;
+
+    case plex_object:					    /* you can't attach a plex to anything */
+	if (find_plex(msg->newname, 0) >= 0) {		    /* we have that name already, */
+	    reply->error = EEXIST;
+	    reply->msg[0] = '\0';
+	    return;
+	}
+	plex = validplex(msg->index, reply);
+	if (plex) {
+	    bcopy(msg->newname, plex->name, MAXPLEXNAME);
+	    update_plex_config(plex->plexno, 0);
+	    save_config();
+	    reply->error = 0;
+	}
+	return;
+
+    case volume_object:					    /* you can't attach a volume to anything */
+	if (find_volume(msg->newname, 0) >= 0) {	    /* we have that name already, */
+	    reply->error = EEXIST;
+	    reply->msg[0] = '\0';
+	    return;
+	}
+	vol = validvol(msg->index, reply);
+	if (vol) {
+	    bcopy(msg->newname, vol->name, MAXVOLNAME);
+	    update_volume_config(msg->index, 0);
+	    save_config();
+	    reply->error = 0;
+	}
+	return;
+
+    case invalid_object:
+	reply->error = EINVAL;
+	reply->msg[0] = '\0';
+    }
+}
+
+/* Replace one object with another */
+void 
+replaceobject(struct vinum_ioctl_msg *msg)
+{
+    struct _ioctl_reply *reply = (struct _ioctl_reply *) msg;
+
+    reply->error = ENODEV;				    /* until I know how to do this */
+    strcpy(reply->msg, "replace not implemented yet");
+/*      save_config (); */
+}
diff --git a/sys/dev/vinum/vinumkw.h b/sys/dev/vinum/vinumkw.h
new file mode 100644
index 0000000..2ffd362
--- /dev/null
+++ b/sys/dev/vinum/vinumkw.h
@@ -0,0 +1,120 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: vinumkw.h,v 1.2 1998/10/21 08:32:32 grog Exp $
+ */
+
+/* Command keywords that vinum knows.  These include both user-level
+ * and kernel-level stuff */
+
+/* Our complete vocabulary.  The names of the commands are
+ * the same as the identifier without the kw_ at the beginning
+ * (i.e. kw_create defines the "create" keyword).  Preprocessor
+ * magic in parser.c does the rest. */
+enum keyword {
+    kw_create,
+    kw_modify,
+    kw_list,
+    kw_l = kw_list,
+    kw_ld,						    /* list drive */
+    kw_ls,						    /* list subdisk */
+    kw_lp,						    /* list plex */
+    kw_lv,						    /* list volume */
+    kw_set,
+    kw_rm,
+    kw_start,
+    kw_stop,
+    kw_drive,
+    kw_sd,
+    kw_subdisk = kw_sd,
+    kw_plex,
+    kw_volume,
+    kw_vol = kw_volume,
+    kw_read,
+    kw_readpol,
+    kw_org,
+    kw_name,
+    kw_concat,
+    kw_striped,
+    kw_raid5,
+    kw_driveoffset,
+    kw_plexoffset,
+    kw_len,
+    kw_length = kw_len,
+    kw_state,
+    kw_setupstate,
+    kw_d,						    /* flag names */
+    kw_f,
+    kw_r,
+    kw_s,
+    kw_v,
+    kw_round,						    /* round robin */
+    kw_prefer,						    /* prefer plex */
+    kw_device,
+    kw_init,
+    kw_label,
+    kw_resetconfig,
+    kw_writethrough,
+    kw_writeback,
+    kw_raw,
+    kw_resetstats,
+    kw_attach,
+    kw_detach,
+    kw_rename,
+    kw_printconfig,
+    kw_replace,
+    kw_detached,
+#ifdef DEBUG
+    kw_debug,						    /* go into debugger */
+#endif
+    kw_info,
+    kw_invalid_keyword = -1
+};
+
+struct _keywords {
+    char *name;
+    enum keyword keyword;
+};
+
+struct keywordset {
+    int size;
+    struct _keywords *k;
+};
+
+extern struct _keywords keywords[];
+extern struct _keywords flag_keywords[];
+
+extern struct keywordset keyword_set;
+extern struct keywordset flag_set;
diff --git a/sys/dev/vinum/vinumlock.c b/sys/dev/vinum/vinumlock.c
new file mode 100644
index 0000000..9376364
--- /dev/null
+++ b/sys/dev/vinum/vinumlock.c
@@ -0,0 +1,137 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: lock.c,v 1.1.1.1 1998/09/16 05:56:21 grog Exp $
+ */
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+
+/* Lock routines.  Currently, we lock either an individual volume
+ * or the global configuration.  I don't think tsleep and
+ * wakeup are SMP safe. FIXME XXX */
+
+/* Lock a volume, wait if it's in use */
+int 
+lockvol(struct volume *vol)
+{
+    int error;
+
+    while ((vol->flags & VF_LOCKED) != 0) {
+	vol->flags |= VF_LOCKING;
+	/* It would seem to make more sense to sleep on
+	 * the address 'vol'.  Unfortuntaly we can't
+	 * guarantee that this address won't change due to
+	 * table expansion.  The address we choose won't change. */
+	if ((error = tsleep(&vinum_conf.volume + vol->devno,
+		    PRIBIO | PCATCH,
+		    "volock",
+		    0)) != 0)
+	    return error;
+    }
+    vol->flags |= VF_LOCKED;
+    return 0;
+}
+
+/* Unlock a volume and let the next one at it */
+void 
+unlockvol(struct volume *vol)
+{
+    vol->flags &= ~VF_LOCKED;
+    if ((vol->flags & VF_LOCKING) != 0) {
+	vol->flags &= ~VF_LOCKING;
+	wakeup(&vinum_conf.volume + vol->devno);
+    }
+}
+
+/* Lock a plex, wait if it's in use */
+int 
+lockplex(struct plex *plex)
+{
+    int error;
+
+    while ((plex->flags & VF_LOCKED) != 0) {
+	plex->flags |= VF_LOCKING;
+	/* It would seem to make more sense to sleep on
+	 * the address 'plex'.  Unfortuntaly we can't
+	 * guarantee that this address won't change due to
+	 * table expansion.  The address we choose won't change. */
+	if ((error = tsleep(&vinum_conf.plex + plex->sdnos[0],
+		    PRIBIO | PCATCH,
+		    "plexlk",
+		    0)) != 0)
+	    return error;
+    }
+    plex->flags |= VF_LOCKED;
+    return 0;
+}
+
+/* Unlock a plex and let the next one at it */
+void 
+unlockplex(struct plex *plex)
+{
+    plex->flags &= ~VF_LOCKED;
+    if ((plex->flags & VF_LOCKING) != 0) {
+	plex->flags &= ~VF_LOCKING;
+	wakeup(&vinum_conf.plex + plex->plexno);
+    }
+}
+
+
+/* Get a lock for the global config, wait if it's not available */
+int 
+lock_config(void)
+{
+    int error;
+
+    while ((vinum_conf.flags & VF_LOCKED) != 0) {
+	vinum_conf.flags |= VF_LOCKING;
+	if ((error = tsleep(&vinum_conf, PRIBIO | PCATCH, "vincfg", 0)) != 0)
+	    return error;
+    }
+    vinum_conf.flags |= VF_LOCKED;
+    return 0;
+}
+
+/* Unlock and wake up any waiters  */
+void 
+unlock_config(void)
+{
+    vinum_conf.flags &= ~VF_LOCKED;
+    if ((vinum_conf.flags & VF_LOCKING) != 0) {
+	vinum_conf.flags &= ~VF_LOCKING;
+	wakeup(&vinum_conf);
+    }
+}
diff --git a/sys/dev/vinum/vinummemory.c b/sys/dev/vinum/vinummemory.c
new file mode 100644
index 0000000..e1ecd0e
--- /dev/null
+++ b/sys/dev/vinum/vinummemory.c
@@ -0,0 +1,198 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: memory.c,v 1.2 1998/10/21 08:32:32 grog Exp $
+ */
+
+#define REALLYKERNEL
+#define USES_VM
+#include "vinumhdr.h"
+
+extern jmp_buf command_fail;				    /* return on a failed command */
+
+#ifdef DEBUG
+#include "request.h"
+extern struct rqinfo rqinfo[];
+extern struct rqinfo *rqip;
+#endif
+
+#if __FreeBSD__ >= 3
+/* Why aren't these declared anywhere? XXX */
+int setjmp(jmp_buf);
+void longjmp(jmp_buf, int);
+#endif
+
+void freedatabuf(struct mc *me);
+caddr_t allocdatabuf(struct mc *me);
+
+void 
+expand_table(void **table, int oldsize, int newsize)
+{
+    if (newsize > oldsize) {
+	int *temp;
+
+	temp = (int *) Malloc(newsize);			    /* allocate a new table */
+	CHECKALLOC(temp, "vinum: Can't expand table\n");
+	if (*table != NULL) {				    /* already something there, */
+	    bcopy((char *) *table, (char *) temp, oldsize); /* copy it to the old table */
+	    Free(*table);
+	}
+	*table = temp;
+    }
+}
+
+#if DEBUG						    /* XXX debug */
+#define MALLOCENTRIES 16384
+int malloccount = 0;
+int highwater = 0;					    /* highest index ever allocated */
+static struct mc malloced[MALLOCENTRIES];
+
+static total_malloced;
+
+caddr_t 
+MMalloc(int size, char *file, int line)
+{
+    caddr_t result;
+    int i;
+    static int seq = 0;
+    int s;
+    struct mc me;					    /* information to pass to allocdatabuf */
+
+    if (malloccount >= MALLOCENTRIES) {			    /* too many */
+	printf("vinum: can't allocate table space to trace memory allocation");
+	return 0;					    /* can't continue */
+    }
+    result = malloc(size, M_DEVBUF, M_WAITOK);		    /* use malloc for smaller and irregular stuff */
+    if (result == NULL)
+	printf("vinum: can't allocate %d bytes from %s:%d\n", size, file, line);
+    else {
+	me.flags = 0;					    /* allocation via malloc */
+	s = splhigh();
+	for (i = 0; i < malloccount; i++) {
+	    if (((result + size) > malloced[i].address)
+		&& (result < malloced[i].address + malloced[i].size)) /* overlap */
+		Debugger("Malloc overlap");
+	}
+	if (result) {
+	    char *f = index(file, '/');			    /* chop off dirname if present */
+
+	    if (f == NULL)
+		f = file;
+	    i = malloccount++;
+	    total_malloced += size;
+	    malloced[i].address = result;
+	    malloced[i].size = size;
+	    malloced[i].line = line;
+	    malloced[i].seq = seq++;
+	    malloced[i].flags = me.flags;
+	    malloced[i].databuf = me.databuf;		    /* only used with kva alloc */
+	    bcopy(f, malloced[i].file, min(strlen(f) + 1, 16));
+	}
+	if (malloccount > highwater)
+	    highwater = malloccount;
+	splx(s);
+    }
+    return result;
+}
+
+void 
+FFree(void *mem, char *file, int line)
+{
+    int i;
+    int s;
+
+    s = splhigh();
+    for (i = 0; i < malloccount; i++) {
+	if ((caddr_t) mem == malloced[i].address) {	    /* found it */
+	    bzero(mem, malloced[i].size);		    /* XXX */
+	    free(mem, M_DEVBUF);
+	    malloccount--;
+	    total_malloced -= malloced[i].size;
+	    if (i < malloccount)			    /* more coming after */
+		bcopy(&malloced[i + 1], &malloced[i], (malloccount - i) * sizeof(struct mc));
+	    splx(s);
+	    return;
+	}
+    }
+    splx(s);
+    printf("Freeing unallocated data at 0x%08x from %s, line %d\n", (int) mem, file, line);
+    Debugger("Free");
+}
+
+void 
+vinum_meminfo(caddr_t data)
+{
+    struct meminfo *m = (struct meminfo *) data;
+
+    m->mallocs = malloccount;
+    m->total_malloced = total_malloced;
+    m->malloced = malloced;
+    m->highwater = highwater;
+}
+
+int 
+vinum_mallocinfo(caddr_t data)
+{
+    struct mc *m = (struct mc *) data;
+    unsigned int ent = *(int *) data;			    /* 1st word is index */
+
+    if (ent >= malloccount)
+	return ENOENT;
+    m->address = malloced[ent].address;
+    m->size = malloced[ent].size;
+    m->line = malloced[ent].line;
+    m->seq = malloced[ent].seq;
+    bcopy(malloced[ent].file, m->file, 16);
+    return 0;
+}
+
+/* return the nth request trace buffer entry.  This
+ * is indexed back from the current entry (which
+ * has index 0) */
+int 
+vinum_rqinfo(caddr_t data)
+{
+    struct rqinfo *rq = (struct rqinfo *) data;
+    int ent = *(int *) data;				    /* 1st word is index */
+    int lastent = rqip - rqinfo;			    /* entry number of current entry */
+
+    if (ent >= RQINFO_SIZE)				    /* out of the table */
+	return ENOENT;
+    if ((ent = lastent - ent - 1) < 0)
+	ent += RQINFO_SIZE;				    /* roll over backwards */
+    bcopy(&rqinfo[ent], rq, sizeof(struct rqinfo));
+    return 0;
+}
+#endif
diff --git a/sys/dev/vinum/vinumparser.c b/sys/dev/vinum/vinumparser.c
new file mode 100644
index 0000000..1dc425c
--- /dev/null
+++ b/sys/dev/vinum/vinumparser.c
@@ -0,0 +1,206 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: parser.c,v 1.1.1.1 1998/09/16 05:56:21 grog Exp $
+ */
+
+/* This file contains the parser for the configuration routines.  It's used
+ * both in the kernel and in the user interface program, thus the separate file. */
+
+/* Go through a text and split up into text tokens.  These are either non-blank
+ * sequences, or any sequence (except \0) enclosed in ' or ".  Embedded ' or
+ * " characters may be escaped by \, which otherwise has no special meaning.
+ *
+ * Delimit by following with a \0, and return pointers to the starts at token [].
+ * Return the number of tokens found as the return value.
+ *
+ * This method has the restriction that a closing " or ' must be followed by
+ * grey space.
+ *
+ * Error conditions are end of line before end of quote, or no space after
+ * a closing quote.  In this case, tokenize() returns -1. */
+
+#include <sys/param.h>
+#ifdef KERNEL
+#undef KERNEL						    /* XXX */
+#define REALLYKERNEL
+#else
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#endif
+/* All this mess for a single struct definition */
+#include <sys/uio.h>
+#include <sys/namei.h>
+#include <sys/disklabel.h>
+#include <sys/mount.h>
+#include <sys/device.h>
+#include <sys/disk.h>
+#include "sys/buf.h"
+
+#include <vinumvar.h>
+#include "vinumkw.h"
+#include "vinumio.h"
+#include "vinumext.h"
+
+#ifdef REALLYKERNEL
+#define isspace(c) ((c == ' ') || (c == '\t'))		    /* check for white space */
+#else /* get it from the headers */
+#include <ctype.h>
+#endif
+
+/* enum keyword is defined in vinumvar.h */
+
+#define keypair(x) { #x, kw_##x }			    /* create pair "foo", kw_foo */
+#define flagkeypair(x) { "-"#x, kw_##x }		    /* create pair "-foo", kw_foo */
+#define KEYWORDSET(x) {sizeof (x) / sizeof (struct _keywords), x}
+
+/* Normal keywords.  These are all the words that vinum knows. */
+struct _keywords keywords[] =
+{keypair(drive),
+    keypair(sd),
+    keypair(subdisk),
+    keypair(plex),
+    keypair(volume),
+    keypair(vol),
+    keypair(setupstate),
+    keypair(readpol),
+    keypair(org),
+    keypair(name),
+    keypair(writethrough),
+    keypair(writeback),
+    keypair(raw),
+    keypair(device),
+    keypair(concat),
+    keypair(raid5),
+    keypair(striped),
+    keypair(plexoffset),
+    keypair(driveoffset),
+    keypair(length),
+    keypair(len),
+    keypair(state),
+    keypair(round),
+    keypair(prefer),
+    keypair(rename),
+    keypair(detached),
+#ifndef KERNEL						    /* for vinum(8) only */
+#ifdef DEBUG
+    keypair(debug),
+#endif
+    keypair(attach),
+    keypair(detach),
+    keypair(printconfig),
+    keypair(replace),
+    keypair(create),
+    keypair(read),
+    keypair(modify),
+    keypair(list),
+    keypair(l),
+    keypair(ld),
+    keypair(ls),
+    keypair(lp),
+    keypair(lv),
+    keypair(info),
+    keypair(set),
+    keypair(rm),
+    keypair(init),
+    keypair(label),
+    keypair(resetconfig),
+    keypair(start),
+    keypair(stop),
+    keypair(resetstats)
+#endif
+};
+struct keywordset keyword_set = KEYWORDSET(keywords);
+
+#ifndef KERNEL
+struct _keywords flag_keywords[] =
+{flagkeypair(f),
+    flagkeypair(d),
+    flagkeypair(v),
+    flagkeypair(s),
+    flagkeypair(r)
+};
+struct keywordset flag_set = KEYWORDSET(flag_keywords);
+
+#endif
+
+int 
+tokenize(char *cptr, char *token[])
+{
+    char delim;						    /* delimiter for searching for the partner */
+    int tokennr;					    /* index of this token */
+    tokennr = 0;					    /* none found yet */
+
+    for (;;) {
+	while (isspace(*cptr))
+	    cptr++;					    /* skip initial white space */
+	if ((*cptr == '\0') || (*cptr == '\n') || (*cptr == '#')) /* end of line */
+	    return tokennr;				    /* return number of tokens found */
+	delim = *cptr;
+	token[tokennr] = cptr;				    /* point to it */
+	tokennr++;					    /* one more */
+	/* XXX this is broken.  It leaves superfluous \\ characters in the text */
+	if ((delim == '\'') || (delim == '"')) {	    /* delimitered */
+	    for (;;) {
+		cptr++;
+		if ((*cptr == delim) && (cptr[-1] != '\\')) { /* found the partner */
+		    cptr++;				    /* move on past */
+		    if (!isspace(*cptr))		    /* error, no space after closing quote */
+			return -1;
+		    *cptr++ = '\0';			    /* delimit */
+		} else if ((*cptr == '\0') || (*cptr == '\n')) /* end of line */
+		    return -1;
+	    }
+	} else {					    /* not quoted */
+	    while ((*cptr != '\0') && (!isspace(*cptr)) && (*cptr != '\n'))
+		cptr++;
+	    if (*cptr != '\0')				    /* not end of the line, */
+		*cptr++ = '\0';				    /* delimit and move to the next */
+	}
+    }
+}
+
+/* Find a keyword and return an index */
+enum keyword 
+get_keyword(char *name, struct keywordset *keywordset)
+{
+    int i;
+    struct _keywords *keywords = keywordset->k;		    /* point to the keywords */
+    for (i = 0; i < keywordset->size; i++)
+	if (!strcmp(name, keywords[i].name))
+	    return (enum keyword) keywords[i].keyword;
+    return kw_invalid_keyword;
+}
diff --git a/sys/dev/vinum/vinumrequest.c b/sys/dev/vinum/vinumrequest.c
new file mode 100644
index 0000000..79c5253
--- /dev/null
+++ b/sys/dev/vinum/vinumrequest.c
@@ -0,0 +1,966 @@
+/* XXX to do:
+
+ * Decide where we need splbio ()
+ */
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: request.c,v 1.3 1998/11/02 04:09:34 grog Exp $
+ */
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+#include "request.h"
+#include <miscfs/specfs/specdev.h>
+#include <sys/resourcevar.h>
+
+/* pointer to ioctl p parameter, to save passing it around */
+extern struct proc *myproc;
+
+enum requeststatus bre(struct request *rq,
+    int plexno,
+    daddr_t * diskstart,
+    daddr_t diskend);
+enum requeststatus bre5(struct request *rq,
+    int plexno,
+    daddr_t * diskstart,
+    daddr_t diskend);
+enum requeststatus build_read_request(struct request *rq, int volplexno);
+enum requeststatus build_write_request(struct request *rq);
+enum requeststatus build_rq_buffer(struct rqelement *rqe, struct plex *plex);
+void freerq(struct request *rq);
+void free_rqg(struct rqgroup *rqg);
+int find_alternate_sd(struct request *rq);
+int check_range_covered(struct request *);
+void complete_rqe(struct buf *bp);
+void complete_raid5_write(struct rqelement *);
+int abortrequest(struct request *rq, int error);
+void sdio(struct buf *bp);
+void sdio_done(struct buf *bp);
+int vinum_bounds_check(struct buf *bp, struct volume *vol);
+caddr_t allocdatabuf(struct rqelement *rqe);
+void freedatabuf(struct rqelement *rqe);
+
+#ifdef DEBUG
+struct rqinfo rqinfo[RQINFO_SIZE];
+struct rqinfo *rqip = rqinfo;
+
+void 
+logrq(enum rqinfo_type type, union rqinfou info, struct buf *ubp)
+{
+    BROKEN_GDB;
+    int s = splhigh();
+
+    vinum_conf.rqipp = &rqip;				    /* XXX for broken gdb */
+    vinum_conf.rqinfop = rqinfo;			    /* XXX for broken gdb */
+
+#if __FreeBSD__ < 3
+    rqip->timestamp = time;				    /* when did this happen? */
+#else
+    microtime(&rqip->timestamp);			    /* when did this happen? */
+#endif
+    rqip->type = type;
+    rqip->bp = ubp;					    /* user buffer */
+    switch (type) {
+    case loginfo_user_bp:
+    case loginfo_user_bpl:
+	bcopy(info.bp, &rqip->info.b, sizeof(struct buf));
+	break;
+
+    case loginfo_iodone:
+    case loginfo_rqe:
+    case loginfo_raid5_data:
+    case loginfo_raid5_parity:
+	bcopy(info.rqe, &rqip->info.rqe, sizeof(struct rqelement));
+	break;
+
+    case loginfo_unused:
+	break;
+    }
+    rqip++;
+    if (rqip >= &rqinfo[RQINFO_SIZE])			    /* wrap around */
+	rqip = rqinfo;
+    splx(s);
+}
+
+#endif
+
+void 
+vinumstrategy(struct buf *bp)
+{
+    BROKEN_GDB;
+    int volno;
+    struct volume *vol = NULL;
+    int s;
+    struct devcode *device = (struct devcode *) &bp->b_dev; /* decode device number */
+    enum requeststatus status;
+
+    /* We may have changed the configuration in
+     * an interrupt context.  Update it now.  It
+     * could change again, so do it in a loop.
+     * XXX this is broken and contains a race condition.
+     * The correct way is to hand it off the the Vinum
+     * daemon, but I haven't found a name for it yet */
+    while (vinum_conf.flags & VF_DIRTYCONFIG) {		    /* config is dirty, save it now */
+	int driveno;
+
+	vinum_conf.flags &= ~VF_DIRTYCONFIG;		    /* turn it off */
+	for (driveno = 0; driveno < vinum_conf.drives_used; driveno++) {
+	    if ((DRIVE[driveno].state == drive_down)	    /* drive down */
+	    &&(DRIVE[driveno].vp != NULL))		    /* but still open */
+		close_drive(&DRIVE[driveno]);		    /* close it now */
+	}
+	save_config();
+    }
+
+    switch (device->type) {
+    case VINUM_SD_TYPE:
+	sdio(bp);
+	return;
+
+	/* In fact, vinum doesn't handle drives: they're
+	 * handled directly by the disk drivers */
+    case VINUM_DRIVE_TYPE:
+    default:
+	bp->b_error = EIO;				    /* I/O error */
+	bp->b_flags |= B_ERROR;
+	biodone(bp);
+	return;
+
+    case VINUM_VOLUME_TYPE:				    /* volume I/O */
+	volno = VOLNO(bp->b_dev);
+	vol = &VOL[volno];
+	if (vol->state != volume_up) {			    /* can't access this volume */
+	    bp->b_error = EIO;				    /* I/O error */
+	    bp->b_flags |= B_ERROR;
+	    biodone(bp);
+	    return;
+	}
+	if (vinum_bounds_check(bp, vol) <= 0) {		    /* don't like them bounds */
+	    biodone(bp);				    /* have nothing to do with this */
+	    return;
+	}
+	/* FALLTHROUGH */
+	/* Plex I/O is pretty much the same as volume I/O
+	 * for a single plex.  Indicate this by passing a NULL
+	 * pointer (set above) for the volume */
+    case VINUM_PLEX_TYPE:
+	bp->b_resid = bp->b_bcount;			    /* transfer everything */
+	vinumstart(bp, 0);
+	return;
+    }
+}
+
+/* Start a transfer.  Return -1 on error,
+ * 0 if OK, 1 if we need to retry.
+ * Parameter reviveok is set when doing
+ * transfers for revives: it allows transfers to
+ * be started immediately when a revive is in
+ * progress.  During revive, normal transfers
+ * are queued if they share address space with
+ * a currently active revive operation. */
+int 
+vinumstart(struct buf *bp, int reviveok)
+{
+    BROKEN_GDB;
+    int plexno;
+    int maxplex;					    /* maximum number of plexes to handle */
+    struct volume *vol;
+    struct rqgroup *rqg;				    /* current plex's requests */
+    struct rqelement *rqe;				    /* individual element */
+    struct request *rq;					    /* build up our request here */
+    int rqno;						    /* index in request list */
+    enum requeststatus status;
+
+#if DEBUG
+    if (debug & DEBUG_LASTREQS)
+	logrq(loginfo_user_bp, bp, bp);
+#endif
+
+    /* XXX In these routines, we're assuming that
+     * we will always be called with bp->b_bcount
+     * which is a multiple of the sector size.  This
+     * is a reasonable assumption, since we are only
+     * called from system routines.  Should we check
+     * anyway? */
+
+    if ((bp->b_bcount % DEV_BSIZE) != 0) {		    /* bad length */
+	bp->b_error = EINVAL;				    /* invalid size */
+	bp->b_flags |= B_ERROR;
+	biodone(bp);
+	return -1;
+    }
+    rq = (struct request *) Malloc(sizeof(struct request)); /* allocate a request struct */
+    if (rq == NULL) {					    /* can't do it */
+	bp->b_error = ENOMEM;				    /* can't get memory */
+	bp->b_flags |= B_ERROR;
+	biodone(bp);
+	return -1;
+    }
+    bzero(rq, sizeof(struct request));
+
+    /* Note the volume ID.  This can be NULL, which
+     * the request building functions use as an
+     * indication for single plex I/O */
+    rq->bp = bp;					    /* and the user buffer struct */
+
+    if (DEVTYPE(bp->b_dev) == VINUM_VOLUME_TYPE) {	    /* it's a volume, */
+	rq->volplex.volno = VOLNO(bp->b_dev);		    /* get the volume number */
+	vol = &VOL[rq->volplex.volno];			    /* and point to it */
+	vol->active++;					    /* one more active request */
+	maxplex = vol->plexes;				    /* consider all its plexes */
+    } else {
+	vol = NULL;					    /* no volume */
+	rq->volplex.plexno = PLEXNO(bp->b_dev);		    /* point to the plex */
+	rq->isplex = 1;					    /* note that it's a plex */
+	maxplex = 1;					    /* just the one plex */
+    }
+
+    if (bp->b_flags & B_READ) {
+	/* This is a read request.  Decide
+	 * which plex to read from.
+	 *
+	 * There's a potential race condition here,
+	 * since we're not locked, and we could end
+	 * up multiply incrementing the round-robin
+	 * counter.  This doesn't have any serious
+	 * effects, however. */
+	if (vol != NULL) {
+	    vol->reads++;
+	    vol->bytes_read += bp->b_bcount;
+	    plexno = vol->preferred_plex;		    /* get the plex to use */
+	    if (plexno < 0) {				    /* round robin */
+		plexno = vol->last_plex_read;
+		vol->last_plex_read++;
+		if (vol->last_plex_read == vol->plexes)	    /* got the the end? */
+		    vol->last_plex_read = 0;		    /* wrap around */
+	    }
+	    status = build_read_request(rq, plexno);	    /* build a request */
+	} else {
+	    daddr_t diskaddr = bp->b_blkno;		    /* start offset of transfer */
+	    status = bre(rq,				    /* build a request list */
+		rq->volplex.plexno,
+		&diskaddr,
+		diskaddr + (bp->b_bcount / DEV_BSIZE));
+	}
+
+	if ((status > REQUEST_RECOVERED)		    /* can't satisfy it */
+	||(bp->b_flags & B_DONE)) {			    /* XXX shouldn't get this without bad status */
+	    if (status == REQUEST_DOWN) {		    /* not enough subdisks */
+		bp->b_error = EIO;			    /* I/O error */
+		bp->b_flags |= B_ERROR;
+	    }
+	    biodone(bp);
+	    freerq(rq);
+	    return -1;
+	} {						    /* XXX */
+	    int result;
+	    int s = splhigh();
+	    result = launch_requests(rq, reviveok);	    /* now start the requests if we can */
+	    splx(s);
+	    return result;
+	}
+    } else
+	/* This is a write operation.  We write to all
+	 * plexes.  If this is a RAID 5 plex, we must also
+	 * update the parity stripe. */
+    {
+	if (vol != NULL) {
+	    vol->writes++;
+	    vol->bytes_written += bp->b_bcount;
+	    status = build_write_request(rq);		    /* Not all the subdisks are up */
+	} else {					    /* plex I/O */
+	    daddr_t diskstart;
+
+	    diskstart = bp->b_blkno;			    /* start offset of transfer */
+	    status = bre(rq,
+		PLEXNO(bp->b_dev),
+		&diskstart,
+		bp->b_blkno + (bp->b_bcount / DEV_BSIZE));  /* build requests for the plex */
+	}
+	if ((status > REQUEST_RECOVERED)		    /* can't satisfy it */
+	||(bp->b_flags & B_DONE)) {			    /* XXX shouldn't get this without bad status */
+	    if (status == REQUEST_DOWN) {		    /* not enough subdisks */
+		bp->b_error = EIO;			    /* I/O error */
+		bp->b_flags |= B_ERROR;
+	    }
+	    if ((bp->b_flags & B_DONE) == 0)
+		biodone(bp);
+	    freerq(rq);
+	    return -1;
+	} {						    /* XXX */
+	    int result;
+	    int s = splhigh();
+	    result = launch_requests(rq, reviveok);	    /* now start the requests if we can */
+	    splx(s);
+	    return result;
+	}
+	/*    return launch_requests (rq, reviveok);     *//* start the requests */
+    }
+}
+
+/* Call the low-level strategy routines to
+ * perform the requests in a struct request */
+int 
+launch_requests(struct request *rq, int reviveok)
+{
+    struct rqgroup *rqg;
+    int rqno;						    /* loop index */
+    struct rqelement *rqe;				    /* current element */
+    int s;
+
+    /* First find out whether we're reviving, and the
+     * request contains a conflict.  If so, we hang
+     * the request off plex->waitlist of the first
+     * plex we find which is reviving */
+    if ((rq->flags & XFR_REVIVECONFLICT)		    /* possible revive conflict */
+    &&(!reviveok)) {					    /* and we don't want to do it now, */
+	struct volume *vol = &VOL[VOLNO(rq->bp->b_dev)];
+	struct plex *plex;
+	int plexno;
+
+	for (plexno = 0; plexno < vol->plexes; plexno++) {  /* find the reviving plex */
+	    plex = &PLEX[vol->plex[plexno]];
+	    if (plex->state == plex_reviving)		    /* found it */
+		break;
+	}
+	if (plexno < vol->plexes) {			    /* found it? */
+	    struct request *waitlist = plex->waitlist;	    /* point to the waiting list */
+
+	    while (waitlist->next != NULL)		    /* find the end */
+		waitlist = waitlist->next;
+	    waitlist->next = rq;			    /* hook our request there */
+	    return 0;					    /* and get out of here */
+	} else						    /* bad vinum, bad */
+	    printf("vinum: can't find reviving plex for volume %s\n", vol->name);
+    }
+    rq->active = 0;					    /* nothing yet */
+    /* XXX This is probably due to a bug */
+    if (rq->rqg == NULL) {				    /* no request */
+	abortrequest(rq, EINVAL);
+	return -1;
+    }
+#if DEBUG
+    if (debug & DEBUG_ADDRESSES)
+	printf("Request: %x\n%s dev 0x%x, offset 0x%x, length %ld\n",
+	    (u_int) rq,
+	    rq->bp->b_flags & B_READ ? "Read" : "Write",
+	    rq->bp->b_dev,
+	    rq->bp->b_blkno,
+	    rq->bp->b_bcount);				    /* XXX */
+    vinum_conf.lastrq = (int) rq;
+    vinum_conf.lastbuf = rq->bp;
+    if (debug & DEBUG_LASTREQS)
+	logrq(loginfo_user_bpl, rq->bp, rq->bp);
+#endif
+    for (rqg = rq->rqg; rqg != NULL; rqg = rqg->next) {	    /* through the whole request chain */
+	rqg->active = rqg->count;			    /* they're all active */
+	rq->active++;					    /* one more active request group */
+	for (rqno = 0; rqno < rqg->count; rqno++) {
+	    rqe = &rqg->rqe[rqno];
+	    if (rqe->flags & XFR_BAD_SUBDISK)		    /* this subdisk is bad, */
+		rqg->active--;				    /* one less active request */
+	    else {
+		struct drive *drive = &DRIVE[rqe->driveno]; /* drive to access */
+		if ((rqe->b.b_flags & B_READ) == 0)
+		    rqe->b.b_vp->v_numoutput++;		    /* one more output going */
+		rqe->b.b_flags |= B_ORDERED;		    /* XXX chase SCSI driver */
+#if DEBUG
+		if (debug & DEBUG_ADDRESSES)
+		    printf("  %s dev 0x%x, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
+			rqe->b.b_flags & B_READ ? "Read" : "Write",
+			rqe->b.b_dev,
+			rqe->sdno,
+			(u_int) (rqe->b.b_blkno - SD[rqe->sdno].driveoffset),
+			rqe->b.b_blkno,
+			rqe->b.b_bcount);		    /* XXX */
+		if (debug & DEBUG_NUMOUTPUT)
+		    printf("  vinumstart sd %d numoutput %ld\n",
+			rqe->sdno,
+			rqe->b.b_vp->v_numoutput);
+		if (debug & DEBUG_LASTREQS)
+		    logrq(loginfo_rqe, rqe, rq->bp);
+#endif
+		/* fire off the request */
+		s = splbio();
+		(*bdevsw[major(rqe->b.b_dev)]->d_strategy) (&rqe->b);
+		splx(s);
+	    }
+	    /* XXX Do we need caching?  Think about this more */
+	}
+    }
+    return 0;
+}
+
+/* define the low-level requests needed to perform a
+ * high-level I/O operation for a specific plex 'plexno'.
+ *
+ * Return 0 if all subdisks involved in the request are up, 1 if some
+ * subdisks are not up, and -1 if the request is at least partially
+ * outside the bounds of the subdisks.
+ *
+ * Modify the pointer *diskstart to point to the end address.  On
+ * read, return on the first bad subdisk, so that the caller
+ * (build_read_request) can try alternatives.
+ *
+ * On entry to this routine, the rqg structures are not assigned.  The
+ * assignment is performed by expandrq().  Strictly speaking, the
+ * elements rqe->sdno of all entries should be set to -1, since 0
+ * (from bzero) is a valid subdisk number.  We avoid this problem by
+ * initializing the ones we use, and not looking at the others (index
+ * >= rqg->requests).
+ */
+enum requeststatus 
+bre(struct request *rq,
+    int plexno,
+    daddr_t * diskaddr,
+    daddr_t diskend)
+{
+    BROKEN_GDB;
+    int sdno;
+    struct sd *sd;
+    struct rqgroup *rqg;
+    struct buf *bp;					    /* user's bp */
+    struct plex *plex;
+    enum requeststatus status;				    /* return value */
+    daddr_t plexoffset;					    /* offset of transfer in plex */
+    daddr_t stripebase;					    /* base address of stripe (1st subdisk) */
+    daddr_t stripeoffset;				    /* offset in stripe */
+    daddr_t blockoffset;				    /* offset in stripe on subdisk */
+    struct rqelement *rqe;				    /* point to this request information */
+    daddr_t diskstart = *diskaddr;			    /* remember where this transfer starts */
+
+    bp = rq->bp;					    /* buffer pointer */
+    status = REQUEST_OK;				    /* return value: OK until proven otherwise */
+    plex = &PLEX[plexno];				    /* point to the plex */
+
+    switch (plex->organization) {
+    case plex_concat:
+	for (sdno = 0; sdno < plex->subdisks; sdno++) {
+	    sd = &SD[plex->sdnos[sdno]];
+	    if ((*diskaddr < (sd->plexoffset + sd->sectors)) /* The request starts before the end of this */
+	    &&(diskend > sd->plexoffset)) {		    /* subdisk and ends after the start of this sd */
+		if ((sd->state != sd_up) || (plex->state != plex_up)) {
+		    enum requeststatus s;
+
+		    s = checksdstate(sd, rq, *diskaddr, diskend); /* do we need to change state? */
+		    if (s)				    /* give up? */
+			return s;			    /* yup */
+		}
+		rqg = allocrqg(rq, 1);			    /* space for the request */
+		if (rqg == NULL) {			    /* malloc failed */
+		    bp->b_flags |= B_ERROR;
+		    bp->b_error = ENOMEM;
+		    biodone(bp);
+		    return REQUEST_ENOMEM;
+		}
+		rqg->plexno = plexno;
+
+		rqe = &rqg->rqe[0];			    /* point to the element */
+		rqe->rqg = rqg;				    /* group */
+		rqe->sdno = sd->sdno;			    /* put in the subdisk number */
+		plexoffset = max(sd->plexoffset, *diskaddr); /* start offset in plex */
+		rqe->sdoffset = plexoffset - sd->plexoffset; /* start offset in subdisk */
+		rqe->useroffset = plexoffset - diskstart;   /* start offset in user buffer */
+		rqe->dataoffset = 0;
+		rqe->datalen = min(diskend - *diskaddr,	    /* number of sectors to transfer in this sd */
+		    sd->sectors - rqe->sdoffset);
+		rqe->groupoffset = 0;			    /* no groups for concatenated plexes */
+		rqe->grouplen = 0;
+		rqe->buflen = rqe->datalen;		    /* buffer length is data buffer length */
+		rqe->flags = 0;
+		rqe->driveno = sd->driveno;
+		*diskaddr += rqe->datalen;		    /* bump the address */
+		if (build_rq_buffer(rqe, plex)) {	    /* build the buffer */
+		    deallocrqg(rqg);
+		    bp->b_flags |= B_ERROR;
+		    bp->b_error = ENOMEM;
+		    biodone(bp);
+		    return REQUEST_ENOMEM;		    /* can't do it */
+		}
+	    }
+	    if (*diskaddr > diskend)			    /* we're finished, */
+		break;					    /* get out of here */
+	}
+	break;
+
+    case plex_striped:
+	{
+	    while (*diskaddr < diskend) {		    /* until we get it all sorted out */
+		/* The offset of the start address from
+		 * the start of the stripe */
+		stripeoffset = *diskaddr % (plex->stripesize * plex->subdisks);
+
+		/* The plex-relative address of the
+		 * start of the stripe */
+		stripebase = *diskaddr - stripeoffset;
+
+		/* The number of the subdisk in which
+		 * the start is located */
+		sdno = stripeoffset / plex->stripesize;
+
+		/* The offset from the beginning of the stripe
+		 * on this subdisk */
+		blockoffset = stripeoffset % plex->stripesize;
+
+		sd = &SD[plex->sdnos[sdno]];		    /* the subdisk in question */
+		if ((sd->state != sd_up) || (plex->state != plex_up)) {
+		    enum requeststatus s;
+
+		    s = checksdstate(sd, rq, *diskaddr, diskend); /* do we need to change state? */
+		    if (s)				    /* give up? */
+			return s;			    /* yup */
+		}
+		rqg = allocrqg(rq, 1);			    /* space for the request */
+		if (rqg == NULL) {			    /* malloc failed */
+		    bp->b_flags |= B_ERROR;
+		    bp->b_error = ENOMEM;
+		    biodone(bp);
+		    return REQUEST_ENOMEM;
+		}
+		rqg->plexno = plexno;
+
+		rqe = &rqg->rqe[0];			    /* point to the element */
+		rqe->rqg = rqg;
+		rqe->sdoffset = stripebase / plex->subdisks + blockoffset; /* start offset in this subdisk */
+		rqe->useroffset = *diskaddr - diskstart;    /* The offset of the start in the user buffer */
+		rqe->dataoffset = 0;
+		rqe->datalen = min(diskend - *diskaddr,	    /* the amount remaining to transfer */
+		    plex->stripesize - blockoffset);	    /* and the amount left in this stripe */
+		rqe->groupoffset = 0;			    /* no groups for striped plexes */
+		rqe->grouplen = 0;
+		rqe->buflen = rqe->datalen;		    /* buffer length is data buffer length */
+		rqe->flags = 0;
+		rqe->sdno = sd->sdno;			    /* put in the subdisk number */
+		rqe->driveno = sd->driveno;
+
+		if (rqe->sdoffset >= sd->sectors) {	    /* starts beyond the end of the subdisk? */
+		    deallocrqg(rqg);
+		    return REQUEST_EOF;
+		} else if (rqe->sdoffset + rqe->datalen > sd->sectors) /* ends beyond the end of the subdisk? */
+		    rqe->datalen = sd->sectors - rqe->sdoffset;	/* yes, truncate */
+
+		if (build_rq_buffer(rqe, plex)) {	    /* build the buffer */
+		    deallocrqg(rqg);
+		    bp->b_flags |= B_ERROR;
+		    bp->b_error = ENOMEM;
+		    biodone(bp);
+		    return REQUEST_ENOMEM;		    /* can't do it */
+		}
+		*diskaddr += rqe->datalen;		    /* look at the remainder */
+		if (*diskaddr < diskend) {		    /* didn't finish the request on this stripe */
+		    plex->multiblock++;			    /* count another one */
+		    if (sdno == plex->subdisks - 1)	    /* last subdisk, */
+			plex->multistripe++;		    /* another stripe as well */
+		}
+	    }
+	}
+	break;
+
+
+    default:
+	printf("vinum: invalid plex type in bre");
+    }
+
+    return status;
+}
+
+/* Build up a request structure for reading volumes.
+ * This function is not needed for plex reads, since there's
+ * no recovery if a plex read can't be satisified. */
+enum requeststatus 
+build_read_request(struct request *rq,			    /* request */
+    int plexindex)
+{							    /* index in the volume's plex table */
+    BROKEN_GDB;
+    struct buf *bp;
+    daddr_t startaddr;					    /* offset of previous part of transfer */
+    daddr_t diskaddr;					    /* offset of current part of transfer */
+    daddr_t diskend;					    /* and end offset of transfer */
+    int plexno;						    /* plex index in vinum_conf */
+    struct rqgroup *rqg;				    /* point to the request we're working on */
+    struct volume *vol;					    /* volume in question */
+    off_t oldstart;					    /* note where we started */
+    int recovered = 0;					    /* set if we recover a read */
+    enum requeststatus status = REQUEST_OK;
+
+    bp = rq->bp;					    /* buffer pointer */
+    diskaddr = bp->b_blkno;				    /* start offset of transfer */
+    diskend = diskaddr + (bp->b_bcount / DEV_BSIZE);	    /* and end offset of transfer */
+    rqg = &rq->rqg[plexindex];				    /* plex request */
+    vol = &VOL[rq->volplex.volno];			    /* point to volume */
+
+    while (diskaddr < diskend) {			    /* build up request components */
+	startaddr = diskaddr;
+	status = bre(rq, vol->plex[plexindex], &diskaddr, diskend); /* build up a request */
+	switch (status) {
+	case REQUEST_OK:
+	    continue;
+
+	case REQUEST_RECOVERED:
+	    recovered = 1;
+	    break;
+
+	case REQUEST_EOF:
+	case REQUEST_ENOMEM:
+	    return status;
+
+	    /* if we get here, we have either had a failure or
+	     * a RAID 5 recovery.  We don't want to use the
+	     * recovery, because it's expensive, so first we
+	     * check if we have alternatives */
+	case REQUEST_DOWN:				    /* can't access the plex */
+	    if (vol != NULL) {				    /* and this is volume I/O */
+		/* Try to satisfy the request
+		 * from another plex */
+		for (plexno = 0; plexno < vol->plexes; plexno++) {
+		    diskaddr = startaddr;		    /* start at the beginning again */
+		    oldstart = startaddr;		    /* and note where that was */
+		    if (plexno != plexindex) {		    /* don't try this plex again */
+			bre(rq, vol->plex[plexno], &diskaddr, diskend);	/* try a request */
+			if (diskaddr > oldstart) {	    /* we satisfied another part */
+			    recovered = 1;		    /* we recovered from the problem */
+			    status = REQUEST_OK;	    /* don't complain about it */
+			    break;
+			}
+		    }
+		    if (plexno == (vol->plexes - 1))	    /* couldn't satisfy the request */
+			return REQUEST_DOWN;		    /* failed */
+		}
+	    } else
+		return REQUEST_DOWN;			    /* bad luck */
+	}
+	if (recovered)
+	    vol->recovered_reads += recovered;		    /* adjust our recovery count */
+    }
+    return status;
+}
+
+/* Build up a request structure for writes.
+ * Return 0 if all subdisks involved in the request are up, 1 if some
+ * subdisks are not up, and -1 if the request is at least partially
+ * outside the bounds of the subdisks. */
+enum requeststatus 
+build_write_request(struct request *rq)
+{							    /* request */
+    BROKEN_GDB;
+    struct buf *bp;
+    daddr_t diskstart;					    /* offset of current part of transfer */
+    daddr_t diskend;					    /* and end offset of transfer */
+    int plexno;						    /* plex index in vinum_conf */
+    struct volume *vol;					    /* volume in question */
+    enum requeststatus status;
+
+    bp = rq->bp;					    /* buffer pointer */
+    vol = &VOL[rq->volplex.volno];			    /* point to volume */
+    diskend = bp->b_blkno + (bp->b_bcount / DEV_BSIZE);	    /* end offset of transfer */
+    status = REQUEST_OK;
+    for (plexno = 0; plexno < vol->plexes; plexno++) {
+	diskstart = bp->b_blkno;			    /* start offset of transfer */
+	status = min(status, bre(rq,			    /* build requests for the plex */
+		vol->plex[plexno],
+		&diskstart,
+		diskend));
+    }
+    return status;
+}
+
+/* Fill in the struct buf part of a request element. */
+enum requeststatus 
+build_rq_buffer(struct rqelement *rqe, struct plex *plex)
+{
+    BROKEN_GDB;
+    struct sd *sd;					    /* point to subdisk */
+    struct volume *vol;
+    struct buf *bp;
+    struct buf *ubp;					    /* user (high level) buffer header */
+
+    vol = &VOL[rqe->rqg->rq->volplex.volno];
+    sd = &SD[rqe->sdno];				    /* point to subdisk */
+    bp = &rqe->b;
+    ubp = rqe->rqg->rq->bp;				    /* pointer to user buffer header */
+
+    /* Initialize the buf struct */
+    bzero(&rqe->b, sizeof(struct buf));
+    bp->b_proc = ubp->b_proc;				    /* process pointer */
+    bp->b_flags = ubp->b_flags & (B_NOCACHE | B_READ | B_ASYNC); /* copy these flags from user bp */
+    bp->b_flags |= B_CALL | B_BUSY;			    /* inform us when it's done */
+    if (plex->state == plex_reviving)
+	bp->b_flags |= B_ORDERED;			    /* keep request order if we're reviving */
+    bp->b_iodone = complete_rqe;			    /* by calling us here */
+    bp->b_dev = DRIVE[rqe->driveno].dev;		    /* drive device */
+    bp->b_blkno = rqe->sdoffset + sd->driveoffset;	    /* start address */
+    bp->b_bcount = rqe->buflen << DEV_BSHIFT;		    /* number of bytes to transfer */
+    bp->b_resid = bp->b_bcount;				    /* and it's still all waiting */
+    bp->b_bufsize = bp->b_bcount;			    /* and buffer size */
+    bp->b_vp = DRIVE[rqe->driveno].vp;			    /* drive vnode */
+    bp->b_rcred = FSCRED;				    /* we have the file system credentials */
+    bp->b_wcred = FSCRED;				    /* we have the file system credentials */
+
+    if (rqe->flags & XFR_MALLOCED) {			    /* this operation requires a malloced buffer */
+	bp->b_data = Malloc(bp->b_bcount);		    /* get a buffer to put it in */
+	if (bp->b_data == NULL) {			    /* failed */
+	    Debugger("XXX");
+	    abortrequest(rqe->rqg->rq, ENOMEM);
+	    return REQUEST_ENOMEM;			    /* no memory */
+	}
+    } else
+	/* Point directly to user buffer data.  This means
+	 * that we don't need to do anything when we have
+	 * finished the transfer */
+	bp->b_data = ubp->b_data + rqe->useroffset * DEV_BSIZE;
+    return 0;
+}
+/* Abort a request: free resources and complete the
+ * user request with the specified error */
+int 
+abortrequest(struct request *rq, int error)
+{
+    struct buf *bp = rq->bp;				    /* user buffer */
+
+    bp->b_flags |= B_ERROR;
+    bp->b_error = error;
+    freerq(rq);						    /* free everything we're doing */
+    biodone(bp);
+    return error;					    /* and give up */
+}
+
+/* Check that our transfer will cover the
+ * complete address space of the user request.
+ *
+ * Return 1 if it can, otherwise 0 */
+int 
+check_range_covered(struct request *rq)
+{
+    /* XXX */
+    return 1;
+}
+
+/* Perform I/O on a subdisk */
+void 
+sdio(struct buf *bp)
+{
+    int s;						    /* spl */
+    struct sd *sd;
+    struct sdbuf *sbp;
+    daddr_t endoffset;
+    struct drive *drive;
+
+    sd = &SD[SDNO(bp->b_dev)];				    /* point to the subdisk */
+    drive = &DRIVE[sd->driveno];
+
+    if (drive->state != drive_up) {			    /* XXX until we get the states fixed */
+	set_sd_state(SDNO(bp->b_dev), sd_obsolete, setstate_force);
+	bp->b_flags |= B_ERROR;
+	bp->b_error = EIO;
+	biodone(bp);
+	return;
+    }
+    /* XXX decide which states we will really accept here.  up
+     * implies it could be involved with a plex, in which
+     * case we don't want to dick with it */
+    if ((sd->state != sd_up)
+	&& (sd->state != sd_initializing)
+	&& (sd->state != sd_reborn)) {			    /* we can't access it */
+	bp->b_flags |= B_ERROR;
+	bp->b_flags = EIO;
+	if (bp->b_flags & B_BUSY)			    /* XXX why isn't this always the case? */
+	    biodone(bp);
+	return;
+    }
+    /* Get a buffer */
+    sbp = (struct sdbuf *) Malloc(sizeof(struct sdbuf));
+    if (sbp == NULL) {
+	bp->b_flags |= B_ERROR;
+	bp->b_error = ENOMEM;
+	biodone(bp);
+	return;
+    }
+    bcopy(bp, &sbp->b, sizeof(struct buf));		    /* start with the user's buffer */
+    sbp->b.b_flags |= B_CALL;				    /* tell us when it's done */
+    sbp->b.b_iodone = sdio_done;			    /* here */
+    sbp->b.b_dev = DRIVE[sd->driveno].dev;		    /* device */
+    sbp->b.b_vp = DRIVE[sd->driveno].vp;		    /* vnode */
+    sbp->b.b_blkno += sd->driveoffset;
+    sbp->bp = bp;					    /* note the address of the original header */
+    sbp->sdno = sd->sdno;				    /* note for statistics */
+    sbp->driveno = sd->driveno;
+    endoffset = bp->b_blkno + sbp->b.b_bcount / DEV_BSIZE;  /* final sector offset */
+    if (endoffset > sd->sectors) {			    /* beyond the end */
+	sbp->b.b_bcount -= (endoffset - sd->sectors) * DEV_BSIZE; /* trim */
+	if (sbp->b.b_bcount <= 0) {			    /* nothing to transfer */
+	    bp->b_resid = bp->b_bcount;			    /* nothing transferred */
+	    /* XXX Grrr.  This doesn't seem to work.  Return
+	     * an error after all */
+	    bp->b_flags |= B_ERROR;
+	    bp->b_error = ENOSPC;
+	    biodone(bp);
+	    Free(sbp);
+	    return;
+	}
+    }
+    if ((sbp->b.b_flags & B_READ) == 0)			    /* write */
+	sbp->b.b_vp->v_numoutput++;			    /* one more output going */
+#if DEBUG
+    if (debug & DEBUG_ADDRESSES)
+	printf("  %s dev 0x%x, sd %d, offset 0x%x, devoffset 0x%x, length %ld\n",
+	    sbp->b.b_flags & B_READ ? "Read" : "Write",
+	    sbp->b.b_dev,
+	    sbp->sdno,
+	    (u_int) (sbp->b.b_blkno - SD[sbp->sdno].driveoffset),
+	    (int) sbp->b.b_blkno,
+	    sbp->b.b_bcount);				    /* XXX */
+    if (debug & DEBUG_NUMOUTPUT)
+	printf("  vinumstart sd %d numoutput %ld\n",
+	    sbp->sdno,
+	    sbp->b.b_vp->v_numoutput);
+#endif
+    s = splbio();
+    (*bdevsw[major(sbp->b.b_dev)]->d_strategy) (&sbp->b);
+    splx(s);
+}
+
+/* Simplified version of bounds_check_with_label
+ * Determine the size of the transfer, and make sure it is
+ * within the boundaries of the partition. Adjust transfer
+ * if needed, and signal errors or early completion.
+ *
+ * Volumes are simpler than disk slices: they only contain
+ * one component (though we call them a, b and c to make
+ * system utilities happy), and they always take up the
+ * complete space of the "partition".
+ *
+ * I'm still not happy with this: why should the label be
+ * protected?  If it weren't so damned difficult to write
+ * one in the first pleace (because it's protected), it wouldn't
+ * be a problem.
+ */
+int 
+vinum_bounds_check(struct buf *bp, struct volume *vol)
+{
+    int maxsize = vol->size;				    /* size of the partition (sectors) */
+    int size = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT; /* size of this request (sectors) */
+
+    /* Would this transfer overwrite the disk label? */
+    if (bp->b_blkno <= LABELSECTOR			    /* starts before or at the label */
+#if LABELSECTOR != 0
+	&& bp->b_blkno + size > LABELSECTOR		    /* and finishes after */
+#endif
+	&& (!(vol->flags & VF_RAW))			    /* and it's not raw */
+	&&major(bp->b_dev) == BDEV_MAJOR		    /* and it's the block device */
+	&& (bp->b_flags & B_READ) == 0			    /* and it's a write */
+	&& (!vol->flags & (VF_WLABEL | VF_LABELLING))) {    /* and we're not allowed to write the label */
+	bp->b_error = EROFS;				    /* read-only */
+	bp->b_flags |= B_ERROR;
+	return -1;
+    }
+    if (size == 0)					    /* no transfer specified, */
+	return 0;					    /* treat as EOF */
+    /* beyond partition? */
+    if (bp->b_blkno < 0					    /* negative start */
+	|| bp->b_blkno + size > maxsize) {		    /* or goes beyond the end of the partition */
+	/* if exactly at end of disk, return an EOF */
+	if (bp->b_blkno == maxsize) {
+	    bp->b_resid = bp->b_bcount;
+	    return 0;
+	}
+	/* or truncate if part of it fits */
+	size = maxsize - bp->b_blkno;
+	if (size <= 0) {				    /* nothing to transfer */
+	    bp->b_error = EINVAL;
+	    bp->b_flags |= B_ERROR;
+	    return -1;
+	}
+	bp->b_bcount = size << DEV_BSHIFT;
+    }
+    bp->b_pblkno = bp->b_blkno;
+    return 1;
+}
+
+/* Allocate a request group and hook
+ * it in in the list for rq */
+struct rqgroup *
+allocrqg(struct request *rq, int elements)
+{
+    struct rqgroup *rqg;				    /* the one we're going to allocate */
+    int size = sizeof(struct rqgroup) + elements * sizeof(struct rqelement);
+
+    rqg = (struct rqgroup *) Malloc(size);
+    if (rqg != NULL) {					    /* malloc OK, */
+	if (rq->rqg)					    /* we already have requests */
+	    rq->lrqg->next = rqg;			    /* hang it off the end */
+	else						    /* first request */
+	    rq->rqg = rqg;				    /* at the start */
+	rq->lrqg = rqg;					    /* this one is the last in the list */
+
+	bzero(rqg, size);				    /* no old junk */
+	rqg->rq = rq;					    /* point back to the parent request */
+	rqg->count = elements;				    /* number of requests in the group */
+    } else
+	Debugger("XXX");
+    return rqg;
+}
+
+/* Deallocate a request group out of a chain.  We do
+ * this by linear search: the chain is short, this
+ * almost never happens, and currently it can only
+ * happen to the first member of the chain. */
+void 
+deallocrqg(struct rqgroup *rqg)
+{
+    struct rqgroup *rqgc = rqg->rq->rqg;		    /* point to the request chain */
+
+    if (rqg->rq->rqg == rqg)				    /* we're first in line */
+	rqg->rq->rqg = rqg->next;			    /* unhook ourselves */
+    else {
+	while (rqgc->next != rqg)			    /* find the group */
+	    rqgc = rqgc->next;
+	rqgc->next = rqg->next;
+    }
+    Free(rqgc);
+}
+
+/* Character device interface */
+int 
+vinumread(dev_t dev, struct uio *uio, int ioflag)
+{
+    return (physio(vinumstrategy, NULL, dev, 1, minphys, uio));
+}
+
+int 
+vinumwrite(dev_t dev, struct uio *uio, int ioflag)
+{
+    return (physio(vinumstrategy, NULL, dev, 0, minphys, uio));
+}
diff --git a/sys/dev/vinum/vinumrevive.c b/sys/dev/vinum/vinumrevive.c
new file mode 100644
index 0000000..75000d8
--- /dev/null
+++ b/sys/dev/vinum/vinumrevive.c
@@ -0,0 +1,129 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: revive.c,v 1.3 1998/11/02 04:10:19 grog Exp $
+ */
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+#include "request.h"
+
+/* revive a block of a plex.  Return an error
+ * indication.  EAGAIN means successful copy, but
+ * that more blocks remain to be copied.
+ * XXX We should specify a block size here.  At the moment,
+ * just take a default value.  FIXME */
+int 
+revive_block(int plexno)
+{
+    struct plex *plex = &PLEX[plexno];
+    struct buf *bp;
+    int error = EAGAIN;
+    int size;						    /* size of revive block, bytes */
+    int s;						    /* priority level */
+
+    if (plex->revive_blocksize == 0) {
+	if (plex->stripesize != 0)			    /* we're striped, don't revive more than */
+	    plex->revive_blocksize = min(DEFAULT_REVIVE_BLOCKSIZE, /* one block at a time */
+		plex->stripesize << DEV_BSHIFT);
+	else
+	    plex->revive_blocksize = DEFAULT_REVIVE_BLOCKSIZE;
+    }
+    size = min(plex->revive_blocksize, (plex->length - plex->revived) << DEV_BSHIFT);
+
+    s = splbio();
+    /* Get a buffer */
+    bp = geteblk(size);
+    if (bp == NULL) {
+	splx(s);
+	return ENOMEM;
+    }
+    if (bp->b_qindex != 0)				    /* on a queue, */
+	bremfree(bp);					    /* remove it */
+    splx(s);
+
+    /* Amount to transfer: block size, unless it
+     * would overlap the end */
+    bp->b_bufsize = size;
+    bp->b_bcount = bp->b_bufsize;
+    bp->b_resid = 0x0;
+    bp->b_blkno = plex->revived;			    /* we've got this far */
+
+    /* XXX what about reviving anonymous plexes? */
+
+    /* First, read the data from the volume.  We don't
+     * care which plex, that's bre's job */
+    bp->b_dev = VINUMBDEV(plex->volno, 0, 0, VINUM_VOLUME_TYPE); /* create the device number */
+    bp->b_flags = B_BUSY | B_READ;
+    vinumstart(bp, 1);
+    biowait(bp);
+    if (bp->b_flags & B_ERROR)
+	error = bp->b_error;
+    else
+	/* Now write to the plex */
+    {
+	s = splbio();
+	if (bp->b_qindex != 0)				    /* on a queue, */
+	    bremfree(bp);				    /* remove it */
+	splx(s);
+	bp->b_dev = VINUMBDEV(plex->volno, plex->volplexno, 0, VINUM_PLEX_TYPE); /* create the device number */
+
+	bp->b_flags = B_BUSY;				    /* make this a write */
+	bp->b_resid = 0x0;
+	vinumstart(bp, 1);
+	biowait(bp);
+	if (bp->b_flags & B_ERROR)
+	    error = bp->b_error;
+	else {
+	    plex->revived += bp->b_bcount >> DEV_BSHIFT;    /* moved this much further down */
+	    if (plex->revived >= plex->length) {	    /* finished */
+		plex->revived = 0;
+		plex->state = plex_up;			    /* do we need to do more? */
+		if (plex->volno >= 0)			    /* we have a volume, */
+		    set_volume_state(plex->volno, volume_up, 0);
+		printf("vinum: plex %s is %s\n", plex->name, plex_state(plex->state));
+		save_config();				    /* and save the updated configuration */
+		error = 0;				    /* we're done */
+	    }
+	}
+	while (plex->waitlist) {			    /* we have waiting requests */
+	    launch_requests(plex->waitlist, 1);		    /* do them now */
+	    plex->waitlist = plex->waitlist->next;	    /* and move on to the next */
+	}
+    }
+    if (bp->b_qindex == 0)				    /* not on a queue, */
+	brelse(bp);					    /* is this kosher? */
+    return error;
+}
diff --git a/sys/dev/vinum/vinumstate.c b/sys/dev/vinum/vinumstate.c
new file mode 100644
index 0000000..8117c53
--- /dev/null
+++ b/sys/dev/vinum/vinumstate.c
@@ -0,0 +1,799 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: state.c,v 1.3 1998/11/02 04:10:45 grog Exp $
+ */
+
+#define REALLYKERNEL
+#include "vinumhdr.h"
+#include "request.h"
+
+/* Update drive state */
+/* Return 1 if the state changes, otherwise 0 */
+int 
+set_drive_state(int driveno, enum drivestate state, int flags)
+{
+    struct drive *drive = &DRIVE[driveno];
+    int oldstate = drive->state;
+    int sdno;
+
+    if (drive->state == drive_unallocated)		    /* no drive to do anything with, */
+	return 0;
+
+    if (state != oldstate) {				    /* don't change it if it's not different */
+	if (state == drive_down) {			    /* the drive's going down */
+	    if ((flags & setstate_force) || (drive->opencount == 0)) { /* we can do it */
+		/* We can't call close() from an interrupt
+		 * context.  Instead, we do it when we
+		 * next call strategy().  This will change
+		 * when the vinum daemon comes onto the scene */
+		if (!(flags & setstate_noupdate))	    /* we can close it */
+		    close_drive(drive);
+	    } else
+		return 0;				    /* don't do it */
+	}
+	drive->state = state;				    /* set the state */
+	printf("vinum: drive %s is %s\n", drive->label.name, drive_state(drive->state));
+	if (((drive->state == drive_up)
+		|| ((drive->state == drive_coming_up)))
+	    && (drive->vp == NULL))			    /* should be open, but we're not */
+	    init_drive(drive);				    /* which changes the state again */
+	if ((state != oldstate)				    /* state has changed */
+	&&((flags & setstate_norecurse) == 0)) {	    /* and we want to recurse, */
+	    for (sdno = 0; sdno < vinum_conf.subdisks_used; sdno++) { /* find this drive's subdisks */
+		if (SD[sdno].driveno == driveno)	    /* belongs to this drive */
+		    set_sd_state(sdno, sd_down, setstate_force | setstate_recursing); /* take it down */
+	    }
+	}
+	if (flags & setstate_noupdate)			    /* don't update now, */
+	    vinum_conf.flags |= VF_DIRTYCONFIG;		    /* wait until later */
+	else
+	    save_config();				    /* yes: save the updated configuration */
+	return 1;
+    }
+    return 0;
+}
+
+/* Try to set the subdisk state.  Return 1 if state changed to
+ * what we wanted, -1 if it changed to something else, and 0
+ * if no change.
+ *
+ * This routine is called both from the user (up, down states
+ * only) and internally.
+ */
+int 
+set_sd_state(int sdno, enum sdstate state, enum setstateflags flags)
+{
+    struct sd *sd = &SD[sdno];
+    int oldstate = sd->state;
+    int status = 1;					    /* status to return */
+
+    if (state == oldstate)
+	return 0;					    /* no change */
+
+    if (sd->state == sd_unallocated)			    /* no subdisk to do anything with, */
+	return 0;
+
+    if (sd->driveoffset < 0) {				    /* not allocated space */
+	sd->state = sd_down;
+	if (state != sd_down)
+	    return -1;
+    } else {						    /*  space allocated */
+	switch (state) {
+	case sd_down:
+	    if ((!flags & setstate_force)		    /* but gently */
+	    &&(sd->plexno >= 0))			    /* and we're attached to a plex, */
+		return 0;				    /* don't do it */
+	    break;
+
+	case sd_up:
+	    if (DRIVE[sd->driveno].state != drive_up)	    /* can't bring the sd up if the drive isn't, */
+		return 0;				    /* not even by force */
+	    switch (sd->state) {
+	    case sd_crashed:
+	    case sd_down:				    /* been down, no data lost */
+		if ((sd->plexno)			    /* we're associated with a plex */
+		&&(((PLEX[sd->plexno].state < plex_firstup) /* and it's not up */
+		||(PLEX[sd->plexno].subdisks > 1))))	    /* or it's the only one */
+		    break;
+		/* XXX Get this right: make sure that other plexes in
+		 * the volume cover this address space, otherwise
+		 * we make this one sd_up */
+		sd->state = sd_reborn;			    /* here it is again */
+		printf("vinum: subdisk %s is %s, not %s\n", sd->name, sd_state(sd->state), sd_state(state));
+		status = -1;
+		break;
+
+	    case sd_init:				    /* brand new */
+		if (flags & setstate_configuring)	    /* we're doing this while configuring */
+		    break;
+		sd->state = sd_empty;			    /* nothing in it */
+		printf("vinum: subdisk %s is %s, not %s\n", sd->name, sd_state(sd->state), sd_state(state));
+		status = -1;
+		break;
+
+	    case sd_initializing:
+		break;					    /* go on and do it */
+
+	    case sd_empty:
+		if ((sd->plexno)			    /* we're associated with a plex */
+		&&(((PLEX[sd->plexno].state < plex_firstup) /* and it's not up */
+		||(PLEX[sd->plexno].subdisks > 1))))	    /* or it's the only one */
+		    break;
+		return 0;				    /* can't do it */
+
+	    default:					    /* can't do it */
+		/* There's no way to bring subdisks up directly from
+		 * other states.  First they need to be initialized
+		 * or revived */
+		return 0;
+	    }
+	    break;
+
+	default:					    /* other ones, only internal with force */
+	    if (flags & setstate_force == 0)		    /* no force?  What's this? */
+		return 0;				    /* don't do it */
+	}
+    }
+    sd->state = state;
+    printf("vinum: subdisk %s is %s\n", sd->name, sd_state(sd->state));
+    if ((flags & setstate_norecurse) == 0)
+	set_plex_state(sd->plexno, plex_up, setstate_recursing); /* update plex state */
+    if ((flags & (setstate_configuring | setstate_recursing)) == 0) { /* save config now */
+	if (setstate_noupdate)				    /* we can't update now, */
+	    vinum_conf.flags |= VF_DIRTYCONFIG;		    /* wait until later */
+	else
+	    save_config();
+    }
+    return status;
+}
+
+/* Called from request routines when they find
+ * a subdisk which is not kosher.  Decide whether
+ * it warrants changing the state.  Return
+ * REQUEST_DOWN if we can't use the subdisk,
+ * REQUEST_OK if we can. */
+enum requeststatus 
+checksdstate(struct sd *sd, struct request *rq, daddr_t diskaddr, daddr_t diskend)
+{
+    struct plex *plex = &PLEX[sd->plexno];
+    int writeop = (rq->bp->b_flags & B_READ) == 0;	    /* note if we're writing */
+
+    /* first, see if the plex wants to be accessed */
+    switch (plex->state) {
+    case plex_reviving:
+	/* When writing, we'll write anything that starts
+	 * up to the current revive pointer, but we'll
+	 * only accept a read which finishes before the
+	 * current revive pointer.
+	 */
+	if ((writeop && (diskaddr > plex->revived))	    /* write starts after current revive pointer */
+	||((!writeop) && (diskend >= plex->revived))) {	    /* or read ends after current revive pointer */
+	    if (writeop) {				    /* writing to a consistent down disk */
+		if (DRIVE[sd->driveno].state == drive_up)
+		    set_sd_state(sd->sdno, sd_stale, setstate_force); /* it's not consistent now */
+		else
+		    set_sd_state(sd->sdno, sd_obsolete, setstate_force); /* it's not consistent now */
+	    }
+	    return REQUEST_DOWN;			    /* that part of the plex is still down */
+	} else if (diskend >= plex->revived)		    /* write finishes beyond revive pointer */
+	    rq->flags |= XFR_REVIVECONFLICT;		    /* note a potential conflict */
+	/* FALLTHROUGH */
+
+    case plex_up:
+    case plex_degraded:
+    case plex_flaky:
+	/* We can access the plex: let's see
+	 * how the subdisk feels */
+	switch (sd->state) {
+	case sd_up:
+	    return REQUEST_OK;
+
+	case sd_reborn:
+	    if (writeop)
+		return REQUEST_OK;			    /* always write to a reborn disk */
+	    /* Handle the mapping.  We don't want to reject
+	     * a read request to a reborn subdisk if that's
+	     * all we have. XXX */
+	    return REQUEST_DOWN;
+
+	case sd_down:
+	case sd_crashed:
+	    if (writeop) {				    /* writing to a consistent down disk */
+		if (DRIVE[sd->driveno].state == drive_up)
+		    set_sd_state(sd->sdno, sd_stale, setstate_force); /* it's not consistent now */
+		else
+		    set_sd_state(sd->sdno, sd_obsolete, setstate_force); /* it's not consistent now */
+	    }
+	    return REQUEST_DOWN;			    /* and it's down one way or another */
+
+	default:
+	    return REQUEST_DOWN;
+	}
+
+    default:
+	return REQUEST_DOWN;
+    }
+}
+
+void 
+add_defective_region(struct plex *plex, off_t offset, size_t length)
+{
+/* XXX get this ordered, and coalesce regions if necessary */
+    if (++plex->defective_regions > plex->defective_region_count)
+	EXPAND(plex->defective_region,
+	    struct plexregion,
+	    plex->defective_region_count,
+	    PLEX_REGION_TABLE_SIZE);
+    plex->defective_region[plex->defective_regions - 1].offset = offset;
+    plex->defective_region[plex->defective_regions - 1].length = length;
+}
+
+void 
+add_unmapped_region(struct plex *plex, off_t offset, size_t length)
+{
+    if (++plex->unmapped_regions > plex->unmapped_region_count)
+	EXPAND(plex->unmapped_region,
+	    struct plexregion,
+	    plex->unmapped_region_count,
+	    PLEX_REGION_TABLE_SIZE);
+    plex->unmapped_region[plex->unmapped_regions - 1].offset = offset;
+    plex->unmapped_region[plex->unmapped_regions - 1].length = length;
+}
+
+/* Rebuild a plex free list and set state if
+ * we have a configuration error */
+void 
+rebuild_plex_unmappedlist(struct plex *plex)
+{
+    int sdno;
+    struct sd *sd;
+    int lastsdend = 0;					    /* end offset of last subdisk */
+
+    if (plex->unmapped_region != NULL) {		    /* we're going to rebuild it */
+	Free(plex->unmapped_region);
+	plex->unmapped_region = NULL;
+	plex->unmapped_regions = 0;
+	plex->unmapped_region_count = 0;
+    }
+    if (plex->defective_region != NULL) {
+	Free(plex->defective_region);
+	plex->defective_region = NULL;
+	plex->defective_regions = 0;
+	plex->defective_region_count = 0;
+    }
+    for (sdno = 0; sdno < plex->subdisks; sdno++) {
+	sd = &SD[plex->sdnos[sdno]];
+	if (sd->plexoffset < lastsdend) {		    /* overlap */
+	    printf("vinum: Plex %s, subdisk %s overlaps previous\n", plex->name, sd->name);
+	    set_plex_state(plex->plexno, plex_down, setstate_force); /* don't allow that */
+	} else if (sd->plexoffset > lastsdend)		    /* gap */
+	    add_unmapped_region(plex, lastsdend, sd->plexoffset - lastsdend);
+	else if (sd->state < sd_reborn)			    /* this part defective */
+	    add_defective_region(plex, sd->plexoffset, sd->sectors);
+	lastsdend = sd->plexoffset + sd->sectors;
+    }
+}
+
+/* return a state map for the subdisks of a plex */
+enum sdstates 
+sdstatemap(struct plex *plex, int *sddowncount)
+{
+    int sdno;
+    enum sdstates statemap = 0;				    /* note the states we find */
+
+    *sddowncount = 0;					    /* no subdisks down yet */
+    for (sdno = 0; sdno < plex->subdisks; sdno++) {
+	struct sd *sd = &SD[plex->sdnos[sdno]];		    /* point to the subdisk */
+
+	switch (sd->state) {
+	case sd_empty:
+	    statemap |= sd_emptystate;
+	    (*sddowncount)++;				    /* another unusable subdisk */
+	    break;
+
+	case sd_init:
+	    statemap |= sd_initstate;
+	    (*sddowncount)++;				    /* another unusable subdisk */
+	    break;
+
+	case sd_down:
+	    statemap |= sd_downstate;
+	    (*sddowncount)++;				    /* another unusable subdisk */
+	    break;
+
+	case sd_crashed:
+	    statemap |= sd_crashedstate;
+	    (*sddowncount)++;				    /* another unusable subdisk */
+	    break;
+
+	case sd_obsolete:
+	    statemap |= sd_obsolete;
+	    (*sddowncount)++;				    /* another unusable subdisk */
+	    break;
+
+	case sd_stale:
+	    statemap |= sd_stalestate;
+	    (*sddowncount)++;				    /* another unusable subdisk */
+	    break;
+
+	case sd_reborn:
+	    statemap |= sd_rebornstate;
+	    break;
+
+	case sd_up:
+	    statemap |= sd_upstate;
+	    break;
+
+	default:
+	    statemap |= sd_otherstate;
+	    break;
+	}
+    }
+    return statemap;
+}
+
+/* determine the state of the volume relative to this plex */
+enum volplexstate 
+vpstate(struct plex *plex)
+{
+    struct volume *vol;
+    enum volplexstate state = volplex_onlyusdown;	    /* state to return */
+    int plexno;
+
+    if (plex->volno < 0)				    /* not associated with a volume */
+	return volplex_onlyusdown;			    /* assume the worst */
+
+    vol = &VOL[plex->volno];				    /* point to our volume */
+    for (plexno = 0; plexno < vol->plexes; plexno++) {
+	if (&PLEX[vol->plex[plexno]] == plex) {		    /* us */
+	    if (PLEX[vol->plex[plexno]].state == plex_up)   /* are we up? */
+		state |= volplex_onlyus;		    /* yes */
+	} else {
+	    if (PLEX[vol->plex[plexno]].state == plex_up)   /* not us */
+		state |= volplex_otherup;		    /* and when they were up, they were up */
+	    else
+		state |= volplex_alldown;		    /* and when they were down, they were down */
+	}
+    }
+    return state;					    /* and when they were only halfway up */
+}							    /* they were neither up nor down */
+
+/* Check if all bits b are set in a */
+int allset(int a, int b);
+
+int 
+allset(int a, int b)
+{
+    return (a & b) == b;
+}
+
+/* Update the state of a plex dependent on its subdisks.
+ * Also rebuild the unmapped_region and defective_region table */
+int 
+set_plex_state(int plexno, enum plexstate state, enum setstateflags flags)
+{
+    int sddowncount = 0;				    /* number of down subdisks */
+    struct plex *plex = &PLEX[plexno];			    /* point to our plex */
+    enum plexstate oldstate = plex->state;
+    enum volplexstate vps = vpstate(plex);		    /* how do we compare with the other plexes? */
+    enum sdstates statemap = sdstatemap(plex, &sddowncount); /* get a map of the subdisk states */
+
+    if ((flags & setstate_force) && (oldstate == state))    /* we're there already, */
+	return 0;					    /* no change */
+
+    if (plex->state == plex_unallocated)		    /* no plex to do anything with, */
+	return 0;
+
+    switch (state) {
+    case plex_up:
+	if ((plex->state == plex_initializing)		    /* we're initializing */
+	&&(statemap != sd_upstate))			    /* but SDs aren't up yet */
+	    return 0;					    /* do nothing */
+
+	/* We don't really care what our state was before
+	 * if we want to come up.  We rely entirely on the
+	 * state of our subdisks and our volume */
+	switch (vps) {
+	case volplex_onlyusdown:
+	case volplex_alldown:				    /* another plex is down, and so are we */
+	    if (statemap == sd_upstate) {		    /* all subdisks ready for action */
+		if ((plex->state == plex_init)		    /* we're brand spanking new */
+		&&(VOL[plex->volno].flags & VF_CONFIG_SETUPSTATE)) { /* and we consider that up */
+							    /* Conceptually, an empty plex does not contain valid data,
+		     * but normally we'll see this state when we have just
+		     * created a plex, and it's either consistent from earlier,
+		     * or we don't care about the previous contents (we're going
+		     * to create a file system or use it for swap).
+		     *
+		     * We need to do this in one swell foop: on the next call
+		     * we will no longer be just empty.
+		     *
+		     * We'll still come back to this function for the remaining
+		     * plexes in the volume.  They'll be up already, so that
+		     * doesn't change anything, but it's not worth the additional
+		     * code to stop doing it. */
+		    struct volume *vol = &VOL[plex->volno];
+		    int plexno;
+
+		    for (plexno = 0; plexno < vol->plexes; plexno++)
+			PLEX[vol->plex[plexno]].state = plex_up;
+		}
+		plex->state = plex_up;			    /* bring up up, anyway */
+	    } else
+		plex->state = plex_down;
+	    break;
+
+	case volplex_onlyusup:				    /* only we are up: others are down */
+	case volplex_onlyus:				    /* we're up and alone */
+	    if ((statemap == sd_upstate)		    /* subdisks all up */
+	    ||(statemap == sd_emptystate))		    /* or all empty */
+		plex->state = plex_up;			    /* go for it */
+	    else if ((statemap & (sd_upstate | sd_reborn)) == statemap)	/* all up or reborn, */
+		plex->state = plex_flaky;
+	    else if (statemap & (sd_upstate | sd_reborn))   /* some up or reborn, */
+		plex->state = plex_degraded;		    /* so far no corruption */
+	    else
+		plex->state = plex_faulty;
+	    break;
+
+	case volplex_otherup:				    /* another plex is up */
+	case volplex_otherupdown:			    /* other plexes are up and down */
+	    {
+		int sdno;
+		struct sd *sd;
+
+		/* Is the data in all subdisks valid? */
+		/* XXX At the moment, subdisks make false
+		 * claims about their validity.  Replace this
+		 * when they tell the truth */
+		/* No: we have invalid or down subdisks */
+		for (sdno = 0; sdno < plex->subdisks; sdno++) {	/* look at these subdisks more carefully */
+		    set_sd_state(plex->sdnos[sdno],	    /* try to get it up */
+			sd_up,
+			setstate_norecurse | setstate_noupdate);
+		    sd = &SD[plex->sdnos[sdno]];	    /* point to subdisk */
+							    /* we can make a stale subdisk up here, because
+		     * we're in the process of bringing it up.
+		     * This wouldn't work in set_sd_state, because
+		     * it would allow bypassing the revive */
+		    if (((sd->state == sd_stale)
+			    || (sd->state == sd_obsolete))
+			&& (DRIVE[sd->driveno].state == drive_up))
+			sd->state = sd_up;
+		}
+		statemap = sdstatemap(plex, &sddowncount);  /* get the new state map */
+		/* Do we need reborn?  They should now all be up */
+		if (statemap == (statemap & (sd_upstate | sd_rebornstate))) { /* got something we can use */
+		    plex->state = plex_reviving;	    /* we need reviving */
+		    return EAGAIN;
+		} else
+		    plex->state = plex_down;		    /* still in error */
+	    }
+	    break;
+
+	case volplex_allup:				    /* all plexes are up */
+	case volplex_someup:
+	    if ((statemap & (sd_upstate | sd_reborn)) == statemap) /* all up or reborn, */
+		break;					    /* no change */
+	    else
+		plex->state = plex_degraded;		    /* we're not all there */
+	}
+
+	if (plex->state != oldstate)
+	    break;
+	return 0;					    /* no change */
+
+    case plex_down:					    /* want to take it down */
+	if (((vps == volplex_onlyus)			    /* we're the only one up */
+	||(vps == volplex_onlyusup))			    /* we're the only one up */
+	&&(!(flags & setstate_force)))			    /* and we don't want to use force */
+	    return 0;					    /* can't do it */
+	plex->state = state;				    /* do it */
+	break;
+
+	/* This is only requested by the driver.
+	 * Trust ourselves */
+    case plex_faulty:
+	plex->state = state;				    /* do it */
+	break;
+
+    case plex_initializing:
+	/* XXX consider what safeguards we need here */
+	if ((flags & setstate_force) == 0)
+	    return 0;
+	plex->state = state;				    /* do it */
+	break;
+
+	/* What's this? */
+    default:
+	return 0;
+    }
+    printf("vinum: plex %s is %s\n", plex->name, plex_state(plex->state));
+    /* Now see what we have left, and whether
+     * we're taking the volume down */
+    if (plex->volno >= 0) {				    /* we have a volume */
+	struct volume *vol = &VOL[plex->volno];
+
+	vps = vpstate(plex);				    /* get our combined state again */
+	if ((flags & setstate_norecurse) == 0) {	    /* we can recurse */
+	    if ((vol->state == volume_up)
+		&& (vps == volplex_alldown))		    /* and we're all down */
+		set_volume_state(plex->volno, volume_down, setstate_recursing);	/* take our volume down */
+	    else if ((vol->state == volume_down)
+		&& (vps & (volplex_otherup | volplex_onlyusup))) /* and at least one is up */
+		set_volume_state(plex->volno, volume_up, setstate_recursing); /* bring our volume up */
+	}
+    }
+    if ((flags & (setstate_configuring | setstate_recursing)) == 0) { /* save config now */
+	if (flags & setstate_noupdate)			    /* don't update now, */
+	    vinum_conf.flags |= VF_DIRTYCONFIG;		    /* wait until later */
+	else
+	    save_config();				    /* yes: save the updated configuration */
+    }
+    return 1;
+}
+
+/* Update the state of a plex dependent on its plexes.
+ * Also rebuild the unmapped_region and defective_region table */
+int 
+set_volume_state(int volno, enum volumestate state, enum setstateflags flags)
+{
+    int plexno;
+    enum plexstates {
+	plex_downstate = 1,				    /* found a plex which is down */
+	plex_degradedstate = 2,				    /* found a plex which is halfway up */
+	plex_upstate = 4				    /* found a plex which is completely up */
+    };
+
+    int plexstatemap = 0;				    /* note the states we find */
+    struct volume *vol = &VOL[volno];			    /* point to our volume */
+
+    if (vol->state == state)				    /* we're there already */
+	return 0;					    /* no change */
+    if (vol->state == volume_unallocated)		    /* no volume to do anything with, */
+	return 0;
+
+    for (plexno = 0; plexno < vol->plexes; plexno++) {
+	struct plex *plex = &PLEX[vol->plex[plexno]];	    /* point to the plex */
+	switch (plex->state) {
+	case plex_degraded:
+	case plex_flaky:
+	case plex_reviving:
+	    plexstatemap |= plex_degradedstate;
+	    break;
+
+	case plex_up:
+	    plexstatemap |= plex_upstate;
+	    break;
+
+	default:
+	    plexstatemap |= plex_downstate;
+	    break;
+	}
+    }
+
+    if (state == volume_up) {				    /* want to come up */
+	if (plexstatemap & plex_upstate) {		    /* we have a plex which is completely up */
+	    vol->state = volume_up;			    /* did it */
+	    printf("vinum: volume %s is %s\n", vol->name, volume_state(vol->state));
+	    if ((flags & (setstate_configuring | setstate_recursing)) == 0) { /* save config now */
+		if (flags & setstate_noupdate)		    /* don't update now, */
+		    vinum_conf.flags |= VF_DIRTYCONFIG;	    /* wait until later */
+		else
+		    save_config();			    /* yes: save the updated configuration */
+	    }
+	    return 1;
+	}
+	/* Here we should check whether we have enough
+	 * coverage for the complete volume.  Writeme XXX */
+    } else if (state == volume_down) {			    /* want to go down */
+	if ((vol->opencount == 0)			    /* not open */
+	||(flags & setstate_force != 0)) {		    /* or we're forcing */
+	    vol->state = volume_down;
+	    printf("vinum: volume %s is %s\n", vol->name, volume_state(vol->state));
+	    if ((flags & (setstate_configuring | setstate_recursing)) == 0) { /* save config now */
+		if (flags & setstate_noupdate)		    /* don't update now, */
+		    vinum_conf.flags |= VF_DIRTYCONFIG;	    /* wait until later */
+		else
+		    save_config();			    /* yes: save the updated configuration */
+	    }
+	    return 1;
+	}
+    }
+    return 0;						    /* no change */
+}
+
+/* Start an object, in other words do what we can to get it up.
+ * This is called from vinumioctl (VINUMSTART).
+ * Return error indications via ioctl_reply
+ */
+void 
+start_object(struct vinum_ioctl_msg *data)
+{
+    int status;
+    int realstatus;					    /* what we really have */
+    int objindex = data->index;				    /* data gets overwritten */
+    struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) data; /* format for returning replies */
+
+    switch (data->type) {
+    case drive_object:
+	status = set_drive_state(objindex, drive_up, setstate_none);
+	realstatus = DRIVE[objindex].state == drive_up;	    /* set status on whether we really did it */
+	break;
+
+    case sd_object:
+	status = set_sd_state(objindex, sd_up, setstate_none); /* set state */
+	realstatus = SD[objindex].state == sd_up;	    /* set status on whether we really did it */
+	break;
+
+    case plex_object:
+	if (PLEX[objindex].state == plex_reviving) {	    /* reviving, */
+	    ioctl_reply->error = revive_block(objindex);    /* revive another block */
+	    ioctl_reply->msg[0] = '\0';			    /* no comment */
+	    return;
+	}
+	status = set_plex_state(objindex, plex_up, setstate_none);
+	realstatus = PLEX[objindex].state == plex_up;	    /* set status on whether we really did it */
+	break;
+
+    case volume_object:
+	status = set_volume_state(objindex, volume_up, setstate_none);
+	realstatus = VOL[objindex].state == volume_up;	    /* set status on whether we really did it */
+	break;
+
+    default:
+	ioctl_reply->error = EINVAL;
+	strcpy(ioctl_reply->msg, "Invalid object type");
+	return;
+    }
+    /* There's no point in saying anything here:
+     * the userland program does it better */
+    ioctl_reply->msg[0] = '\0';
+    if (realstatus == 0)				    /* couldn't do it */
+	ioctl_reply->error = EINVAL;
+    else
+	ioctl_reply->error = 0;
+}
+
+/* Stop an object, in other words do what we can to get it down
+ * This is called from vinumioctl (VINUMSTOP).
+ * Return error indications via ioctl_reply.
+ */
+void 
+stop_object(struct vinum_ioctl_msg *data)
+{
+    int status = 1;
+    int objindex = data->index;				    /* save the number from change */
+    struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) data; /* format for returning replies */
+
+    switch (data->type) {
+    case drive_object:
+	status = set_drive_state(objindex, drive_down, data->force);
+	break;
+
+    case sd_object:
+	status = set_sd_state(objindex, sd_down, data->force);
+	break;
+
+    case plex_object:
+	status = set_plex_state(objindex, plex_down, data->force);
+	break;
+
+    case volume_object:
+	status = set_volume_state(objindex, volume_down, data->force);
+	break;
+
+    default:
+	ioctl_reply->error = EINVAL;
+	strcpy(ioctl_reply->msg, "Invalid object type");
+	return;
+    }
+    ioctl_reply->msg[0] = '\0';
+    if (status == 0)					    /* couldn't do it */
+	ioctl_reply->error = EINVAL;
+    else
+	ioctl_reply->error = 0;
+}
+
+/* VINUM_SETSTATE ioctl: set an object state
+ * msg is the message passed by the user */
+void 
+setstate(struct vinum_ioctl_msg *msg)
+{
+    int sdno;
+    struct sd *sd;
+    struct plex *plex;
+    struct _ioctl_reply *ioctl_reply = (struct _ioctl_reply *) msg; /* format for returning replies */
+
+    switch (msg->state) {
+    case object_down:
+	stop_object(msg);
+	break;
+
+    case object_initializing:
+	switch (msg->type) {
+	case sd_object:
+	    sd = &SD[msg->index];
+	    if ((msg->index >= vinum_conf.subdisks_used)
+		|| (sd->state == sd_unallocated)) {
+		sprintf(ioctl_reply->msg, "Invalid subdisk %d", msg->index);
+		ioctl_reply->error = EFAULT;
+		return;
+	    }
+	    set_sd_state(msg->index, sd_initializing, msg->force);
+	    if (sd->state != sd_initializing) {
+		strcpy(ioctl_reply->msg, "Can't set state");
+		ioctl_reply->error = EINVAL;
+	    } else
+		ioctl_reply->error = 0;
+	    break;
+
+	case plex_object:
+	    plex = &PLEX[msg->index];
+	    if ((msg->index >= vinum_conf.plexes_used)
+		|| (plex->state == plex_unallocated)) {
+		sprintf(ioctl_reply->msg, "Invalid subdisk %d", msg->index);
+		ioctl_reply->error = EFAULT;
+		return;
+	    }
+	    set_plex_state(msg->index, plex_initializing, msg->force);
+	    if (plex->state != plex_initializing) {
+		strcpy(ioctl_reply->msg, "Can't set state");
+		ioctl_reply->error = EINVAL;
+	    } else {
+		ioctl_reply->error = 0;
+		for (sdno = 0; sdno < plex->subdisks; sdno++) {
+		    sd = &SD[plex->sdnos[sdno]];
+		    set_sd_state(plex->sdnos[sdno], sd_initializing, msg->force);
+		    if (sd->state != sd_initializing) {
+			strcpy(ioctl_reply->msg, "Can't set state");
+			ioctl_reply->error = EINVAL;
+			break;
+		    }
+		}
+	    }
+	    break;
+
+	default:
+	    strcpy(ioctl_reply->msg, "Invalid object");
+	    ioctl_reply->error = EINVAL;
+	}
+	break;
+
+    case object_up:
+	start_object(msg);
+    }
+}
diff --git a/sys/dev/vinum/vinumstate.h b/sys/dev/vinum/vinumstate.h
new file mode 100644
index 0000000..78bec4e
--- /dev/null
+++ b/sys/dev/vinum/vinumstate.h
@@ -0,0 +1,213 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: vinumstate.h,v 1.1.1.1 1998/09/16 05:56:21 grog Exp $
+ */
+
+/* This file gets read by makestatetext to create text files
+ * with the names of the states, so don't change the file
+ * format */
+
+enum volumestate {
+    volume_unallocated,
+    /* present but unused.  Must be 0 */
+
+    volume_uninit,
+    /* mentioned elsewhere but not defined */
+
+    volume_down,
+
+    /* The volume is up and functional, but not all plexes may be available */
+    volume_up,
+    volume_laststate = volume_up			    /* last value, for table dimensions */
+};
+
+enum plexstate {
+    /* An empty entry, not a plex at all.   */
+    plex_unallocated,
+
+    /* The plex has been allocated, but there configuration
+     * is not complete */
+    plex_init,
+
+    /* A plex which has gone completely down because of
+     * I/O errors. */
+    plex_faulty,
+
+    /* A plex which has been taken down by the
+     * administrator. */
+    plex_down,
+
+    /* A plex which is currently being brought up after
+     * being not up.  This involves copying data from
+     * another plex */
+    plex_reviving,
+
+    /* A plex which is being initialized */
+    plex_initializing,
+
+    /* *** The remaining states represent plexes which are
+     * at least partially up.  Keep these separate so that
+     * they can be checked more easily. */
+
+    /* A plex entry which is at least partially up.  Not
+     * all subdisks are available, and an inconsistency
+     * has occurred.  If no other plex is uncorrupted,
+     * the volume is no longer consistent. */
+    plex_corrupt,
+
+    plex_firstup = plex_corrupt,			    /* first "up" state */
+
+    /* A plex entry which is at least partially up.  Not
+     * all subdisks are available, but so far no
+     * inconsistency has occurred (this will change with
+     * the first write to the address space occupied by
+     * a defective subdisk).  A RAID 5 plex with one subdisk
+     * down will remain degraded even after a write */
+    plex_degraded,
+
+    /* A plex which is really up, but which has a reborn
+     * subdisk which we don't completely trust, and
+     * which we don't want to read if we can avoid it */
+    plex_flaky,
+
+    /* A plex entry which is completely up.  All subdisks
+     * are up. */
+    plex_up,
+
+    plex_laststate = plex_up				    /* last value, for table dimensions */
+};
+
+/* subdisk states */
+enum sdstate {
+    /* An empty entry, not a subdisk at all. */
+    sd_unallocated,
+
+    /* A subdisk entry which has not been created
+     * completely.  Some fields may be empty.
+     */
+    sd_uninit,
+
+    /* A subdisk entry which has been created completely.
+     * All fields are correct, but the disk hasn't
+     * been updated.
+     */
+    sd_init,
+
+    /* A subdisk entry which has been created completely and
+     * which is currently being initialized */
+    sd_initializing,
+
+    /* A subdisk entry which has been created completely.
+     * All fields are correct, and the disk has been
+     * updated, but there is no data on the disk.
+     */
+    sd_empty,
+
+    /* *** The following states represent invalid data */
+    /* A subdisk entry which has been created completely.
+     * All fields are correct, the disk has been updated,
+     * and the data was valid, but since then the drive
+     * has gone down, and as a result updates have been
+     * missed.
+     */
+    sd_obsolete,
+
+    /* A subdisk entry which has been created completely.
+     * All fields are correct, the disk has been updated,
+     * and the data was valid, but since then the drive
+     * has gone down, updates have been lost, and then
+     * the drive came up again.
+     */
+    sd_stale,
+
+    /* *** The following states represent valid, inaccessible data */
+    /* A subdisk entry which has been created completely.
+     * All fields are correct, the disk has been updated,
+     * and the data was valid, but since then the drive
+     * has gone down.   No attempt has been made to write
+     * to the subdisk since the crash.
+     */
+    sd_crashed,
+
+    /* A subdisk entry which was up, which contained
+     * valid data, and which was taken down by the
+     * administrator.  The data is valid. */
+    sd_down,
+
+    /* *** The following states represent accessible subdisks
+     * with valid data */
+
+    /* A subdisk entry which has been created completely.
+     * All fields are correct, the disk has been updated,
+     * and the data was valid, but since then the drive
+     * has gone down and up again.  No updates were lost,
+     * but it is possible that the subdisk has been
+     * damaged.  We won't read from this subdisk if we
+     * have a choice.  If this is the only subdisk which
+     * covers this address space in the plex, we set its
+     * state to sd_up under these circumstances, so this
+     * status implies that there is another subdisk to
+     * fulfil the request.
+     */
+    sd_reborn,
+
+    /* A subdisk entry which has been created completely.
+     * All fields are correct, the disk has been updated,
+     * and the data is valid.
+     */
+    sd_up,
+
+    sd_laststate = sd_up				    /* last value, for table dimensions */
+};
+
+enum drivestate {
+    drive_unallocated,
+    /* present but unused.  Must be 0 */
+
+    drive_uninit,
+    /* just mentioned in some other config entry */
+
+    drive_down,
+    /* not accessible */
+
+    drive_coming_up,
+    /* in the process of being brought up */
+
+    drive_up,
+    /* up and running */
+
+    drive_laststate = drive_up				    /* last value, for table dimensions */
+};
diff --git a/sys/dev/vinum/vinumutil.c b/sys/dev/vinum/vinumutil.c
new file mode 100644
index 0000000..84cfabc
--- /dev/null
+++ b/sys/dev/vinum/vinumutil.c
@@ -0,0 +1,211 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: util.c,v 1.1.1.1 1998/09/16 05:56:21 grog Exp $
+ */
+
+/* This file contains utility routines used both in kernel and user context */
+
+#include "vinumhdr.h"
+#include "statetexts.h"
+#ifndef REALLYKERNEL
+#include <stdio.h>
+extern jmp_buf command_fail;				    /* return on a failed command */
+#endif
+
+static char numeric_state[32];				    /* temporary buffer for ASCII conversions */
+#define STATECOUNT(x) (sizeof (x##statetext) / sizeof (char *))
+/* Return drive state as a string */
+char *
+drive_state(enum drivestate state)
+{
+    if (((unsigned) state) >= STATECOUNT(drive)) {
+	sprintf(numeric_state, "Invalid state %d", (int) state);
+	return numeric_state;
+    } else
+	return drivestatetext[state];
+}
+
+/* Return volume state as a string */
+char *
+volume_state(enum volumestate state)
+{
+    if (((unsigned) state) >= STATECOUNT(vol)) {
+	sprintf(numeric_state, "Invalid state %d", (int) state);
+	return numeric_state;
+    } else
+	return volstatetext[state];
+}
+
+/* Return plex state as a string */
+char *
+plex_state(enum plexstate state)
+{
+    if (((unsigned) state) >= STATECOUNT(plex)) {
+	sprintf(numeric_state, "Invalid state %d", (int) state);
+	return numeric_state;
+    } else
+	return plexstatetext[state];
+}
+
+/* Return plex organization as a string */
+char *
+plex_org(enum plexorg org)
+{
+    switch (org) {
+    case plex_disorg:					    /* disorganized */
+	return "disorg";
+	break;
+
+    case plex_concat:					    /* concatenated plex */
+	return "concat";
+	break;
+
+    case plex_striped:					    /* striped plex */
+	return "striped";
+	break;
+
+
+    default:
+	sprintf(numeric_state, "Invalid org %d", (int) org);
+	return numeric_state;
+    }
+}
+
+/* Return sd state as a string */
+char *
+sd_state(enum sdstate state)
+{
+    if (((unsigned) state) >= STATECOUNT(sd)) {
+	sprintf(numeric_state, "Invalid state %d", (int) state);
+	return numeric_state;
+    } else
+	return sdstatetext[state];
+}
+
+/* Now convert in the other direction */
+/* These are currently used only internally,
+ * so we don't do too much error checking */
+enum drivestate 
+DriveState(char *text)
+{
+    int i;
+    for (i = 0; i < STATECOUNT(drive); i++)
+	if (strcmp(text, drivestatetext[i]) == 0)	    /* found it */
+	    return (enum drivestate) i;
+    return -1;
+}
+
+enum sdstate 
+SdState(char *text)
+{
+    int i;
+    for (i = 0; i < STATECOUNT(sd); i++)
+	if (strcmp(text, sdstatetext[i]) == 0)		    /* found it */
+	    return (enum sdstate) i;
+    return -1;
+}
+
+enum plexstate 
+PlexState(char *text)
+{
+    int i;
+    for (i = 0; i < STATECOUNT(plex); i++)
+	if (strcmp(text, plexstatetext[i]) == 0)	    /* found it */
+	    return (enum plexstate) i;
+    return -1;
+}
+
+enum volumestate 
+VolState(char *text)
+{
+    int i;
+    for (i = 0; i < STATECOUNT(vol); i++)
+	if (strcmp(text, volstatetext[i]) == 0)		    /* found it */
+	    return (enum volstate) i;
+    return -1;
+}
+
+/* Take a number with an optional scale factor and convert
+ * it to a number of bytes.
+ *
+ * The scale factors are:
+ *
+ * b    blocks (of 512 bytes)
+ * k    kilobytes (1024 bytes)
+ * m    megabytes (of 1024 * 1024 bytes)
+ * g    gigabytes (of 1024 * 1024 * 1024 bytes)
+ */
+u_int64_t 
+sizespec(char *spec)
+{
+    u_int64_t size;
+    char *s;
+
+    size = 0;
+    s = spec;
+    if ((*s >= '0') && (*s <= '9')) {			    /* it's numeric */
+	while ((*s >= '0') && (*s <= '9'))		    /* it's numeric */
+	    size = size * 10 + *s++ - '0';		    /* convert it */
+	switch (*s) {
+	case '\0':
+	    return size;
+
+	case 'B':
+	case 'b':
+	    return size * 512;
+
+	case 'K':
+	case 'k':
+	    return size * 1024;
+
+	case 'M':
+	case 'm':
+	    return size * 1024 * 1024;
+
+	case 'G':
+	case 'g':
+	    return size * 1024 * 1024 * 1024;
+	}
+    }
+#ifdef REALLYKERNEL
+    throw_rude_remark(EINVAL, "Invalid length specification: %s", spec);
+#else
+    fprintf(stderr, "Invalid length specification: %s", spec);
+    longjmp(command_fail, -1);
+#endif
+    /* NOTREACHED */
+    return -1;
+}
diff --git a/sys/dev/vinum/vinumvar.h b/sys/dev/vinum/vinumvar.h
new file mode 100644
index 0000000..a7e7e2f
--- /dev/null
+++ b/sys/dev/vinum/vinumvar.h
@@ -0,0 +1,516 @@
+/*-
+ * Copyright (c) 1997, 1998
+ *	Nan Yang Computer Services Limited.  All rights reserved.
+ *
+ *  This software is distributed under the so-called ``Berkeley
+ *  License'':
+ *
+ * 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 Nan Yang Computer
+ *      Services Limited.
+ * 4. Neither the name of the Company 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 ``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 company 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.
+ *
+ * $Id: vinumvar.h,v 1.3 1998/11/02 04:11:16 grog Exp $
+ */
+
+/* XXX gdb can't find our global pointers, so use this kludge to
+ * point to them locally.  Remove after testing */
+#define BROKEN_GDB struct _vinum_conf *VC = &vinum_conf
+
+#include <sys/time.h>
+#include "vinumstate.h"
+/* Some configuration maxima.  They're an enum because
+ * we can't define global constants.  Sorry about that.
+ *
+ * These aren't as bad as they look: most of them are soft limits.
+ */
+
+enum constants {
+    VINUM_HEADER = 512,					    /* size of header on disk */
+    MAXCONFIGLINE = 1024,				    /* maximum size of a single config line */
+    /* XXX Do we still need this? */
+    MINVINUMSLICE = 1048576,				    /* minimum size of a slice */
+
+    CDEV_MAJOR = 91,					    /* major number for character device */
+    BDEV_MAJOR = 25,					    /* and block device */
+
+    ROUND_ROBIN_READPOL = -1,				    /* round robin read policy */
+
+    /* type field in minor number */
+    VINUM_VOLUME_TYPE = 0,
+    VINUM_PLEX_TYPE = 1,
+    VINUM_SD_TYPE = 2,
+    VINUM_DRIVE_TYPE = 3,
+    VINUM_SUPERDEV_TYPE = 4,				    /* super device. */
+
+    /* Shifts for the individual fields in the device */
+    VINUM_TYPE_SHIFT = 28,
+    VINUM_VOL_SHIFT = 0,
+    VINUM_PLEX_SHIFT = 16,
+    VINUM_SD_SHIFT = 20,
+    VINUM_VOL_WIDTH = 8,
+    VINUM_PLEX_WIDTH = 3,
+    VINUM_SD_WIDTH = 8,
+    MAJORDEV_SHIFT = 8,
+
+    MAXPLEX = 8,					    /* maximum number of plexes in a volume */
+    MAXSD = 256,					    /* maximum number of subdisks in a plex */
+    MAXDRIVENAME = 32,					    /* maximum length of a device name */
+    MAXSDNAME = 64,					    /* maximum length of a subdisk name */
+    MAXPLEXNAME = 64,					    /* maximum length of a plex name */
+    MAXVOLNAME = 64,					    /* maximum length of a volume name */
+    MAXNAME = 64,					    /* maximum length of any name */
+
+
+/* Create a block device number */
+#define VINUMBDEV(v,p,s,t)  ((BDEV_MAJOR << MAJORDEV_SHIFT)	\
+			     | (v << VINUM_VOL_SHIFT)		\
+			     | (p << VINUM_PLEX_SHIFT)		\
+			     | (s << VINUM_SD_SHIFT) 		\
+			     | (t << VINUM_TYPE_SHIFT) )
+
+/* And a character device number */
+#define VINUMCDEV(v,p,s,t)  ((CDEV_MAJOR << MAJORDEV_SHIFT)	\
+			     | (v << VINUM_VOL_SHIFT)		\
+			     | (p << VINUM_PLEX_SHIFT)		\
+			     | (s << VINUM_SD_SHIFT) 		\
+			     | (t << VINUM_TYPE_SHIFT) )
+
+/* extract device type */
+#define DEVTYPE(x) ((x >> VINUM_TYPE_SHIFT) & 7)
+
+/* extract volume number */
+#define VOLNO(x) (x & ((1 << VINUM_VOL_WIDTH) - 1))
+
+/* extract plex number */
+#define PLEXNO(x) (VOL [VOLNO (x)].plex [(x >> VINUM_PLEX_SHIFT) & ((1 << VINUM_PLEX_WIDTH) - 1)])
+
+/* extract subdisk number */
+#define SDNO(x) (PLEX [PLEXNO (x)].sdnos [(x >> VINUM_SD_SHIFT) & ((1 << VINUM_SD_WIDTH) - 1)])
+
+/* extract drive number */
+#define DRIVENO(x) (SD [SDNO (x)].driveno)
+
+    VINUM_SUPERDEV = VINUMBDEV(0, 0, 0, VINUM_SUPERDEV_TYPE), /* superdevice number */
+
+/* the number of object entries to cater for initially, and also the
+ * value by which they are incremented.  It doesn't take long
+ * to extend them, so theoretically we could start with 1 of each, but
+ * it's untidy to allocate such small areas.  These values are
+ * probably too small.
+ */
+
+    INITIAL_DRIVES = 4,
+    INITIAL_VOLUMES = 4,
+    INITIAL_PLEXES = 8,
+    INITIAL_SUBDISKS = 16,
+    INITIAL_SUBDISKS_IN_PLEX = 4,			    /* number of subdisks to allocate to a plex */
+    INITIAL_SUBDISKS_IN_DRIVE = 4,			    /* number of subdisks to allocate to a drive */
+    INITIAL_DRIVE_FREELIST = 16,			    /* number of entries in drive freelist */
+    PLEX_REGION_TABLE_SIZE = 8,				    /* number of entries in plex region tables */
+    INITIAL_LOCKS = 8,					    /* number of locks to allocate to a volume */
+    DEFAULT_REVIVE_BLOCKSIZE = 32768,			    /* size of block to transfer in one op */
+    VINUMHOSTNAMELEN = 32,				    /* host name field in label */
+};
+
+/* device numbers */
+
+/*
+ *  31 30   28  27                  20  19 18    16  15                 8    7                   0
+ * |-----------------------------------------------------------------------------------------------|
+ * |X |  Type  |    Subdisk number     | X| Plex   |      Major number     |  volume number        |
+ * |-----------------------------------------------------------------------------------------------|
+ *
+ *    0x2                 03                 1           19                      06
+ */
+struct devcode {
+/* CARE.  These fields assume a big-endian word.  On a
+ * little-endian system, they're the wrong way around */
+    unsigned volume:8;					    /* up to 256 volumes */
+    unsigned major:8;					    /* this is where the major number fits */
+    unsigned plex:3;					    /* up to 8 plexes per volume */
+    unsigned unused:1;					    /* up for grabs */
+    unsigned sd:8;					    /* up to 256 subdisks per plex */
+    unsigned type:3;					    /* type of object */
+    /* type field
+       VINUM_VOLUME = 0,
+       VINUM_PLEX = 1,
+       VINUM_SUBDISK = 2,
+       VINUM_DRIVE = 3,
+       VINUM_SUPERDEV = 4, */
+    unsigned signbit:1;					    /* to make 32 bits */
+};
+
+#define VINUM_DIR   "/dev/vinum"
+#define VINUM_RDIR   "/dev/rvinum"
+#define VINUM_SUPERDEV_NAME VINUM_DIR"/control"
+
+/* Flags for all objects.  Most of them only apply to
+ * specific objects, but we have space for all in any
+ * 32 bit flags word. */
+enum objflags {
+    VF_LOCKED = 1,					    /* somebody has locked access to this object */
+    VF_LOCKING = 2,					    /* we want access to this object */
+    VF_WRITETHROUGH = 8,				    /* volume: write through */
+    VF_INITED = 0x10,					    /* unit has been initialized */
+    VF_WLABEL = 0x20,					    /* label area is writable */
+    VF_LABELLING = 0x40,				    /* unit is currently being labelled */
+    VF_WANTED = 0x80,					    /* someone is waiting to obtain a lock */
+    VF_RAW = 0x100,					    /* raw volume (no file system) */
+    VF_LOADED = 0x200,					    /* module is loaded */
+    VF_CONFIGURING = 0x400,				    /* somebody is changing the config */
+    VF_WILL_CONFIGURE = 0x800,				    /* somebody wants to change the config */
+    VF_CONFIG_INCOMPLETE = 0x1000,			    /* haven't finished changing the config */
+    VF_CONFIG_SETUPSTATE = 0x2000,			    /* set a volume up if all plexes are empty */
+    VF_READING_CONFIG = 0x4000,				    /* we're reading config database from disk */
+    VF_KERNELOP = 0x8000,				    /* we're performing ops from kernel space */
+    VF_DIRTYCONFIG = 0x10000,				    /* config needs updating */
+};
+
+/* Global configuration information for the vinum subsystem */
+struct _vinum_conf {
+    /* Pointers to vinum structures */
+    struct drive *drive;
+    struct sd *sd;
+    struct plex *plex;
+    struct volume *volume;
+
+    /* the number allocated */
+    int drives_allocated;
+    int subdisks_allocated;
+    int plexes_allocated;
+    int volumes_allocated;
+
+    /* and the number currently in use */
+    int drives_used;
+    int subdisks_used;
+    int plexes_used;
+    int volumes_used;
+
+    int flags;
+    int opencount;					    /* number of times we've been opened */
+#if DEBUG
+    int lastrq;
+    struct buf *lastbuf;
+    struct rqinfo **rqipp;
+    struct rqinfo *rqinfop;
+#endif
+};
+
+/* Use these defines to simplify code */
+#define DRIVE vinum_conf.drive
+#define SD vinum_conf.sd
+#define PLEX vinum_conf.plex
+#define VOL vinum_conf.volume
+#define VFLAGS vinum_conf.flags
+
+/* Slice header
+
+ * Vinum drives start with this structure:
+ *
+ *\                                            Sector
+ * |--------------------------------------|
+ * |   PDP-11 memorial boot block         |      0
+ * |--------------------------------------|
+ * |   Disk label, maybe                  |      1
+ * |--------------------------------------|
+ * |   Slice definition  (vinum_hdr)      |      2
+ * |--------------------------------------|
+ * |                                      |
+ * |   Configuration info, first copy     |      3
+ * |                                      |
+ * |--------------------------------------|
+ * |                                      |
+ * |   Configuration info, second copy    |      3 + size of config
+ * |                                      |
+ * |--------------------------------------|
+ */
+
+/* Sizes and offsets of our information */
+enum {
+    VINUM_LABEL_OFFSET = 4096,				    /* offset of vinum label */
+    VINUMHEADERLEN = 512,				    /* size of vinum label */
+    VINUM_CONFIG_OFFSET = 4608,				    /* offset of first config copy */
+    MAXCONFIG = 65536,					    /* and size of config copy */
+    DATASTART = (MAXCONFIG * 2 + VINUM_CONFIG_OFFSET) / DEV_BSIZE /* this is where the data starts */
+};
+
+/* hostname is 256 bytes long, but we don't need to shlep
+ * multiple copies in vinum.  We use the host name just
+ * to identify this system, and 32 bytes should be ample
+ * for that purpose */
+
+struct vinum_label {
+    char sysname[VINUMHOSTNAMELEN];			    /* system name at time of creation */
+    char name[MAXDRIVENAME];				    /* our name of the drive */
+    struct timeval date_of_birth;			    /* the time it was created */
+    struct timeval last_update;				    /* and the time of last update */
+    off_t drive_size;					    /* total size in bytes of the drive.
+							    * This value includes the headers */
+};
+
+struct vinum_hdr {
+    long long magic;					    /* we're long on magic numbers */
+    /* XXX Get these right for big-endian */
+#define VINUM_MAGIC    22322600044678729LL		    /* should be this */
+#define VINUM_NOMAGIC  22322600044678990LL		    /* becomes this after obliteration */
+    int config_length;					    /* size in bytes of each copy of the
+							    * configuration info.
+							    * This must be a multiple of the sector size. */
+
+    struct vinum_label label;				    /* unique label */
+};
+
+/* Information returned from read_drive_label */
+enum drive_label_info {
+    DL_CANT_OPEN,					    /* invalid partition */
+    DL_NOT_OURS,					    /* valid partition, but no vinum label */
+    DL_DELETED_LABEL,					    /* valid partition, deleted label found */
+    DL_WRONG_DRIVE,					    /* drive name doesn't match */
+    DL_OURS						    /* valid partition and label found */
+};
+
+/*** Drive definitions ***/
+/* A drive corresponds to a disk slice.  We use a different term to show
+ * the difference in usage: it doesn't have to be a slice, and could
+ * theroretically be a complete, unpartitioned disk */
+
+struct drive {
+    enum drivestate state;				    /* current state */
+    int subdisks_allocated;				    /* number of entries in sd */
+    int subdisks_used;					    /* and the number used */
+    int blocksize;					    /* size of fs blocks */
+    u_int64_t sectors_available;			    /* number of sectors still available */
+    int secsperblock;
+    int lasterror;					    /* last error on drive */
+    int driveno;					    /* index of drive in vinum_conf */
+    int opencount;					    /* number of up subdisks */
+    u_int64_t reads;					    /* number of reads on this drive */
+    u_int64_t writes;					    /* number of writes on this drive */
+    u_int64_t bytes_read;				    /* number of bytes read */
+    u_int64_t bytes_written;				    /* number of bytes written */
+    dev_t dev;						    /* and device number */
+    char devicename[MAXDRIVENAME];			    /* name of the slice it's on */
+    struct vnode *vp;					    /* vnode pointer */
+    struct proc *p;
+    struct vinum_label label;				    /* and the label information */
+    struct partinfo partinfo;				    /* partition information */
+    int freelist_size;					    /* number of entries alloced in free list */
+    int freelist_entries;				    /* number of entries used in free list */
+    struct drive_freelist {				    /* sorted list of free space on drive */
+	u_int64_t offset;
+	long sectors;
+    } *freelist;
+};
+
+/*** Subdisk definitions ***/
+
+struct sd {
+    enum sdstate state;					    /* state */
+    /* offsets in blocks */
+    int64_t driveoffset;				    /* offset on drive */
+    int64_t plexoffset;					    /* offset in plex */
+    u_int64_t sectors;					    /* and length in sectors */
+    int plexno;						    /* index of plex, if it belongs */
+    int driveno;					    /* index of the drive on which it is located */
+    int sdno;						    /* our index in vinum_conf */
+    int pid;						    /* pid of process which opened us */
+    u_int64_t reads;					    /* number of reads on this subdisk */
+    u_int64_t writes;					    /* number of writes on this subdisk */
+    u_int64_t bytes_read;				    /* number of bytes read */
+    u_int64_t bytes_written;				    /* number of bytes written */
+    char name[MAXSDNAME];				    /* name of subdisk */
+};
+
+/*** Plex definitions ***/
+
+/* kinds of plex organization */
+enum plexorg {
+    plex_disorg,					    /* disorganized */
+    plex_concat,					    /* concatenated plex */
+    plex_striped,					    /* striped plex */
+    plex_raid5						    /* RAID5 plex */
+};
+
+/* Region in plex (either defective or unmapped) */
+struct plexregion {
+    u_int64_t offset;					    /* start of region */
+    u_int64_t length;					    /* length */
+};
+
+struct plex {
+    enum plexorg organization;				    /* Plex organization */
+    enum plexstate state;				    /* and current state */
+    u_int64_t length;					    /* total length of plex (max offset) */
+    int flags;
+    int stripesize;					    /* size of stripe or raid band, in sectors */
+    int subdisks;					    /* number of associated subdisks */
+    int subdisks_allocated;				    /* number of subdisks allocated space for */
+    int *sdnos;						    /* list of component subdisks */
+    int plexno;						    /* index of plex in vinum_conf */
+    int volno;						    /* index of volume */
+    int volplexno;					    /* number of plex in volume */
+    int pid;						    /* pid of process which opened us */
+    /* Lock information */
+    int locks;						    /* number of locks used */
+    int alloclocks;					    /* number of locks allocated */
+    struct rangelock *lock;				    /* ranges of locked addresses */
+    /* Statistics */
+    u_int64_t reads;					    /* number of reads on this plex */
+    u_int64_t writes;					    /* number of writes on this plex */
+    u_int64_t bytes_read;				    /* number of bytes read */
+    u_int64_t bytes_written;				    /* number of bytes written */
+    u_int64_t multiblock;				    /* requests that needed more than one block */
+    u_int64_t multistripe;				    /* requests that needed more than one stripe */
+    /* revive parameters */
+    u_int64_t revived;					    /* block number of current revive request */
+    int revive_blocksize;				    /* revive block size (bytes) */
+    int revive_interval;				    /* and time to wait between transfers */
+    struct request *waitlist;				    /* list of requests waiting on revive op */
+    /* geometry control */
+    int defective_regions;				    /* number of regions which are defective */
+    int defective_region_count;				    /* number of entries in defective_region */
+    struct plexregion *defective_region;		    /* list of offset/length pairs: defective sds */
+    int unmapped_regions;				    /* number of regions which are missing */
+    int unmapped_region_count;				    /* number of entries in unmapped_region */
+    struct plexregion *unmapped_region;			    /* list of offset/length pairs: missing sds */
+    char name[MAXPLEXNAME];				    /* name of plex */
+};
+
+/*** Volume definitions ***/
+
+
+struct volume {
+    enum volumestate state;				    /* current state */
+    int plexes;						    /* number of plexes */
+    int preferred_plex;					    /* plex to read from, -1 for round-robin */
+    int last_plex_read;					    /* index of plex used for last read,
+							    * for round-robin */
+    dev_t devno;					    /* device number */
+    int flags;						    /* status and configuration flags */
+    int opencount;					    /* number of opens (all the same process) */
+    int openflags;					    /* flags supplied to last open(2) */
+    u_int64_t size;					    /* size of volume */
+    int disk;						    /* disk index */
+    int blocksize;					    /* logical block size */
+    int active;						    /* number of outstanding requests active */
+    int subops;						    /* and the number of suboperations */
+    pid_t pid;						    /* pid of locker */
+    /* Statistics */
+    u_int64_t bytes_read;				    /* number of bytes read */
+    u_int64_t bytes_written;				    /* number of bytes written */
+    u_int64_t reads;					    /* number of reads on this volume */
+    u_int64_t writes;					    /* number of writes on this volume */
+    u_int64_t recovered_reads;				    /* reads recovered from another plex */
+    /* Unlike subdisks in the plex, space for the plex pointers is static */
+    int plex[MAXPLEX];					    /* index of plexes */
+    char name[MAXVOLNAME];				    /* name of volume */
+    struct disklabel label;				    /* for DIOCGPART */
+};
+
+/* Table expansion.  Expand table, which contains oldcount
+ * entries of type element, by increment entries, and change
+ * oldcount accordingly */
+#define EXPAND(table, element, oldcount, increment)         \
+{							    \
+  expand_table ((void **) &table,			    \
+		oldcount * sizeof (element),		    \
+		(oldcount + increment) * sizeof (element) ); \
+  oldcount += increment;				    \
+  }
+
+/* Information on vinum's memory usage */
+struct meminfo {
+    int mallocs;					    /* number of malloced blocks */
+    int total_malloced;					    /* total amount malloced */
+    int highwater;					    /* maximum number of mallocs */
+    struct mc *malloced;				    /* pointer to kernel table */
+};
+
+struct mc {
+    int seq;
+    int size;
+    short line;
+    short flags;
+#define ALLOC_KVA 1					    /* allocated via kva calls */
+    int *databuf;					    /* really vm_object_t */
+    caddr_t address;
+    char file[16];
+};
+
+/* These enums are used by the state transition
+ * routines.  They're in bit map format:
+ *
+ * Bit 0: Other plexes in the volume are down
+ * Bit 1: Other plexes in the volume are up
+ * Bit 2: The current plex is up
+ * Maybe they should be local to
+ * state.c */
+enum volplexstate {
+    volplex_onlyusdown = 0,				    /* we're the only plex, and we're down */
+    volplex_alldown,					    /* 1: another plex is down, and so are we */
+    volplex_otherup,					    /* 2: another plex is up */
+    volplex_otherupdown,				    /* other plexes are up and down */
+    volplex_onlyus,					    /* 4: we're up and alone */
+    volplex_onlyusup,					    /* only we are up, others are down */
+    volplex_allup,					    /* all plexes are up */
+    volplex_someup					    /* some plexes are up, including us */
+};
+
+/* state map for plex */
+enum sdstates {
+    sd_emptystate = 1,
+    sd_downstate = 2,					    /* found an SD which is down */
+    sd_crashedstate = 4,				    /* found an SD which is crashed */
+    sd_obsoletestate = 8,				    /* found an SD which is obsolete */
+    sd_stalestate = 16,					    /* found an SD which is stale */
+    sd_rebornstate = 32,				    /* found an SD which is reborn */
+    sd_upstate = 64,					    /* found an SD which is up */
+    sd_initstate = 128,					    /* found an SD which is init */
+    sd_otherstate = 256					    /* found an SD in some other state */
+};
+
+/* This is really just a parameter to pass to
+ * set_<foo>_state, but since it needs to be known
+ * in the external definitions, we need to define
+ * it here */
+enum setstateflags {
+    setstate_none = 0,					    /* no flags */
+    setstate_force = 1,					    /* force the state change */
+    setstate_configuring = 2,				    /* we're currently configuring, don't save */
+    setstate_recursing = 4,				    /* we're called from another setstate function */
+    setstate_norecurse = 8,				    /* don't call other setstate functions */
+    setstate_noupdate = 16				    /* don't update config */
+};
+
+#ifdef DEBUG
+/* Debugging stuff */
+#define DEBUG_ADDRESSES 1
+#define DEBUG_NUMOUTPUT 2
+#define DEBUG_RESID     4				    /* go into debugger in complete_rqe */
+#define DEBUG_LASTREQS  8				    /* keep a circular buffer of last requests */
+#define DEBUG_REMOTEGDB 256				    /* go into remote gdb */
+#endif