d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

First commit of the GEOM subsystem to make it easier for people to

Browse Source 
test and play with this.

This is not yet production quality and should be run only on dedicated
test boxes.

For people who want to develop transformations for GEOM there exist a
set of shims to run geom in userland (ask phk@freebsd.org).

Reports of all kinds to: phk@freebsd.org
Please include in report:
        dmesg
        sysctl debug.geomdot
        sysctl debug.geomconf

Known significant limitations:
        no kernel dump facility.
        ioctls severely restricted.

Sponsored by:   DARPA, NAI Labs
This commit is contained in:
Poul-Henning Kamp 2002-03-11 21:42:35 +00:00
parent fe86c44885
commit dd84a43c1d
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=92108
13 changed files with 3690 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

290
sys/geom/geom.h Normal file
View File

@ -0,0 +1,290 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/sx.h>
#include <sys/queue.h>
#ifndef _KERNEL
/*
* The GEOM subsystem makes a few concessions in order to be able to run as a
* user-land simulation as well as a kernel component.
*/
#include <geom/geom_sim.h>
#endif
struct g_method;
struct g_geom;
struct g_consumer;
struct g_provider;
struct g_event;
struct thread;
struct bio;
struct sbuf;
LIST_HEAD(method_list_head, g_method);
TAILQ_HEAD(g_tailq_head, g_geom);
TAILQ_HEAD(event_tailq_head, g_event);
extern struct g_tailq_head geoms;
extern struct event_tailq_head events;
extern int g_debugflags;
#define G_METHOD_INITSTUFF { 0, 0 }, { 0 }, 0
typedef struct g_geom * g_create_geom_t (struct g_method *mp,
struct g_provider *pp, char *name);
typedef struct g_geom * g_taste_t (struct g_method *, struct g_provider *,
struct thread *tp, int flags);
#define G_TF_NORMAL 0
#define G_TF_INSIST 1
#define G_TF_TRANSPARENT 2
typedef int g_access_t (struct g_provider *, int, int, int);
/* XXX: not sure about the thread arg */
typedef void g_orphan_t (struct g_consumer *, struct thread *);
typedef void g_start_t (struct bio *);
typedef void g_spoiled_t (struct g_consumer *);
typedef void g_dumpconf_t (struct sbuf *, char *indent, struct g_geom *,
struct g_consumer *, struct g_provider *);
/*
* The g_method structure describes a transformation method. In other words
* all BSD disklabel handlers share one g_method, all MBR handlers share
* one common g_method and so on.
* Certain operations are instantiated on the method, most notably the
* taste and create_geom functions.
* XXX: should access and orphan go into g_geom ?
* XXX: would g_class be a better and less confusing name ?
*/
struct g_method {
char *name;
g_taste_t *taste;
g_access_t *access;
g_orphan_t *orphan;
g_create_geom_t *create_geom;
LIST_ENTRY(g_method) method;
LIST_HEAD(,g_geom) geom;
struct g_event *event;
};
/*
* The g_geom is an instance of a g_method.
*/
struct g_geom {
char *name;
struct g_method *method;
LIST_ENTRY(g_geom) geom;
LIST_HEAD(,g_consumer) consumer;
LIST_HEAD(,g_provider) provider;
TAILQ_ENTRY(g_geom) geoms; /* XXX: better name */
int rank;
g_start_t *start;
g_spoiled_t *spoiled;
g_dumpconf_t *dumpconf;
void *softc;
struct g_event *event;
unsigned flags;
#define G_GEOM_WITHER 1
};
/*
* The g_bioq is a queue of struct bio's.
* XXX: possibly collection point for statistics.
* XXX: should (possibly) be collapsed with sys/bio.h::bio_queue_head.
*/
struct g_bioq {
TAILQ_HEAD(, bio) bio_queue;
struct mtx bio_queue_lock;
int bio_queue_length;
};
/*
* A g_consumer is an attachment point for a g_provider. One g_consumer
* can only be attached to one g_provider, but multiple g_consumers
* can be attached to one g_provider.
*/
struct g_consumer {
struct g_geom *geom;
LIST_ENTRY(g_consumer) consumer;
struct g_provider *provider;
LIST_ENTRY(g_consumer) consumers; /* XXX: better name */
int acr, acw, ace;
struct g_event *event;
int biocount;
int spoiled;
};
/*
* A g_provider is a "logical disk".
*/
struct g_provider {
char *name;
LIST_ENTRY(g_provider) provider;
struct g_geom *geom;
LIST_HEAD(,g_consumer) consumers;
int acr, acw, ace;
int error;
struct g_event *event;
TAILQ_ENTRY(g_provider) orphan;
int index;
};
/*
* Various internal actions are tracked by tagging g_event[s] onto
* an internal eventqueue.
*/
enum g_events {
EV_NEW_METHOD, /* method */
EV_NEW_PROVIDER, /* provider */
EV_SPOILED, /* provider, consumer */
EV_LAST
};
struct g_event {
enum g_events event;
TAILQ_ENTRY(g_event) events;
struct g_method *method;
struct g_geom *geom;
struct g_provider *provider;
struct g_consumer *consumer;
};
/* geom_dump.c */
struct sbuf * g_conf(void);
struct sbuf * g_conf_specific(struct g_method *mp, struct g_geom *gp, struct g_provider *pp, struct g_consumer *cp);
struct sbuf * g_confdot(void);
void g_hexdump(void *ptr, int length);
void g_trace(int level, char *, ...);
# define G_T_TOPOLOGY 1
# define G_T_BIO 2
# define G_T_ACCESS 4
/* geom_event.c */
void g_event_init(void);
void g_orphan_provider(struct g_provider *pp, int error);
void g_post_event(enum g_events ev, struct g_method *mp, struct g_geom *gp, struct g_provider *pp, struct g_consumer *cp);
void g_rattle(void);
void g_run_events(struct thread *tp);
void g_silence(void);
/* geom_subr.c */
int g_access_abs(struct g_consumer *cp, int read, int write, int exclusive);
int g_access_rel(struct g_consumer *cp, int read, int write, int exclusive);
void g_add_method(struct g_method *mp);
int g_attach(struct g_consumer *cp, struct g_provider *pp);
struct g_geom *g_create_geomf(char *method, struct g_provider *, char *fmt, ...);
void g_destroy_consumer(struct g_consumer *cp);
void g_destroy_geom(struct g_geom *pp);
void g_destroy_provider(struct g_provider *pp);
void g_dettach(struct g_consumer *cp);
void g_error_provider(struct g_provider *pp, int error);
int g_haveattr(struct bio *bp, char *attribute, void *val, int len);
int g_haveattr_int(struct bio *bp, char *attribute, int val);
int g_haveattr_off_t(struct bio *bp, char *attribute, off_t val);
struct g_geom * g_insert_geom(char *method, struct g_consumer *cp);
extern struct method_list_head g_methods;
struct g_consumer * g_new_consumer(struct g_geom *gp);
struct g_geom * g_new_geomf(struct g_method *mp, char *fmt, ...);
struct g_provider * g_new_providerf(struct g_geom *gp, char *fmt, ...);
void g_spoil(struct g_provider *pp, struct g_consumer *cp);
int g_std_access(struct g_provider *pp, int dr, int dw, int de);
void g_std_done(struct bio *bp);
void g_std_spoiled(struct g_consumer *cp);
extern char *g_wait_event, *g_wait_sim, *g_wait_up, *g_wait_down;
/* geom_io.c */
struct bio * g_clone_bio(struct bio *);
void g_destroy_bio(struct bio *);
void g_io_deliver(struct bio *bp);
int g_io_getattr(char *attr, struct g_consumer *cp, int *len, void *ptr, struct thread *tp);
void g_io_init(void);
void g_io_request(struct bio *bp, struct g_consumer *cp);
void g_io_schedule_down(struct thread *tp);
void g_io_schedule_up(struct thread *tp);
int g_io_setattr(char *attr, struct g_consumer *cp, int len, void *ptr, struct thread *tp);
struct bio *g_new_bio(void);
void * g_read_data(struct g_consumer *cp, off_t offset, off_t length, int *error);
/* geom_kern.c / geom_kernsim.c */
void g_init(void);
#ifdef _KERNEL
MALLOC_DECLARE(M_GEOM);
static __inline void *
g_malloc(int size, int flags)
{
void *p;
mtx_lock(&Giant);
p = malloc(size, M_GEOM, flags);
mtx_unlock(&Giant);
return (p);
}
static __inline void
g_free(void *ptr)
{
mtx_lock(&Giant);
free(ptr, M_GEOM);
mtx_unlock(&Giant);
}
extern struct sx topology_lock;
#define g_topology_lock() sx_xlock(&topology_lock)
#define g_topology_unlock() sx_xunlock(&topology_lock)
#define g_topology_assert() sx_assert(&topology_lock, SX_XLOCKED)
#define DECLARE_GEOM_METHOD(method, name) \
static void \
name##init(void) \
{ \
mtx_unlock(&Giant); \
g_add_method(&method); \
mtx_lock(&Giant); \
} \
SYSINIT(name, SI_SUB_PSEUDO, SI_ORDER_FIRST, name##init, NULL);
#endif

257
sys/geom/geom_bsd.c Normal file
View File

@ -0,0 +1,257 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#ifndef _KERNEL
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <err.h>
#else
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/bio.h>
#include <sys/malloc.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#endif
#include <sys/errno.h>
#include <sys/disklabel.h>
#include <geom/geom.h>
#include <geom/geom_slice.h>
#define BSD_METHOD_NAME "BSD-method"
struct g_bsd_softc {
struct disklabel ondisk;
struct disklabel inram;
};
static void
ondisk2inram(struct g_bsd_softc *sc)
{
struct partition *ppp;
unsigned offset;
int i;
sc->inram = sc->ondisk;
offset = sc->inram.d_partitions[RAW_PART].p_offset;
for (i = 0; i < 8; i++) {
ppp = &sc->inram.d_partitions[i];
if (ppp->p_offset >= offset)
ppp->p_offset -= offset;
}
sc->inram.d_checksum = 0;
sc->inram.d_checksum = dkcksum(&sc->inram);
}
static int
g_bsd_start(struct bio *bp)
{
struct g_geom *gp;
struct g_bsd_softc *ms;
struct g_slicer *gsp;
struct partinfo pi;
gp = bp->bio_to->geom;
gsp = gp->softc;
ms = gsp->softc;
if (g_haveattr(bp, "IOCTL::DIOCGDINFO",
&ms->inram,
sizeof ms->inram))
return (1);
if (!strcmp(bp->bio_attribute, "IOCTL::DIOCGPART")) {
pi.disklab = &ms->inram;
pi.part = &ms->inram.d_partitions[bp->bio_to->index];
if (g_haveattr(bp, "IOCTL::DIOCGPART", &pi, sizeof pi))
return (1);
}
return (0);
}
static void
g_bsd_dumpconf(struct sbuf *sb, char *indent, struct g_geom *gp, struct g_consumer *cp __unused, struct g_provider *pp)
{
#if 0
struct g_mbr_softc *ms;
struct g_slicer *gsp;
gsp = gp->softc;
ms = gsp->softc;
if (pp != NULL) {
sbuf_printf(sb, "%s<type>%d</type>\n",
indent, ms->type[pp->index]);
}
#endif
g_slice_dumpconf(sb, indent, gp, cp, pp);
}
static struct g_geom *
g_bsd_taste(struct g_method *mp, struct g_provider *pp, struct thread *tp, int flags)
{
struct g_geom *gp;
struct g_consumer *cp;
struct g_provider *pp2;
int error, i, j, npart;
u_char *buf;
struct g_bsd_softc *ms;
struct disklabel *dl;
u_int secsize;
u_int fwsectors, fwheads;
off_t mediasize;
struct partition *ppp, *ppr;
g_trace(G_T_TOPOLOGY, "bsd_taste(%s,%s)", mp->name, pp->name);
g_topology_assert();
if (flags == G_TF_NORMAL &&
!strcmp(pp->geom->method->name, BSD_METHOD_NAME))
return (NULL);
gp = g_slice_new(mp, 8, pp, &cp, &ms, sizeof *ms, g_bsd_start);
if (gp == NULL)
return (NULL);
g_topology_unlock();
gp->dumpconf = g_bsd_dumpconf;
npart = 0;
while (1) { /* a trick to allow us to use break */
j = sizeof i;
error = g_io_getattr("MBR::type", cp, &j, &i, tp);
if (!error && i != 165 && flags == G_TF_NORMAL)
break;
j = sizeof secsize;
error = g_io_getattr("GEOM::sectorsize", cp, &j, &secsize, tp);
if (error) {
secsize = 512;
printf("g_bsd_taste: error %d Sectors are %d bytes\n",
error, secsize);
}
j = sizeof mediasize;
error = g_io_getattr("GEOM::mediasize", cp, &j, &mediasize, tp);
if (error) {
mediasize = 0;
printf("g_error %d Mediasize is %lld bytes\n",
error, mediasize);
}
buf = g_read_data(cp, secsize * LABELSECTOR, secsize, &error);
if (buf == NULL || error != 0)
break;
bcopy(buf, &ms->ondisk, sizeof(ms->ondisk));
dl = &ms->ondisk;
g_free(buf);
if (dl->d_magic != DISKMAGIC)
break;
if (dl->d_magic2 != DISKMAGIC)
break;
if (dkcksum(dl) != 0)
break;
if (bootverbose)
g_hexdump(dl, sizeof(*dl));
if (dl->d_secsize < secsize)
break;
if (dl->d_secsize > secsize)
secsize = dl->d_secsize;
ppr = &dl->d_partitions[2];
for (i = 0; i < 8; i++) {
ppp = &dl->d_partitions[i];
if (ppp->p_size == 0)
continue;
npart++;
pp2 = g_slice_addslice(gp, i,
((off_t)(ppp->p_offset - ppr->p_offset)) << 9ULL,
((off_t)ppp->p_size) << 9ULL,
"%s%c", pp->name, 'a' + i);
g_error_provider(pp2, 0);
}
ondisk2inram(ms);
break;
}
if (npart == 0 && (
(flags == G_TF_INSIST && mediasize != 0) ||
(flags == G_TF_TRANSPARENT))) {
dl = &ms->ondisk;
bzero(dl, sizeof *dl);
dl->d_magic = DISKMAGIC;
dl->d_magic2 = DISKMAGIC;
ppp = &dl->d_partitions[RAW_PART];
ppp->p_offset = 0;
ppp->p_size = mediasize / secsize;
dl->d_npartitions = MAXPARTITIONS;
dl->d_interleave = 1;
dl->d_secsize = secsize;
dl->d_rpm = 3600;
j = sizeof fwsectors;
error = g_io_getattr("GEOM::fwsectors", cp, &j, &fwsectors, tp);
if (error)
dl->d_nsectors = 32;
else
dl->d_nsectors = fwsectors;
error = g_io_getattr("GEOM::fwheads", cp, &j, &fwheads, tp);
if (error)
dl->d_ntracks = 64;
else
dl->d_ntracks = fwheads;
dl->d_secpercyl = dl->d_nsectors * dl->d_ntracks;
dl->d_ncylinders = ppp->p_size / dl->d_secpercyl;
dl->d_secperunit = ppp->p_size;
dl->d_checksum = 0;
dl->d_checksum = dkcksum(dl);
ms->inram = ms->ondisk;
pp2 = g_slice_addslice(gp, RAW_PART,
0, mediasize, "%s%c", pp->name, 'a' + RAW_PART);
g_error_provider(pp2, 0);
npart = 1;
}
g_topology_lock();
error = g_access_rel(cp, -1, 0, 0);
if (npart > 0)
return (gp);
g_std_spoiled(cp);
return (NULL);
}
static struct g_method g_bsd_method = {
BSD_METHOD_NAME,
g_bsd_taste,
g_slice_access,
g_slice_orphan,
NULL,
G_METHOD_INITSTUFF
};
DECLARE_GEOM_METHOD(g_bsd_method, g_bsd);

382
sys/geom/geom_dev.c Normal file
View File

@ -0,0 +1,382 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/bio.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/disk.h>
#include <sys/fcntl.h>
#include <geom/geom.h>
#define CDEV_MAJOR 4
static d_open_t g_dev_open;
static d_close_t g_dev_close;
static d_strategy_t g_dev_strategy;
static d_ioctl_t g_dev_ioctl;
static d_psize_t g_dev_psize;
static struct cdevsw g_dev_cdevsw = {
/* open */ g_dev_open,
/* close */ g_dev_close,
/* read */ physread,
/* write */ physwrite,
/* ioctl */ g_dev_ioctl,
/* poll */ nopoll,
/* mmap */ nommap,
/* strategy */ g_dev_strategy,
/* name */ "g_dev",
/* maj */ CDEV_MAJOR,
/* dump */ nodump,
/* psize */ g_dev_psize,
/* flags */ D_DISK | D_CANFREE | D_TRACKCLOSE,
};
static g_taste_t g_dev_taste;
static g_orphan_t g_dev_orphan;
static struct g_method g_dev_method = {
"DEV-method",
g_dev_taste,
NULL,
g_dev_orphan,
NULL,
G_METHOD_INITSTUFF
};
static void
g_dev_clone(void *arg, char *name, int namelen, dev_t *dev)
{
struct g_geom *gp;
if (*dev != NODEV)
return;
g_trace(G_T_TOPOLOGY, "g_dev_clone(%s)", name);
g_rattle();
/* XXX: can I drop Giant here ??? */
/* g_topology_lock(); */
LIST_FOREACH(gp, &g_dev_method.geom, geom) {
if (strcmp(gp->name, name))
continue;
*dev = gp->softc;
g_trace(G_T_TOPOLOGY, "g_dev_clone(%s) = %p", name, *dev);
return;
}
/* g_topology_unlock(); */
return;
}
static void
g_dev_register_cloner(void *foo __unused)
{
static int once;
if (!once) {
if (!once)
EVENTHANDLER_REGISTER(dev_clone, g_dev_clone, 0, 1000);
once++;
}
}
SYSINIT(geomdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE,g_dev_register_cloner,NULL);
static struct g_geom *
g_dev_taste(struct g_method *mp, struct g_provider *pp, struct thread *tp __unused, int insist __unused)
{
struct g_geom *gp;
struct g_consumer *cp;
static int unit;
#if 1
u_int secsize;
off_t mediasize;
int error, j;
#endif
dev_t dev;
g_trace(G_T_TOPOLOGY, "dev_taste(%s,%s)", mp->name, pp->name);
g_topology_assert();
LIST_FOREACH(cp, &pp->consumers, consumers)
if (cp->geom->method == mp)
return (NULL);
gp = g_new_geomf(mp, pp->name);
cp = g_new_consumer(gp);
g_attach(cp, pp);
#if 1
error = g_access_rel(cp, 1, 0, 0);
g_topology_unlock();
if (!error) {
j = sizeof secsize;
error = g_io_getattr("GEOM::sectorsize", cp, &j, &secsize, tp);
if (error) {
secsize = 512;
printf("g_bsd_taste: error %d Sectors are %d bytes\n",
error, secsize);
}
j = sizeof mediasize;
error = g_io_getattr("GEOM::mediasize", cp, &j, &mediasize, tp);
if (error) {
mediasize = 0;
printf("g_error %d Mediasize is %lld bytes\n",
error, mediasize);
}
g_topology_lock();
g_access_rel(cp, -1, 0, 0);
g_topology_unlock();
} else {
secsize = 512;
mediasize = 0;
}
#else
g_topology_unlock();
#endif
mtx_lock(&Giant);
#if 1
if (mediasize != 0)
printf("GEOM: \"%s\" %lld bytes in %lld sectors of %u bytes\n",
pp->name, mediasize, mediasize / secsize, secsize);
else
printf("GEOM: \"%s\" (size unavailable)\n", pp->name);
#endif
dev = make_dev(&g_dev_cdevsw, unit++,
UID_ROOT, GID_WHEEL, 0600, gp->name);
gp->softc = dev;
dev->si_drv1 = gp;
dev->si_drv2 = cp;
mtx_unlock(&Giant);
g_topology_lock();
return (gp);
}
static int
g_dev_open(dev_t dev, int flags, int fmt, struct thread *td)
{
struct g_geom *gp;
struct g_consumer *cp;
int error, r, w, e;
gp = dev->si_drv1;
cp = dev->si_drv2;
if (gp == NULL || cp == NULL)
return(ENXIO);
g_trace(G_T_ACCESS, "g_dev_open(%s, %d, %d, %p)",
gp->name, flags, fmt, td);
mtx_unlock(&Giant);
g_topology_lock();
g_silence();
r = flags & FREAD ? 1 : 0;
w = flags & FWRITE ? 1 : 0;
e = flags & O_EXCL ? 1 : 0;
error = g_access_rel(cp, r, w, e);
g_topology_unlock();
mtx_lock(&Giant);
g_rattle();
return(error);
}
static int
g_dev_close(dev_t dev, int flags, int fmt, struct thread *td)
{
struct g_geom *gp;
struct g_consumer *cp;
int error, r, w, e;
gp = dev->si_drv1;
cp = dev->si_drv2;
if (gp == NULL || cp == NULL)
return(ENXIO);
g_trace(G_T_ACCESS, "g_dev_close(%s, %d, %d, %p)",
gp->name, flags, fmt, td);
mtx_unlock(&Giant);
g_topology_lock();
g_silence();
r = flags & FREAD ? -1 : 0;
w = flags & FWRITE ? -1 : 0;
e = flags & O_EXCL ? -1 : 0;
error = g_access_rel(cp, r, w, e);
g_topology_unlock();
mtx_lock(&Giant);
g_rattle();
return (error);
}
static int
g_dev_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
{
struct g_geom *gp;
struct g_consumer *cp;
char *nm;
int i, error;
gp = dev->si_drv1;
cp = dev->si_drv2;
error = 0;
mtx_unlock(&Giant);
switch (cmd) {
case DIOCGDINFO: nm = "IOCTL::DIOCGDINFO"; break;
case DIOCGDVIRGIN: nm = "IOCTL::DIOCGDVIRGIN"; break;
case DIOCGPART: nm = "IOCTL::DIOCGPART"; break;
default: nm = "?"; break;
}
i = IOCGROUP(cmd);
if (*nm == '?') {
printf("IOCTL(0x%lx) \"%s\"", cmd, gp->name);
if (i > ' ' && i <= '~')
printf(" '%c'", (int)IOCGROUP(cmd));
else
printf(" 0x%lx", IOCGROUP(cmd));
printf("/%ld ", cmd & 0xff);
if (cmd & IOC_IN)
printf("I");
if (cmd & IOC_OUT)
printf("O");
printf("(%ld)", IOCPARM_LEN(cmd));
printf(" \"%s\"\n", nm);
error = ENOIOCTL;
}
if (error == 0) {
i = IOCPARM_LEN(cmd);
error = g_io_getattr(nm, cp, &i, data, td);
if (error != 0 && cmd == DIOCGDVIRGIN) {
g_topology_lock();
gp = g_create_geomf("BSD-method", cp->provider, NULL);
g_topology_unlock();
}
}
mtx_lock(&Giant);
g_rattle();
if (error == ENOIOCTL)
error = ENOTTY;
return (error);
}
static int
g_dev_psize(dev_t dev)
{
struct g_consumer *cp;
int i, error;
off_t mediasize;
cp = dev->si_drv2;
i = sizeof mediasize;
error = g_io_getattr("GEOM::mediasize", cp, &i, &mediasize, NULL);
if (error)
return (-1);
return (mediasize >> DEV_BSHIFT);
}
static void
g_dev_done(struct bio *bp2)
{
struct bio *bp;
bp = bp2->bio_linkage;
bp->bio_error = bp2->bio_error;
if (bp->bio_error != 0) {
g_trace(G_T_BIO, "g_dev_done(%p) had error %d",
bp2, bp->bio_error);
bp->bio_flags |= BIO_ERROR;
} else {
g_trace(G_T_BIO, "g_dev_done(%p/%p) resid %ld completed %lld",
bp2, bp, bp->bio_resid, bp2->bio_completed);
}
bp->bio_resid = bp->bio_bcount - bp2->bio_completed;
g_destroy_bio(bp2);
mtx_lock(&Giant);
biodone(bp);
mtx_unlock(&Giant);
}
static void
g_dev_strategy(struct bio *bp)
{
struct g_geom *gp;
struct g_consumer *cp;
struct bio *bp2;
dev_t dev;
mtx_unlock(&Giant);
dev = bp->bio_dev;
gp = dev->si_drv1;
cp = dev->si_drv2;
bp2 = g_clone_bio(bp);
bp2->bio_offset = (off_t)bp->bio_blkno << DEV_BSHIFT;
bp2->bio_length = (off_t)bp->bio_bcount;
bp2->bio_done = g_dev_done;
g_trace(G_T_BIO,
"g_dev_strategy(%p/%p) offset %lld length %lld data %p cmd %d",
bp, bp2, bp->bio_offset, bp2->bio_length, bp2->bio_data,
bp2->bio_cmd);
g_io_request(bp2, cp);
mtx_lock(&Giant);
}
static void
g_dev_orphan(struct g_consumer *cp, struct thread *tp)
{
struct g_geom *gp;
dev_t dev;
gp = cp->geom;
g_trace(G_T_TOPOLOGY, "g_dev_orphan(%p(%s))", cp, gp->name);
g_topology_assert();
if (cp->biocount > 0)
return;
dev = gp->softc;
destroy_dev(dev);
if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0)
g_access_rel(cp, -cp->acr, -cp->acw, -cp->ace);
g_dettach(cp);
g_destroy_consumer(cp);
g_destroy_geom(gp);
}
DECLARE_GEOM_METHOD(g_dev_method, g_dev)

232
sys/geom/geom_disk.c Normal file
View File

@ -0,0 +1,232 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include "opt_geom.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/sysctl.h>
#include <sys/bio.h>
#include <sys/conf.h>
#include <sys/disk.h>
#include <sys/malloc.h>
#include <sys/sysctl.h>
#include <machine/md_var.h>
#include <sys/ctype.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <geom/geom.h>
static g_access_t g_disk_access;
struct g_method g_disk_method = {
"DISK-method",
NULL,
g_disk_access,
NULL,
NULL,
{ 0, 0 },
{ 0 }
};
static int
g_disk_access(struct g_provider *pp, int r, int w, int e)
{
struct disk *dp;
dev_t dev;
int error;
g_trace(G_T_ACCESS, "g_disk_access(%s, %d, %d, %d)",
pp->name, r, w, e);
g_topology_assert();
r += pp->acr;
w += pp->acw;
e += pp->ace;
dp = pp->geom->softc;
dev = dp->d_dev;
if ((pp->acr + pp->acw + pp->ace) == 0 && (r + w + e) > 0) {
mtx_lock(&Giant);
error = devsw(dev)->d_open(dev, 3, 0, NULL);
if (error != 0)
printf("Opened disk %s -> %d\n", pp->name, error);
mtx_unlock(&Giant);
} else if ((pp->acr + pp->acw + pp->ace) > 0 && (r + w + e) == 0) {
mtx_lock(&Giant);
error = devsw(dev)->d_close(dev, 3, 0, NULL);
if (error != 0)
printf("Closed disk %s -> %d\n", pp->name, error);
mtx_unlock(&Giant);
} else {
error = 0;
}
return (error);
}
static void
g_disk_done(struct bio *bp)
{
mtx_unlock(&Giant);
bp->bio_completed = bp->bio_length - bp->bio_resid;
g_std_done(bp);
mtx_lock(&Giant);
}
static void
g_disk_start(struct bio *bp)
{
struct bio *bp2;
dev_t dev;
struct disk *dp;
dp = bp->bio_to->geom->softc;
dev = dp->d_dev;
switch(bp->bio_cmd) {
case BIO_READ:
case BIO_WRITE:
bp2 = g_clone_bio(bp);
bp2->bio_done = g_disk_done;
bp2->bio_blkno = bp2->bio_offset >> DEV_BSHIFT;
bp2->bio_pblkno = bp2->bio_blkno;
bp2->bio_bcount = bp2->bio_length;
bp2->bio_dev = dev;
mtx_lock(&Giant);
devsw(dev)->d_strategy(bp2);
mtx_unlock(&Giant);
break;
case BIO_GETATTR:
if (g_haveattr_int(bp, "GEOM::sectorsize",
dp->d_label.d_secsize))
return;
if (g_haveattr_int(bp, "GEOM::fwsectors",
dp->d_label.d_nsectors))
return;
if (g_haveattr_int(bp, "GEOM::fwheads",
dp->d_label.d_ntracks))
return;
if (g_haveattr_int(bp, "GEOM::fwcylinders",
dp->d_label.d_ncylinders))
return;
if (g_haveattr_off_t(bp, "GEOM::mediasize",
dp->d_label.d_secsize * (off_t)dp->d_label.d_secperunit))
return;
bp->bio_error = ENOIOCTL;
g_io_deliver(bp);
return;
default:
bp->bio_error = EOPNOTSUPP;
g_io_deliver(bp);
return;
}
}
dev_t
disk_create(int unit, struct disk *dp, int flags, struct cdevsw *cdevsw, struct cdevsw *proto)
{
static int once;
struct g_geom *gp;
struct g_provider *pp;
dev_t dev;
mtx_unlock(&Giant);
if (!once) {
g_add_method(&g_disk_method);
once++;
}
dev = g_malloc(sizeof *dev, M_WAITOK | M_ZERO);
dp->d_dev = dev;
dev->si_devsw = cdevsw;
dev->si_disk = dp;
dev->si_udev = dkmakeminor(unit, WHOLE_DISK_SLICE, RAW_PART);
g_topology_lock();
gp = g_new_geomf(&g_disk_method, "%s%d", cdevsw->d_name, unit);
gp->start = g_disk_start;
gp->softc = dp;
dp->d_softc = gp;
pp = g_new_providerf(gp, "%s", gp->name);
g_error_provider(pp, 0);
g_topology_unlock();
mtx_lock(&Giant);
return (dev);
}
void disk_dev_synth(dev_t dev);
void
disk_dev_synth(dev_t dev)
{
return;
}
void
disk_destroy(dev_t dev)
{
struct disk *dp;
struct g_geom *gp;
dp = dev->si_disk;
gp = dp->d_softc;
g_free(dev);
gp->flags |= G_GEOM_WITHER;
g_orphan_provider(LIST_FIRST(&gp->provider), ENXIO);
}
void
disk_invalidate (struct disk *disk)
{
}
int
disk_dumpcheck(dev_t dev, u_int *count, u_int *blkno, u_int *secsize)
{
return (ENXIO);
}
SYSCTL_INT(_debug_sizeof, OID_AUTO, disklabel, CTLFLAG_RD,
0, sizeof(struct disklabel), "sizeof(struct disklabel)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, diskslices, CTLFLAG_RD,
0, sizeof(struct diskslices), "sizeof(struct diskslices)");
SYSCTL_INT(_debug_sizeof, OID_AUTO, disk, CTLFLAG_RD,
0, sizeof(struct disk), "sizeof(struct disk)");

275
sys/geom/geom_dump.c Normal file
View File

@ -0,0 +1,275 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/sbuf.h>
#ifndef _KERNEL
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <err.h>
#else
#include <sys/systm.h>
#include <sys/malloc.h>
#endif
#include <machine/stdarg.h>
#include <geom/geom.h>
static void
g_confdot_consumer(struct sbuf *sb, struct g_consumer *cp)
{
sbuf_printf(sb, "z%p [label=\"r%dw%de%d\\nbio #%d\"];\n",
cp, cp->acr, cp->acw, cp->ace, cp->biocount);
if (cp->provider)
sbuf_printf(sb, "z%p -> z%p;\n", cp, cp->provider);
}
static void
g_confdot_provider(struct sbuf *sb, struct g_provider *pp)
{
sbuf_printf(sb, "z%p [shape=hexagon,label=\"%s\\nr%dw%de%d\\nerr#%d\"];\n",
pp, pp->name, pp->acr, pp->acw, pp->ace, pp->error);
}
static void
g_confdot_geom(struct sbuf *sb, struct g_geom *gp)
{
struct g_consumer *cp;
struct g_provider *pp;
sbuf_printf(sb, "z%p [shape=box,label=\"%s\\n%s\\nr#%d\"];\n",
gp, gp->method->name, gp->name, gp->rank);
LIST_FOREACH(cp, &gp->consumer, consumer) {
g_confdot_consumer(sb, cp);
sbuf_printf(sb, "z%p -> z%p;\n", gp, cp);
}
LIST_FOREACH(pp, &gp->provider, provider) {
g_confdot_provider(sb, pp);
sbuf_printf(sb, "z%p -> z%p;\n", pp, gp);
}
}
static void
g_confdot_method(struct sbuf *sb, struct g_method *mp)
{
struct g_geom *gp;
LIST_FOREACH(gp, &mp->geom, geom)
g_confdot_geom(sb, gp);
}
struct sbuf *
g_confdot(void)
{
struct g_method *mp;
struct sbuf *sb;
sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
sbuf_clear(sb);
sbuf_printf(sb, "digraph geom {\n");
LIST_FOREACH(mp, &g_methods, method)
g_confdot_method(sb, mp);
sbuf_printf(sb, "};\n");
sbuf_finish(sb);
return (sb);
}
static void
g_conf_consumer(struct sbuf *sb, struct g_consumer *cp)
{
sbuf_printf(sb, "\t<consumer>\n");
sbuf_printf(sb, "\t <ref>%p</ref>\n", cp);
sbuf_printf(sb, "\t <geom><ref>%p</ref></geom>\n", cp->geom);
sbuf_printf(sb, "\t <provider><ref>%p</ref></provider>\n", cp->provider);
sbuf_printf(sb, "\t <mode>r%dw%de%d</mode>\n",
cp->acr, cp->acw, cp->ace);
if (cp->geom->dumpconf) {
sbuf_printf(sb, "\t <config>\n");
cp->geom->dumpconf(sb, "\t ", cp->geom, cp, NULL);
sbuf_printf(sb, "\t </config>\n");
}
sbuf_printf(sb, "\t</consumer>\n");
}
static void
g_conf_provider(struct sbuf *sb, struct g_provider *pp)
{
sbuf_printf(sb, "\t<provider>\n", pp);
sbuf_printf(sb, "\t <ref>%p</ref>\n", pp);
sbuf_printf(sb, "\t <geom><ref>%p</ref></geom>\n", pp->geom);
sbuf_printf(sb, "\t <mode>r%dw%de%d</mode>\n",
pp->acr, pp->acw, pp->ace);
sbuf_printf(sb, "\t <name>%s</name>\n", pp->name);
if (pp->geom->dumpconf) {
sbuf_printf(sb, "\t <config>\n");
pp->geom->dumpconf(sb, "\t ", pp->geom, NULL, pp);
sbuf_printf(sb, "\t </config>\n");
}
sbuf_printf(sb, "\t</provider>\n");
}
static void
g_conf_geom(struct sbuf *sb, struct g_geom *gp, struct g_provider *pp, struct g_consumer *cp)
{
struct g_consumer *cp2;
struct g_provider *pp2;
sbuf_printf(sb, " <geom>\n");
sbuf_printf(sb, " <ref>%p</ref>\n", gp);
sbuf_printf(sb, " <method><ref>%p</ref></method>\n", gp->method);
sbuf_printf(sb, " <name>%s</name>\n", gp->name);
sbuf_printf(sb, " <rank>%d</rank>\n", gp->rank);
if (gp->dumpconf) {
sbuf_printf(sb, " <config>\n");
gp->dumpconf(sb, "\t", gp, NULL, NULL);
sbuf_printf(sb, " </config>\n");
}
LIST_FOREACH(cp2, &gp->consumer, consumer) {
if (cp != NULL && cp != cp2)
continue;
g_conf_consumer(sb, cp2);
}
LIST_FOREACH(pp2, &gp->provider, provider) {
if (pp != NULL && pp != pp2)
continue;
g_conf_provider(sb, pp2);
}
sbuf_printf(sb, " </geom>\n");
}
static void
g_conf_method(struct sbuf *sb, struct g_method *mp, struct g_geom *gp, struct g_provider *pp, struct g_consumer *cp)
{
struct g_geom *gp2;
sbuf_printf(sb, " <method>\n");
sbuf_printf(sb, " <ref>%p</ref>\n", mp);
sbuf_printf(sb, " <name>%s</name>\n", mp->name);
LIST_FOREACH(gp2, &mp->geom, geom) {
if (gp != NULL && gp != gp2)
continue;
g_conf_geom(sb, gp2, pp, cp);
}
sbuf_printf(sb, " </method>\n");
}
struct sbuf *
g_conf_specific(struct g_method *mp, struct g_geom *gp, struct g_provider *pp, struct g_consumer *cp)
{
struct g_method *mp2;
struct sbuf *sb;
sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
sbuf_clear(sb);
sbuf_printf(sb, "<mesh>\n");
LIST_FOREACH(mp2, &g_methods, method) {
if (mp != NULL && mp != mp2)
continue;
g_conf_method(sb, mp2, gp, pp, cp);
}
sbuf_printf(sb, "</mesh>\n");
sbuf_finish(sb);
return (sb);
}
struct sbuf *
g_conf()
{
return (g_conf_specific(NULL, NULL, NULL, NULL));
}
void
g_trace(int level, char *fmt, ...)
{
va_list ap;
struct sbuf *sb;
if (!(g_debugflags & level))
return;
va_start(ap, fmt);
mtx_lock(&Giant);
sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
sbuf_vprintf(sb, fmt, ap);
sbuf_finish(sb);
mtx_unlock(&Giant);
printf("%s\n", sbuf_data(sb));
sbuf_delete(sb);
}
void
g_hexdump(void *ptr, int length)
{
int i, j, k;
unsigned char *cp;
cp = ptr;
for (i = 0; i < length; i+= 16) {
printf("%04x ", i);
for (j = 0; j < 16; j++) {
k = i + j;
if (k < length)
printf(" %02x", cp[k]);
else
printf(" ");
}
printf(" |");
for (j = 0; j < 16; j++) {
k = i + j;
if (k >= length)
printf(" ");
else if (cp[k] >= ' ' && cp[k] <= '~')
printf("%c", cp[k]);
else
printf(".");
}
printf("|\n");
}
}

299
sys/geom/geom_event.c Normal file
View File

@ -0,0 +1,299 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
/*
* XXX: How do we in general know that objects referenced in events
* have not been destroyed before we get around to handle the event ?
*/
#include <sys/param.h>
#ifndef _KERNEL
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <err.h>
#else
#include <sys/malloc.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#endif
#include <sys/errno.h>
#include <sys/time.h>
#include <geom/geom.h>
static struct event_tailq_head g_events = TAILQ_HEAD_INITIALIZER(g_events);
static u_int g_pending_events, g_silence_events;
static void g_do_event(struct g_event *ep, struct thread *tp);
static TAILQ_HEAD(,g_provider) g_doorstep = TAILQ_HEAD_INITIALIZER(g_doorstep);
static struct mtx g_doorlock;
void
g_silence(void)
{
g_silence_events = 1;
}
void
g_rattle(void)
{
g_silence_events = 0;
mtx_lock(&Giant);
wakeup(&g_silence_events);
while (g_pending_events)
tsleep(&g_pending_events, PPAUSE, "g_rattle", hz/5);
mtx_unlock(&Giant);
}
void
g_orphan_provider(struct g_provider *pp, int error)
{
g_trace(G_T_TOPOLOGY, "g_orphan_provider(%p(%s), %d)",
pp, pp->name, error);
KASSERT(error != 0,
("g_orphan_provider(%p(%s), 0) error must be non-zero\n",
pp, pp->name));
pp->error = error;
mtx_lock(&g_doorlock);
TAILQ_INSERT_TAIL(&g_doorstep, pp, orphan);
mtx_unlock(&g_doorlock);
mtx_lock(&Giant);
wakeup(&g_wait_event);
mtx_unlock(&Giant);
}
/*
* This function is called once on each provider which the event handler
* finds on its g_doorstep.
*/
static void
g_orphan_register(struct g_provider *pp, struct thread *tp)
{
struct g_consumer *cp, *cp2;
g_trace(G_T_TOPOLOGY, "g_orphan_register(%s)", pp->name);
g_topology_assert();
/*
* Tell all consumers the bad news.
* Don't get surprised if they self-destruct.
*/
cp = LIST_FIRST(&pp->consumers);
while (cp != NULL) {
cp2 = LIST_NEXT(cp, consumers);
KASSERT(cp->geom->method->orphan != NULL,
("method %s has no orphan, geom %s",
cp->geom->method->name, cp->geom->name));
cp->geom->method->orphan(cp, tp);
cp = cp2;
}
}
static void
g_destroy_event(struct g_event *ep)
{
g_free(ep);
}
static void
g_do_event(struct g_event *ep, struct thread *tp)
{
struct g_method *mp, *mp2;
struct g_geom *gp;
struct g_consumer *cp, *cp2;
struct g_provider *pp;
int i;
g_trace(G_T_TOPOLOGY, "g_do_event(%p) %d m:%p g:%p p:%p c:%p - ",
ep, ep->event, ep->method, ep->geom, ep->provider, ep->consumer);
g_topology_assert();
switch (ep->event) {
case EV_NEW_METHOD:
mp2 = ep->method;
if (mp2->taste == NULL)
break;
LIST_FOREACH(mp, &g_methods, method) {
if (mp2 == mp)
continue;
LIST_FOREACH(gp, &mp->geom, geom) {
LIST_FOREACH(pp, &gp->provider, provider) {
mp2->taste(ep->method, pp, tp, 0);
g_topology_assert();
}
}
}
break;
case EV_NEW_PROVIDER:
g_trace(G_T_TOPOLOGY, "EV_NEW_PROVIDER(%s)",
ep->provider->name);
LIST_FOREACH(mp, &g_methods, method) {
if (mp->taste == NULL)
continue;
i = 1;
LIST_FOREACH(cp, &ep->provider->consumers, consumers)
if(cp->geom->method == mp)
i = 0;
if (i) {
mp->taste(mp, ep->provider, tp, 0);
g_topology_assert();
}
}
break;
case EV_SPOILED:
g_trace(G_T_TOPOLOGY, "EV_SPOILED(%p(%s),%p)",
ep->provider, ep->provider->name, ep->consumer);
cp = LIST_FIRST(&ep->provider->consumers);
while (cp != NULL) {
cp2 = LIST_NEXT(cp, consumers);
if (cp->spoiled) {
g_trace(G_T_TOPOLOGY, "spoiling %p (%s) (%p)",
cp, cp->geom->name, cp->geom->spoiled);
if (cp->geom->spoiled != NULL)
cp->geom->spoiled(cp);
cp->spoiled = 0;
}
cp = cp2;
}
break;
case EV_LAST:
default:
KASSERT(1 == 0, ("Unknown event %d", ep->event));
}
}
static int
one_event(struct thread *tp)
{
struct g_event *ep;
struct g_provider *pp;
g_topology_lock();
for (;;) {
mtx_lock(&g_doorlock);
pp = TAILQ_FIRST(&g_doorstep);
if (pp != NULL)
TAILQ_REMOVE(&g_doorstep, pp, orphan);
mtx_unlock(&g_doorlock);
if (pp == NULL)
break;
g_orphan_register(pp, tp);
}
ep = TAILQ_FIRST(&g_events);
if (ep == NULL) {
g_topology_unlock();
return (0);
}
TAILQ_REMOVE(&g_events, ep, events);
if (ep->method != NULL)
ep->method->event = NULL;
if (ep->geom != NULL)
ep->geom->event = NULL;
if (ep->provider != NULL)
ep->provider->event = NULL;
if (ep->consumer != NULL)
ep->consumer->event = NULL;
g_do_event(ep, tp);
g_pending_events--;
if (g_pending_events == 0) {
mtx_lock(&Giant);
wakeup(&g_pending_events);
mtx_unlock(&Giant);
}
g_topology_unlock();
g_destroy_event(ep);
return (1);
}
void
g_run_events(struct thread *tp)
{
while (one_event(tp))
;
}
void
g_post_event(enum g_events ev, struct g_method *mp, struct g_geom *gp, struct g_provider *pp, struct g_consumer *cp)
{
struct g_event *ep;
g_trace(G_T_TOPOLOGY, "g_post_event(%d, %p, %p, %p, %p)",
ev, mp, gp, pp, cp);
g_topology_assert();
ep = g_malloc(sizeof *ep, M_WAITOK | M_ZERO);
ep->event = ev;
if (mp != NULL) {
ep->method = mp;
KASSERT(mp->event == NULL, ("Double event on method"));
mp->event = ep;
}
if (gp != NULL) {
ep->geom = gp;
KASSERT(gp->event == NULL, ("Double event on geom"));
gp->event = ep;
}
if (pp != NULL) {
ep->provider = pp;
KASSERT(pp->event == NULL, ("Double event on provider"));
pp->event = ep;
}
if (cp != NULL) {
ep->consumer = cp;
KASSERT(cp->event == NULL, ("Double event on consumer"));
cp->event = ep;
}
g_pending_events++;
TAILQ_INSERT_TAIL(&g_events, ep, events);
mtx_lock(&Giant);
wakeup(&g_wait_event);
mtx_unlock(&Giant);
}
void
g_event_init()
{
mtx_init(&g_doorlock, "GEOM orphanage", MTX_DEF);
}

375
sys/geom/geom_io.c Normal file
View File

@ -0,0 +1,375 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#ifndef _KERNEL
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <err.h>
#include <sched.h>
#else
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bio.h>
#endif
#include <sys/errno.h>
#include <geom/geom.h>
static struct g_bioq g_bio_run_down;
static struct g_bioq g_bio_run_up;
static struct g_bioq g_bio_idle;
#include <machine/atomic.h>
static void
g_bioq_lock(struct g_bioq *bq)
{
mtx_lock(&bq->bio_queue_lock);
}
static void
g_bioq_unlock(struct g_bioq *bq)
{
mtx_unlock(&bq->bio_queue_lock);
}
#if 0
static void
g_bioq_destroy(struct g_bioq *bq)
{
mtx_destroy(&bq->bio_queue_lock);
}
#endif
static void
g_bioq_init(struct g_bioq *bq)
{
TAILQ_INIT(&bq->bio_queue);
mtx_init(&bq->bio_queue_lock, "bio queue", MTX_DEF);
}
static struct bio *
g_bioq_first(struct g_bioq *bq)
{
struct bio *bp;
g_bioq_lock(bq);
bp = TAILQ_FIRST(&bq->bio_queue);
if (bp != NULL) {
TAILQ_REMOVE(&bq->bio_queue, bp, bio_queue);
bq->bio_queue_length--;
}
g_bioq_unlock(bq);
return (bp);
}
static void
g_bioq_enqueue_tail(struct bio *bp, struct g_bioq *rq)
{
g_bioq_lock(rq);
TAILQ_INSERT_TAIL(&rq->bio_queue, bp, bio_queue);
rq->bio_queue_length++;
g_bioq_unlock(rq);
}
struct bio *
g_new_bio(void)
{
struct bio *bp;
bp = g_bioq_first(&g_bio_idle);
if (bp == NULL)
bp = g_malloc(sizeof *bp, M_WAITOK | M_ZERO);
g_trace(G_T_BIO, "g_new_bio() = %p", bp);
return (bp);
}
void
g_destroy_bio(struct bio *bp)
{
g_trace(G_T_BIO, "g_destroy_bio(%p)", bp);
bzero(bp, sizeof *bp);
g_bioq_enqueue_tail(bp, &g_bio_idle);
}
struct bio *
g_clone_bio(struct bio *bp)
{
struct bio *bp2;
bp2 = g_new_bio();
bp2->bio_linkage = bp;
bp2->bio_cmd = bp->bio_cmd;
bp2->bio_length = bp->bio_length;
bp2->bio_offset = bp->bio_offset;
bp2->bio_data = bp->bio_data;
bp2->bio_attribute = bp->bio_attribute;
g_trace(G_T_BIO, "g_clone_bio(%p) = %p", bp, bp2);
return(bp2);
}
void
g_io_init()
{
g_bioq_init(&g_bio_run_down);
g_bioq_init(&g_bio_run_up);
g_bioq_init(&g_bio_idle);
}
int
g_io_setattr(char *attr, struct g_consumer *cp, int len, void *ptr, struct thread *tp __unused)
{
struct bio *bp;
int error;
g_trace(G_T_BIO, "bio_setattr(%s)", attr);
do {
bp = g_new_bio();
bp->bio_cmd = BIO_SETATTR;
bp->bio_done = NULL;
bp->bio_attribute = attr;
bp->bio_length = len;
bp->bio_data = ptr;
g_io_request(bp, cp);
while ((bp->bio_flags & BIO_DONE) == 0) {
mtx_lock(&Giant);
tsleep(bp, 0, "setattr", hz / 10);
mtx_unlock(&Giant);
}
error = bp->bio_error;
g_destroy_bio(bp);
if (error == EBUSY)
tsleep(&error, 0, "setattr_busy", hz);
} while(error == EBUSY);
return (error);
}
int
g_io_getattr(char *attr, struct g_consumer *cp, int *len, void *ptr, struct thread *tp __unused)
{
struct bio *bp;
int error;
g_trace(G_T_BIO, "bio_getattr(%s)", attr);
do {
bp = g_new_bio();
bp->bio_cmd = BIO_GETATTR;
bp->bio_done = NULL;
bp->bio_attribute = attr;
bp->bio_length = *len;
bp->bio_data = ptr;
g_io_request(bp, cp);
while ((bp->bio_flags & BIO_DONE) == 0) {
mtx_lock(&Giant);
tsleep(bp, 0, "getattr", hz / 10);
mtx_unlock(&Giant);
}
*len = bp->bio_completed;
error = bp->bio_error;
g_destroy_bio(bp);
if (error == EBUSY)
tsleep(&error, 0, "getattr_busy", hz);
} while(error == EBUSY);
return (error);
}
void
g_io_request(struct bio *bp, struct g_consumer *cp)
{
int error;
KASSERT(cp != NULL, ("bio_request on thin air"));
error = 0;
bp->bio_from = cp;
bp->bio_to = cp->provider;
/* begin_stats(&bp->stats); */
atomic_add_int(&cp->biocount, 1);
if (bp->bio_to == NULL)
error = ENXIO;
if (!error) {
switch(bp->bio_cmd) {
case BIO_READ:
case BIO_GETATTR:
if (cp->acr == 0)
error = EPERM;
break;
case BIO_WRITE:
if (cp->acw == 0)
error = EPERM;
break;
case BIO_SETATTR:
case BIO_DELETE:
case BIO_FORMAT:
if ((cp->acw == 0) || (cp->ace == 0))
error = EPERM;
break;
default:
error = EPERM;
break;
}
}
/* if provider is marked for error, don't disturb */
if (!error)
error = bp->bio_to->error;
if (error) {
bp->bio_error = error;
/* finish_stats(&bp->stats); */
g_trace(G_T_BIO,
"bio_request(%p) from %p(%s) to %p(%s) cmd %d error %d\n",
bp, bp->bio_from, bp->bio_from->geom->name,
bp->bio_to, bp->bio_to->name, bp->bio_cmd, bp->bio_error);
g_bioq_enqueue_tail(bp, &g_bio_run_up);
mtx_lock(&Giant);
wakeup(&g_wait_up);
mtx_unlock(&Giant);
} else {
g_trace(G_T_BIO, "bio_request(%p) from %p(%s) to %p(%s) cmd %d",
bp, bp->bio_from, bp->bio_from->geom->name,
bp->bio_to, bp->bio_to->name, bp->bio_cmd);
g_bioq_enqueue_tail(bp, &g_bio_run_down);
mtx_lock(&Giant);
wakeup(&g_wait_down);
mtx_unlock(&Giant);
}
}
void
g_io_deliver(struct bio *bp)
{
g_trace(G_T_BIO,
"g_io_deliver(%p) from %p(%s) to %p(%s) cmd %d error %d",
bp, bp->bio_from, bp->bio_from->geom->name,
bp->bio_to, bp->bio_to->name, bp->bio_cmd, bp->bio_error);
/* finish_stats(&bp->stats); */
g_bioq_enqueue_tail(bp, &g_bio_run_up);
mtx_lock(&Giant);
wakeup(&g_wait_up);
mtx_unlock(&Giant);
}
void
g_io_schedule_down(struct thread *tp __unused)
{
struct bio *bp;
for(;;) {
bp = g_bioq_first(&g_bio_run_down);
if (bp == NULL)
break;
bp->bio_to->geom->start(bp);
}
}
void
g_io_schedule_up(struct thread *tp __unused)
{
struct bio *bp;
struct g_consumer *cp;
for(;;) {
bp = g_bioq_first(&g_bio_run_up);
if (bp == NULL)
break;
cp = bp->bio_from;
bp->bio_flags |= BIO_DONE;
atomic_add_int(&cp->biocount, -1);
if (bp->bio_done != NULL) {
bp->bio_done(bp);
} else {
mtx_lock(&Giant);
wakeup(bp);
mtx_unlock(&Giant);
}
}
}
void *
g_read_data(struct g_consumer *cp, off_t offset, off_t length, int *error)
{
struct bio *bp;
void *ptr;
int errorc;
do {
bp = g_new_bio();
bp->bio_cmd = BIO_READ;
bp->bio_done = NULL;
bp->bio_offset = offset;
bp->bio_length = length;
ptr = g_malloc(length, M_WAITOK);
bp->bio_data = ptr;
g_io_request(bp, cp);
while ((bp->bio_flags & BIO_DONE) == 0) {
mtx_lock(&Giant);
tsleep(bp, 0, "g_read_data", hz / 10);
mtx_unlock(&Giant);
}
errorc = bp->bio_error;
if (error != NULL)
*error = errorc;
g_destroy_bio(bp);
if (errorc) {
g_free(ptr);
ptr = NULL;
}
if (errorc == EBUSY)
tsleep(&errorc, 0, "g_read_data_busy", hz);
} while (errorc == EBUSY);
return (ptr);
}

192
sys/geom/geom_kern.c Normal file
View File

@ -0,0 +1,192 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bio.h>
#include <sys/sysctl.h>
#include <sys/proc.h>
#include <sys/kthread.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/sx.h>
#include <sys/sbuf.h>
#include <sys/errno.h>
#include <geom/geom.h>
MALLOC_DEFINE(M_GEOM, "GEOM", "Geom data structures");
struct sx topology_lock;
static struct proc *g_up_proc;
int g_debugflags;
static void
g_up_procbody(void)
{
struct proc *p = g_up_proc;
struct thread *tp = &p->p_xxthread;
curthread->td_base_pri = PRIBIO;
for(;;) {
g_io_schedule_up(tp);
mtx_lock(&Giant);
tsleep(&g_wait_up, PRIBIO, "g_up", hz/10);
mtx_unlock(&Giant);
}
}
struct kproc_desc g_up_kp = {
"g_up",
g_up_procbody,
&g_up_proc,
};
static struct proc *g_down_proc;
static void
g_down_procbody(void)
{
struct proc *p = g_down_proc;
struct thread *tp = &p->p_xxthread;
curthread->td_base_pri = PRIBIO;
for(;;) {
g_io_schedule_down(tp);
mtx_lock(&Giant);
tsleep(&g_wait_down, PRIBIO, "g_down", hz/10);
mtx_unlock(&Giant);
}
}
struct kproc_desc g_down_kp = {
"g_down",
g_down_procbody,
&g_down_proc,
};
static struct proc *g_event_proc;
static void
g_event_procbody(void)
{
struct proc *p = g_event_proc;
struct thread *tp = &p->p_xxthread;
curthread->td_base_pri = PRIBIO;
for(;;) {
g_run_events(tp);
mtx_lock(&Giant);
tsleep(&g_wait_event, PRIBIO, "g_events", hz/10);
mtx_unlock(&Giant);
}
}
struct kproc_desc g_event_kp = {
"g_event",
g_event_procbody,
&g_event_proc,
};
void
g_init(void)
{
printf("Initializing GEOMetry subsystem\n");
if (bootverbose)
g_debugflags |= G_T_TOPOLOGY;
sx_init(&topology_lock, "GEOM topology");
g_io_init();
g_event_init();
mtx_lock(&Giant);
kproc_start(&g_event_kp);
kproc_start(&g_up_kp);
kproc_start(&g_down_kp);
mtx_unlock(&Giant);
}
static int
sysctl_debug_geomdot(SYSCTL_HANDLER_ARGS)
{
int i, error;
struct sbuf *sb;
i = 0;
sb = g_confdot();
error = sysctl_handle_opaque(oidp, sbuf_data(sb), sbuf_len(sb), req);
sbuf_delete(sb);
return (error);
}
SYSCTL_PROC(_debug, OID_AUTO, geomdot, CTLTYPE_STRING|CTLFLAG_RD,
0, 0, sysctl_debug_geomdot, "A",
"Dump the GEOM config");
static int
sysctl_debug_geomconf(SYSCTL_HANDLER_ARGS)
{
int i, error;
struct sbuf *sb;
i = 0;
sb = g_conf();
error = sysctl_handle_opaque(oidp, sbuf_data(sb), sbuf_len(sb), req);
sbuf_delete(sb);
return (error);
}
SYSCTL_PROC(_debug, OID_AUTO, geomconf, CTLTYPE_STRING|CTLFLAG_RD,
0, 0, sysctl_debug_geomconf, "A",
"Dump the GEOM config");
SYSCTL_INT(_debug, OID_AUTO, geomdebugflags, CTLTYPE_INT|CTLFLAG_RW,
&g_debugflags, 0, "");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_method, CTLTYPE_INT|CTLFLAG_RD,
0, sizeof(struct g_method), "");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_geom, CTLTYPE_INT|CTLFLAG_RD,
0, sizeof(struct g_geom), "");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_provider, CTLTYPE_INT|CTLFLAG_RD,
0, sizeof(struct g_provider), "");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_consumer, CTLTYPE_INT|CTLFLAG_RD,
0, sizeof(struct g_consumer), "");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_bioq, CTLTYPE_INT|CTLFLAG_RD,
0, sizeof(struct g_bioq), "");
SYSCTL_INT(_debug_sizeof, OID_AUTO, g_event, CTLTYPE_INT|CTLFLAG_RD,
0, sizeof(struct g_event), "");

211
sys/geom/geom_mbr.c Normal file
View File

@ -0,0 +1,211 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#ifndef _KERNEL
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <sys/param.h>
#include <stdlib.h>
#include <err.h>
#else
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bio.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#endif
#include <sys/errno.h>
#include <sys/disklabel.h>
#include <sys/sbuf.h>
#include <geom/geom.h>
#include <geom/geom_slice.h>
#define MBR_METHOD_NAME "MBR-method"
struct g_mbr_softc {
int type [NDOSPART];
struct dos_partition dospart[NDOSPART];
};
static int
g_mbr_start(struct bio *bp)
{
struct g_provider *pp;
struct g_geom *gp;
struct g_mbr_softc *mp;
struct g_slicer *gsp;
int index;
pp = bp->bio_to;
index = pp->index;
gp = pp->geom;
gsp = gp->softc;
mp = gsp->softc;
if (bp->bio_cmd == BIO_GETATTR) {
if (g_haveattr_int(bp, "MBR::type", mp->type[index]))
return (1);
}
return (0);
}
static void
g_mbr_dumpconf(struct sbuf *sb, char *indent, struct g_geom *gp, struct g_consumer *cp __unused, struct g_provider *pp)
{
struct g_mbr_softc *mp;
struct g_slicer *gsp;
g_slice_dumpconf(sb, indent, gp, cp, pp);
gsp = gp->softc;
mp = gsp->softc;
if (pp != NULL) {
sbuf_printf(sb, "%s<type>%d</type>\n",
indent, mp->type[pp->index]);
}
}
static struct dos_partition historical_bogus_partition_table[NDOSPART] = {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0x80, 0, 1, 0, DOSPTYP_386BSD, 255, 255, 255, 0, 50000, },
};
static struct dos_partition historical_bogus_partition_table_fixed[NDOSPART] = {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0x80, 0, 1, 0, DOSPTYP_386BSD, 254, 255, 255, 0, 50000, },
};
static void
g_mbr_print(int i __unused, struct dos_partition *dp __unused)
{
#if 0
g_hexdump(dp, sizeof(dp[0]));
printf("[%d] f:%02x typ:%d", i, dp->dp_flag, dp->dp_typ);
printf(" s(CHS):%d/%d/%d", dp->dp_scyl, dp->dp_shd, dp->dp_ssect);
printf(" e(CHS):%d/%d/%d", dp->dp_ecyl, dp->dp_ehd, dp->dp_esect);
printf(" s:%d l:%d\n", dp->dp_start, dp->dp_size);
#endif
}
static struct g_geom *
g_mbr_taste(struct g_method *mp, struct g_provider *pp, struct thread *tp, int insist)
{
struct g_geom *gp;
struct g_consumer *cp;
struct g_provider *pp2;
int error, i, j, npart;
struct dos_partition dp[NDOSPART];
struct g_mbr_softc *ms;
u_char *buf;
g_trace(G_T_TOPOLOGY, "mbr_taste(%s,%s)", mp->name, pp->name);
g_topology_assert();
gp = g_slice_new(mp, NDOSPART, pp, &cp, &ms, sizeof *ms, g_mbr_start);
if (gp == NULL)
return (NULL);
g_topology_unlock();
gp->dumpconf = g_mbr_dumpconf;
npart = 0;
while (1) { /* a trick to allow us to use break */
if (gp->rank != 2 && insist == 0)
break;
j = sizeof i;
/* For now we only support 512 bytes sectors */
error = g_io_getattr("GEOM::sectorsize", cp, &j, &i, tp);
if (!error && i != 512)
break;
buf = g_read_data(cp, 0, 512, &error);
if (buf == NULL || error != 0)
break;
if (buf[0x1fe] != 0x55 && buf[0x1ff] != 0xaa) {
g_free(buf);
break;
}
bcopy(buf + DOSPARTOFF, dp, sizeof(dp));
g_free(buf);
if (bcmp(dp, historical_bogus_partition_table,
sizeof historical_bogus_partition_table) == 0)
break;
if (bcmp(dp, historical_bogus_partition_table_fixed,
sizeof historical_bogus_partition_table_fixed) == 0)
break;
npart = 0;
for (i = 0; i < NDOSPART; i++) {
if (dp[i].dp_flag != 0 && dp[i].dp_flag != 0x80)
continue;
if (dp[i].dp_size == 0)
continue;
g_mbr_print(i, dp + i);
npart++;
ms->type[i] = dp[i].dp_typ;
pp2 = g_slice_addslice(gp, i,
((off_t)dp[i].dp_start) << 9ULL,
((off_t)dp[i].dp_size) << 9ULL,
"%ss%d", gp->name, i + 1);
}
break;
}
g_topology_lock();
error = g_access_rel(cp, -1, 0, 0);
if (npart > 0) {
LIST_FOREACH(pp, &gp->provider, provider)
g_error_provider(pp, 0);
return (gp);
}
g_std_spoiled(cp);
return (NULL);
}
static struct g_method g_mbr_method = {
MBR_METHOD_NAME,
g_mbr_taste,
g_slice_access,
g_slice_orphan,
NULL,
G_METHOD_INITSTUFF
};
DECLARE_GEOM_METHOD(g_mbr_method, g_mbr);

200
sys/geom/geom_mbrext.c Normal file
View File

@ -0,0 +1,200 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#ifndef _KERNEL
#include <sys/param.h>
#ifndef _KERNEL
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <sys/param.h>
#include <stdlib.h>
#include <err.h>
#else
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bio.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#endif
#include <sys/errno.h>
#include <sys/disklabel.h>
#include <sys/sbuf.h>
#include <geom/geom.h>
#include <geom/geom_slice.h>
#define MBR_METHOD_NAME "MBR-method"
#define MBREXT_METHOD_NAME "MBREXT-method"
#define NDOSEXTPART 32
struct g_mbrext_softc {
int type [NDOSEXTPART];
};
static int
g_mbrext_start(struct bio *bp)
{
struct g_provider *pp;
struct g_geom *gp;
struct g_mbrext_softc *mp;
struct g_slicer *gsp;
int index;
pp = bp->bio_to;
index = pp->index;
gp = pp->geom;
gsp = gp->softc;
mp = gsp->softc;
if (bp->bio_cmd == BIO_GETATTR) {
if (g_haveattr_int(bp, "MBR::type", mp->type[index]))
return (1);
}
return (0);
}
static void
g_mbrext_dumpconf(struct sbuf *sb, char *indent, struct g_geom *gp, struct g_consumer *cp __unused, struct g_provider *pp)
{
struct g_mbrext_softc *mp;
struct g_slicer *gsp;
g_slice_dumpconf(sb, indent, gp, cp, pp);
gsp = gp->softc;
mp = gsp->softc;
if (pp != NULL) {
sbuf_printf(sb, "%s<type>%d</type>\n",
indent, mp->type[pp->index]);
}
}
static void
g_mbrext_print(int i, struct dos_partition *dp)
{
g_hexdump(dp, sizeof(dp[0]));
printf("[%d] f:%02x typ:%d", i, dp->dp_flag, dp->dp_typ);
printf(" s(CHS):%d/%d/%d", dp->dp_scyl, dp->dp_shd, dp->dp_ssect);
printf(" e(CHS):%d/%d/%d", dp->dp_ecyl, dp->dp_ehd, dp->dp_esect);
printf(" s:%d l:%d\n", dp->dp_start, dp->dp_size);
}
static struct g_geom *
g_mbrext_taste(struct g_method *mp, struct g_provider *pp, struct thread *tp __unused, int insist __unused)
{
struct g_geom *gp;
struct g_consumer *cp;
struct g_provider *pp2;
int error, i, j, slice;
struct g_mbrext_softc *ms;
off_t off;
u_char *buf;
struct dos_partition dp[4];
g_trace(G_T_TOPOLOGY, "g_mbrext_taste(%s,%s)", mp->name, pp->name);
g_topology_assert();
if (strcmp(pp->geom->method->name, MBR_METHOD_NAME))
return (NULL);
gp = g_slice_new(mp, NDOSEXTPART, pp, &cp, &ms, sizeof *ms, g_mbrext_start);
if (gp == NULL)
return (NULL);
g_topology_unlock();
gp->dumpconf = g_mbrext_dumpconf;
off = 0;
slice = 0;
while (1) { /* a trick to allow us to use break */
j = sizeof i;
error = g_io_getattr("MBR::type", cp, &j, &i, tp);
if (error || i != DOSPTYP_EXT)
break;
for (;;) {
buf = g_read_data(cp, off, DEV_BSIZE, &error);
if (buf == NULL || error != 0)
break;
if (buf[0x1fe] != 0x55 && buf[0x1ff] != 0xaa)
break;
bcopy(buf + DOSPARTOFF, dp, sizeof(dp));
g_free(buf);
g_mbrext_print(0, dp);
g_mbrext_print(1, dp + 1);
if (dp[0].dp_flag == 0 && dp[0].dp_size != 0) {
pp2 = g_slice_addslice(gp, slice,
(((off_t)dp[0].dp_start) << 9ULL) + off,
((off_t)dp[0].dp_size) << 9ULL,
"%*.*s%d",
strlen(gp->name) - 1,
strlen(gp->name) - 1,
gp->name,
slice + 5);
ms->type[slice] = dp[0].dp_typ;
slice++;
g_error_provider(pp2, 0);
}
if (dp[1].dp_flag != 0)
break;
if (dp[1].dp_typ != DOSPTYP_EXT)
break;
if (dp[1].dp_size == 0)
break;
off = ((off_t)dp[1].dp_start) << 9ULL;
}
break;
}
g_topology_lock();
error = g_access_rel(cp, -1, 0, 0);
if (slice > 0)
return (gp);
g_topology_assert();
g_std_spoiled(cp);
g_topology_assert();
return (NULL);
}
static struct g_method g_mbrext_method = {
MBREXT_METHOD_NAME,
g_mbrext_taste,
g_slice_access,
g_slice_orphan,
NULL,
G_METHOD_INITSTUFF
};
DECLARE_GEOM_METHOD(g_mbrext_method, g_mbrext);
#endif

278
sys/geom/geom_slice.c Normal file
View File

@ -0,0 +1,278 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#ifndef _KERNEL
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <err.h>
#else
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bio.h>
#include <sys/sysctl.h>
#include <sys/proc.h>
#include <sys/kthread.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#endif
#include <sys/errno.h>
#include <sys/sbuf.h>
#include <geom/geom.h>
#include <geom/geom_slice.h>
#include <machine/stdarg.h>
struct g_slicer *
g_slice_init(unsigned nslice, unsigned scsize)
{
struct g_slicer *gsp;
gsp = g_malloc(sizeof *gsp + nslice * sizeof(struct g_slice) + scsize,
M_WAITOK | M_ZERO);
gsp->softc = gsp + 1;
gsp->slices = (struct g_slice *)((u_char *)gsp->softc + scsize);
gsp->nslice = nslice;
return (gsp);
}
int
g_slice_access(struct g_provider *pp, int dr, int dw, int de)
{
int error, i;
struct g_geom *gp;
struct g_consumer *cp;
struct g_provider *pp2;
struct g_slicer *gsp;
struct g_slice *gsl, *gsl2;
gp = pp->geom;
cp = LIST_FIRST(&gp->consumer);
KASSERT (cp != NULL, ("g_slice_access but no consumer"));
gsp = gp->softc;
gsl = &gsp->slices[pp->index];
for (i = 0; i < gsp->nslice; i++) {
gsl2 = &gsp->slices[i];
if (gsl2->length == 0)
continue;
if (i == pp->index)
continue;
if (gsl->offset + gsl->length <= gsl2->offset)
continue;
if (gsl2->offset + gsl2->length <= gsl->offset)
continue;
/* overlap */
pp2 = gsl2->provider;
if ((pp->acw + dw) > 0 && pp2->ace > 0)
return (EPERM);
if ((pp->ace + de) > 0 && pp2->acw > 0)
return (EPERM);
}
/* On first open, grab an extra "exclusive" bit */
if (cp->acr == 0 && cp->acw == 0 && cp->ace == 0)
de++;
/* ... and let go of it on last close */
if ((cp->acr + dr) == 0 && (cp->acw + dw) == 0 && (cp->ace + de) == 1)
de--;
error = g_access_rel(cp, dr, dw, de);
return (error);
}
void
g_slice_start(struct bio *bp)
{
struct bio *bp2;
struct g_provider *pp;
struct g_geom *gp;
struct g_consumer *cp;
struct g_slicer *gsp;
struct g_slice *gsl;
int index;
pp = bp->bio_to;
gp = pp->geom;
gsp = gp->softc;
cp = LIST_FIRST(&gp->consumer);
index = pp->index;
switch(bp->bio_cmd) {
case BIO_READ:
case BIO_WRITE:
case BIO_DELETE:
gsl = &gsp->slices[index];
if (bp->bio_offset > gsl->length) {
bp->bio_error = EINVAL; /* XXX: EWHAT ? */
g_io_deliver(bp);
return;
}
bp2 = g_clone_bio(bp);
if (bp2->bio_offset + bp2->bio_length > gsl->length)
bp2->bio_length = gsl->length - bp2->bio_offset;
bp2->bio_done = g_std_done;
bp2->bio_offset += gsl->offset;
g_io_request(bp2, cp);
return;
case BIO_GETATTR:
case BIO_SETATTR:
if (g_haveattr_off_t(bp, "GEOM::mediasize",
gsp->slices[index].length))
return;
if (gsp->start(bp))
return;
bp2 = g_clone_bio(bp);
bp2->bio_done = g_std_done;
g_io_request(bp2, cp);
break;
default:
bp->bio_error = EOPNOTSUPP;
g_io_deliver(bp);
return;
}
}
void
g_slice_dumpconf(struct sbuf *sb, char *indent, struct g_geom *gp, struct g_consumer *cp __unused, struct g_provider *pp)
{
struct g_mbr_softc *mp;
struct g_slicer *gsp;
gsp = gp->softc;
mp = gsp->softc;
if (pp != NULL) {
sbuf_printf(sb, "%s<index>%u</index>\n", indent, pp->index);
sbuf_printf(sb, "%s<length>%llu</length>\n",
indent, gsp->slices[pp->index].length);
sbuf_printf(sb, "%s<seclength>%llu</seclength>\n",
indent, gsp->slices[pp->index].length / 512);
sbuf_printf(sb, "%s<offset>%llu</offset>\n",
indent, gsp->slices[pp->index].offset);
sbuf_printf(sb, "%s<secoffset>%llu</secoffset>\n",
indent, gsp->slices[pp->index].offset / 512);
}
}
struct g_provider *
g_slice_addslice(struct g_geom *gp, int index, off_t offset, off_t length, char *fmt, ...)
{
struct g_provider *pp;
struct g_slicer *gsp;
va_list ap;
struct sbuf *sb;
g_trace(G_T_TOPOLOGY, "g_slice_addslice()");
g_topology_lock();
gsp = gp->softc;
va_start(ap, fmt);
sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
sbuf_vprintf(sb, fmt, ap);
sbuf_finish(sb);
pp = g_new_providerf(gp, sbuf_data(sb));
pp->index = index;
gsp->slices[index].length = length;
gsp->slices[index].offset = offset;
gsp->slices[index].provider = pp;
sbuf_delete(sb);
g_topology_unlock();
return(pp);
}
struct g_geom *
g_slice_new(struct g_method *mp, int slices, struct g_provider *pp, struct g_consumer **cpp, void *extrap, int extra, g_slice_start_t *start)
{
struct g_geom *gp;
struct g_slicer *gsp;
struct g_consumer *cp;
void **vp;
int error;
g_topology_assert();
vp = (void **)extrap;
gp = g_new_geomf(mp, "%s", pp->name);
gsp = g_slice_init(slices, extra);
gsp->start = start;
gp->softc = gsp;
gp->start = g_slice_start;
gp->spoiled = g_std_spoiled;
gp->dumpconf = g_slice_dumpconf;
cp = g_new_consumer(gp);
g_attach(cp, pp);
error = g_access_rel(cp, 1, 0, 0);
if (error) {
g_dettach(cp);
g_destroy_consumer(cp);
g_free(gp->softc);
g_destroy_geom(gp);
return (NULL);
}
*vp = gsp->softc;
*cpp = cp;
return (gp);
}
void
g_slice_orphan(struct g_consumer *cp, struct thread *tp __unused)
{
struct g_geom *gp;
struct g_provider *pp;
int error;
g_trace(G_T_TOPOLOGY, "g_slice_orphan(%p/%s)", cp, cp->provider->name);
g_topology_assert();
KASSERT(cp->provider->error != 0,
("g_slice_orphan with error == 0"));
gp = cp->geom;
gp->flags |= G_GEOM_WITHER;
/* First prevent any new requests */
error = cp->provider->error;
LIST_FOREACH(pp, &gp->provider, provider)
g_orphan_provider(pp, error);
return;
if (cp->biocount > 0)
return;
/* Then selfdestruct */
if (cp->acr != 0 || cp->acw != 0 || cp->ace != 0)
g_access_abs(cp, 0, 0, 0);
g_dettach(cp);
g_destroy_consumer(cp);
return;
}

60
sys/geom/geom_slice.h Normal file
View File

@ -0,0 +1,60 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
struct g_slice {
off_t offset;
off_t length;
struct g_provider *provider;
};
typedef int g_slice_start_t (struct bio *bp);
struct g_slicer {
int nslice;
struct g_slice *slices;
void *softc;
g_slice_start_t *start;
};
void g_slice_orphan(struct g_consumer *cp, struct thread *tp);
struct g_slicer * g_slice_init(unsigned nslice, unsigned scsize);
int g_slice_access(struct g_provider *pp, int dr, int dw, int de);
void g_slice_start(struct bio *bp);
void g_slice_dumpconf(struct sbuf *sb, char *indent, struct g_geom *gp, struct g_consumer *cp __unused, struct g_provider *pp);
struct g_provider * g_slice_addslice(struct g_geom *gp, int index, off_t offset, off_t length, char *fmt, ...);
struct g_geom * g_slice_new(struct g_method *mp, int slices, struct g_provider *pp, struct g_consumer **cpp, void *extrap, int extra, g_slice_start_t *start);

639
sys/geom/geom_subr.c Normal file
View File

@ -0,0 +1,639 @@
/*-
* Copyright (c) 2002 Poul-Henning Kamp
* Copyright (c) 2002 Networks Associates Technology, Inc.
* All rights reserved.
*
* This software was developed for the FreeBSD Project by Poul-Henning Kamp
* and NAI Labs, the Security Research Division of Network Associates, Inc.
* under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
* DARPA CHATS research program.
*
* 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. The names of the authors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* 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.
*
* $FreeBSD$
*/
#include <sys/param.h>
#ifndef _KERNEL
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <err.h>
#else
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bio.h>
#include <sys/sysctl.h>
#include <sys/proc.h>
#include <sys/kthread.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#endif
#include <sys/errno.h>
#include <sys/sbuf.h>
#include <geom/geom.h>
#include <machine/stdarg.h>
struct method_list_head g_methods = LIST_HEAD_INITIALIZER(g_methods);
static struct g_tailq_head geoms = TAILQ_HEAD_INITIALIZER(geoms);
static int g_nproviders;
char *g_wait_event, *g_wait_up, *g_wait_down, *g_wait_sim;
static int g_ignition;
void
g_add_method(struct g_method *mp)
{
if (!g_ignition) {
g_ignition++;
g_init();
}
g_topology_lock();
g_trace(G_T_TOPOLOGY, "g_add_method(%s)", mp->name);
LIST_INIT(&mp->geom);
LIST_INSERT_HEAD(&g_methods, mp, method);
if (g_nproviders > 0)
g_post_event(EV_NEW_METHOD, mp, NULL, NULL, NULL);
g_topology_unlock();
}
struct g_geom *
g_new_geomf(struct g_method *mp, char *fmt, ...)
{
struct g_geom *gp;
va_list ap;
struct sbuf *sb;
g_topology_assert();
va_start(ap, fmt);
mtx_lock(&Giant);
sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
sbuf_vprintf(sb, fmt, ap);
sbuf_finish(sb);
mtx_unlock(&Giant);
gp = g_malloc(sizeof *gp + sbuf_len(sb) + 1, M_WAITOK | M_ZERO);
gp->name = (char *)(gp + 1);
gp->method = mp;
gp->rank = 1;
LIST_INIT(&gp->consumer);
LIST_INIT(&gp->provider);
LIST_INSERT_HEAD(&mp->geom, gp, geom);
TAILQ_INSERT_HEAD(&geoms, gp, geoms);
strcpy(gp->name, sbuf_data(sb));
sbuf_delete(sb);
return (gp);
}
void
g_destroy_geom(struct g_geom *gp)
{
g_trace(G_T_TOPOLOGY, "g_destroy_geom(%p(%s))", gp, gp->name);
g_topology_assert();
KASSERT(gp->event == NULL, ("g_destroy_geom() with event"));
KASSERT(LIST_EMPTY(&gp->consumer),
("g_destroy_geom(%s) with consumer(s) [%p]",
gp->name, LIST_FIRST(&gp->consumer)));
KASSERT(LIST_EMPTY(&gp->provider),
("g_destroy_geom(%s) with provider(s) [%p]",
gp->name, LIST_FIRST(&gp->consumer)));
LIST_REMOVE(gp, geom);
TAILQ_REMOVE(&geoms, gp, geoms);
g_free(gp);
}
struct g_consumer *
g_new_consumer(struct g_geom *gp)
{
struct g_consumer *cp;
g_topology_assert();
KASSERT(gp->method->orphan != NULL,
("g_new_consumer on method(%s) without orphan", gp->method->name));
cp = g_malloc(sizeof *cp, M_WAITOK | M_ZERO);
cp->geom = gp;
LIST_INSERT_HEAD(&gp->consumer, cp, consumer);
return(cp);
}
void
g_destroy_consumer(struct g_consumer *cp)
{
g_trace(G_T_TOPOLOGY, "g_destroy_consumer(%p)", cp);
g_topology_assert();
KASSERT(cp->event == NULL, ("g_destroy_consumer() with event"));
KASSERT (cp->provider == NULL, ("g_destroy_consumer but attached"));
KASSERT (cp->acr == 0, ("g_destroy_consumer with acr"));
KASSERT (cp->acw == 0, ("g_destroy_consumer with acw"));
KASSERT (cp->ace == 0, ("g_destroy_consumer with ace"));
LIST_REMOVE(cp, consumer);
g_free(cp);
}
struct g_provider *
g_new_providerf(struct g_geom *gp, char *fmt, ...)
{
struct g_provider *pp;
struct sbuf *sb;
va_list ap;
g_topology_assert();
va_start(ap, fmt);
mtx_lock(&Giant);
sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
sbuf_vprintf(sb, fmt, ap);
sbuf_finish(sb);
mtx_unlock(&Giant);
pp = g_malloc(sizeof *pp + sbuf_len(sb) + 1, M_WAITOK | M_ZERO);
pp->name = (char *)(pp + 1);
strcpy(pp->name, sbuf_data(sb));
sbuf_delete(sb);
LIST_INIT(&pp->consumers);
pp->error = ENXIO;
pp->geom = gp;
LIST_INSERT_HEAD(&gp->provider, pp, provider);
g_nproviders++;
g_post_event(EV_NEW_PROVIDER, NULL, NULL, pp, NULL);
return (pp);
}
void
g_error_provider(struct g_provider *pp, int error)
{
pp->error = error;
}
void
g_destroy_provider(struct g_provider *pp)
{
struct g_geom *gp;
struct g_consumer *cp;
g_topology_assert();
KASSERT(pp->event == NULL, ("g_destroy_provider() with event"));
KASSERT(LIST_EMPTY(&pp->consumers),
("g_destroy_provider but attached"));
KASSERT (pp->acr == 0, ("g_destroy_provider with acr"));
KASSERT (pp->acw == 0, ("g_destroy_provider with acw"));
KASSERT (pp->acw == 0, ("g_destroy_provider with ace"));
g_nproviders--;
LIST_REMOVE(pp, provider);
gp = pp->geom;
g_free(pp);
if (!(gp->flags & G_GEOM_WITHER))
return;
if (!LIST_EMPTY(&gp->provider))
return;
for (;;) {
cp = LIST_FIRST(&gp->consumer);
if (cp == NULL)
break;
g_dettach(cp);
g_destroy_consumer(cp);
}
g_destroy_geom(gp);
}
/*
* We keep the "geoms" list sorted by topological order (== increasing
* numerical rank) at all times.
* When an attach is done, the attaching geoms rank is invalidated
* and it is moved to the tail of the list.
* All geoms later in the sequence has their ranks reevaluated in
* sequence. If we cannot assign rank to a geom because it's
* prerequisites do not have rank, we move that element to the tail
* of the sequence with invalid rank as well.
* At some point we encounter our original geom and if we stil fail
* to assign it a rank, there must be a loop and we fail back to
* g_attach() which dettach again and calls redo_rank again
* to fix up the damage.
* It would be much simpler code wise to do it recursively, but we
* can't risk that on the kernel stack.
*/
static int
redo_rank(struct g_geom *gp)
{
struct g_consumer *cp;
struct g_geom *gp1, *gp2;
int n, m;
g_topology_assert();
/* Invalidate this geoms rank and move it to the tail */
gp1 = TAILQ_NEXT(gp, geoms);
if (gp1 != NULL) {
gp->rank = 0;
TAILQ_REMOVE(&geoms, gp, geoms);
TAILQ_INSERT_TAIL(&geoms, gp, geoms);
} else {
gp1 = gp;
}
/* re-rank the rest of the sequence */
for (; gp1 != NULL; gp1 = gp2) {
gp1->rank = 0;
m = 1;
LIST_FOREACH(cp, &gp1->consumer, consumer) {
if (cp->provider == NULL)
continue;
n = cp->provider->geom->rank;
if (n == 0) {
m = 0;
break;
} else if (n >= m)
m = n + 1;
}
gp1->rank = m;
gp2 = TAILQ_NEXT(gp1, geoms);
/* got a rank, moving on */
if (m != 0)
continue;
/* no rank to original geom means loop */
if (gp == gp1) {
return (ELOOP);
/* no rank, put it at the end move on */
TAILQ_REMOVE(&geoms, gp1, geoms);
TAILQ_INSERT_TAIL(&geoms, gp1, geoms);
}
}
return (0);
}
int
g_attach(struct g_consumer *cp, struct g_provider *pp)
{
int error;
g_topology_assert();
KASSERT(cp->provider == NULL, ("attach but attached"));
cp->provider = pp;
LIST_INSERT_HEAD(&pp->consumers, cp, consumers);
error = redo_rank(cp->geom);
if (error) {
LIST_REMOVE(cp, consumers);
cp->provider = NULL;
redo_rank(cp->geom);
}
return (error);
}
void
g_dettach(struct g_consumer *cp)
{
struct g_provider *pp;
g_trace(G_T_TOPOLOGY, "g_dettach(%p)", cp);
KASSERT(cp != (void*)0xd0d0d0d0, ("ARGH!"));
g_topology_assert();
KASSERT(cp->provider != NULL, ("dettach but not attached"));
KASSERT(cp->acr == 0, ("dettach but nonzero acr"));
KASSERT(cp->acw == 0, ("dettach but nonzero acw"));
KASSERT(cp->ace == 0, ("dettach but nonzero ace"));
KASSERT(cp->biocount == 0, ("dettach but nonzero biocount"));
pp = cp->provider;
LIST_REMOVE(cp, consumers);
cp->provider = NULL;
if (LIST_EMPTY(&pp->consumers)) {
if (pp->geom->flags & G_GEOM_WITHER)
g_destroy_provider(pp);
}
redo_rank(cp->geom);
}
/*
* g_access_abs()
*
* Access-check with absolute new values: Just fall through
* and use the relative version.
*/
int
g_access_abs(struct g_consumer *cp, int acr, int acw, int ace)
{
g_topology_assert();
return(g_access_rel(cp,
acr - cp->acr,
acw - cp->acw,
ace - cp->ace));
}
/*
* g_access_rel()
*
* Access-check with delta values. The question asked is "can provider
* "cp" change the access counters by the relative amounts dc[rwe] ?"
*/
int
g_access_rel(struct g_consumer *cp, int dcr, int dcw, int dce)
{
struct g_provider *pp;
int pr,pw,pe;
int error;
pp = cp->provider;
g_trace(G_T_ACCESS, "g_access_rel(%p(%s), %d, %d, %d)",
cp, pp->name, dcr, dcw, dce);
g_topology_assert();
KASSERT(cp->provider != NULL, ("access but not attached"));
KASSERT(cp->acr + dcr >= 0, ("access resulting in negative acr"));
KASSERT(cp->acw + dcw >= 0, ("access resulting in negative acw"));
KASSERT(cp->ace + dce >= 0, ("access resulting in negative ace"));
KASSERT(pp->geom->method->access != NULL, ("NULL method->access"));
/*
* If our method cares about being spoiled, and we have been, we
* are probably just ahead of the event telling us that. Fail
* now rather than having to unravel this later.
*/
if (cp->geom->spoiled != NULL && cp->spoiled) {
KASSERT(dcr >= 0, ("spoiled but dcr = %d", dcr));
KASSERT(dcw >= 0, ("spoiled but dce = %d", dcw));
KASSERT(dce >= 0, ("spoiled but dcw = %d", dce));
KASSERT(cp->acr == 0, ("spoiled but cp->acr = %d", cp->acr));
KASSERT(cp->acw == 0, ("spoiled but cp->acw = %d", cp->acw));
KASSERT(cp->ace == 0, ("spoiled but cp->ace = %d", cp->ace));
return(ENXIO);
}
/*
* Figure out what counts the provider would have had, if this
* consumer had (r0w0e0) at this time.
*/
pr = pp->acr - cp->acr;
pw = pp->acw - cp->acw;
pe = pp->ace - cp->ace;
g_trace(G_T_ACCESS,
"open delta:[r%dw%de%d] old:[r%dw%de%d] provider:[r%dw%de%d] %p(%s)",
dcr, dcw, dce,
cp->acr, cp->acw, cp->ace,
pp->acr, pp->acw, pp->ace,
pp, pp->name);
/* If we try exclusive but already write: fail */
if (dce > 0 && pw > 0)
return (EPERM);
/* If we try write but already exclusive: fail */
if (dcw > 0 && pe > 0)
return (EPERM);
/* If we try to open more but provider is error'ed: fail */
if ((dcr > 0 || dcw > 0 || dce > 0) && pp->error != 0)
return (pp->error);
/* Ok then... */
/*
* If we open first write, spoil any partner consumers.
* If we close last write, trigger re-taste.
*/
if (pp->acw == 0 && dcw != 0)
g_spoil(pp, cp);
else if (pp->acw != 0 && pp->acw == -dcw && !(pp->geom->flags & G_GEOM_WITHER))
g_post_event(EV_NEW_PROVIDER, NULL, NULL, pp, NULL);
error = pp->geom->method->access(pp, dcr, dcw, dce);
if (!error) {
pp->acr += dcr;
pp->acw += dcw;
pp->ace += dce;
cp->acr += dcr;
cp->acw += dcw;
cp->ace += dce;
}
return (error);
}
int
g_haveattr_int(struct bio *bp, char *attribute, int val)
{
return (g_haveattr(bp, attribute, &val, sizeof val));
}
int
g_haveattr_off_t(struct bio *bp, char *attribute, off_t val)
{
return (g_haveattr(bp, attribute, &val, sizeof val));
}
int
g_haveattr(struct bio *bp, char *attribute, void *val, int len)
{
int error;
if (strcmp(bp->bio_attribute, attribute))
return (0);
if (bp->bio_length != len) {
printf("bio_length %lld len %d -> EFAULT\n", bp->bio_length, len);
error = EFAULT;
} else {
error = 0;
bcopy(val, bp->bio_data, len);
bp->bio_completed = len;
}
bp->bio_error = error;
g_io_deliver(bp);
return (1);
}
int
g_std_access(struct g_provider *pp __unused,
int dr __unused, int dw __unused, int de __unused)
{
return (0);
}
void
g_std_done(struct bio *bp)
{
struct bio *bp2;
bp2 = bp->bio_linkage;
bp2->bio_error = bp->bio_error;
bp2->bio_completed = bp->bio_completed;
g_destroy_bio(bp);
g_io_deliver(bp2);
}
/* XXX: maybe this is only g_slice_spoiled */
void
g_std_spoiled(struct g_consumer *cp)
{
struct g_geom *gp;
struct g_provider *pp;
g_trace(G_T_TOPOLOGY, "g_std_spoiled(%p)", cp);
g_topology_assert();
g_dettach(cp);
gp = cp->geom;
LIST_FOREACH(pp, &gp->provider, provider)
g_orphan_provider(pp, ENXIO);
g_destroy_consumer(cp);
if (LIST_EMPTY(&gp->provider) && LIST_EMPTY(&gp->consumer))
g_destroy_geom(gp);
else
gp->flags |= G_GEOM_WITHER;
}
/*
* Spoiling happens when a provider is opened for writing, but consumers
* which are configured by in-band data are attached (slicers for instance).
* Since the write might potentially change the in-band data, such consumers
* need to re-evaluate their existence after the writing session closes.
* We do this by (offering to) tear them down when the open for write happens
* in return for a re-taste when it closes again.
* Together with the fact that such consumers grab an 'e' bit whenever they
* are open, regardless of mode, this ends up DTRT.
*/
void
g_spoil(struct g_provider *pp, struct g_consumer *cp)
{
struct g_consumer *cp2;
g_topology_assert();
LIST_FOREACH(cp2, &pp->consumers, consumers) {
if (cp2 == cp)
continue;
/*
KASSERT(cp2->acr == 0, ("spoiling cp->acr = %d", cp2->acr));
KASSERT(cp2->acw == 0, ("spoiling cp->acw = %d", cp2->acw));
*/
KASSERT(cp2->ace == 0, ("spoiling cp->ace = %d", cp2->ace));
cp2->spoiled++;
}
g_post_event(EV_SPOILED, NULL, NULL, pp, cp);
}
static struct g_method *
g_method_by_name(char *name)
{
struct g_method *mp;
g_trace(G_T_TOPOLOGY, "g_method_by_name(%s)", name);
g_topology_assert();
LIST_FOREACH(mp, &g_methods, method)
if (!strcmp(mp->name, name))
return (mp);
return (NULL);
}
struct g_geom *
g_create_geomf(char *method, struct g_provider *pp, char *fmt, ...)
{
va_list ap;
struct sbuf *sb;
char *s;
struct g_method *mp;
struct g_geom *gp;
g_trace(G_T_TOPOLOGY, "g_create_geom(%s, %p(%s))", method,
pp, pp == NULL ? "" : pp->name);
g_topology_assert();
gp = NULL;
mp = g_method_by_name(method);
if (mp == NULL)
return (NULL);
if (fmt != NULL) {
va_start(ap, fmt);
mtx_lock(&Giant);
sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND);
sbuf_vprintf(sb, fmt, ap);
sbuf_finish(sb);
mtx_unlock(&Giant);
s = sbuf_data(sb);
} else {
s = NULL;
}
if (pp != NULL)
gp = mp->taste(mp, pp, NULL, G_TF_INSIST);
if (gp == NULL && mp->create_geom == NULL)
return (NULL);
if (gp == NULL)
gp = mp->create_geom(mp, pp, s);
/* XXX: delete sbuf */
return (gp);
}
struct g_geom *
g_insert_geom(char *method, struct g_consumer *cp)
{
struct g_method *mp;
struct g_geom *gp;
struct g_provider *pp, *pp2;
struct g_consumer *cp2;
int error;
g_trace(G_T_TOPOLOGY, "g_insert_geomf(%s, %p)", method, cp);
g_topology_assert();
KASSERT(cp->provider != NULL, ("g_insert_geomf but not attached"));
/* XXX: check for events ?? */
mp = g_method_by_name(method);
if (mp == NULL)
return (NULL);
if (mp->create_geom == NULL)
return (NULL);
pp = cp->provider;
gp = mp->taste(mp, pp, NULL, G_TF_TRANSPARENT);
if (gp == NULL)
return (NULL);
pp2 = LIST_FIRST(&gp->provider);
cp2 = LIST_FIRST(&gp->consumer);
cp2->acr += pp->acr;
cp2->acw += pp->acw;
cp2->ace += pp->ace;
pp2->acr += pp->acr;
pp2->acw += pp->acw;
pp2->ace += pp->ace;
LIST_REMOVE(cp, consumers);
LIST_INSERT_HEAD(&pp2->consumers, cp, consumers);
cp->provider = pp2;
error = redo_rank(gp);
KASSERT(error == 0, ("redo_rank failed in g_insert_geom"));
return (gp);
}