/*-
 * Copyright (c) 2002, 2005, 2006, 2007 Marcel Moolenaar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/bio.h>
#include <sys/diskmbr.h>
#include <sys/endian.h>
#include <sys/kernel.h>
#include <sys/kobj.h>
#include <sys/limits.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/queue.h>
#include <sys/sbuf.h>
#include <sys/systm.h>
#include <sys/uuid.h>
#include <geom/geom.h>
#include <geom/geom_ctl.h>
#include <geom/part/g_part.h>

#include "g_part_if.h"

static kobj_method_t g_part_null_methods[] = {
	{ 0, 0 }
};

static struct g_part_scheme g_part_null_scheme = {
	NULL,
	g_part_null_methods,
	sizeof(struct g_part_table),
};
G_PART_SCHEME_DECLARE(g_part_null_scheme);

SET_DECLARE(g_part_scheme_set, struct g_part_scheme);

struct g_part_alias_list {
	const char *lexeme;
	enum g_part_alias alias;
} g_part_alias_list[G_PART_ALIAS_COUNT] = {
	{ "@efi", G_PART_ALIAS_EFI },
	{ "@freebsd", G_PART_ALIAS_FREEBSD },
	{ "@freebsd-swap", G_PART_ALIAS_FREEBSD_SWAP },
	{ "@freebsd-ufs", G_PART_ALIAS_FREEBSD_UFS },
	{ "@freebsd-vinum", G_PART_ALIAS_FREEBSD_VINUM },
	{ "@mbr", G_PART_ALIAS_MBR }
};

/*
 * The GEOM partitioning class.
 */
static g_ctl_req_t g_part_ctlreq;
static g_ctl_destroy_geom_t g_part_destroy_geom;
static g_taste_t g_part_taste;

static g_access_t g_part_access;
static g_dumpconf_t g_part_dumpconf;
static g_orphan_t g_part_orphan;
static g_spoiled_t g_part_spoiled;
static g_start_t g_part_start;

static struct g_class g_part_class = {
	.name = "PART",
	.version = G_VERSION,
	/* Class methods. */
	.ctlreq = g_part_ctlreq,
	.destroy_geom = g_part_destroy_geom,
	.taste = g_part_taste,
	/* Geom methods. */
	.access = g_part_access,
	.dumpconf = g_part_dumpconf,
	.orphan = g_part_orphan,
	.spoiled = g_part_spoiled,
	.start = g_part_start,
};

DECLARE_GEOM_CLASS(g_part_class, g_part);

enum g_part_ctl {
	G_PART_CTL_NONE,
	G_PART_CTL_ADD,
	G_PART_CTL_COMMIT,
	G_PART_CTL_CREATE,
	G_PART_CTL_DELETE,
	G_PART_CTL_DESTROY,
	G_PART_CTL_MODIFY,
	G_PART_CTL_MOVE,
	G_PART_CTL_QUERY,
	G_PART_CTL_RECOVER,
	G_PART_CTL_RESIZE,
	G_PART_CTL_UNDO
};

/*
 * Support functions.
 */

static void g_part_wither(struct g_geom *, int);

const char *
g_part_alias_name(enum g_part_alias alias)
{
	int i;

	for (i = 0; i < G_PART_ALIAS_COUNT; i++) {
		if (g_part_alias_list[i].alias != alias)
			continue;
		return (g_part_alias_list[i].lexeme);
	}

	return (NULL);
}

struct g_part_entry *
g_part_new_entry(struct g_part_table *table, int index, quad_t start,
    quad_t end)
{
	struct g_part_entry *entry, *last;

	last = NULL;
	LIST_FOREACH(entry, &table->gpt_entry, gpe_entry) {
		if (entry->gpe_index == index)
			break;
		if (entry->gpe_index > index) {
			entry = NULL;
			break;
		}
		last = entry;
	}
	if (entry == NULL) {
		entry = g_malloc(table->gpt_scheme->gps_entrysz,
		    M_WAITOK | M_ZERO);
		entry->gpe_index = index;
		if (last == NULL)
			LIST_INSERT_HEAD(&table->gpt_entry, entry, gpe_entry);
		else
			LIST_INSERT_AFTER(last, entry, gpe_entry);
	}
	entry->gpe_start = start;
	entry->gpe_end = end;
	return (entry);
}

static void
g_part_new_provider(struct g_geom *gp, struct g_part_table *table,
    struct g_part_entry *entry)
{
	char buf[32];
	struct g_consumer *cp;
	struct g_provider *pp;

	cp = LIST_FIRST(&gp->consumer);
	pp = cp->provider;

	entry->gpe_offset = entry->gpe_start * pp->sectorsize;

	if (entry->gpe_pp == NULL) {
		entry->gpe_pp = g_new_providerf(gp, "%s%s", gp->name,
		    G_PART_NAME(table, entry, buf, sizeof(buf)));
		entry->gpe_pp->private = entry;		/* Close the circle. */
	}
	entry->gpe_pp->index = entry->gpe_index - 1;	/* index is 1-based. */
	entry->gpe_pp->mediasize = (entry->gpe_end - entry->gpe_start + 1) *
	    pp->sectorsize;
	entry->gpe_pp->sectorsize = pp->sectorsize;
	entry->gpe_pp->flags = pp->flags & G_PF_CANDELETE;
	if (pp->stripesize > 0) {
		entry->gpe_pp->stripesize = pp->stripesize;
		entry->gpe_pp->stripeoffset = (pp->stripeoffset +
		    entry->gpe_offset) % pp->stripesize;
	}
	g_error_provider(entry->gpe_pp, 0);
}

static int
g_part_parm_geom(const char *p, struct g_geom **v)
{
	struct g_geom *gp;

	LIST_FOREACH(gp, &g_part_class.geom, geom) {
		if (!strcmp(p, gp->name))
			break;
	}
	if (gp == NULL)
		return (EINVAL);
	*v = gp;
	return (0);
}

static int
g_part_parm_provider(const char *p, struct g_provider **v)
{
	struct g_provider *pp;

	pp = g_provider_by_name(p);
	if (pp == NULL)
		return (EINVAL);
	*v = pp;
	return (0);
}

static int
g_part_parm_quad(const char *p, quad_t *v)
{
	char *x;
	quad_t q;

	q = strtoq(p, &x, 0);
	if (*x != '\0' || q < 0)
		return (EINVAL);
	*v = q;
	return (0);
}

static int
g_part_parm_scheme(const char *p, struct g_part_scheme **v)
{
	struct g_part_scheme **iter, *s;

	s = NULL;
	SET_FOREACH(iter, g_part_scheme_set) {
		if ((*iter)->name == NULL)
			continue;
		if (!strcmp((*iter)->name, p)) {
			s = *iter;
			break;
		}
	}
	if (s == NULL)
		return (EINVAL);
	*v = s;
	return (0);
}

static int
g_part_parm_str(const char *p, const char **v)
{

	if (p[0] == '\0')
		return (EINVAL);
	*v = p;
	return (0);
}

static int
g_part_parm_uint(const char *p, u_int *v)
{
	char *x;
	long l;

	l = strtol(p, &x, 0);
	if (*x != '\0' || l < 0 || l > INT_MAX)
		return (EINVAL);
	*v = (unsigned int)l;
	return (0);
}

static int
g_part_probe(struct g_geom *gp, struct g_consumer *cp, int depth)
{
	struct g_part_scheme **iter, *scheme;
	struct g_part_table *table;
	int pri, probe;

	table = gp->softc;
	scheme = (table != NULL) ? table->gpt_scheme : &g_part_null_scheme;
	pri = (scheme != &g_part_null_scheme) ? G_PART_PROBE(table, cp) :
	    INT_MIN;
	if (pri == 0)
		goto done;
	if (pri > 0) {	/* error */
		scheme = &g_part_null_scheme;
		pri = INT_MIN;
	}

	SET_FOREACH(iter, g_part_scheme_set) {
		if ((*iter) == &g_part_null_scheme)
			continue;
		table = (void *)kobj_create((kobj_class_t)(*iter), M_GEOM,
		    M_WAITOK);
		table->gpt_gp = gp;
		table->gpt_scheme = *iter;
		table->gpt_depth = depth;
		probe = G_PART_PROBE(table, cp);
		if (probe <= 0 && probe > pri) {
			pri = probe;
			scheme = *iter;
			if (gp->softc != NULL)
				kobj_delete((kobj_t)gp->softc, M_GEOM);
			gp->softc = table;
			if (pri == 0)
				goto done;
		} else
			kobj_delete((kobj_t)table, M_GEOM);
	}

done:
	return ((scheme == &g_part_null_scheme) ? ENXIO : 0);
}

/*
 * Control request functions.
 */

static int
g_part_ctl_add(struct gctl_req *req, struct g_part_parms *gpp)
{
	char buf[16];
	struct g_geom *gp;
	struct g_provider *pp;
	struct g_part_entry *delent, *last, *entry;
	struct g_part_table *table;
	quad_t end;
	unsigned int index;
	int error;

	gp = gpp->gpp_geom;
	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, gp->name));
	g_topology_assert();

	pp = LIST_FIRST(&gp->consumer)->provider;
	table = gp->softc;
	end = gpp->gpp_start + gpp->gpp_size - 1;

	if (gpp->gpp_start < table->gpt_first ||
	    gpp->gpp_start > table->gpt_last) {
		gctl_error(req, "%d start '%jd'", EINVAL,
		    (intmax_t)gpp->gpp_start);
		return (EINVAL);
	}
	if (end < gpp->gpp_start || end > table->gpt_last) {
		gctl_error(req, "%d size '%jd'", EINVAL,
		    (intmax_t)gpp->gpp_size);
		return (EINVAL);
	}
	if (gpp->gpp_index > table->gpt_entries) {
		gctl_error(req, "%d index '%d'", EINVAL, gpp->gpp_index);
		return (EINVAL);
	}

	delent = last = NULL;
	index = (gpp->gpp_index > 0) ? gpp->gpp_index : 1;
	LIST_FOREACH(entry, &table->gpt_entry, gpe_entry) {
		if (entry->gpe_deleted) {
			if (entry->gpe_index == index)
				delent = entry;
			continue;
		}
		if (entry->gpe_index == index) {
			index = entry->gpe_index + 1;
			last = entry;
		}
		if (gpp->gpp_start >= entry->gpe_start &&
		    gpp->gpp_start <= entry->gpe_end) {
			gctl_error(req, "%d start '%jd'", ENOSPC,
			    (intmax_t)gpp->gpp_start);
			return (ENOSPC);
		}
		if (end >= entry->gpe_start && end <= entry->gpe_end) {
			gctl_error(req, "%d end '%jd'", ENOSPC, (intmax_t)end);
			return (ENOSPC);
		}
		if (gpp->gpp_start < entry->gpe_start && end > entry->gpe_end) {
			gctl_error(req, "%d size '%jd'", ENOSPC,
			    (intmax_t)gpp->gpp_size);
			return (ENOSPC);
		}
	}
	if (gpp->gpp_index > 0 && index != gpp->gpp_index) {
		gctl_error(req, "%d index '%d'", EEXIST, gpp->gpp_index);
		return (EEXIST);
	}
	snprintf(buf, sizeof(buf), "%d", index);
	gctl_set_param(req, "index", buf, strlen(buf) + 1);

	entry = (delent == NULL) ? g_malloc(table->gpt_scheme->gps_entrysz,
	    M_WAITOK | M_ZERO) : delent;
	entry->gpe_index = index;
	entry->gpe_start = gpp->gpp_start;
	entry->gpe_end = end;
	error = G_PART_ADD(table, entry, gpp);
	if (error) {
		gctl_error(req, "%d", error);
		if (delent == NULL)
			g_free(entry);
		return (error);
	}
	if (delent == NULL) {
		if (last == NULL)
			LIST_INSERT_HEAD(&table->gpt_entry, entry, gpe_entry);
		else
			LIST_INSERT_AFTER(last, entry, gpe_entry);
		entry->gpe_created = 1;
	} else {
		entry->gpe_deleted = 0;
		entry->gpe_modified = 1;
	}
	g_part_new_provider(gp, table, entry);
	return (0);
}

static int
g_part_ctl_commit(struct gctl_req *req, struct g_part_parms *gpp)
{
	struct g_consumer *cp;
	struct g_geom *gp;
	struct g_provider *pp;
	struct g_part_entry *entry, *tmp;
	struct g_part_table *table;
	char *buf;
	int error, i;

	gp = gpp->gpp_geom;
	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, gp->name));
	g_topology_assert();

	table = gp->softc;
	if (!table->gpt_opened) {
		gctl_error(req, "%d", EPERM);
		return (EPERM);
	}

	cp = LIST_FIRST(&gp->consumer);
	if ((table->gpt_smhead | table->gpt_smtail) != 0) {
		pp = cp->provider;
		buf = g_malloc(pp->sectorsize, M_WAITOK | M_ZERO);
		while (table->gpt_smhead != 0) {
			i = ffs(table->gpt_smhead) - 1;
			error = g_write_data(cp, i * pp->sectorsize, buf,
			    pp->sectorsize);
			if (error) {
				g_free(buf);
				goto fail;
			}
			table->gpt_smhead &= ~(1 << i);
		}
		while (table->gpt_smtail != 0) {
			i = ffs(table->gpt_smtail) - 1;
			error = g_write_data(cp, pp->mediasize - (i + 1) *
			    pp->sectorsize, buf, pp->sectorsize);
			if (error) {
				g_free(buf);
				goto fail;
			}
			table->gpt_smtail &= ~(1 << i);
		}
		g_free(buf);
	}

	if (table->gpt_scheme == &g_part_null_scheme) {
		g_access(cp, -1, -1, -1);
		g_part_wither(gp, ENXIO);
		return (0);
	}

	error = G_PART_WRITE(table, cp);
	if (error)
		goto fail;

	LIST_FOREACH_SAFE(entry, &table->gpt_entry, gpe_entry, tmp) {
		if (!entry->gpe_deleted) {
			entry->gpe_created = 0;
			entry->gpe_modified = 0;
			continue;
		}
		LIST_REMOVE(entry, gpe_entry);
		g_free(entry);
	}
	table->gpt_created = 0;
	table->gpt_opened = 0;
	g_access(cp, -1, -1, -1);
	return (0);

fail:
	gctl_error(req, "%d", error);
	return (error);
}

static int
g_part_ctl_create(struct gctl_req *req, struct g_part_parms *gpp)
{
	struct g_consumer *cp;
	struct g_geom *gp;
	struct g_provider *pp;
	struct g_part_scheme *scheme;
	struct g_part_table *null, *table;
	int attr, error;

	pp = gpp->gpp_provider;
	scheme = gpp->gpp_scheme;
	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, pp->name));
	g_topology_assert();

	/* Check that there isn't already a g_part geom on the provider. */
	error = g_part_parm_geom(pp->name, &gp);
	if (!error) {
		null = gp->softc;
		if (null->gpt_scheme != &g_part_null_scheme) {
			gctl_error(req, "%d geom '%s'", EEXIST, pp->name);
			return (EEXIST);
		}
	} else
		null = NULL;

	if ((gpp->gpp_parms & G_PART_PARM_ENTRIES) &&
	    (gpp->gpp_entries < scheme->gps_minent ||
	     gpp->gpp_entries > scheme->gps_maxent)) {
		gctl_error(req, "%d entries '%d'", EINVAL, gpp->gpp_entries);
		return (EINVAL);
	}

	if (null == NULL)
		gp = g_new_geomf(&g_part_class, "%s", pp->name);
	gp->softc = kobj_create((kobj_class_t)gpp->gpp_scheme, M_GEOM,
	    M_WAITOK);
	table = gp->softc;
	table->gpt_gp = gp;
	table->gpt_scheme = gpp->gpp_scheme;
	table->gpt_entries = (gpp->gpp_parms & G_PART_PARM_ENTRIES) ?
	    gpp->gpp_entries : scheme->gps_minent;
	LIST_INIT(&table->gpt_entry);
	if (null == NULL) {
		cp = g_new_consumer(gp);
		error = g_attach(cp, pp);
		if (error == 0)
			error = g_access(cp, 1, 1, 1);
		if (error != 0) {
			g_part_wither(gp, error);
			gctl_error(req, "%d geom '%s'", error, pp->name);
			return (error);
		}
		table->gpt_opened = 1;
	} else {
		cp = LIST_FIRST(&gp->consumer);
		table->gpt_opened = null->gpt_opened;
		table->gpt_smhead = null->gpt_smhead;
		table->gpt_smtail = null->gpt_smtail;
	}

	g_topology_unlock();

	/* Make sure we can nest and if so, determine our depth. */
	error = g_getattr("PART::isleaf", cp, &attr);
	if (!error && attr) {
		error = ENODEV;
		goto fail;
	}
	error = g_getattr("PART::depth", cp, &attr);
	table->gpt_depth = (!error) ? attr + 1 : 0;

	error = G_PART_CREATE(table, gpp);
	if (error)
		goto fail;

	g_topology_lock();

	table->gpt_created = 1;
	if (null != NULL)
		kobj_delete((kobj_t)null, M_GEOM);
	return (0);

fail:
	g_topology_lock();
	if (null == NULL) {
		g_access(cp, -1, -1, -1);
		g_part_wither(gp, error);
	} else {
		kobj_delete((kobj_t)gp->softc, M_GEOM);
		gp->softc = null;
	}
	gctl_error(req, "%d provider", error);
	return (error);
}

static int
g_part_ctl_delete(struct gctl_req *req, struct g_part_parms *gpp)
{
	struct g_geom *gp;
	struct g_provider *pp;
	struct g_part_entry *entry;
	struct g_part_table *table;

	gp = gpp->gpp_geom;
	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, gp->name));
	g_topology_assert();

	table = gp->softc;

	LIST_FOREACH(entry, &table->gpt_entry, gpe_entry) {
		if (entry->gpe_deleted)
			continue;
		if (entry->gpe_index == gpp->gpp_index)
			break;
	}
	if (entry == NULL) {
		gctl_error(req, "%d index '%d'", ENOENT, gpp->gpp_index);
		return (ENOENT);
	}

	pp = entry->gpe_pp;
	if (pp->acr > 0 || pp->acw > 0 || pp->ace > 0) {
		gctl_error(req, "%d", EBUSY);
		return (EBUSY);
	}

	pp->private = NULL;
	entry->gpe_pp = NULL;
	if (entry->gpe_created) {
		LIST_REMOVE(entry, gpe_entry);
		g_free(entry);
	} else {
		entry->gpe_modified = 0;
		entry->gpe_deleted = 1;
	}
	g_wither_provider(pp, ENXIO);
	return (0);
}

static int
g_part_ctl_destroy(struct gctl_req *req, struct g_part_parms *gpp)
{
	struct g_geom *gp;
	struct g_part_entry *entry;
	struct g_part_table *null, *table;
	int error;

	gp = gpp->gpp_geom;
	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, gp->name));
	g_topology_assert();

	table = gp->softc;
	LIST_FOREACH(entry, &table->gpt_entry, gpe_entry) {
		if (entry->gpe_deleted)
			continue;
		gctl_error(req, "%d", EBUSY);
		return (EBUSY);
	}

	error = G_PART_DESTROY(table, gpp);
	if (error) {
		gctl_error(req, "%d", error);
		return (error);
	}

	gp->softc = kobj_create((kobj_class_t)&g_part_null_scheme, M_GEOM,
	    M_WAITOK);
	null = gp->softc;
	null->gpt_gp = gp;
	null->gpt_scheme = &g_part_null_scheme;
	LIST_INIT(&null->gpt_entry);
	null->gpt_depth = table->gpt_depth;
	null->gpt_opened = table->gpt_opened;
	null->gpt_smhead = table->gpt_smhead;
	null->gpt_smtail = table->gpt_smtail;

	while ((entry = LIST_FIRST(&table->gpt_entry)) != NULL) {
		LIST_REMOVE(entry, gpe_entry);
		g_free(entry);
	}
	kobj_delete((kobj_t)table, M_GEOM);

	return (0);
}

static int
g_part_ctl_modify(struct gctl_req *req, struct g_part_parms *gpp)
{
	struct g_geom *gp;
	struct g_part_entry *entry;
	struct g_part_table *table;
	int error;

	gp = gpp->gpp_geom;
	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, gp->name));
	g_topology_assert();

	table = gp->softc;

	LIST_FOREACH(entry, &table->gpt_entry, gpe_entry) {
		if (entry->gpe_deleted)
			continue;
		if (entry->gpe_index == gpp->gpp_index)
			break;
	}
	if (entry == NULL) {
		gctl_error(req, "%d index '%d'", ENOENT, gpp->gpp_index);
		return (ENOENT);
	}

	error = G_PART_MODIFY(table, entry, gpp);
	if (error) {
		gctl_error(req, "%d", error);
		return (error);
	}

	if (!entry->gpe_created)
		entry->gpe_modified = 1;
	return (0);
}

static int
g_part_ctl_move(struct gctl_req *req, struct g_part_parms *gpp)
{
	gctl_error(req, "%d verb 'move'", ENOSYS);
	return (ENOSYS);
} 

static int
g_part_ctl_query(struct gctl_req *req, struct g_part_parms *gpp)
{
	gctl_error(req, "%d verb 'query'", ENOSYS);
	return (ENOSYS);
} 

static int
g_part_ctl_recover(struct gctl_req *req, struct g_part_parms *gpp)
{
	gctl_error(req, "%d verb 'recover'", ENOSYS);
	return (ENOSYS);
}

static int
g_part_ctl_resize(struct gctl_req *req, struct g_part_parms *gpp)
{
	gctl_error(req, "%d verb 'resize'", ENOSYS);
	return (ENOSYS);
} 

static int
g_part_ctl_undo(struct gctl_req *req, struct g_part_parms *gpp)
{
	struct g_consumer *cp;
	struct g_provider *pp;
	struct g_geom *gp;
	struct g_part_entry *entry, *tmp;
	struct g_part_table *table;
	int error, reprobe;

	gp = gpp->gpp_geom;
	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, gp->name));
	g_topology_assert();

	table = gp->softc;
	if (!table->gpt_opened) {
		gctl_error(req, "%d", EPERM);
		return (EPERM);
	}

	cp = LIST_FIRST(&gp->consumer);
	LIST_FOREACH_SAFE(entry, &table->gpt_entry, gpe_entry, tmp) {
		entry->gpe_modified = 0;
		if (entry->gpe_created) {
			pp = entry->gpe_pp;
			pp->private = NULL;
			entry->gpe_pp = NULL;
			g_wither_provider(pp, ENXIO);
			entry->gpe_deleted = 1;
		}
		if (entry->gpe_deleted) {
			LIST_REMOVE(entry, gpe_entry);
			g_free(entry);
		}
	}

	g_topology_unlock();

	reprobe = (table->gpt_scheme == &g_part_null_scheme ||
	    table->gpt_created) ? 1 : 0;

	if (reprobe) {
		if (!LIST_EMPTY(&table->gpt_entry)) {
			error = EBUSY;
			goto fail;
		}
		error = g_part_probe(gp, cp, table->gpt_depth);
		if (error)
			goto fail;
		table = gp->softc;
	}

	error = G_PART_READ(table, cp);
	if (error)
		goto fail;

	g_topology_lock();

	LIST_FOREACH(entry, &table->gpt_entry, gpe_entry)
		g_part_new_provider(gp, table, entry);

	table->gpt_opened = 0;
	g_access(cp, -1, -1, -1);
	return (0);

fail:
	g_topology_lock();
	gctl_error(req, "%d", error);
	return (error);
}

static void
g_part_wither(struct g_geom *gp, int error)
{
	struct g_part_entry *entry;
	struct g_part_table *table;

	table = gp->softc;
	if (table != NULL) {
		while ((entry = LIST_FIRST(&table->gpt_entry)) != NULL) {
			LIST_REMOVE(entry, gpe_entry);
			g_free(entry);
		}
		if (gp->softc != NULL) {
			kobj_delete((kobj_t)gp->softc, M_GEOM);
			gp->softc = NULL;
		}
	}
	g_wither_geom(gp, error);
}

/*
 * Class methods.
 */

static void
g_part_ctlreq(struct gctl_req *req, struct g_class *mp, const char *verb)
{
	struct g_part_parms gpp;
	struct g_part_table *table;
	struct gctl_req_arg *ap;
	const char *p;
	enum g_part_ctl ctlreq;
	unsigned int i, mparms, oparms, parm;
	int error, modifies;

	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s,%s)", __func__, mp->name, verb));
	g_topology_assert();

	ctlreq = G_PART_CTL_NONE;
	modifies = 0;
	mparms = oparms = 0;
	switch (*verb) {
	case 'a':
		if (!strcmp(verb, "add")) {
			ctlreq = G_PART_CTL_ADD;
			modifies = 1;
			mparms = G_PART_PARM_GEOM | G_PART_PARM_SIZE |
			    G_PART_PARM_START | G_PART_PARM_TYPE;
			oparms = G_PART_PARM_FLAGS | G_PART_PARM_INDEX |
			    G_PART_PARM_LABEL;
		}
		break;
	case 'c':
		if (!strcmp(verb, "commit")) {
			ctlreq = G_PART_CTL_COMMIT;
			mparms = G_PART_PARM_GEOM;
			oparms = G_PART_PARM_FLAGS;
		} else if (!strcmp(verb, "create")) {
			ctlreq = G_PART_CTL_CREATE;
			modifies = 1;
			mparms = G_PART_PARM_PROVIDER |
			    G_PART_PARM_SCHEME;
			oparms = G_PART_PARM_ENTRIES | G_PART_PARM_FLAGS;
		}
		break;
	case 'd':
		if (!strcmp(verb, "delete")) {
			ctlreq = G_PART_CTL_DELETE;
			modifies = 1;
			mparms = G_PART_PARM_GEOM | G_PART_PARM_INDEX;
			oparms = G_PART_PARM_FLAGS;
		} else if (!strcmp(verb, "destroy")) {
			ctlreq = G_PART_CTL_DESTROY;
			modifies = 1;
			mparms = G_PART_PARM_GEOM;
			oparms = G_PART_PARM_FLAGS;
		}
		break;
	case 'm':
		if (!strcmp(verb, "modify")) {
			ctlreq = G_PART_CTL_MODIFY;
			modifies = 1;
			mparms = G_PART_PARM_GEOM | G_PART_PARM_INDEX;
			oparms = G_PART_PARM_FLAGS | G_PART_PARM_LABEL |
			    G_PART_PARM_TYPE;
		} else if (!strcmp(verb, "move")) {
			ctlreq = G_PART_CTL_MOVE;
			modifies = 1;
			mparms = G_PART_PARM_GEOM | G_PART_PARM_INDEX;
			oparms = G_PART_PARM_FLAGS;
		}
		break;
	case 'q':
		if (!strcmp(verb, "query")) {
			ctlreq = G_PART_CTL_QUERY;
			mparms = G_PART_PARM_REQUEST | G_PART_PARM_RESPONSE;
			oparms = G_PART_PARM_FLAGS | G_PART_PARM_GEOM;
		}
		break;
	case 'r':
		if (!strcmp(verb, "recover")) {
			ctlreq = G_PART_CTL_RECOVER;
			modifies = 1;
			mparms = G_PART_PARM_GEOM;
			oparms = G_PART_PARM_FLAGS;
		} else if (!strcmp(verb, "resize")) {
			ctlreq = G_PART_CTL_RESIZE;
			modifies = 1;
			mparms = G_PART_PARM_GEOM | G_PART_PARM_INDEX;
			oparms = G_PART_PARM_FLAGS;
		}
		break;
	case 'u':
		if (!strcmp(verb, "undo")) {
			ctlreq = G_PART_CTL_UNDO;
			mparms = G_PART_PARM_GEOM;
			oparms = G_PART_PARM_FLAGS;
		}
		break;
	}
	if (ctlreq == G_PART_CTL_NONE) {
		gctl_error(req, "%d verb '%s'", EINVAL, verb);
		return;
	}

	bzero(&gpp, sizeof(gpp));
	for (i = 0; i < req->narg; i++) {
		ap = &req->arg[i];
		parm = 0;
		switch (ap->name[0]) {
		case 'c':
			if (!strcmp(ap->name, "class"))
				continue;
			break;
		case 'e':
			if (!strcmp(ap->name, "entries"))
				parm = G_PART_PARM_ENTRIES;
			break;
		case 'f':
			if (!strcmp(ap->name, "flags"))
				parm = G_PART_PARM_FLAGS;
			break;
		case 'g':
			if (!strcmp(ap->name, "geom"))
				parm = G_PART_PARM_GEOM;
			break;
		case 'i':
			if (!strcmp(ap->name, "index"))
				parm = G_PART_PARM_INDEX;
			break;
		case 'l':
			if (!strcmp(ap->name, "label"))
				parm = G_PART_PARM_LABEL;
			break;
		case 'p':
			if (!strcmp(ap->name, "provider"))
				parm = G_PART_PARM_PROVIDER;
			break;
		case 'r':
			if (!strcmp(ap->name, "request"))
				parm = G_PART_PARM_REQUEST;
			else if (!strcmp(ap->name, "response"))
				parm = G_PART_PARM_RESPONSE;
			break;
		case 's':
			if (!strcmp(ap->name, "scheme"))
				parm = G_PART_PARM_SCHEME;
			else if (!strcmp(ap->name, "size"))
				parm = G_PART_PARM_SIZE;
			else if (!strcmp(ap->name, "start"))
				parm = G_PART_PARM_START;
			break;
		case 't':
			if (!strcmp(ap->name, "type"))
				parm = G_PART_PARM_TYPE;
			break;
		case 'v':
			if (!strcmp(ap->name, "verb"))
				continue;
			break;
		}
		if ((parm & (mparms | oparms)) == 0) {
			gctl_error(req, "%d param '%s'", EINVAL, ap->name);
			return;
		}
		p = gctl_get_asciiparam(req, ap->name);
		if (p == NULL) {
			gctl_error(req, "%d param '%s'", ENOATTR, ap->name);
			return;
		}
		switch (parm) {
		case G_PART_PARM_ENTRIES:
			error = g_part_parm_uint(p, &gpp.gpp_entries);
			break;
		case G_PART_PARM_FLAGS:
			error = g_part_parm_str(p, &gpp.gpp_flags);
			break;
		case G_PART_PARM_GEOM:
			error = g_part_parm_geom(p, &gpp.gpp_geom);
			break;
		case G_PART_PARM_INDEX:
			error = g_part_parm_uint(p, &gpp.gpp_index);
			break;
		case G_PART_PARM_LABEL:
			error = g_part_parm_str(p, &gpp.gpp_label);
			break;
		case G_PART_PARM_PROVIDER:
			error = g_part_parm_provider(p, &gpp.gpp_provider);
			break;
		case G_PART_PARM_REQUEST:
			error = g_part_parm_str(p, &gpp.gpp_request);
			break;
		case G_PART_PARM_RESPONSE:
			error = 0;	/* Write-only parameter. */
			break;
		case G_PART_PARM_SCHEME:
			error = g_part_parm_scheme(p, &gpp.gpp_scheme);
			break;
		case G_PART_PARM_SIZE:
			error = g_part_parm_quad(p, &gpp.gpp_size);
			break;
		case G_PART_PARM_START:
			error = g_part_parm_quad(p, &gpp.gpp_start);
			break;
		case G_PART_PARM_TYPE:
			error = g_part_parm_str(p, &gpp.gpp_type);
			break;
		default:
			error = EDOOFUS;
			break;
		}
		if (error) {
			gctl_error(req, "%d %s '%s'", error, ap->name, p);
			return;
		}
		gpp.gpp_parms |= parm;
	}
	if ((gpp.gpp_parms & mparms) != mparms) {
		parm = mparms - (gpp.gpp_parms & mparms);
		gctl_error(req, "%d param '%x'", ENOATTR, parm);
		return;
	}

	/* Obtain permissions if possible/necessary. */
	if (modifies && (gpp.gpp_parms & G_PART_PARM_GEOM)) {
		table = gpp.gpp_geom->softc;
		if (table != NULL && !table->gpt_opened) {
			error = g_access(LIST_FIRST(&gpp.gpp_geom->consumer),
			    1, 1, 1);
			if (error) {
				gctl_error(req, "%d geom '%s'", error,
				    gpp.gpp_geom->name);
				return;
			}
			table->gpt_opened = 1;
		}
	}

	error = EDOOFUS;	/* Prevent bogus  uninit. warning. */
	switch (ctlreq) {
	case G_PART_CTL_NONE:
		panic("%s", __func__);
	case G_PART_CTL_ADD:
		error = g_part_ctl_add(req, &gpp);
		break;
	case G_PART_CTL_COMMIT:
		error = g_part_ctl_commit(req, &gpp);
		break;
	case G_PART_CTL_CREATE:
		error = g_part_ctl_create(req, &gpp);
		break;
	case G_PART_CTL_DELETE:
		error = g_part_ctl_delete(req, &gpp);
		break;
	case G_PART_CTL_DESTROY:
		error = g_part_ctl_destroy(req, &gpp);
		break;
	case G_PART_CTL_MODIFY:
		error = g_part_ctl_modify(req, &gpp);
		break;
	case G_PART_CTL_MOVE:
		error = g_part_ctl_move(req, &gpp);
		break;
	case G_PART_CTL_QUERY:
		error = g_part_ctl_query(req, &gpp);
		break;
	case G_PART_CTL_RECOVER:
		error = g_part_ctl_recover(req, &gpp);
		break;
	case G_PART_CTL_RESIZE:
		error = g_part_ctl_resize(req, &gpp);
		break;
	case G_PART_CTL_UNDO:
		error = g_part_ctl_undo(req, &gpp);
		break;
	}
}

static int
g_part_destroy_geom(struct gctl_req *req, struct g_class *mp,
    struct g_geom *gp)
{

	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s,%s)", __func__, mp->name, gp->name));
	g_topology_assert();

	g_part_wither(gp, EINVAL);
	return (0);
}

static struct g_geom *
g_part_taste(struct g_class *mp, struct g_provider *pp, int flags __unused)
{
	struct g_consumer *cp;
	struct g_geom *gp;
	struct g_part_entry *entry;
	struct g_part_table *table;
	int attr, depth;
	int error;

	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s,%s)", __func__, mp->name, pp->name));
	g_topology_assert();

	/*
	 * Create a GEOM with consumer and hook it up to the provider.
	 * With that we become part of the topology. Optain read access
	 * to the provider.
	 */
	gp = g_new_geomf(mp, "%s", pp->name);
	cp = g_new_consumer(gp);
	error = g_attach(cp, pp);
	if (error == 0)
		error = g_access(cp, 1, 0, 0);
	if (error != 0) {
		g_part_wither(gp, error);
		return (NULL);
	}

	g_topology_unlock();

	/* Make sure we can nest and if so, determine our depth. */
	error = g_getattr("PART::isleaf", cp, &attr);
	if (!error && attr) {
		error = ENODEV;
		goto fail;
	}
	error = g_getattr("PART::depth", cp, &attr);
	depth = (!error) ? attr + 1 : 0;

	error = g_part_probe(gp, cp, depth);
	if (error)
		goto fail;

	table = gp->softc;
	error = G_PART_READ(table, cp);
	if (error)
		goto fail;

	g_topology_lock();
	LIST_FOREACH(entry, &table->gpt_entry, gpe_entry)
		g_part_new_provider(gp, table, entry);

	g_access(cp, -1, 0, 0);
	return (gp);

 fail:
	g_topology_lock();
	g_access(cp, -1, 0, 0);
	g_part_wither(gp, error);
	return (NULL);
}

/*
 * Geom methods.
 */

static int
g_part_access(struct g_provider *pp, int dr, int dw, int de)
{
	struct g_consumer *cp;

	G_PART_TRACE((G_T_ACCESS, "%s(%s,%d,%d,%d)", __func__, pp->name, dr,
	    dw, de));

	cp = LIST_FIRST(&pp->geom->consumer);

	/* We always gain write-exclusive access. */
	return (g_access(cp, dr, dw, dw + de));
}

static void
g_part_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
    struct g_consumer *cp, struct g_provider *pp)
{
	char buf[64];
	struct g_part_entry *entry;
	struct g_part_table *table;

	KASSERT(sb != NULL && gp != NULL, (__func__));
	table = gp->softc;

	if (indent == NULL) {
		KASSERT(cp == NULL && pp != NULL, (__func__));
		entry = pp->private;
		if (entry == NULL)
			return;
		sbuf_printf(sb, " i %u o %ju ty %s", entry->gpe_index,
		    (uintmax_t)entry->gpe_offset,
		    G_PART_TYPE(table, entry, buf, sizeof(buf)));
	} else if (cp != NULL) {	/* Consumer configuration. */
		KASSERT(pp == NULL, (__func__));
		/* none */
	} else if (pp != NULL) {	/* Provider configuration. */
		entry = pp->private;
		if (entry == NULL)
			return;
		sbuf_printf(sb, "%s<index>%u</index>\n", indent,
		    entry->gpe_index);
		sbuf_printf(sb, "%s<type>%s</type>\n", indent,
		    G_PART_TYPE(table, entry, buf, sizeof(buf)));
		sbuf_printf(sb, "%s<offset>%ju</offset>\n", indent,
		    (uintmax_t)entry->gpe_offset);
		sbuf_printf(sb, "%s<length>%ju</length>\n", indent,
		    (uintmax_t)pp->mediasize);
		G_PART_DUMPCONF(table, entry, sb, indent);
	} else {			/* Geom configuration. */
		sbuf_printf(sb, "%s<entries>%u</entries>\n", indent,
		    table->gpt_entries);
		sbuf_printf(sb, "%s<first>%ju</first>\n", indent,
		    (uintmax_t)table->gpt_first);
		sbuf_printf(sb, "%s<last>%ju</last>\n", indent,
		    (uintmax_t)table->gpt_last);
		G_PART_DUMPCONF(table, NULL, sb, indent);
	}
}

static void
g_part_orphan(struct g_consumer *cp)
{
	struct g_provider *pp;

	pp = cp->provider;
	KASSERT(pp != NULL, (__func__));
	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, pp->name));
	g_topology_assert();

	KASSERT(pp->error != 0, (__func__));
	g_part_wither(cp->geom, pp->error);
}

static void
g_part_spoiled(struct g_consumer *cp)
{

	G_PART_TRACE((G_T_TOPOLOGY, "%s(%s)", __func__, cp->provider->name));
	g_topology_assert();

	g_part_wither(cp->geom, ENXIO);
}

static void
g_part_start(struct bio *bp)
{
	struct bio *bp2;
	struct g_consumer *cp;
	struct g_geom *gp;
	struct g_part_entry *entry;
	struct g_part_table *table;
	struct g_kerneldump *gkd;
	struct g_provider *pp;
	int attr;

	pp = bp->bio_to;
	gp = pp->geom;
	table = gp->softc;
	cp = LIST_FIRST(&gp->consumer);

	G_PART_TRACE((G_T_BIO, "%s: cmd=%d, provider=%s", __func__, bp->bio_cmd,
	    pp->name));

	entry = pp->private;
	if (entry == NULL) {
		g_io_deliver(bp, ENXIO);
		return;
	}

	switch(bp->bio_cmd) {
	case BIO_DELETE:
	case BIO_READ:
	case BIO_WRITE:
		if (bp->bio_offset >= pp->mediasize) {
			g_io_deliver(bp, EIO);
			return;
		}
		bp2 = g_clone_bio(bp);
		if (bp2 == NULL) {
			g_io_deliver(bp, ENOMEM);
			return;
		}
		if (bp2->bio_offset + bp2->bio_length > pp->mediasize)
			bp2->bio_length = pp->mediasize - bp2->bio_offset;
		bp2->bio_done = g_std_done;
		bp2->bio_offset += entry->gpe_offset;
		g_io_request(bp2, cp);
		return;
	case BIO_FLUSH:
		break;
	case BIO_GETATTR:
		if (!strcmp("GEOM::kerneldump", bp->bio_attribute)) {
			/*
			 * Check that the partition is suitable for kernel
			 * dumps. Typically only swap partitions should be
			 * used.
			 */
			if (!G_PART_DUMPTO(table, entry)) {
				g_io_deliver(bp, ENXIO);
				return;
			}
			gkd = (struct g_kerneldump *)bp->bio_data;
			if (gkd->offset >= pp->mediasize) {
				g_io_deliver(bp, EIO);
				return;
			}
			if (gkd->offset + gkd->length > pp->mediasize)
				gkd->length = pp->mediasize - gkd->offset;
			gkd->offset += entry->gpe_offset;
		} else if (!strcmp("PART::isleaf", bp->bio_attribute)) {
			if (bp->bio_length != sizeof(int)) {
				g_io_deliver(bp, EFAULT);
				return;
			}
			attr = table->gpt_isleaf ? 1 : 0;
			bcopy(&attr, bp->bio_data, sizeof(int));
			bp->bio_completed = sizeof(int);
			g_io_deliver(bp, 0);
			return;
		} else if (!strcmp("PART::depth", bp->bio_attribute)) {
			if (bp->bio_length != sizeof(int)) {
				g_io_deliver(bp, EFAULT);
				return;
			}
			bcopy(&table->gpt_depth, bp->bio_data, sizeof(int));
			bp->bio_completed = sizeof(int);
			g_io_deliver(bp, 0);
			return;
		}
		break;
	default:
		g_io_deliver(bp, EOPNOTSUPP);
		return;
	}

	bp2 = g_clone_bio(bp);
	if (bp2 == NULL) {
		g_io_deliver(bp, ENOMEM);
		return;
	}
	bp2->bio_done = g_std_done;
	g_io_request(bp2, cp);
}