2004-06-12 21:16:10 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 2004 Lukas Ertl
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/bio.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/kthread.h>
|
|
|
|
#include <sys/libkern.h>
|
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/module.h>
|
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
|
|
|
|
#include <geom/geom.h>
|
|
|
|
#include <geom/vinum/geom_vinum_var.h>
|
|
|
|
#include <geom/vinum/geom_vinum_raid5.h>
|
|
|
|
#include <geom/vinum/geom_vinum.h>
|
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
static void gv_plex_completed_request(struct gv_plex *, struct bio *);
|
|
|
|
static void gv_plex_normal_request(struct gv_plex *, struct bio *);
|
|
|
|
static void gv_plex_worker(void *);
|
2004-11-26 12:01:00 +00:00
|
|
|
static int gv_check_parity(struct gv_plex *, struct bio *,
|
|
|
|
struct gv_raid5_packet *);
|
|
|
|
static int gv_normal_parity(struct gv_plex *, struct bio *,
|
|
|
|
struct gv_raid5_packet *);
|
2004-09-18 13:44:43 +00:00
|
|
|
|
2004-06-12 21:16:10 +00:00
|
|
|
/* XXX: is this the place to catch dying subdisks? */
|
|
|
|
static void
|
|
|
|
gv_plex_orphan(struct g_consumer *cp)
|
|
|
|
{
|
|
|
|
struct g_geom *gp;
|
|
|
|
struct gv_plex *p;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
g_topology_assert();
|
|
|
|
gp = cp->geom;
|
|
|
|
g_trace(G_T_TOPOLOGY, "gv_plex_orphan(%s)", gp->name);
|
|
|
|
|
|
|
|
if (cp->acr != 0 || cp->acw != 0 || cp->ace != 0)
|
|
|
|
g_access(cp, -cp->acr, -cp->acw, -cp->ace);
|
|
|
|
error = cp->provider->error;
|
|
|
|
if (error == 0)
|
|
|
|
error = ENXIO;
|
|
|
|
g_detach(cp);
|
|
|
|
g_destroy_consumer(cp);
|
|
|
|
if (!LIST_EMPTY(&gp->consumer))
|
|
|
|
return;
|
|
|
|
|
|
|
|
p = gp->softc;
|
2004-06-18 19:53:33 +00:00
|
|
|
if (p != NULL) {
|
2004-09-13 17:44:47 +00:00
|
|
|
gv_kill_plex_thread(p);
|
2004-06-18 19:53:33 +00:00
|
|
|
p->geom = NULL;
|
|
|
|
p->provider = NULL;
|
|
|
|
p->consumer = NULL;
|
|
|
|
}
|
2004-06-16 14:41:04 +00:00
|
|
|
gp->softc = NULL;
|
2004-06-12 21:16:10 +00:00
|
|
|
g_wither_geom(gp, error);
|
|
|
|
}
|
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
void
|
2004-06-12 21:16:10 +00:00
|
|
|
gv_plex_done(struct bio *bp)
|
|
|
|
{
|
2004-09-18 13:44:43 +00:00
|
|
|
struct gv_plex *p;
|
|
|
|
|
|
|
|
p = bp->bio_from->geom->softc;
|
|
|
|
bp->bio_cflags |= GV_BIO_DONE;
|
|
|
|
mtx_lock(&p->bqueue_mtx);
|
2006-01-06 18:03:17 +00:00
|
|
|
bioq_insert_tail(p->bqueue, bp);
|
2004-09-18 13:44:43 +00:00
|
|
|
wakeup(p);
|
|
|
|
mtx_unlock(&p->bqueue_mtx);
|
2004-06-12 21:16:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the correct subdisk to send the bio to and build a bio to send. */
|
|
|
|
static int
|
2004-09-18 13:44:43 +00:00
|
|
|
gv_plexbuffer(struct gv_plex *p, struct bio *bp, caddr_t addr, off_t boff, off_t bcount)
|
2004-06-12 21:16:10 +00:00
|
|
|
{
|
|
|
|
struct g_geom *gp;
|
|
|
|
struct gv_sd *s;
|
2004-09-18 13:44:43 +00:00
|
|
|
struct bio *cbp, *pbp;
|
2004-06-12 21:16:10 +00:00
|
|
|
int i, sdno;
|
2004-09-18 13:44:43 +00:00
|
|
|
off_t len_left, real_len, real_off;
|
|
|
|
off_t stripeend, stripeno, stripestart;
|
2004-06-12 21:16:10 +00:00
|
|
|
|
|
|
|
if (p == NULL || LIST_EMPTY(&p->subdisks))
|
|
|
|
return (ENXIO);
|
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
s = NULL;
|
|
|
|
gp = bp->bio_to->geom;
|
|
|
|
|
2004-06-12 21:16:10 +00:00
|
|
|
/*
|
|
|
|
* We only handle concatenated and striped plexes here. RAID5 plexes
|
|
|
|
* are handled in build_raid5_request().
|
|
|
|
*/
|
|
|
|
switch (p->org) {
|
|
|
|
case GV_PLEX_CONCAT:
|
|
|
|
/*
|
|
|
|
* Find the subdisk where this request starts. The subdisks in
|
|
|
|
* this list must be ordered by plex_offset.
|
|
|
|
*/
|
|
|
|
LIST_FOREACH(s, &p->subdisks, in_plex) {
|
|
|
|
if (s->plex_offset <= boff &&
|
|
|
|
s->plex_offset + s->size > boff)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Subdisk not found. */
|
|
|
|
if (s == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
|
|
|
|
/* Calculate corresponding offsets on disk. */
|
|
|
|
real_off = boff - s->plex_offset;
|
|
|
|
len_left = s->size - real_off;
|
|
|
|
real_len = (bcount > len_left) ? len_left : bcount;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GV_PLEX_STRIPED:
|
|
|
|
/* The number of the stripe where the request starts. */
|
|
|
|
stripeno = boff / p->stripesize;
|
|
|
|
|
|
|
|
/* The number of the subdisk where the stripe resides. */
|
|
|
|
sdno = stripeno % p->sdcount;
|
|
|
|
|
|
|
|
/* Find the right subdisk. */
|
|
|
|
i = 0;
|
|
|
|
LIST_FOREACH(s, &p->subdisks, in_plex) {
|
|
|
|
if (i == sdno)
|
|
|
|
break;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Subdisk not found. */
|
|
|
|
if (s == NULL)
|
|
|
|
return (ENXIO);
|
|
|
|
|
|
|
|
/* The offset of the stripe from the start of the subdisk. */
|
|
|
|
stripestart = (stripeno / p->sdcount) *
|
|
|
|
p->stripesize;
|
|
|
|
|
|
|
|
/* The offset at the end of the stripe. */
|
|
|
|
stripeend = stripestart + p->stripesize;
|
|
|
|
|
|
|
|
/* The offset of the request on this subdisk. */
|
|
|
|
real_off = boff - (stripeno * p->stripesize) +
|
|
|
|
stripestart;
|
|
|
|
|
|
|
|
/* The length left in this stripe. */
|
|
|
|
len_left = stripeend - real_off;
|
|
|
|
|
|
|
|
real_len = (bcount <= len_left) ? bcount : len_left;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now check if we can handle the request on this subdisk. */
|
|
|
|
switch (s->state) {
|
|
|
|
case GV_SD_UP:
|
|
|
|
/* If the subdisk is up, just continue. */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GV_SD_STALE:
|
2004-09-18 13:44:43 +00:00
|
|
|
if (!(bp->bio_cflags & GV_BIO_SYNCREQ))
|
2004-06-12 21:16:10 +00:00
|
|
|
return (ENXIO);
|
|
|
|
|
2008-10-26 17:20:37 +00:00
|
|
|
G_VINUM_DEBUG(1, "sd %s is initializing", s->name);
|
2004-06-12 21:16:10 +00:00
|
|
|
gv_set_sd_state(s, GV_SD_INITIALIZING, GV_SETSTATE_FORCE);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GV_SD_INITIALIZING:
|
|
|
|
if (bp->bio_cmd == BIO_READ)
|
|
|
|
return (ENXIO);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* All other subdisk states mean it's not accessible. */
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clone the bio and adjust the offsets and sizes. */
|
|
|
|
cbp = g_clone_bio(bp);
|
|
|
|
if (cbp == NULL)
|
|
|
|
return (ENOMEM);
|
|
|
|
cbp->bio_offset = real_off;
|
|
|
|
cbp->bio_length = real_len;
|
|
|
|
cbp->bio_data = addr;
|
2004-09-18 13:44:43 +00:00
|
|
|
cbp->bio_done = g_std_done;
|
|
|
|
cbp->bio_caller2 = s->consumer;
|
|
|
|
if ((bp->bio_cflags & GV_BIO_SYNCREQ)) {
|
|
|
|
cbp->bio_cflags |= GV_BIO_SYNCREQ;
|
2004-06-12 21:16:10 +00:00
|
|
|
cbp->bio_done = gv_plex_done;
|
2004-09-18 13:44:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bp->bio_driver1 == NULL) {
|
|
|
|
bp->bio_driver1 = cbp;
|
|
|
|
} else {
|
|
|
|
pbp = bp->bio_driver1;
|
|
|
|
while (pbp->bio_caller1 != NULL)
|
|
|
|
pbp = pbp->bio_caller1;
|
|
|
|
pbp->bio_caller1 = cbp;
|
|
|
|
}
|
|
|
|
|
2004-06-12 21:16:10 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gv_plex_start(struct bio *bp)
|
|
|
|
{
|
|
|
|
struct gv_plex *p;
|
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
switch(bp->bio_cmd) {
|
|
|
|
case BIO_READ:
|
|
|
|
case BIO_WRITE:
|
|
|
|
case BIO_DELETE:
|
|
|
|
break;
|
|
|
|
case BIO_GETATTR:
|
|
|
|
default:
|
|
|
|
g_io_deliver(bp, EOPNOTSUPP);
|
|
|
|
return;
|
|
|
|
}
|
2004-06-12 21:16:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We cannot handle this request if too many of our subdisks are
|
|
|
|
* inaccessible.
|
|
|
|
*/
|
2004-09-18 13:44:43 +00:00
|
|
|
p = bp->bio_to->geom->softc;
|
|
|
|
if ((p->state < GV_PLEX_DEGRADED) &&
|
|
|
|
!(bp->bio_cflags & GV_BIO_SYNCREQ)) {
|
|
|
|
g_io_deliver(bp, ENXIO);
|
2004-06-12 21:16:10 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
mtx_lock(&p->bqueue_mtx);
|
2006-01-06 18:03:17 +00:00
|
|
|
bioq_disksort(p->bqueue, bp);
|
2004-09-18 13:44:43 +00:00
|
|
|
wakeup(p);
|
|
|
|
mtx_unlock(&p->bqueue_mtx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gv_plex_worker(void *arg)
|
|
|
|
{
|
|
|
|
struct bio *bp;
|
|
|
|
struct gv_plex *p;
|
|
|
|
struct gv_sd *s;
|
|
|
|
|
|
|
|
p = arg;
|
|
|
|
KASSERT(p != NULL, ("NULL p"));
|
|
|
|
|
|
|
|
mtx_lock(&p->bqueue_mtx);
|
|
|
|
for (;;) {
|
|
|
|
/* We were signaled to exit. */
|
|
|
|
if (p->flags & GV_PLEX_THREAD_DIE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Take the first BIO from our queue. */
|
2006-01-06 18:03:17 +00:00
|
|
|
bp = bioq_takefirst(p->bqueue);
|
|
|
|
if (bp == NULL) {
|
2004-09-18 13:44:43 +00:00
|
|
|
msleep(p, &p->bqueue_mtx, PRIBIO, "-", hz/10);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
mtx_unlock(&p->bqueue_mtx);
|
|
|
|
|
|
|
|
/* A completed request. */
|
|
|
|
if (bp->bio_cflags & GV_BIO_DONE) {
|
2004-09-30 12:57:35 +00:00
|
|
|
if (bp->bio_cflags & GV_BIO_SYNCREQ ||
|
|
|
|
bp->bio_cflags & GV_BIO_REBUILD) {
|
2004-09-18 13:44:43 +00:00
|
|
|
s = bp->bio_to->private;
|
|
|
|
if (bp->bio_error == 0)
|
|
|
|
s->initialized += bp->bio_length;
|
|
|
|
if (s->initialized >= s->size) {
|
|
|
|
g_topology_lock();
|
|
|
|
gv_set_sd_state(s, GV_SD_UP,
|
|
|
|
GV_SETSTATE_CONFIG);
|
|
|
|
g_topology_unlock();
|
|
|
|
s->initialized = 0;
|
|
|
|
}
|
2004-09-30 12:57:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bp->bio_cflags & GV_BIO_SYNCREQ)
|
2004-09-18 13:44:43 +00:00
|
|
|
g_std_done(bp);
|
2004-09-30 12:57:35 +00:00
|
|
|
else
|
2004-09-18 13:44:43 +00:00
|
|
|
gv_plex_completed_request(p, bp);
|
2004-06-12 21:16:10 +00:00
|
|
|
/*
|
2004-09-18 13:44:43 +00:00
|
|
|
* A sub-request that was hold back because it interfered with
|
|
|
|
* another sub-request.
|
2004-06-12 21:16:10 +00:00
|
|
|
*/
|
2004-09-18 13:44:43 +00:00
|
|
|
} else if (bp->bio_cflags & GV_BIO_ONHOLD) {
|
|
|
|
/* Is it still locked out? */
|
|
|
|
if (gv_stripe_active(p, bp)) {
|
2004-10-26 21:01:42 +00:00
|
|
|
/* Park the bio on the waiting queue. */
|
2004-09-18 13:44:43 +00:00
|
|
|
mtx_lock(&p->bqueue_mtx);
|
2006-01-06 18:03:17 +00:00
|
|
|
bioq_disksort(p->wqueue, bp);
|
2004-09-18 13:44:43 +00:00
|
|
|
mtx_unlock(&p->bqueue_mtx);
|
|
|
|
} else {
|
|
|
|
bp->bio_cflags &= ~GV_BIO_ONHOLD;
|
|
|
|
g_io_request(bp, bp->bio_caller2);
|
|
|
|
}
|
2004-06-12 21:16:10 +00:00
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
/* A normal request to this plex. */
|
2006-01-06 18:03:17 +00:00
|
|
|
} else
|
2004-09-18 13:44:43 +00:00
|
|
|
gv_plex_normal_request(p, bp);
|
|
|
|
|
|
|
|
mtx_lock(&p->bqueue_mtx);
|
|
|
|
}
|
|
|
|
mtx_unlock(&p->bqueue_mtx);
|
|
|
|
p->flags |= GV_PLEX_THREAD_DEAD;
|
|
|
|
wakeup(p);
|
|
|
|
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_exit(ENXIO);
|
2004-09-18 13:44:43 +00:00
|
|
|
}
|
|
|
|
|
2004-11-26 12:01:00 +00:00
|
|
|
static int
|
|
|
|
gv_normal_parity(struct gv_plex *p, struct bio *bp, struct gv_raid5_packet *wp)
|
|
|
|
{
|
|
|
|
struct bio *cbp, *pbp;
|
|
|
|
int finished, i;
|
|
|
|
|
|
|
|
finished = 1;
|
|
|
|
|
|
|
|
if (wp->waiting != NULL) {
|
|
|
|
pbp = wp->waiting;
|
|
|
|
wp->waiting = NULL;
|
|
|
|
cbp = wp->parity;
|
|
|
|
for (i = 0; i < wp->length; i++)
|
|
|
|
cbp->bio_data[i] ^= pbp->bio_data[i];
|
|
|
|
g_io_request(pbp, pbp->bio_caller2);
|
|
|
|
finished = 0;
|
|
|
|
|
|
|
|
} else if (wp->parity != NULL) {
|
|
|
|
cbp = wp->parity;
|
|
|
|
wp->parity = NULL;
|
|
|
|
g_io_request(cbp, cbp->bio_caller2);
|
|
|
|
finished = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (finished);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
gv_check_parity(struct gv_plex *p, struct bio *bp, struct gv_raid5_packet *wp)
|
|
|
|
{
|
2006-01-06 18:03:17 +00:00
|
|
|
struct bio *pbp;
|
2004-11-26 12:01:00 +00:00
|
|
|
int err, finished, i;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
finished = 1;
|
|
|
|
|
|
|
|
if (wp->waiting != NULL) {
|
|
|
|
pbp = wp->waiting;
|
|
|
|
wp->waiting = NULL;
|
|
|
|
g_io_request(pbp, pbp->bio_caller2);
|
|
|
|
finished = 0;
|
|
|
|
|
|
|
|
} else if (wp->parity != NULL) {
|
2006-01-06 18:03:17 +00:00
|
|
|
pbp = wp->parity;
|
2004-11-26 12:01:00 +00:00
|
|
|
wp->parity = NULL;
|
|
|
|
|
|
|
|
/* Check if the parity is correct. */
|
|
|
|
for (i = 0; i < wp->length; i++) {
|
2006-01-06 18:03:17 +00:00
|
|
|
if (bp->bio_data[i] != pbp->bio_data[i]) {
|
2004-11-26 12:01:00 +00:00
|
|
|
err = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The parity is not correct... */
|
|
|
|
if (err) {
|
|
|
|
bp->bio_parent->bio_error = EAGAIN;
|
|
|
|
|
|
|
|
/* ... but we rebuild it. */
|
|
|
|
if (bp->bio_parent->bio_cflags & GV_BIO_PARITY) {
|
2006-01-06 18:03:17 +00:00
|
|
|
g_io_request(pbp, pbp->bio_caller2);
|
2004-11-26 12:01:00 +00:00
|
|
|
finished = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clean up the BIO we would have used for rebuilding the
|
|
|
|
* parity.
|
|
|
|
*/
|
|
|
|
if (finished) {
|
|
|
|
bp->bio_parent->bio_inbed++;
|
2006-01-06 18:03:17 +00:00
|
|
|
g_destroy_bio(pbp);
|
2004-11-26 12:01:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return (finished);
|
|
|
|
}
|
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
void
|
|
|
|
gv_plex_completed_request(struct gv_plex *p, struct bio *bp)
|
|
|
|
{
|
|
|
|
struct bio *cbp, *pbp;
|
|
|
|
struct gv_bioq *bq, *bq2;
|
|
|
|
struct gv_raid5_packet *wp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
wp = bp->bio_driver1;
|
|
|
|
|
|
|
|
switch (bp->bio_parent->bio_cmd) {
|
|
|
|
case BIO_READ:
|
|
|
|
if (wp == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
TAILQ_FOREACH_SAFE(bq, &wp->bits, queue, bq2) {
|
|
|
|
if (bq->bp == bp) {
|
|
|
|
TAILQ_REMOVE(&wp->bits, bq, queue);
|
|
|
|
g_free(bq);
|
|
|
|
for (i = 0; i < wp->length; i++)
|
|
|
|
wp->data[i] ^= bp->bio_data[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (TAILQ_EMPTY(&wp->bits)) {
|
|
|
|
bp->bio_parent->bio_completed += wp->length;
|
2004-10-26 21:01:42 +00:00
|
|
|
if (wp->lockbase != -1) {
|
2004-09-18 13:44:43 +00:00
|
|
|
TAILQ_REMOVE(&p->packets, wp, list);
|
2004-10-26 21:01:42 +00:00
|
|
|
/* Bring the waiting bios back into the game. */
|
|
|
|
mtx_lock(&p->bqueue_mtx);
|
2006-01-06 18:03:17 +00:00
|
|
|
pbp = bioq_takefirst(p->wqueue);
|
|
|
|
while (pbp != NULL) {
|
|
|
|
bioq_disksort(p->bqueue, pbp);
|
|
|
|
pbp = bioq_takefirst(p->wqueue);
|
|
|
|
}
|
2004-10-26 21:01:42 +00:00
|
|
|
mtx_unlock(&p->bqueue_mtx);
|
|
|
|
}
|
2004-09-18 13:44:43 +00:00
|
|
|
g_free(wp);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BIO_WRITE:
|
|
|
|
if (wp == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Check if we need to handle parity data. */
|
|
|
|
TAILQ_FOREACH_SAFE(bq, &wp->bits, queue, bq2) {
|
|
|
|
if (bq->bp == bp) {
|
|
|
|
TAILQ_REMOVE(&wp->bits, bq, queue);
|
|
|
|
g_free(bq);
|
|
|
|
cbp = wp->parity;
|
|
|
|
if (cbp != NULL) {
|
|
|
|
for (i = 0; i < wp->length; i++)
|
|
|
|
cbp->bio_data[i] ^=
|
|
|
|
bp->bio_data[i];
|
|
|
|
}
|
|
|
|
break;
|
2004-06-12 21:16:10 +00:00
|
|
|
}
|
2004-09-18 13:44:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle parity data. */
|
|
|
|
if (TAILQ_EMPTY(&wp->bits)) {
|
2004-11-26 12:01:00 +00:00
|
|
|
if (bp->bio_parent->bio_cflags & GV_BIO_CHECK)
|
|
|
|
i = gv_check_parity(p, bp, wp);
|
|
|
|
else
|
|
|
|
i = gv_normal_parity(p, bp, wp);
|
|
|
|
|
|
|
|
/* All of our sub-requests have finished. */
|
|
|
|
if (i) {
|
2004-09-18 13:44:43 +00:00
|
|
|
bp->bio_parent->bio_completed += wp->length;
|
|
|
|
TAILQ_REMOVE(&p->packets, wp, list);
|
2004-10-26 21:01:42 +00:00
|
|
|
/* Bring the waiting bios back into the game. */
|
|
|
|
mtx_lock(&p->bqueue_mtx);
|
2006-01-06 18:03:17 +00:00
|
|
|
pbp = bioq_takefirst(p->wqueue);
|
|
|
|
while (pbp != NULL) {
|
|
|
|
bioq_disksort(p->bqueue, pbp);
|
|
|
|
pbp = bioq_takefirst(p->wqueue);
|
|
|
|
}
|
2004-10-26 21:01:42 +00:00
|
|
|
mtx_unlock(&p->bqueue_mtx);
|
2004-09-18 13:44:43 +00:00
|
|
|
g_free(wp);
|
2004-06-12 21:16:10 +00:00
|
|
|
}
|
2004-09-18 13:44:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2004-06-12 21:16:10 +00:00
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
pbp = bp->bio_parent;
|
|
|
|
if (pbp->bio_error == 0)
|
|
|
|
pbp->bio_error = bp->bio_error;
|
|
|
|
|
|
|
|
/* When the original request is finished, we deliver it. */
|
|
|
|
pbp->bio_inbed++;
|
|
|
|
if (pbp->bio_inbed == pbp->bio_children)
|
|
|
|
g_io_deliver(pbp, pbp->bio_error);
|
|
|
|
|
|
|
|
/* Clean up what we allocated. */
|
|
|
|
if (bp->bio_cflags & GV_BIO_MALLOC)
|
|
|
|
g_free(bp->bio_data);
|
|
|
|
g_destroy_bio(bp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gv_plex_normal_request(struct gv_plex *p, struct bio *bp)
|
|
|
|
{
|
|
|
|
struct bio *cbp, *pbp;
|
|
|
|
struct gv_bioq *bq, *bq2;
|
|
|
|
struct gv_raid5_packet *wp, *wp2;
|
|
|
|
caddr_t addr;
|
|
|
|
off_t bcount, boff;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
bcount = bp->bio_length;
|
|
|
|
addr = bp->bio_data;
|
|
|
|
boff = bp->bio_offset;
|
|
|
|
|
|
|
|
/* Walk over the whole length of the request, we might split it up. */
|
|
|
|
while (bcount > 0) {
|
|
|
|
wp = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RAID5 plexes need special treatment, as a single write
|
|
|
|
* request involves several read/write sub-requests.
|
|
|
|
*/
|
|
|
|
if (p->org == GV_PLEX_RAID5) {
|
|
|
|
wp = g_malloc(sizeof(*wp), M_WAITOK | M_ZERO);
|
|
|
|
wp->bio = bp;
|
|
|
|
TAILQ_INIT(&wp->bits);
|
|
|
|
|
2004-09-30 12:57:35 +00:00
|
|
|
if (bp->bio_cflags & GV_BIO_REBUILD)
|
|
|
|
err = gv_rebuild_raid5(p, wp, bp, addr,
|
|
|
|
boff, bcount);
|
2004-11-26 12:01:00 +00:00
|
|
|
else if (bp->bio_cflags & GV_BIO_CHECK)
|
|
|
|
err = gv_check_raid5(p, wp, bp, addr,
|
|
|
|
boff, bcount);
|
2004-09-30 12:57:35 +00:00
|
|
|
else
|
|
|
|
err = gv_build_raid5_req(p, wp, bp, addr,
|
|
|
|
boff, bcount);
|
2004-09-18 13:44:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Building the sub-request failed, we probably need to
|
|
|
|
* clean up a lot.
|
|
|
|
*/
|
|
|
|
if (err) {
|
2008-10-26 17:20:37 +00:00
|
|
|
G_VINUM_LOGREQ(0, bp, "plex request failed.");
|
2004-09-18 13:44:43 +00:00
|
|
|
TAILQ_FOREACH_SAFE(bq, &wp->bits, queue, bq2) {
|
|
|
|
TAILQ_REMOVE(&wp->bits, bq, queue);
|
|
|
|
g_free(bq);
|
|
|
|
}
|
|
|
|
if (wp->waiting != NULL) {
|
|
|
|
if (wp->waiting->bio_cflags &
|
|
|
|
GV_BIO_MALLOC)
|
|
|
|
g_free(wp->waiting->bio_data);
|
|
|
|
g_destroy_bio(wp->waiting);
|
|
|
|
}
|
|
|
|
if (wp->parity != NULL) {
|
|
|
|
if (wp->parity->bio_cflags &
|
|
|
|
GV_BIO_MALLOC)
|
|
|
|
g_free(wp->parity->bio_data);
|
|
|
|
g_destroy_bio(wp->parity);
|
|
|
|
}
|
|
|
|
g_free(wp);
|
|
|
|
|
|
|
|
TAILQ_FOREACH_SAFE(wp, &p->packets, list, wp2) {
|
|
|
|
if (wp->bio == bp) {
|
|
|
|
TAILQ_REMOVE(&p->packets, wp,
|
|
|
|
list);
|
|
|
|
TAILQ_FOREACH_SAFE(bq,
|
|
|
|
&wp->bits, queue, bq2) {
|
|
|
|
TAILQ_REMOVE(&wp->bits,
|
|
|
|
bq, queue);
|
|
|
|
g_free(bq);
|
|
|
|
}
|
|
|
|
g_free(wp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cbp = bp->bio_driver1;
|
|
|
|
while (cbp != NULL) {
|
|
|
|
pbp = cbp->bio_caller1;
|
|
|
|
if (cbp->bio_cflags & GV_BIO_MALLOC)
|
|
|
|
g_free(cbp->bio_data);
|
|
|
|
g_destroy_bio(cbp);
|
|
|
|
cbp = pbp;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_io_deliver(bp, err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TAILQ_EMPTY(&wp->bits))
|
|
|
|
g_free(wp);
|
|
|
|
else if (wp->lockbase != -1)
|
|
|
|
TAILQ_INSERT_TAIL(&p->packets, wp, list);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Requests to concatenated and striped plexes go straight
|
|
|
|
* through.
|
|
|
|
*/
|
|
|
|
} else {
|
|
|
|
err = gv_plexbuffer(p, bp, addr, boff, bcount);
|
|
|
|
|
|
|
|
/* Building the sub-request failed. */
|
|
|
|
if (err) {
|
2008-10-26 17:20:37 +00:00
|
|
|
G_VINUM_LOGREQ(0, bp, "plex request failed.");
|
2004-09-18 13:44:43 +00:00
|
|
|
cbp = bp->bio_driver1;
|
|
|
|
while (cbp != NULL) {
|
|
|
|
pbp = cbp->bio_caller1;
|
|
|
|
g_destroy_bio(cbp);
|
|
|
|
cbp = pbp;
|
|
|
|
}
|
|
|
|
g_io_deliver(bp, err);
|
|
|
|
return;
|
|
|
|
}
|
2004-06-12 21:16:10 +00:00
|
|
|
}
|
2004-09-18 13:44:43 +00:00
|
|
|
|
|
|
|
/* Abuse bio_caller1 as linked list. */
|
|
|
|
pbp = bp->bio_driver1;
|
|
|
|
while (pbp->bio_caller1 != NULL)
|
|
|
|
pbp = pbp->bio_caller1;
|
|
|
|
bcount -= pbp->bio_length;
|
|
|
|
addr += pbp->bio_length;
|
|
|
|
boff += pbp->bio_length;
|
|
|
|
}
|
2004-06-12 21:16:10 +00:00
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
/* Fire off all sub-requests. */
|
|
|
|
pbp = bp->bio_driver1;
|
|
|
|
while (pbp != NULL) {
|
|
|
|
/*
|
|
|
|
* RAID5 sub-requests need to come in correct order, otherwise
|
|
|
|
* we trip over the parity, as it might be overwritten by
|
|
|
|
* another sub-request.
|
|
|
|
*/
|
|
|
|
if (pbp->bio_driver1 != NULL &&
|
|
|
|
gv_stripe_active(p, pbp)) {
|
2004-10-26 21:01:42 +00:00
|
|
|
/* Park the bio on the waiting queue. */
|
2004-09-18 13:44:43 +00:00
|
|
|
pbp->bio_cflags |= GV_BIO_ONHOLD;
|
|
|
|
mtx_lock(&p->bqueue_mtx);
|
2006-01-06 18:03:17 +00:00
|
|
|
bioq_disksort(p->wqueue, pbp);
|
2004-09-18 13:44:43 +00:00
|
|
|
mtx_unlock(&p->bqueue_mtx);
|
|
|
|
} else
|
|
|
|
g_io_request(pbp, pbp->bio_caller2);
|
|
|
|
pbp = pbp->bio_caller1;
|
2004-06-12 21:16:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
gv_plex_access(struct g_provider *pp, int dr, int dw, int de)
|
|
|
|
{
|
2008-12-27 14:32:39 +00:00
|
|
|
struct gv_plex *p;
|
2004-06-12 21:16:10 +00:00
|
|
|
struct g_geom *gp;
|
|
|
|
struct g_consumer *cp, *cp2;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
gp = pp->geom;
|
2008-12-27 14:32:39 +00:00
|
|
|
p = gp->softc;
|
|
|
|
KASSERT(p != NULL, ("NULL p"));
|
|
|
|
|
|
|
|
if (p->org == GV_PLEX_RAID5) {
|
|
|
|
if (dw > 0 && dr == 0)
|
|
|
|
dr = 1;
|
|
|
|
else if (dw < 0 && dr == 0)
|
|
|
|
dr = -1;
|
|
|
|
}
|
2004-06-12 21:16:10 +00:00
|
|
|
|
|
|
|
LIST_FOREACH(cp, &gp->consumer, consumer) {
|
|
|
|
error = g_access(cp, dr, dw, de);
|
|
|
|
if (error) {
|
|
|
|
LIST_FOREACH(cp2, &gp->consumer, consumer) {
|
|
|
|
if (cp == cp2)
|
|
|
|
break;
|
|
|
|
g_access(cp2, -dr, -dw, -de);
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
}
|
2005-01-21 18:24:20 +00:00
|
|
|
return (0);
|
2004-06-12 21:16:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct g_geom *
|
|
|
|
gv_plex_taste(struct g_class *mp, struct g_provider *pp, int flags __unused)
|
|
|
|
{
|
|
|
|
struct g_geom *gp;
|
2004-07-30 23:40:38 +00:00
|
|
|
struct g_consumer *cp, *cp2;
|
2004-06-12 21:16:10 +00:00
|
|
|
struct g_provider *pp2;
|
|
|
|
struct gv_plex *p;
|
|
|
|
struct gv_sd *s;
|
|
|
|
struct gv_softc *sc;
|
2004-07-30 23:40:38 +00:00
|
|
|
int error;
|
2004-06-12 21:16:10 +00:00
|
|
|
|
|
|
|
g_trace(G_T_TOPOLOGY, "gv_plex_taste(%s, %s)", mp->name, pp->name);
|
|
|
|
g_topology_assert();
|
|
|
|
|
|
|
|
/* We only want to attach to subdisks. */
|
|
|
|
if (strcmp(pp->geom->class->name, "VINUMDRIVE"))
|
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
/* Find the VINUM class and its associated geom. */
|
|
|
|
gp = find_vinum_geom();
|
|
|
|
if (gp == NULL)
|
|
|
|
return (NULL);
|
|
|
|
sc = gp->softc;
|
|
|
|
KASSERT(sc != NULL, ("gv_plex_taste: NULL sc"));
|
|
|
|
|
|
|
|
/* Find out which subdisk the offered provider corresponds to. */
|
|
|
|
s = pp->private;
|
|
|
|
KASSERT(s != NULL, ("gv_plex_taste: NULL s"));
|
|
|
|
|
|
|
|
/* Now find the correct plex where this subdisk belongs to. */
|
|
|
|
p = gv_find_plex(sc, s->plex);
|
2005-08-16 15:12:44 +00:00
|
|
|
if (p == NULL) {
|
2008-10-26 17:20:37 +00:00
|
|
|
G_VINUM_DEBUG(0, "%s: NULL p for '%s'", __func__, s->name);
|
2005-08-16 15:12:44 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
2004-06-12 21:16:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add this subdisk to this plex. Since we trust the on-disk
|
|
|
|
* configuration, we don't check the given value (should we?).
|
|
|
|
* XXX: shouldn't be done here
|
|
|
|
*/
|
|
|
|
gv_sd_to_plex(p, s, 0);
|
|
|
|
|
|
|
|
/* Now check if there's already a geom for this plex. */
|
|
|
|
gp = p->geom;
|
|
|
|
|
|
|
|
/* Yes, there is already a geom, so we just add the consumer. */
|
|
|
|
if (gp != NULL) {
|
2004-07-30 23:40:38 +00:00
|
|
|
cp2 = LIST_FIRST(&gp->consumer);
|
2004-06-12 21:16:10 +00:00
|
|
|
/* Need to attach a new consumer to this subdisk. */
|
|
|
|
cp = g_new_consumer(gp);
|
2004-07-30 23:40:38 +00:00
|
|
|
error = g_attach(cp, pp);
|
|
|
|
if (error) {
|
2008-10-26 17:20:37 +00:00
|
|
|
G_VINUM_DEBUG(0, "unable to attach consumer to %s",
|
2004-07-30 23:40:38 +00:00
|
|
|
pp->name);
|
|
|
|
g_destroy_consumer(cp);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
/* Adjust the access counts of the new consumer. */
|
|
|
|
if ((cp2 != NULL) && (cp2->acr || cp2->acw || cp2->ace)) {
|
|
|
|
error = g_access(cp, cp2->acr, cp2->acw, cp2->ace);
|
|
|
|
if (error) {
|
2008-10-26 17:20:37 +00:00
|
|
|
G_VINUM_DEBUG(0, "unable to set access counts"
|
|
|
|
" for consumer on %s", pp->name);
|
2004-07-30 23:40:38 +00:00
|
|
|
g_detach(cp);
|
|
|
|
g_destroy_consumer(cp);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
}
|
2004-06-12 21:16:10 +00:00
|
|
|
s->consumer = cp;
|
|
|
|
|
|
|
|
/* Adjust the size of the providers this plex has. */
|
|
|
|
LIST_FOREACH(pp2, &gp->provider, provider)
|
|
|
|
pp2->mediasize = p->size;
|
|
|
|
|
2004-07-31 21:34:21 +00:00
|
|
|
/* Update the size of the volume this plex is attached to. */
|
|
|
|
if (p->vol_sc != NULL)
|
|
|
|
gv_update_vol_size(p->vol_sc, p->size);
|
|
|
|
|
2005-01-19 14:08:16 +00:00
|
|
|
/*
|
2006-01-06 18:03:17 +00:00
|
|
|
* If necessary, create bio queues, queue mutex and a worker
|
|
|
|
* thread.
|
2005-01-19 14:08:16 +00:00
|
|
|
*/
|
2006-01-06 18:03:17 +00:00
|
|
|
if (p->bqueue == NULL) {
|
|
|
|
p->bqueue = g_malloc(sizeof(struct bio_queue_head),
|
|
|
|
M_WAITOK | M_ZERO);
|
|
|
|
bioq_init(p->bqueue);
|
|
|
|
}
|
|
|
|
if (p->wqueue == NULL) {
|
|
|
|
p->wqueue = g_malloc(sizeof(struct bio_queue_head),
|
|
|
|
M_WAITOK | M_ZERO);
|
|
|
|
bioq_init(p->wqueue);
|
|
|
|
}
|
2005-01-19 14:08:16 +00:00
|
|
|
if (mtx_initialized(&p->bqueue_mtx) == 0)
|
|
|
|
mtx_init(&p->bqueue_mtx, "gv_plex", NULL, MTX_DEF);
|
|
|
|
if (!(p->flags & GV_PLEX_THREAD_ACTIVE)) {
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_create(gv_plex_worker, p, NULL, 0, 0, "gv_p %s",
|
2005-01-19 14:08:16 +00:00
|
|
|
p->name);
|
|
|
|
p->flags |= GV_PLEX_THREAD_ACTIVE;
|
|
|
|
}
|
|
|
|
|
2004-06-12 21:16:10 +00:00
|
|
|
return (NULL);
|
|
|
|
|
|
|
|
/* We need to create a new geom. */
|
|
|
|
} else {
|
|
|
|
gp = g_new_geomf(mp, "%s", p->name);
|
|
|
|
gp->start = gv_plex_start;
|
|
|
|
gp->orphan = gv_plex_orphan;
|
|
|
|
gp->access = gv_plex_access;
|
|
|
|
gp->softc = p;
|
|
|
|
p->geom = gp;
|
|
|
|
|
2004-09-18 13:44:43 +00:00
|
|
|
TAILQ_INIT(&p->packets);
|
2006-01-06 18:03:17 +00:00
|
|
|
p->bqueue = g_malloc(sizeof(struct bio_queue_head),
|
|
|
|
M_WAITOK | M_ZERO);
|
|
|
|
bioq_init(p->bqueue);
|
|
|
|
p->wqueue = g_malloc(sizeof(struct bio_queue_head),
|
|
|
|
M_WAITOK | M_ZERO);
|
|
|
|
bioq_init(p->wqueue);
|
2004-09-18 13:44:43 +00:00
|
|
|
mtx_init(&p->bqueue_mtx, "gv_plex", NULL, MTX_DEF);
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_create(gv_plex_worker, p, NULL, 0, 0, "gv_p %s",
|
2004-09-18 13:44:43 +00:00
|
|
|
p->name);
|
|
|
|
p->flags |= GV_PLEX_THREAD_ACTIVE;
|
2004-06-12 21:16:10 +00:00
|
|
|
|
|
|
|
/* Attach a consumer to this provider. */
|
|
|
|
cp = g_new_consumer(gp);
|
|
|
|
g_attach(cp, pp);
|
|
|
|
s->consumer = cp;
|
|
|
|
|
|
|
|
/* Create a provider for the outside world. */
|
|
|
|
pp2 = g_new_providerf(gp, "gvinum/plex/%s", p->name);
|
|
|
|
pp2->mediasize = p->size;
|
|
|
|
pp2->sectorsize = pp->sectorsize;
|
|
|
|
p->provider = pp2;
|
|
|
|
g_error_provider(pp2, 0);
|
|
|
|
return (gp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
gv_plex_destroy_geom(struct gctl_req *req, struct g_class *mp,
|
|
|
|
struct g_geom *gp)
|
|
|
|
{
|
|
|
|
struct gv_plex *p;
|
|
|
|
|
|
|
|
g_trace(G_T_TOPOLOGY, "gv_plex_destroy_geom: %s", gp->name);
|
|
|
|
g_topology_assert();
|
|
|
|
|
|
|
|
p = gp->softc;
|
|
|
|
|
|
|
|
KASSERT(p != NULL, ("gv_plex_destroy_geom: null p of '%s'", gp->name));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a RAID5 plex, check if its worker thread is still active
|
|
|
|
* and signal it to self destruct.
|
|
|
|
*/
|
2004-09-13 17:44:47 +00:00
|
|
|
gv_kill_plex_thread(p);
|
2004-06-12 21:16:10 +00:00
|
|
|
/* g_free(sc); */
|
|
|
|
g_wither_geom(gp, ENXIO);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define VINUMPLEX_CLASS_NAME "VINUMPLEX"
|
|
|
|
|
|
|
|
static struct g_class g_vinum_plex_class = {
|
|
|
|
.name = VINUMPLEX_CLASS_NAME,
|
2004-08-08 07:57:53 +00:00
|
|
|
.version = G_VERSION,
|
2004-06-12 21:16:10 +00:00
|
|
|
.taste = gv_plex_taste,
|
|
|
|
.destroy_geom = gv_plex_destroy_geom,
|
|
|
|
};
|
|
|
|
|
|
|
|
DECLARE_GEOM_CLASS(g_vinum_plex_class, g_vinum_plex);
|