release/3.0.0

1 files changed, 882 insertions, 0 deletions

diff --git a/lkm/vinum/request.c b/lkm/vinum/request.c
new file mode 100644
index 000000000000..589eb3fac0ba
--- /dev/null
+++ b/lkm/vinum/request.c
@@ -0,0 +1,882 @@
+/* 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));
+}