xref: /onnv-gate/usr/src/uts/common/io/lvm/md/md_rename.c (revision 2077:ef90dc4e9399)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"


/*
 * rename or exchange identities of virtual device nodes
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>

#include <sys/lvm/mdvar.h>
#include <sys/lvm/md_rename.h>

#include <sys/sysevent/eventdefs.h>
#include <sys/sysevent/svm.h>

extern	major_t		md_major;
extern	unit_t		md_nunits;
extern	set_t		md_nsets;
extern	md_set_t	md_set[];

#define	ROLE(r)						\
	((r) == MDRR_PARENT?	"parent":		\
	(r) == MDRR_SELF?	"self":			\
	(r) == MDRR_CHILD?	"child":		\
	(r) == MDRR_UNK?	"<unknown>": "<garbage>")

#define	OP_STR(op)							\
		(((op) == MDRNOP_UNK)?		"<unknown>"	:	\
		    ((op) == MDRNOP_RENAME)?	"rename"	:	\
		    ((op) == MDRNOP_EXCHANGE)?	"exchange"	:	\
						"<garbage>")
int md_rename_debug = 0;

/* delta guard rails */
const unsigned long long	DELTA_BEG	= (0xDad08888a110beefull);
const unsigned long long	DELTA_END	= (0xa110Beef88880Dadull);

const unsigned long long	DELTA_BEG_FREED	= (0xBad0c0ed0fed0dadull);
const unsigned long long	DELTA_END_FREED	= (0x0Fed0dadbad0c0edull);

/* transaction guard rails */
const unsigned long long	TXN_BEG		= (0xDad01eadc0ed2badull);
const unsigned long long	TXN_END		= (0xc0ed2badDad01eadull);

const unsigned long long	TXNUN_BEG	= (0xcafe0fedbad0beefull);
const unsigned long long	TXNUN_END	= (0xbad0beefcafe0fedull);

const unsigned int		guard_shift	= (sizeof (u_longlong_t) - 3);
const md_stackcap_t		MD_CAN_DO_ANYTHING	= (md_stackcap_t)0;

typedef struct role_change_mapping_tab_t {
	const int			ord;
	const md_renrole_t		old_role;
	const md_renrole_t		new_role;
	const char			*svc_name;
	md_ren_roleswap_svc_t * const	default_svc;
} role_change_tab_t;

/*
 *  The actual table is at the end of the file, so we don't need
 *  many forward references
 */
static	role_change_tab_t	role_swap_tab[];

#define	ILLEGAL_ROLESWAP_SVC	((md_ren_roleswap_svc_t *)(0xA1100BAD))
#define	NO_DEFAULT_ROLESWAP_SVC	((md_ren_roleswap_svc_t *)(NULL))
#define	ILLEGAL_SVC_NAME	(NULL)

/*
 *
 * Role swap rule table:
 *
 *                                New Role
 *      +---------------------------------------------------------------|
 *      |        |    Parent       |       Self     |      Child        |
 *      +--------+-----------------+----------------+-------------------+
 *      | Parent | no default      | ...no default  | illegal	        |
 *      |        | 1 (update kids) | 2  (update to) | 3	                |
 * Old  +--------+-----------------+----------------+-------------------+
 * Role | Self   | ...self update  | ...rename self | no default (down  |
 *      |        | 4   update up | 5	            | 6    update from) |
 *      +--------+-----------------+----------------+-------------------+
 *      | Child  | illegal         | ...child       | ...update         |
 *      |        | 7	           | 8   update to  | 9	parent          |
 *      +---------------------------------------------------------------+
 *
 * and notes:
 *
 * - Boxes 1, 4 and 6 are the most interesting. They are responsible
 *   for updating the from unit's data structures. These may involve
 *   finding (former or future) children, resetting name keys and the like.
 *
 * - The "rename" operation is boxes 1, 5 and 9. Most of the work
 *   is done in box 5, since that contains both the "from" and "to"
 *   unit struct for rename.
 *
 *  (There's got to be an eigen function for this; that diagonal
 *   axis is a role identity operation searching for an expression.)
 *
 * - Almost every transaction will call more than one of these.
 *   (Only a rename of a unit with no relatives will only call
 *   a single box.)
 *
 * - Box 4 "...update from" is the generic self->parent modifier.
 * - Box 8 "...update to" is the generic child->self modifier.
 *   These can be generic because all of the information which
 *   needs to be updated is in the common portion of the unit
 *   structure when changing from their respective roles.
 *
 * - Boxes 1, 2 and 6 ("no default") indicate that per-metadevice
 *   information must be updated. For example, in box 1, children
 *   identities must be updated. Since different metadevice types
 *   detect and manipulate their children differently, there can
 *   be no generic "md_rename" function in this box.
 *
 * In addition to the named services in the table above, there
 * are other named services used by rename/exchange.
 * MDRNM_LIST_URFOLKS, MDRNM_LIST_URSELF, MDRNM_LIST_URKIDS
 * list a device's parents, self and children, respectively.
 * In most cases the default functions can be used for parents
 * and self. Top-level devices, are not required to have a
 * "list folks" named service. Likewise, devices which can
 * not have metadevice children, are not required to have the
 * "list kids" named service. The LIST_UR* functions call back into
 * the base driver (md_build_rendelta()) to package the changes to
 * a device for addition onto the tree. The LIST_UR* named service
 * then adds this "rename delta" onto the delta tree itself.
 * This keeps private knowledge appropriately encapsulated.
 * They return the number of devices which will need to be changed,
 * and hence the number of elements they've added to the delta list
 * or -1 for error.
 *
 * Other named services used by rename/exchange are:
 * "lock" (MDRNM_LOCK), "unlock" (MDRNM_UNLOCK) and "check" (MDRNM_CHECK).
 * These (un) write-lock all of the relevant in-core structs,
 * including the unit structs for the device and quiesce i/o as necessary.
 * The "check" named service verifies that this device
 * is in a state where rename could and may occur at this time.
 * Since the role_swap functions themselves cannot be undone
 * (at least in this implementation), it is check()'s job to
 * verify that the device is renamable (sic) or, if not, abort.
 * The check function for the device participating in the role
 * of "self" is usually where rename or exchange validity is verified.
 *
 * All of these functions take two arguments which may be thought
 * of as the collective state changes of the tree of devices
 * (md_rendelta_t *family) and the rename transaction state
 * (md_rentxn_t rtxn or rtxnp).
 *
 */


/*
 * rename unit lock
 * (default name service routine MDRNM_LOCK)
 */
static intptr_t
md_rename_lock(md_rendelta_t *delta, md_rentxn_t *rtxnp)
{
	minor_t		 mnum;
	md_renop_t	 op;

	ASSERT(delta);
	ASSERT(rtxnp);

	if (!delta || !rtxnp) {
		(void) mdsyserror(&rtxnp->mde, EINVAL);
		return (EINVAL);
	}
	mnum = md_getminor(delta->dev);
	op = rtxnp->op;

	/*
	 * target doesn't exist if renaming (by definition),
	 * so it need not be locked
	 */
	if (op == MDRNOP_RENAME && mnum == rtxnp->to.mnum) {
		return (0);
	}

	ASSERT(delta->uip);
	if (!delta->uip) {
		(void) mdmderror(&rtxnp->mde, MDE_UNIT_NOT_SETUP, mnum);
		return (ENODEV);
	}

	ASSERT(delta->unp);
	if (!delta->unp) {
		(void) mdmderror(&rtxnp->mde, MDE_UNIT_NOT_SETUP, mnum);
		return (ENODEV);
	}

	ASSERT(!UNIT_WRITER_HELD(delta->unp));

	(void) md_unit_writerlock(delta->uip);

	ASSERT(UNIT_WRITER_HELD(delta->unp));

	return (0);
}

/*
 * (default name service routine MDRNM_UNLOCK)
 */
/* ARGSUSED */
static void
md_rename_unlock(
	md_rendelta_t	*delta,
	md_rentxn_t	*rtxnp)
{
	ASSERT(delta);
	ASSERT(delta->uip);
	ASSERT(delta->unp);

	ASSERT(UNIT_WRITER_HELD(delta->unp));

	(void) md_unit_writerexit(delta->uip);

	ASSERT(!UNIT_WRITER_HELD(delta->unp));
}

/*
 * This is used by the various MDRNM_LIST* named services.
 */
md_rendelta_t *
md_build_rendelta(
	md_renrole_t	 old_role,
	md_renrole_t	 new_role,
	md_dev64_t	 dev,
	md_rendelta_t	*prev,
	md_unit_t	*unp,
	mdi_unit_t	*uip,
	md_error_t	*ep)
{
	int		 err	= 0;
	md_rendelta_t	*new;

	new = (md_rendelta_t *)kmem_alloc(sizeof (md_rendelta_t), KM_SLEEP);

	new->beginning	= DELTA_BEG;
	new->dev	= dev;
	new->new_role	= new_role;
	new->old_role	= old_role;
	new->next	= NULL;
	new->prev	= prev;
	new->unp = unp;
	new->uip = uip;
	bzero((void *) &new->txn_stat, sizeof (md_rendstat_t));

	/*
	 * For non-meta devices that are being renamed (in the future,
	 * that is) we would need to pass in default functions to
	 * accommodate them, provided the default function is
	 * truly capable of performing the lock/check/unlock function
	 * on opaque devices.
	 */

	new->lock	= md_get_named_service(dev, /* modindex */ 0,
						MDRNM_LOCK, md_rename_lock);

	new->unlock	= (md_ren_void_svc_t *)md_get_named_service(dev,
					/* modindex */ 0, MDRNM_UNLOCK,
					(intptr_t (*)()) md_rename_unlock);

	new->check	= md_get_named_service(dev, /* modindex */ 0,
					    MDRNM_CHECK, /* Default */ NULL);

	new->role_swap	= NULL;	/* set this when the roles are determined */

	if (!new->lock || !new->unlock || !new->check) {
		(void) mdmderror(ep, MDE_RENAME_CONFIG_ERROR, md_getminor(dev));
		err = EINVAL;
		goto out;
	}

	new->end = DELTA_END;

out:
	if (err != 0) {
		if (new) {
			new->beginning	= DELTA_BEG_FREED;
			new->end	= DELTA_END_FREED;

			kmem_free(new, sizeof (md_rendelta_t));
			new = NULL;
		}
	}

	if (prev) {
		prev->next = new;
	}

	return (new);
}

/*
 * md_store_recid()
 * used by role swap functions
 */
void
md_store_recid(
	int		*prec_idx,
	mddb_recid_t	*recid_list,
	md_unit_t	*un)
{
	mddb_recid_t	*rp;
	bool_t		 add_recid;

	ASSERT(prec_idx);
	ASSERT(recid_list);
	ASSERT(recid_list[*prec_idx] == 0);
	ASSERT(*prec_idx >= 0);

	for (add_recid = TRUE, rp = recid_list; add_recid && rp && *rp; rp++) {
		if (MD_RECID(un) == *rp) {
			add_recid = FALSE;
		}
	}

	if (add_recid) {
		recid_list[(*prec_idx)++] = MD_RECID(un);
	}
}

/*
 * MDRNM_LIST_URFOLKS: generic named svc entry point
 * add all parents onto the list pointed to by dlpp
 * (only weird multi-parented devices need to have their
 * own named svc  to do this.)
 */
static int
md_rename_listfolks(md_rendelta_t **dlpp, md_rentxn_t *rtxnp)
{
	md_rendelta_t	*new;

	ASSERT(rtxnp);
	ASSERT(dlpp);
	ASSERT(*dlpp == NULL);
	ASSERT((rtxnp->op == MDRNOP_EXCHANGE) || (rtxnp->op == MDRNOP_RENAME));
	ASSERT(rtxnp->from.uip);
	ASSERT(rtxnp->from.unp);

	if ((!rtxnp->from.uip) || (!rtxnp->from.unp)) {
		(void) mdmderror(&rtxnp->mde, MDE_UNIT_NOT_SETUP,
							rtxnp->from.mnum);
		return (-1);
	}

	if (!MD_HAS_PARENT(MD_PARENT(rtxnp->from.unp))) {
		return (0);
	}

	/*
	 * If supporting log renaming (and other multiparented devices)
	 * callout to each misc module to claim this waif and return the
	 * md_dev64_t of its parents.
	 */
	if (MD_PARENT(rtxnp->from.unp) == MD_MULTI_PARENT) {
		(void) mdmderror(&rtxnp->mde, MDE_RENAME_SOURCE_BAD,
							rtxnp->from.mnum);
		return (2);
	}

	if ((rtxnp->op == MDRNOP_RENAME) ||
	    (MD_PARENT(rtxnp->from.unp) != MD_SID(rtxnp->to.unp))) {

		new = md_build_rendelta(
			    MDRR_PARENT,
			    MDRR_PARENT,
			    md_makedevice(md_major, MD_PARENT(rtxnp->from.unp)),
			    NULL,
			    MD_UNIT(MD_PARENT(rtxnp->from.unp)),
			    MDI_UNIT(MD_PARENT(rtxnp->from.unp)),
			    &rtxnp->mde);
	} else {
		/* parent is swapping roles with self */
		new = md_build_rendelta(
			    MDRR_PARENT,
			    MDRR_SELF,
			    md_makedevice(md_major, MD_SID(rtxnp->to.unp)),
			    NULL,
			    rtxnp->to.unp,
			    rtxnp->to.uip,
			    &rtxnp->mde);
	}

	if (!new) {
		if (mdisok(&rtxnp->mde)) {
			(void) mdsyserror(&rtxnp->mde, ENOMEM);
		}
		return (-1);
	}

	*dlpp = new;

	return (1);
}

/*
 * MDRNM_LIST_URSELF: named svc entry point
 * add all delta entries appropriate for ourselves onto the deltalist pointed
 * to by dlpp
 */
static int
md_rename_listself(md_rendelta_t **dlpp, md_rentxn_t *rtxnp)
{
	md_rendelta_t	*new, *p;
	bool_t		 exchange_up	= FALSE;

	ASSERT(rtxnp);
	ASSERT(dlpp);
	ASSERT((rtxnp->op == MDRNOP_EXCHANGE) || (rtxnp->op == MDRNOP_RENAME));
	ASSERT(rtxnp->from.unp);
	ASSERT(rtxnp->from.uip);

	if ((!rtxnp->from.uip) || (!rtxnp->from.unp)) {
		(void) mdmderror(&rtxnp->mde, MDE_UNIT_NOT_SETUP,
							rtxnp->from.mnum);
		return (-1);
	}

	for (p = *dlpp; p && p->next != NULL; p = p->next) {
		/* NULL */
	}

	/*
	 * renaming or
	 * from's parent is not to and to's parent is not from
	 */
	if (rtxnp->op == MDRNOP_RENAME) {
		new = md_build_rendelta(
				MDRR_SELF,
				MDRR_SELF,
				md_makedevice(md_major, rtxnp->from.mnum),
				p,
				rtxnp->from.unp,
				rtxnp->from.uip,
				&rtxnp->mde);
	} else {

		if (MD_PARENT(rtxnp->from.unp) == MD_SID(rtxnp->to.unp)) {
			exchange_up = TRUE;
		}

		/* self and parent are flipping */
		new = md_build_rendelta(
				MDRR_SELF,
				exchange_up? MDRR_PARENT: MDRR_CHILD,
				md_makedevice(md_major, rtxnp->from.mnum),
				p,
				rtxnp->from.unp,
				rtxnp->from.uip,
				&rtxnp->mde);
	}

	if (!new) {
		if (mdisok(&rtxnp->mde)) {
			(void) mdsyserror(&rtxnp->mde, ENOMEM);
		}
		return (-1);
	}

	if (!*dlpp) {
		*dlpp = new;
	}

	return (1);
}

/*
 * free the tree of all deltas to devices involved in the rename transaction
 */
static void
free_dtree(md_rendelta_t *family)
{
	md_rendelta_t	*next		= NULL;
	int		 i		= 0;
	md_rendelta_t	*r;

	for (r = family; (NULL != r); r = next, i++) {

		next		= r->next;

		/* shift << because it makes the resultant pattern readable */
		r->beginning	= DELTA_BEG_FREED ^ (i << guard_shift);
		r->end		= DELTA_END_FREED ^ (i << guard_shift);

		kmem_free(r, sizeof (md_rendelta_t));
	}
}

/*
 * walk down family tree, calling lock service function
 */
static int
lock_dtree(md_rendelta_t *family, md_rentxn_t *rtxnp)
{
	md_rendelta_t	*r;
	int		 rc;

	ASSERT(family);
	ASSERT(rtxnp);

	if (!family || !rtxnp) {
		return (EINVAL);
	}

	for (rc = 0, r = family; r; r = r->next) {

		ASSERT(r->unp);
		ASSERT(!UNIT_WRITER_HELD(r->unp));
		ASSERT(r->lock);

		if ((rc = (int)(*r->lock) (r, rtxnp)) != 0) {
			return (rc);
		}
		r->txn_stat.locked = TRUE;
	}

	return (0);
}

/*
 * We rely on check() (MDRNM_CHECK) to make exhaustive checks,
 * since we don't attempt to undo role_swap() failures.
 *
 * To implement an undo() function would require each role_swap()
 * to store a log of previous state of the structures it changes,
 * presumably anchored by the rendelta.
 *
 */
static int
check_dtree(md_rendelta_t *family, md_rentxn_t *rtxnp)
{
	md_rendelta_t	*r;
	int		 rc;

	ASSERT(family);
	ASSERT(rtxnp);

	if (!family || !rtxnp) {
		/* no error packet to set? */
		return (EINVAL);
	}

	for (r = family, rc = 0; r; r = r->next) {

		ASSERT(UNIT_WRITER_HELD(r->unp));
		ASSERT(r->txn_stat.locked);

		/*
		 * <to> doesn't exist for rename
		 */
		if (!(rtxnp->op == MDRNOP_RENAME &&
		    md_getminor(r->dev) == rtxnp->to.mnum)) {
			ASSERT(r->uip);
			r->txn_stat.is_open = md_unit_isopen(r->uip);
		}

		/*
		 * if only allowing offline rename/exchanges, check
		 * for top being trans because it opens its sub-devices
		 */

		switch (rtxnp->revision) {
		case MD_RENAME_VERSION_OFFLINE:
			if ((r->txn_stat.is_open) &&
				(!rtxnp->stat.trans_in_stack)) {
				(void) mdmderror(&rtxnp->mde, MDE_RENAME_BUSY,
							md_getminor(r->dev));
				return (EBUSY);
			}
			break;

		case MD_RENAME_VERSION_ONLINE:
			break;

		default:
			(void) mdmderror(&rtxnp->mde, MDE_RENAME_CONFIG_ERROR,
						md_getminor(r->dev));
			return (EINVAL);
		}

		/* MD_UN_MOD_INPROGRESS includes the MD_UN_RENAMING bit */

		if (MD_STATUS(r->unp) & MD_UN_MOD_INPROGRESS) {
			(void) mdmderror(&rtxnp->mde, MDE_RENAME_BUSY,
							md_getminor(r->dev));
			return (EBUSY);
		}

		MD_STATUS(r->unp) |= MD_UN_RENAMING;

		if ((rc = (int)(*r->check)(r, rtxnp)) != 0) {
			return (rc);
		}

		/* and be sure we can proceed */
		if (!(r->role_swap)) {
			(void) mdmderror(&rtxnp->mde, MDE_RENAME_CONFIG_ERROR,
							md_getminor(r->dev));
			return (EINVAL);
		}
		r->txn_stat.checked = TRUE;
	}

	return (0);
}


/*
 * rename role_swap() functions are responsible for updating their
 * own parent, self and children references in both on-disk
 * and in-core structures, as well as storing the changed
 * record ids into recids and incrementing rec_idx.
 */

static void
role_swap_dtree(md_rendelta_t *family, md_rentxn_t *rtxnp)
{
	md_rendelta_t	*r;

	ASSERT(family);
	ASSERT(rtxnp);

	for (r = family; r; r = r->next) {
		ASSERT(r->role_swap);
		ASSERT(r->txn_stat.locked);
		ASSERT(r->txn_stat.checked);

		(*r->role_swap)(r, rtxnp);

		r->txn_stat.role_swapped = TRUE;
	}

	/*
	 * there's some work to do, but not more than expected
	 */
	ASSERT(rtxnp->rec_idx > 0);
	ASSERT(rtxnp->rec_idx < rtxnp->n_recids);

	if (rtxnp->rec_idx >= rtxnp->n_recids || rtxnp->rec_idx <= 0) {
		/*
		 * There's no way to indicate error from here,
		 * and even if we could, there's no undo mechanism.
		 * We've already modified the in-core structs, so
		 * We can't continue w/o committing, but we
		 * don't appear to have anything to commit.
		 */
		cmn_err(CE_PANIC,
			"md_rename: role_swap_dtree(family:%p, rtxnp:%p)",
					(void *) family, (void *) rtxnp);
		return;
	}
	rtxnp->recids[rtxnp->rec_idx] = 0;

	mddb_commitrecs_wrapper(rtxnp->recids);
}

/*
 * walk down delta tree, calling the unlock service for each device,
 * provided any of the devices appear to have been locked
 */
static void
unlock_dtree(md_rendelta_t *family, md_rentxn_t *rtxnp)
{
	md_rendelta_t	*r;
	uint_t		 any_locked	= FALSE;

	ASSERT(family);
	ASSERT(rtxnp);

	for (r = family; r; r = r->next) {

		ASSERT(!(r->txn_stat.unlocked)); /* "has been unlocked" */
		any_locked |= r->txn_stat.locked;
	}

	if (any_locked) {

		/* unwind in reverse order */
		for (r = family; NULL != r->next; r = r->next) {
			/* NULL */
		}

		for (; NULL != r; r = r->prev) {
			MD_STATUS(r->unp) &= ~MD_UN_RENAMING;
			ASSERT(r->unlock);
			r->unlock(r, rtxnp);
			r->txn_stat.unlocked = TRUE;
		}
	}
}

/*
 * MDRNM_UPDATE_SELF
 * This role swap function is identical for all unit types,
 * so keep it here. It's also the best example because it
 * touches all the modified portions of the relevant
 * in-common structures.
 */
static void
md_rename_update_self(
	md_rendelta_t	*delta,
	md_rentxn_t	*rtxnp)
{
	minor_t		from_min, to_min;
	sv_dev_t	sv;
	mddb_de_ic_t	*dep;
	mddb_rb32_t	*rbp;

	ASSERT(rtxnp);
	ASSERT(rtxnp->op == MDRNOP_RENAME);
	ASSERT(delta);
	ASSERT(delta->unp);
	ASSERT(delta->uip);
	ASSERT(rtxnp->rec_idx >= 0);
	ASSERT(rtxnp->recids);
	ASSERT(delta->old_role == MDRR_SELF);
	ASSERT(delta->new_role == MDRR_SELF);
	ASSERT(md_getminor(delta->dev) == rtxnp->from.mnum);

	from_min = rtxnp->from.mnum;
	to_min = rtxnp->to.mnum;

	/*
	 * self id changes in our own unit struct
	 */
	MD_SID(delta->unp) = to_min;

	/*
	 * make sure that dest always has correct un_revision
	 * and rb_revision
	 */
	delta->unp->c.un_revision |= MD_FN_META_DEV;
	dep = mddb_getrecdep(MD_RECID(delta->unp));
	ASSERT(dep);
	rbp = dep->de_rb;
	if (rbp->rb_revision & MDDB_REV_RB) {
		rbp->rb_revision = MDDB_REV_RBFN;
	} else if (rbp->rb_revision & MDDB_REV_RB64) {
		rbp->rb_revision = MDDB_REV_RB64FN;
	}

	/*
	 * clear old array pointers to unit in-core and unit
	 */

	MDI_VOIDUNIT(from_min) = NULL;
	MD_VOIDUNIT(from_min) = NULL;

	/*
	 * and point the new slots at the unit in-core and unit structs
	 */

	MDI_VOIDUNIT(to_min) = delta->uip;
	MD_VOIDUNIT(to_min) = delta->unp;

	/*
	 * recreate kstats
	 * - destroy the ones associated with our former identity
	 * - reallocate and associate them with our new identity
	 */
	md_kstat_destroy_ui(delta->uip);
	md_kstat_init_ui(to_min, delta->uip);

	/*
	 * the unit in-core reference to the get next link's id changes
	 */

	delta->uip->ui_link.ln_id = to_min;

	/*
	 * name space addition of new key was done from user-level
	 * remove the old name's key here
	 */

	sv.setno = MD_MIN2SET(from_min);
	sv.key = rtxnp->from.key;

	md_rem_names(&sv, 1);

	/*
	 * Remove associated device node as well
	 */
	md_remove_minor_node(from_min);

	/*
	 * and store the record id (from the unit struct) into recids
	 * for later commitment by md_rename()
	 */
	md_store_recid(&rtxnp->rec_idx, rtxnp->recids, delta->unp);
}

/*
 * Either one of our siblings and/or our parent changed identities.
 */
static void
md_renexch_update_parent(
	md_rendelta_t	*delta,
	md_rentxn_t	*rtxnp)
{
	ASSERT(rtxnp);
	ASSERT((MDRNOP_RENAME == rtxnp->op) || (rtxnp->op == MDRNOP_EXCHANGE));
	ASSERT(rtxnp->rec_idx >= 0);
	ASSERT(rtxnp->recids);
	ASSERT(delta);
	ASSERT(delta->unp);
	ASSERT(delta->old_role == MDRR_CHILD);
	ASSERT(delta->new_role == MDRR_CHILD);
	ASSERT((MD_PARENT(delta->unp) == rtxnp->from.mnum) ||
		(MD_PARENT(delta->unp) == rtxnp->to.mnum));

	if (MD_PARENT(delta->unp) == rtxnp->from.mnum) {
		MD_PARENT(delta->unp) = rtxnp->to.mnum;
	}

	md_store_recid(&rtxnp->rec_idx, rtxnp->recids, delta->unp);
}

/*
 * exchange up (child->self)
 */
static void
md_exchange_child_update_to(
	md_rendelta_t	*delta,
	md_rentxn_t	*rtxnp)
{
	minor_t from_min, to_min;

	ASSERT(rtxnp);
	ASSERT(rtxnp->op == MDRNOP_EXCHANGE);
	ASSERT(rtxnp->rec_idx >= 0);
	ASSERT(rtxnp->recids);
	ASSERT(delta);
	ASSERT(delta->unp);
	ASSERT(delta->uip);
	ASSERT(delta->old_role == MDRR_CHILD);
	ASSERT(delta->new_role == MDRR_SELF);
	ASSERT(md_getminor(delta->dev) == rtxnp->to.mnum);

	from_min = rtxnp->from.mnum;
	to_min = rtxnp->to.mnum;

	/*
	 * self id changes in our own unit struct
	 * Note:
	 * - Since we're assuming the identity of "from" we use its mnum even
	 *   though we're updating the "to" structures.
	 */

	MD_SID(delta->unp) = from_min;

	/*
	 * our parent identifier becomes the new self, who was "to"
	 */

	MD_PARENT(delta->unp) = to_min;

	/*
	 * point the set array pointers at the "new" unit and unit in-cores
	 * Note:
	 * - The other half of this transfer is done in the "update from"
	 *   rename/exchange named service.
	 */

	MD_VOIDUNIT(from_min) = delta->unp;
	MDI_VOIDUNIT(from_min) = delta->uip;

	/*
	 * transfer kstats
	 */

	delta->uip->ui_kstat = rtxnp->from.kstatp;

	/*
	 * the unit in-core reference to the get next link's id changes
	 */

	delta->uip->ui_link.ln_id = from_min;

	/*
	 * name space additions, if necessary, were done from user-level.
	 * name space deletions, if necessary, were done in "exchange_from"
	 */

	/*
	 * and store the record id (from the unit struct) into recids
	 * for later comitment by md_rename()
	 */

	md_store_recid(&rtxnp->rec_idx, rtxnp->recids, delta->unp);
}

/*
 * exchange up (self->parent)
 */
static void
md_exchange_self_update_from_up(
	md_rendelta_t	*delta,
	md_rentxn_t	*rtxnp)
{
	minor_t from_min, to_min;

	ASSERT(rtxnp);
	ASSERT(rtxnp->op == MDRNOP_EXCHANGE);
	ASSERT(rtxnp->rec_idx >= 0);
	ASSERT(rtxnp->recids);
	ASSERT(delta);
	ASSERT(delta->unp);
	ASSERT(delta->uip);
	ASSERT(delta->old_role == MDRR_SELF);
	ASSERT(delta->new_role == MDRR_PARENT);
	ASSERT(md_getminor(delta->dev) == rtxnp->from.mnum);

	from_min = rtxnp->from.mnum;
	to_min = rtxnp->to.mnum;

	/*
	 * self id changes in our own unit struct
	 * Note:
	 * - Since we're assuming the identity of "to" we use its mnum
	 *   while we're updating the "to" structures.
	 */

	MD_SID(delta->unp) = to_min;

	/*
	 * our parent identifier becomes the new parent, who was "from"
	 */

	MD_PARENT(delta->unp) = from_min;

	/*
	 * point the set array pointers at the "new" unit and unit in-cores
	 * Note:
	 * - The other half of this transfer is done in the "update from"
	 *   rename/exchange named service.
	 */

	MD_VOIDUNIT(to_min) = delta->unp;
	MDI_VOIDUNIT(to_min) = delta->uip;

	/*
	 * transfer kstats
	 */

	delta->uip->ui_kstat = rtxnp->to.kstatp;

	/*
	 * the unit in-core reference to the get next link's id changes
	 */

	delta->uip->ui_link.ln_id = to_min;

	/*
	 * name space additions, if necessary, were done from user-level.
	 * name space deletions, if necessary, were done in "exchange_from"
	 */

	/*
	 * and store the record id (from the unit struct) into recids
	 * for later comitment by md_rename()
	 */

	md_store_recid(&rtxnp->rec_idx, rtxnp->recids, delta->unp);
}

/*
 * The order of the called role swap functions is critical.
 * If they're not ordered as "all parents", then "all self"
 * then "all child" transitions, we will almost certainly
 * corrupt the data base and the in-core linkages. So,
 * verify that the list built by the individual drivers is
 * ok here.
 *
 * We could have done fancy bit encodings of the roles so
 * it all fit into a single word and we wouldn't need the
 * prev_ord field. But, since cpu power is cheaper than
 * than people power, they're all separate for easier
 * debugging and maintaining. (In the unlikely event that
 * rename/exchange ever becomes cpu-limited, and this
 * algorithm is the bottleneck, we should revisit this.)
 */

static bool_t
role_swap_is_valid(
	int		 previous,
	int		 current,
	md_rendelta_t	*delta,
	md_rentxn_t	*rtxnp)
{
	bool_t	valid	= FALSE;

	/*
	 * we've backed up in processing the role table
	 */
	if ((previous > current) &&
	    (delta->prev && (delta->old_role != delta->prev->old_role))) {
		goto out;
	}

	/*
	 * we're repeating the same role transition
	 */
	if (previous == current) {
		switch (delta->old_role) {
		case MDRR_PARENT:
			/*
			 * require at least one of the devices to
			 * be multiparented for us to allow another
			 * parent transition
			 */
			if ((MD_MULTI_PARENT != MD_PARENT(rtxnp->from.unp)) &&
			    (MD_MULTI_PARENT != MD_PARENT(rtxnp->to.unp))) {
				goto out;
			}
			break;

		case MDRR_CHILD:
			/* it's ok to have multiple children */
			break;

		case MDRR_SELF:
			/* it's never ok to have multiple self transitions */
			/* FALLTHROUGH */
		default:
			goto out;
		}
	}

	valid = TRUE;
out:
	if (!valid) {
		if (md_rename_debug != 0) {
			cmn_err(CE_NOTE, "previous: %d, current: %d, role: %s",
					previous, current,
					ROLE(delta->old_role));
			delay(3*drv_usectohz(1000000));
			ASSERT(FALSE);
		}
	}

	return (valid);
}

static role_change_tab_t *
lookup_role(md_renrole_t old_role, md_renrole_t new_role)
{
	role_change_tab_t	*rp;
	role_change_tab_t	*found = NULL;

	for (rp = role_swap_tab; !found && (rp->old_role != MDRR_UNK); rp++) {

		if (rp->old_role == old_role && rp->new_role == new_role) {
			found = rp;
		}
	}
	/*
	 * we require a named svc if we've got two devices
	 * claiming to be changing roles in this manner
	 */
	ASSERT(found);
	ASSERT(found->default_svc != ILLEGAL_ROLESWAP_SVC);
	ASSERT(found->svc_name != ILLEGAL_SVC_NAME);

	if (!found ||
	    (found->default_svc == ILLEGAL_ROLESWAP_SVC) ||
	    (found->svc_name == ILLEGAL_SVC_NAME)) {
		return (NULL);
	}

	return (found);
}

/*
 * fill in the role swap named svc., now that we know each device
 * and its changing role
 */
static int
valid_roleswap_dtree(
	md_rendelta_t	*family,
	md_rentxn_t	*rtxnp
)
{
	md_rendelta_t		*r;
	role_change_tab_t	*rolep;
	minor_t			 from_min, to_min;
	int			 prev_ord	= -1;
	bool_t			found_self	= FALSE;
	int			 err		= 0;

	ASSERT(family);
	ASSERT(rtxnp);

	from_min = rtxnp->from.mnum;
	to_min = rtxnp->to.mnum;

	for (r = family; r; r = r->next, prev_ord = rolep->ord) {

		if (!(rolep = lookup_role(r->old_role, r->new_role))) {
			(void) mdmderror(&rtxnp->mde,
					MDE_RENAME_CONFIG_ERROR, from_min);
			err = EOPNOTSUPP;
			goto out;
		}
		r->role_swap = (md_ren_roleswap_svc_t *)md_get_named_service(
					r->dev, /* modindex */ 0,
					(char *)rolep->svc_name,
					(intptr_t (*)()) rolep->default_svc);

		/*
		 * someone probably called the ioctl directly and
		 * incorrectly, rather than via the libmeta wrappers
		 */
		if (!(r->role_swap)) {
			(void) mdmderror(&rtxnp->mde,
					MDE_RENAME_TARGET_UNRELATED, to_min);
			err = EOPNOTSUPP;
			goto out;
		}

		if (!role_swap_is_valid(prev_ord, rolep->ord, r, rtxnp)) {
			(void) mdmderror(&rtxnp->mde,
					MDE_RENAME_CONFIG_ERROR, from_min);
			err = EINVAL;
			goto out;
		}

		if (rolep->old_role == MDRR_SELF) {
			found_self = TRUE;
		}

		if (MD_PARENT(r->unp) == MD_MULTI_PARENT) {
			(void) mdmderror(&rtxnp->mde, MDE_RENAME_TARGET_BAD,
							md_getminor(r->dev));
			err = EINVAL;
			goto out;
		}
	}

	/*
	 * must be at least one selfish device
	 */
	ASSERT(found_self);
	if (!found_self) {
		(void) mdmderror(&rtxnp->mde,
					MDE_RENAME_CONFIG_ERROR, from_min);
		err = EINVAL;
		goto out;
	}

out:
	return (err);
}

/*
 * dump contents of rename transaction
 */
static void
dump_txn(md_rentxn_t *rtxnp) {

	if (md_rename_debug == 0) {
		return;
	}

	cmn_err(CE_NOTE, "rtxnp: %p", (void *) rtxnp);
	if (rtxnp) {
		cmn_err(CE_NOTE, "beginning: %llx, op: %s",
			rtxnp->beginning, OP_STR(rtxnp->op));

		cmn_err(CE_NOTE,
	"revision: %d, uflags: %d, rec_idx: %d, n_recids: %d, rec_ids: %p%s",
			rtxnp->revision, rtxnp->uflags,
			rtxnp->rec_idx, rtxnp->n_recids, (void *) rtxnp->recids,
			rtxnp->stat.trans_in_stack? " (trans in stack)": "");
		cmn_err(CE_NOTE, " from: beginning: %llx",
							rtxnp->from.beginning);
		cmn_err(CE_NOTE, "    minor: %lX, key: %lX",
			(ulong_t)rtxnp->from.mnum, (ulong_t)rtxnp->from.key);
		cmn_err(CE_NOTE, "    unp: %lX, uip: %lX",
			(ulong_t)rtxnp->from.unp, (ulong_t)rtxnp->from.uip);
		cmn_err(CE_NOTE, "    end: %llx", rtxnp->from.end);
		cmn_err(CE_NOTE, "  to: beginning: %llx", rtxnp->to.beginning);
		cmn_err(CE_NOTE, "    minor: %lX, key: %lX",
			(ulong_t)rtxnp->to.mnum, (ulong_t)rtxnp->to.key);
		cmn_err(CE_NOTE, "    unp: %lX, uip: %lX",
			(ulong_t)rtxnp->to.unp, (ulong_t)rtxnp->to.uip);
		cmn_err(CE_NOTE, "    end: %llx", rtxnp->to.end);
		cmn_err(CE_NOTE, "end: %llx\n", rtxnp->end);
	}
	delay(drv_usectohz(1000000));
}

/*
 * dump contents of all deltas
 */
static void
dump_dtree(md_rendelta_t *family)
{
	md_rendelta_t	*r;
	int		i;

	if (md_rename_debug == 0) {
		return;
	}

	for (r = family, i = 0; r; r = r->next, i++) {
		cmn_err(CE_NOTE, "%d.  beginning: %llx", i, r->beginning);
		cmn_err(CE_NOTE, "  r: %lX, dev: %lX, next: %lx, prev: %lx",
					(ulong_t)r, (ulong_t)r->dev,
					(ulong_t)r->next, (ulong_t)r->prev);

		cmn_err(CE_NOTE, "  role: %s -> %s, unp: %lx, uip: %lx",
			ROLE(r->old_role), ROLE(r->new_role),
			(ulong_t)r->unp, (ulong_t)r->uip);
		cmn_err(CE_NOTE,
		"  lock: %lx, unlock: %lx\n\t  check: %lx, role_swap: %lx",
			(ulong_t)r->lock, (ulong_t)r->unlock,
			(ulong_t)r->check, (ulong_t)r->role_swap);
		if (*((uint_t *)(&r->txn_stat)) != 0) {
			cmn_err(CE_NOTE, "status: (0x%x) %s%s%s%s%s",
			*((uint_t *)(&r->txn_stat)),
			r->txn_stat.is_open?		"is_open "	: "",
			r->txn_stat.locked?		"locked "	: "",
			r->txn_stat.checked?		"checked "	: "",
			r->txn_stat.role_swapped?	"role_swapped "	: "",
			r->txn_stat.unlocked?		"unlocked"	: "");
		}
		cmn_err(CE_NOTE, "end: %llx\n", r->end);
	}
	delay(drv_usectohz(1000000));
}

/*
 * validate the rename request parameters
 */
static int
validate_txn_parms(md_rentxn_t *rtxnp)
{
	minor_t	to_min, from_min;

	ASSERT(rtxnp);

	from_min = rtxnp->from.mnum;
	to_min = rtxnp->to.mnum;

	switch (rtxnp->revision) {
	case MD_RENAME_VERSION_OFFLINE:
		if (rtxnp->uflags != 0) {
			(void) mdmderror(&rtxnp->mde, MDE_RENAME_CONFIG_ERROR,
								from_min);
			return (ENOTSUP);
		}
		break;

	case MD_RENAME_VERSION_ONLINE:
		/* not supported until 5.0 */
		/* FALLTHROUGH */

	default:
		(void) mdmderror(&rtxnp->mde, MDE_RENAME_CONFIG_ERROR,
								from_min);
		return (EPROTONOSUPPORT);
	}

	if ((rtxnp->from.uip = MDI_UNIT(from_min)) == NULL) {
		(void) mdmderror(&rtxnp->mde, MDE_UNIT_NOT_SETUP, from_min);
		return (ENODEV);
	}

	if (!md_dev_exists(md_makedevice(md_major, from_min))) {
		(void) mdmderror(&rtxnp->mde, MDE_UNIT_NOT_SETUP, from_min);
		return (ENODEV);
	}

	if ((rtxnp->from.key == MD_KEYBAD) || (rtxnp->from.key == MD_KEYWILD)) {
		(void) mdmderror(&rtxnp->mde, MDE_INVAL_UNIT, from_min);
		return (EINVAL);
	}

	rtxnp->from.kstatp = rtxnp->from.uip->ui_kstat;
	rtxnp->from.unp = MD_UNIT(from_min);

	if (MD_MIN2SET(to_min) != MD_MIN2SET(from_min)) {
		(void) mdmderror(&rtxnp->mde, MDE_INVAL_UNIT, to_min);
		return (EINVAL);
	}

	switch (rtxnp->op) {
	case MDRNOP_EXCHANGE:
		rtxnp->to.unp = MD_UNIT(to_min);
		rtxnp->to.uip = MDI_UNIT(to_min);

		/*
		 * exchange requires target to exist
		 */

		if ((rtxnp->to.uip == NULL) ||
		    (md_dev_exists(md_makedevice(md_major, to_min)) == NULL)) {
			(void) mdmderror(&rtxnp->mde, MDE_UNIT_NOT_SETUP,
									to_min);
			return (ENODEV);
		}

		if ((rtxnp->to.key == MD_KEYBAD) ||
		    (rtxnp->to.key == MD_KEYWILD)) {
			(void) mdmderror(&rtxnp->mde, MDE_INVAL_UNIT, to_min);
			return (EINVAL);
		}

		/*
		 * <from> is not in the role of <self>,
		 * that is,
		 * <from> has a parent, which is <to> and <to> has a parent too
		 * or
		 * <to> has a parent, which is <from> and <to> can have a child
		 */
		if ((MD_HAS_PARENT(MD_PARENT(rtxnp->from.unp))) &&
		    (MD_PARENT(rtxnp->from.unp) == to_min) &&
		    MD_HAS_PARENT(MD_PARENT(rtxnp->to.unp))) {
			(void) mdmderror(&rtxnp->mde, MDE_RENAME_ORDER,
								from_min);
			return (EINVAL);
		}

		if ((MD_HAS_PARENT(MD_PARENT(rtxnp->to.unp))) &&
		    (MD_PARENT(rtxnp->to.unp) == from_min) &&
		    (MD_CAPAB(rtxnp->to.unp) & MD_CAN_META_CHILD)) {
			(void) mdmderror(&rtxnp->mde, MDE_RENAME_ORDER,
								from_min);
			return (EINVAL);
		}

		rtxnp->to.kstatp = rtxnp->to.uip->ui_kstat;
		break;

	case MDRNOP_RENAME:

		/*
		 * rename requires <to> not to exist
		 */

		if (MDI_UNIT(to_min) ||
		    md_dev_exists(md_makedevice(md_major, to_min))) {

			(void) mdmderror(&rtxnp->mde, MDE_UNIT_ALREADY_SETUP,
									to_min);
			return (EEXIST);
		}

		/*
		 * and to be within valid ranges for the current
		 * limits on number of sets and metadevices
		 */
		if ((MD_MIN2SET(to_min) >= md_nsets) ||
		    (MD_MIN2UNIT(to_min) >= md_nunits)) {
			(void) mdmderror(&rtxnp->mde, MDE_INVAL_UNIT, to_min);
			return (EINVAL);
		}

		rtxnp->to.unp = NULL;
		rtxnp->to.uip = NULL;
		rtxnp->to.kstatp = NULL;
		break;

	default:
		(void) mdmderror(&rtxnp->mde, MDE_RENAME_CONFIG_ERROR,
								from_min);
		return (EINVAL);
	}

	/*
	 * install guard rails
	 */
	rtxnp->beginning = TXN_BEG;

	rtxnp->from.beginning	= TXNUN_BEG;
	rtxnp->from.end		= TXNUN_END;

	rtxnp->to.beginning	= TXNUN_BEG;
	rtxnp->to.end		= TXNUN_END;

	rtxnp->end = TXN_END;

	return (0);
}

/*
 * If the device being changed exhibits this capability, set the list
 * relatives function pointer to the named service that lists the
 * appropriate relatives for this capability.
 */
static int
set_list_rels_funcp(
	md_rentxn_t		 *rtxnp,
	md_stackcap_t		 capability,
	char			 *svc_name,
	md_ren_list_svc_t	 default_svc_func,
	md_ren_list_svc_t	 **list_relatives_funcp
)
{
	int		 err;
	minor_t		 from_min;
	md_dev64_t	 from_dev;
	md_unit_t	*from_un;
	mdi_unit_t	*from_ui;

	ASSERT(rtxnp);
	ASSERT((rtxnp->op == MDRNOP_RENAME) || (rtxnp->op == MDRNOP_EXCHANGE));
	ASSERT(list_relatives_funcp);

	from_min	= rtxnp->from.mnum;
	from_dev	= md_makedevice(md_major, from_min);
	from_un		= MD_UNIT(from_min);
	from_ui		= MDI_UNIT(from_min);
	err		= 0;

	if (!from_ui || !from_un) {
		(void) mdmderror(&rtxnp->mde, MDE_UNIT_NOT_SETUP, from_min);
		err = EINVAL;
		goto out;
	}

	if ((capability == MD_CAN_DO_ANYTHING) ||
	    ((MD_CAPAB(from_un) & capability) == capability)) {

			*list_relatives_funcp = (md_ren_list_svc_t *)
					md_get_named_service(from_dev,
					/* modindex */ 0, svc_name,
					(intptr_t (*)()) default_svc_func);

			ASSERT(*list_relatives_funcp);
			if (!(*list_relatives_funcp)) {
				(void) mdmderror(&rtxnp->mde,
					MDE_RENAME_CONFIG_ERROR, from_min);
				err = EINVAL;
				goto out;
			}
	} else {
		*list_relatives_funcp = (md_ren_list_svc_t *)NULL;
	}

out:
	return (err);
}

/*
 * call list relations function, bump recid counter
 * by number of members added to the delta list.
 * Validate that the number of members added is within bounds.
 */
static int
list_relations(
		md_rendelta_t		**family,
		md_rentxn_t		 *rtxnp,
		md_ren_list_svc_t	 *add_relatives_funcp,
		int			  valid_min,
		int			  valid_max
)
{
	int	n_added;
	int	err = 0;

	ASSERT(family);
	ASSERT(rtxnp);

	if (!family || !rtxnp) {
		err = EINVAL;
		goto out;
	}

	n_added = 0;

	/* no relations of this type */
	if (!add_relatives_funcp) {
		goto out;
	}

	n_added = (*add_relatives_funcp) (family, rtxnp);

	if ((n_added < valid_min) || (n_added > valid_max)) {
		if (mdisok(&rtxnp->mde)) {
			(void) mdmderror(&rtxnp->mde, MDE_RENAME_CONFIG_ERROR,
							rtxnp->from.mnum);
		}
		err = EINVAL;
		goto out;
	}

	rtxnp->n_recids += n_added;

out:
	return (err);
}

/*
 * build recid array
 */
static int
alloc_recids(md_rendelta_t *family, md_rentxn_t *rtxnp)
{
	int	err	= 0;

	if (!family || !rtxnp) {
		err = ENOMEM;
		goto out;
	}

	rtxnp->rec_idx = 0;

	if (rtxnp->n_recids == 0) {
		err = EINVAL;
		goto out;
	}

	rtxnp->n_recids += 1;	/* terminator */

	rtxnp->recids = kmem_alloc(sizeof (mddb_recid_t) * rtxnp->n_recids,
	    KM_SLEEP);
	if (!(rtxnp->recids)) {
		err = ENOMEM;
		goto out;
	}

	bzero((void *) rtxnp->recids,
				(sizeof (mddb_recid_t) * rtxnp->n_recids));
out:
	if (err != 0) {
		(void) mdsyserror(&rtxnp->mde, err);
	}

	return (err);
}

/*
 * build family tree (parent(s), self, children)
 * The order of the resultant list is important, as it governs
 * the order of locking, checking and changing the unit structures.
 * Since we'll be changing them, we may not use the MD_UNIT, MDI_UNIT,
 * and other pointer which depend on the array being correct.
 * Use only the cached pointers (in rtxnp.)
 */
static md_rendelta_t *
build_dtree(md_rentxn_t *rtxnp)
{
	md_ren_list_svc_t	*add_folks, *add_self, *add_kids;
	int			 err;
	md_rendelta_t		*family	= NULL;

	ASSERT(rtxnp);
	ASSERT((rtxnp->op == MDRNOP_RENAME) || (rtxnp->op == MDRNOP_EXCHANGE));

	err = set_list_rels_funcp(rtxnp, MD_CAN_PARENT, MDRNM_LIST_URFOLKS,
					md_rename_listfolks, &add_folks);

	if (err) {
		goto out;
	}

	err = set_list_rels_funcp(rtxnp, MD_CAN_DO_ANYTHING, MDRNM_LIST_URSELF,
						md_rename_listself, &add_self);
	if (err) {
		goto out;
	}

	err = set_list_rels_funcp(rtxnp, MD_CAN_META_CHILD, MDRNM_LIST_URKIDS,
				/* no default list func */ ((int (*)()) NULL),
								&add_kids);
	if (err) {
		goto out;
	}

	rtxnp->n_recids = 0;	/* accumulated by list_relations() */

	if ((err = list_relations(&family, rtxnp, add_folks, 0, 1)) != 0) {
		goto out;
	}

	if ((err = list_relations(&family, rtxnp, add_self, 1, 1)) != 0) {
		goto out;
	}

	err = list_relations(&family, rtxnp, add_kids, 0, md_nunits);
	if (err != 0) {
		goto out;
	}

	/*
	 * delta tree is still empty?
	 */
	if ((!family) || (rtxnp->n_recids == 0)) {
		(void) mdmderror(&rtxnp->mde, MDE_RENAME_CONFIG_ERROR,
							rtxnp->from.mnum);
		err = EINVAL;
		goto out;
	}

	/*
	 * verify role change interactions
	 */
	if ((err = valid_roleswap_dtree(family, rtxnp)) != 0) {
		goto out;
	}

	if ((err = alloc_recids(family, rtxnp)) != 0) {
		goto out;
	}

out:
	if (err != 0) {
		free_dtree(family);
		dump_dtree(family);	/* yes, after freeing it */
		family = NULL;
	}

	return (family);
}


/*
 * (MD_IOCRENAME) rename/exchange ioctl entry point
 * calls individual driver named service entry points
 * to build a list of devices which need state changed,
 * to verify that they're in a state where renames may occur,
 * and to modify themselves into their new identities
 */

int
md_rename(
	md_rename_t	*mrp,
	IOLOCK		*iolockp)
{
	md_rendelta_t	*family		= NULL;
	md_rentxn_t	rtxn;
	int		err		= 0;
	set_t		setno;
	mdc_unit_t	*mdc;

	ASSERT(iolockp);
	if (mrp == NULL)
		return (EINVAL);

	setno = MD_MIN2SET(mrp->from.mnum);
	if (setno >= md_nsets) {
		return (EINVAL);
	}

	/*
	 * Early exit if top is eof trans
	 */
	mdc = (mdc_unit_t *)md_set[setno].s_un[MD_MIN2UNIT(mrp->from.mnum)];
	while (mdc != NULL) {
	    if (!MD_HAS_PARENT(mdc->un_parent)) {
		break;
	    } else {
		mdc = (mdc_unit_t *)md_set[setno].s_un[MD_MIN2UNIT
		    (mdc->un_parent)];
	    }
	}

	if (mdc && mdc->un_type == MD_METATRANS) {
		return (EINVAL);
	}


	mdclrerror(&mrp->mde);

	bzero((void *) &rtxn, sizeof (md_rentxn_t));
	mdclrerror(&rtxn.mde);

	/*
	 * encapsulate user parameters
	 */
	rtxn.from.key	= mrp->from.key;
	rtxn.to.key	= mrp->to.key;
	rtxn.from.mnum	= mrp->from.mnum;
	rtxn.to.mnum	= mrp->to.mnum;
	rtxn.op		= mrp->op;
	rtxn.uflags	= mrp->flags;
	rtxn.revision	= mrp->revision;

	if (MD_MIN2UNIT(mrp->to.mnum) >= md_nunits) {
		err = EINVAL;
		goto cleanup;
	}

	/*
	 * catch this early, before taking any locks
	 */
	if (md_get_setstatus(setno) & MD_SET_STALE) {
		(void) (mdmddberror(&rtxn.mde, MDE_DB_STALE, rtxn.from.mnum,
						MD_MIN2SET(rtxn.from.mnum)));
		err = EROFS;
		goto cleanup;
	}

	/*
	 * Locking and re-validation (of the per-unit state) is
	 * done by the rename lock/unlock service, for now only take
	 * the array lock.
	 */
	md_array_writer(iolockp);

	/*
	 * validate the rename/exchange parameters
	 * rtxn is filled in on succesful completion of validate_txn_parms()
	 */
	if ((err = validate_txn_parms(&rtxn)) != 0) {
		goto cleanup;
	}

	/*
	 * build list of work to do, the "delta tree" for related devices
	 */
	if (!(family = build_dtree(&rtxn))) {
		err = ENOMEM;
		goto cleanup;
	}
	dump_txn(&rtxn);
	dump_dtree(family);

	if ((err = lock_dtree(family, &rtxn)) != 0) {
		goto cleanup;
	}

	if ((err = check_dtree(family, &rtxn)) != 0) {
		goto cleanup;
	}
	dump_txn(&rtxn);

	role_swap_dtree(family, &rtxn);	/* commits the recids */

	/*
	 * let folks know
	 */
	SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_RENAME_SRC, SVM_TAG_METADEVICE,
	    MD_MIN2SET(rtxn.from.mnum), rtxn.from.mnum);
	SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_RENAME_DST, SVM_TAG_METADEVICE,
	    MD_MIN2SET(rtxn.from.mnum), rtxn.from.mnum);

cleanup:

	if (err != 0 && mdisok(&rtxn.mde)) {
		(void) mdsyserror(&rtxn.mde, EINVAL);
	}

	if (family) {
		unlock_dtree(family, &rtxn);
		free_dtree(family);
		dump_dtree(family);
		family = NULL;
	}

	if (rtxn.recids && (rtxn.n_recids > 0)) {
		kmem_free(rtxn.recids, sizeof (mddb_recid_t) * rtxn.n_recids);
	}

	if (!mdisok(&rtxn.mde)) {
		(void) mdstealerror(&mrp->mde, &rtxn.mde);
	}

	return (0);	/* success/failure will be communicated via rtxn.mde */
}

static role_change_tab_t
role_swap_tab[] =
{
	{
		1,			/* ordinal */
		MDRR_PARENT,		/* old role */
		MDRR_PARENT,		/* new role */
		MDRNM_UPDATE_KIDS,	/* named service */
		NO_DEFAULT_ROLESWAP_SVC	/* default role swap function */
	},
	{
		2,
		MDRR_PARENT,
		MDRR_SELF,
		MDRNM_PARENT_UPDATE_TO,
		NO_DEFAULT_ROLESWAP_SVC
	},
	{
		3,
		MDRR_PARENT,
		MDRR_CHILD,
		ILLEGAL_SVC_NAME,
		ILLEGAL_ROLESWAP_SVC
	},
	{
		4,
		MDRR_SELF,
		MDRR_PARENT,
		MDRNM_SELF_UPDATE_FROM_UP,
		md_exchange_self_update_from_up
	},
	{
		5,
		MDRR_SELF,
		MDRR_SELF,
		MDRNM_UPDATE_SELF,
		md_rename_update_self
	},
	{
		6,
		MDRR_SELF,
		MDRR_CHILD,
		MDRNM_SELF_UPDATE_FROM_DOWN,
		NO_DEFAULT_ROLESWAP_SVC
	},
	{
		7,
		MDRR_CHILD,
		MDRR_PARENT,
		ILLEGAL_SVC_NAME,
		ILLEGAL_ROLESWAP_SVC
	},
	{
		8,
		MDRR_CHILD,
		MDRR_SELF,
		MDRNM_CHILD_UPDATE_TO,
		md_exchange_child_update_to
	},
	{
		9,
		MDRR_CHILD,
		MDRR_CHILD,
		MDRNM_UPDATE_FOLKS,
		md_renexch_update_parent
	},

	/* terminator is old_role == MDRR_UNK */
	{
		0,
		MDRR_UNK,
		MDRR_UNK,
		ILLEGAL_SVC_NAME,
		NO_DEFAULT_ROLESWAP_SVC
	}
};