Refer to vinum driver sources in a single location (outside of the

kernel src/sys tree, sigh - it should really be sys/dev/vinum/*).

23 files changed, 8 insertions, 8249 deletions

diff --git a/sys/modules/vinum/COPYRIGHT b/sys/modules/vinum/COPYRIGHT
deleted file mode 100644
index 4ee95f20ce5c..000000000000
--- a/sys/modules/vinum/COPYRIGHT
+++ /dev/null
@@ -1,37 +0,0 @@
-/*-
- * 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 1998/03/05 06:07:05 grog Exp grog $
- */
diff --git a/sys/modules/vinum/Makefile b/sys/modules/vinum/Makefile
index 6489222ef0c3..ee119e376774 100644
--- a/sys/modules/vinum/Makefile
+++ b/sys/modules/vinum/Makefile
@@ -1,21 +1,20 @@
-#       $Id: Makefile,v 1.2 1998/09/28 04:21:20 grog Exp $ 
+#       $Id: Makefile,v 1.3 1998/10/16 04:30:51 peter Exp $ 
 
-.PATH:  ${.CURDIR}/../../dev/ccd
+# XXX this should be ../../dev/vinum
+SOURCE=	${.CURDIR}/../../../lkm/vinum
+
+.PATH:  ${SOURCE}
 KMOD=   vinum
-SRCS=   vinum.c vinum.h vnode_if.h parser.c config.c io.c util.c vinumhdr.h request.h \
+SRCS=   vinum.c 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=
-CFLAGS = -I${.CURDIR} -O -g -I/usr/include/machine -DDEBUG -Wall -Wno-unused -Wno-parentheses
+CFLAGS = -I${SOURCE} -O -g -I/usr/include/machine -DDEBUG -Wall -Wno-unused -Wno-parentheses
 
-CLEANFILES+=    vinum.h vnode_if.h vnode_if.c
+CLEANFILES+=    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
 
diff --git a/sys/modules/vinum/config.c b/sys/modules/vinum/config.c
deleted file mode 100644
index fd31c5e07c46..000000000000
--- a/sys/modules/vinum/config.c
+++ /dev/null
@@ -1,1712 +0,0 @@
-/* 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.17 1998/08/14 04:49:26 grog Exp grog $
- */
-
-#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 */
-    }
-    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 MP)
- * 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 */
-}
-
-/* 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;
-}
-
-/* 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;
-}
-
-/* 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;
-}
-
-/* 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')
-	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 */
-
-    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:
-	    ++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 */
-
-    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:
-	    {
-		int namedplexno;
-
-		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/modules/vinum/interrupt.c b/sys/modules/vinum/interrupt.c
deleted file mode 100644
index e7eb034faf4b..000000000000
--- a/sys/modules/vinum/interrupt.c
+++ /dev/null
@@ -1,190 +0,0 @@
-/* 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.1 1998/08/13 06:12:27 grog Exp grog $
- */
-
-#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 */
-
-    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); /* take the subdisk down */
-    }
-    /* 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;
-    }
-    ubp = rq->bp;					    /* user buffer */
-    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 & 4) {
-	    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/modules/vinum/io.c b/sys/modules/vinum/io.c
deleted file mode 100644
index a16a33a9e8bc..000000000000
--- a/sys/modules/vinum/io.c
+++ /dev/null
@@ -1,886 +0,0 @@
-/*-
- * 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.16 1998/08/10 23:47:21 grog Exp grog $
- */
-
-#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 __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;
-    }
-    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);
-	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->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/modules/vinum/lock.c b/sys/modules/vinum/lock.c
deleted file mode 100644
index ed69649fccdc..000000000000
--- a/sys/modules/vinum/lock.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/*-
- * 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.6 1998/07/28 06:32:57 grog Exp grog $
- */
-
-#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/modules/vinum/makestatetext b/sys/modules/vinum/makestatetext
deleted file mode 100755
index ca5eb2dc3c3d..000000000000
--- a/sys/modules/vinum/makestatetext
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/bin/sh
-# Make statetexts.h from vinumstate.h
-# $Id: makestatetext,v 1.4 1998/03/13 05:36:16 grog Exp grog $
-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/modules/vinum/memory.c b/sys/modules/vinum/memory.c
deleted file mode 100644
index 5dee671167b0..000000000000
--- a/sys/modules/vinum/memory.c
+++ /dev/null
@@ -1,186 +0,0 @@
-
-/*-
- * 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.16 1998/08/08 04:43:22 grog Exp grog $
- */
-
-#define REALLYKERNEL
-#define USES_VM
-#include "vinumhdr.h"
-
-extern 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
-
-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;
-    }
-}
-
-#ifndef DEBUG
-/* increase the size of a request block */
-void 
-expandrq(struct plexrq *prq)
-{
-    expand_table((void **) &prq->rqe,
-	prq->requests * sizeof(struct rqelement),
-	  (prq->requests + RQELTS) * sizeof(struct rqelement));
-    bzero(&prq->rqe[prq->requests], RQELTS * sizeof(struct rqelement));	/* clear the new part */
-    prq->rqcount += RQELTS;
-}
-
-#endif
-
-#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) {
-	    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(file, malloced[i].file, min(strlen(file) + 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;
-}
-
-#endif
diff --git a/sys/modules/vinum/parser.c b/sys/modules/vinum/parser.c
deleted file mode 100644
index 9e7f791a7d14..000000000000
--- a/sys/modules/vinum/parser.c
+++ /dev/null
@@ -1,206 +0,0 @@
-/*-
- * 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.11 1998/08/10 08:50:42 grog Exp grog $
- */
-
-/* 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/modules/vinum/request.c b/sys/modules/vinum/request.c
deleted file mode 100644
index 589eb3fac0ba..000000000000
--- a/sys/modules/vinum/request.c
+++ /dev/null
@@ -1,882 +0,0 @@
-/* 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.17 1998/08/13 06:04:47 grog Exp grog $
- */
-
-#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);
-
-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;
-
-    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;
-
-    /* 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;
-	}
-	return launch_requests(rq, reviveok);		    /* now start the requests if we can */
-    } 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;
-	}
-	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\nWrite dev 0x%x, offset 0x%x, length %ld\n",
-	    (u_int) rq,
-	    rq->bp->b_dev,
-	    rq->bp->b_blkno,
-	    rq->bp->b_bcount);				    /* XXX */
-    vinum_conf.lastrq = (int) rq;
-    vinum_conf.lastbuf = 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 */
-#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);
-#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/modules/vinum/request.h b/sys/modules/vinum/request.h
deleted file mode 100644
index b4beccca9b42..000000000000
--- a/sys/modules/vinum/request.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*-
- * 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.10 1998/08/03 07:15:26 grog Exp grog $
- */
-
-/* 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 */
-};
diff --git a/sys/modules/vinum/revive.c b/sys/modules/vinum/revive.c
deleted file mode 100644
index 216dc4887d41..000000000000
--- a/sys/modules/vinum/revive.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*-
- * 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.1.1.1 1998/09/16 05:56:21 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;
-    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, plex->stripesize); /* one block at a time */
-	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/modules/vinum/state.c b/sys/modules/vinum/state.c
deleted file mode 100644
index 2ce2ed0c29e5..000000000000
--- a/sys/modules/vinum/state.c
+++ /dev/null
@@ -1,755 +0,0 @@
-/*-
- * 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 2.6 1998/08/19 08:04:47 grog Exp grog $
- */
-
-#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 || (drive->opencount == 0)) {	    /* we can do it */
-		close_drive(drive);
-		drive->state = state;
-		printf("vinum: drive %s is %s\n", drive->label.name, drive_state(drive->state));
-	    } else
-		return 0;				    /* don't do it */
-	}
-	drive->state = state;				    /* set the 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 */
-	    }
-	    save_config();				    /* and 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_obsolete:
-	    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 */
-	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 */
-	    if ((statemap == sd_upstate)		    /* subdisks all up */
-	    ||(statemap == sd_emptystate)		    /* or all empty */
-	    ) {
-		/* Is the data in all subdisks valid? */
-		if (statemap == statemap & (sd_downstate | sd_rebornstate | sd_upstate))
-		    break;				    /* yes, we can bring the plex up */
-		plex->state = plex_reviving;		    /* we need reviving */
-		return EAGAIN;
-	    } else
-		plex->state = plex_faulty;		    /* 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 */
-	save_config();
-    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 */
-		save_config();
-	    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 */
-		save_config();
-	    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/modules/vinum/statetexts.h b/sys/modules/vinum/statetexts.h
deleted file mode 100644
index b7ce4eb54bef..000000000000
--- a/sys/modules/vinum/statetexts.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*-
- * 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 1998/03/05 06:07:05 grog Exp grog $
- */
-/* 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/modules/vinum/util.c b/sys/modules/vinum/util.c
deleted file mode 100644
index 512140438fc9..000000000000
--- a/sys/modules/vinum/util.c
+++ /dev/null
@@ -1,211 +0,0 @@
-/*-
- * 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.7 1998/08/07 09:23:10 grog Exp grog $
- */
-
-/* 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/modules/vinum/vinum.c b/sys/modules/vinum/vinum.c
deleted file mode 100644
index 62c6b3fa7678..000000000000
--- a/sys/modules/vinum/vinum.c
+++ /dev/null
@@ -1,543 +0,0 @@
-/*-
- * 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.1.1.1 1998/09/16 05:56:21 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);
-
-#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;
-/*   Debugger ("vinum_load"); */
-    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);
-STATIC int
-vinum_modevent(module_t mod, modeventtype_t type, void *unused)
-{
-    struct sync_args dummyarg = {0};
-
-    BROKEN_GDB;
-    switch (type) {
-    case MOD_LOAD:
-	/* Debugger ("vinum_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;
-
-/* XXX This is bogus.  We don't need to open
- * a device to find its 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/modules/vinum/vinumext.h b/sys/modules/vinum/vinumext.h
deleted file mode 100644
index 4b7d5a01d642..000000000000
--- a/sys/modules/vinum/vinumext.h
+++ /dev/null
@@ -1,214 +0,0 @@
-/*-
- * 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.14 1998/08/11 00:03:57 grog Exp grog $
- */
-
-/* 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);
-
-/* Memory allocation */
-void vinum_meminfo(caddr_t data);
-int vinum_mallocinfo(caddr_t data);
-
-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);
-
-#ifdef DEBUG
-#define expandrq(prq) \
-{  \
-  expand_table ((void **) &prq->rqe, \
-		prq->requests * sizeof (struct rqelement), \
-		(prq->requests + RQELTS) * sizeof (struct rqelement) ); \
-  bzero (&prq->rqe [prq->requests], RQELTS * sizeof (struct rqelement)); \
-  prq->rqcount += RQELTS; \
-  }
-#else
-void expandrq(struct plexrq *);
-#endif
diff --git a/sys/modules/vinum/vinumhdr.h b/sys/modules/vinum/vinumhdr.h
deleted file mode 100644
index 22a856182396..000000000000
--- a/sys/modules/vinum/vinumhdr.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*-
- * 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.7 1998/08/07 04:41:18 grog Exp grog $ */
-
-#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> */
-#include <machine/cputypes.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/modules/vinum/vinumio.h b/sys/modules/vinum/vinumio.h
deleted file mode 100644
index be79528a6db8..000000000000
--- a/sys/modules/vinum/vinumio.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*-
- * 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.10 1998/08/10 05:46:19 grog Exp grog $
- */
-
-#define MAX_IOCTL_REPLY 256
-#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 */
diff --git a/sys/modules/vinum/vinumioctl.c b/sys/modules/vinum/vinumioctl.c
deleted file mode 100644
index 6dbe3c6bf4d6..000000000000
--- a/sys/modules/vinum/vinumioctl.c
+++ /dev/null
@@ -1,787 +0,0 @@
-/* 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.1 1998/08/14 08:46:10 grog Exp grog $
- */
-
-#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>
-#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) {
-	    /* XXX #ifdef DEBUG */
-	case VINUM_DEBUG:
-	    boothowto |= RB_GDB;			    /* serial debug line */
-	    if (((struct debuginfo *) data)->changeit)	    /* change debug settings */
-		debug = (((struct debuginfo *) data)->param);
-	    else
-		Debugger("vinum debug");
-	    ioctl_reply = (struct _ioctl_reply *) data;	    /* reinstate the address to reply to */
-	    ioctl_reply->error = 0;
-	    return 0;
-	    /* XXX #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_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/modules/vinum/vinumkw.h b/sys/modules/vinum/vinumkw.h
deleted file mode 100644
index 1a81f37656f4..000000000000
--- a/sys/modules/vinum/vinumkw.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*-
- * 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.7 1998/08/07 02:35:51 grog Exp grog $
- */
-
-/* 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 */
-    kw_info,
-#endif
-    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/modules/vinum/vinumstate.h b/sys/modules/vinum/vinumstate.h
deleted file mode 100644
index 0b07590b2cf6..000000000000
--- a/sys/modules/vinum/vinumstate.h
+++ /dev/null
@@ -1,213 +0,0 @@
-/*-
- * 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.11 1998/08/04 06:22:49 grog Exp grog $
- */
-
-/* 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/modules/vinum/vinumvar.h b/sys/modules/vinum/vinumvar.h
deleted file mode 100644
index ca54f76aad02..000000000000
--- a/sys/modules/vinum/vinumvar.h
+++ /dev/null
@@ -1,510 +0,0 @@
-/*-
- * 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.15 1998/08/14 06:36:41 grog Exp grog $
- */
-
-/* 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.  Only the MAXCONFIG parameter is set in stone
- */
-
-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,
-
-
-/* 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 */
-};
-
-/* 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"
-#define MAXDRIVENAME   32				    /* maximum length of a device name */
-#define MAXSDNAME      64				    /* maximum length of a subdisk name */
-#define MAXPLEXNAME    64				    /* maximum length of a plex name */
-#define MAXVOLNAME     64				    /* maximum length of a volume name */
-#define MAXNAME        64				    /* maximum length of any name */
-#define MAXVOLPLEX      8				    /* maximum number of plexes in a volume */
-
-/* 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 */
-};
-
-/* 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;
-#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 */
-#define VINUMHOSTNAMELEN 32
-
-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 ***/
-
-#define MAXPLEX		8				    /* maximum number of plexes */
-
-
-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 */
-};
-
-#ifdef DEBUG
-/* Debugging stuff */
-#define DEBUG_ADDRESSES 1
-#define DEBUG_NUMOUTPUT 2
-#endif