lvm/softpart/sp_ioctl.c

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Soft partitioning metadevice driver (md_sp), administrative routines.
 *
 * This file contains the administrative routines for the soft partitioning
 * metadevice driver.  All administration is done through the use of ioctl's.
 *
 * The primary ioctl's supported by soft partitions are as follows:
 *
 *	MD_IOCSET	- set up a new soft partition.
 *	MD_IOCGET	- get the unit structure of a soft partition.
 *	MD_IOCRESET	- delete a soft partition.
 *	MD_IOCGROW	- add space to a soft partition.
 *	MD_IOCGETDEVS	- get the device the soft partition is built on.
 *	MD_IOC_SPSTATUS	- set the status (un_status field in the soft
 *			  partition unit structure) for one or more soft
 *			  partitions.
 *
 * Note that, as with other metadevices, the majority of the work for
 * building/growing/deleting soft partitions is performed in userland
 * (specifically in libmeta, see meta_sp.c).  The driver's main administrative
 * function is to maintain the in-core & metadb entries associated with a soft
 * partition.
 *
 * In addition, a few other ioctl's are supported via helper routines in
 * the md driver.  These are:
 *
 *	DKIOCINFO	- get "disk" information.
 *	DKIOCGEOM	- get geometry information.
 *	DKIOCGVTOC	- get vtoc information.
 */
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/user.h>
#include <sys/uio.h>
#include <sys/t_lock.h>
#include <sys/buf.h>
#include <sys/dkio.h>
#include <sys/vtoc.h>
#include <sys/kmem.h>
#include <vm/page.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/mkdev.h>
#include <sys/stat.h>
#include <sys/open.h>
#include <sys/lvm/mdvar.h>
#include <sys/lvm/md_sp.h>
#include <sys/lvm/md_notify.h>
#include <sys/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/debug.h>
#include <sys/model.h>

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

extern int		md_status;

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

extern md_ops_t		sp_md_ops;
extern md_krwlock_t	md_unit_array_rw;
extern major_t		md_major;

/*
 * FUNCTION:	sp_getun()
 * INPUT:	mnum	- minor number of soft partition to get.
 * OUTPUT:	mde	- return error pointer.
 * RETURNS:	mp_unit_t *	- ptr to unit structure requested
 *		NULL		- error
 * PURPOSE:	Returns a reference to the soft partition unit structure
 *		indicated by the passed-in minor number.
 */
static mp_unit_t *
sp_getun(minor_t mnum, md_error_t *mde)
{
	mp_unit_t	*un;
	mdi_unit_t	*ui;
	set_t		setno = MD_MIN2SET(mnum);

	/* check set */
	if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits)) {
		(void) mdmderror(mde, MDE_INVAL_UNIT, mnum);
		return (NULL);
	}

	if (md_get_setstatus(setno) & MD_SET_STALE) {
		(void) mdmddberror(mde, MDE_DB_STALE, mnum, setno);
		return (NULL);
	}

	ui = MDI_UNIT(mnum);

	if (ui == NULL) {
		(void) mdmderror(mde, MDE_UNIT_NOT_SETUP, mnum);
		return (NULL);
	}

	un = (mp_unit_t *)MD_UNIT(mnum);

	if (un->c.un_type != MD_METASP) {
		(void) mdmderror(mde, MDE_NOT_SP, mnum);
		return (NULL);
	}

	return (un);
}


/*
 * FUNCTION:	sp_setstatus()
 * INPUT:	d	- data ptr passed in from ioctl.
 *		mode	- pass-through to ddi_copyin.
 *		lockp	- lock ptr.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	Set the status of one or more soft partitions atomically.
 *		this implements the MD_IOC_SPSTATUS ioctl.  Soft partitions
 *		are passed in as an array of minor numbers.  The un_status
 *		field in the unit structure of each soft partition is set to
 *		the status passed in and all unit structures are recommitted
 *		to the metadb at once.
 */
static int
sp_setstatus(void *d, int mode, IOLOCK *lockp)
{
	minor_t		*minors;
	mp_unit_t	*un;
	mddb_recid_t	*recids;
	int		i, nunits, sz;
	int		err = 0;
	sp_status_t	status;
	md_error_t	*mdep;

	md_sp_statusset_t	*msp = (md_sp_statusset_t *)d;

	nunits = msp->num_units;
	sz = msp->size;
	status = msp->new_status;
	mdep = &msp->mde;

	mdclrerror(mdep);
	/* allocate minor number and recids arrays */
	minors = kmem_alloc(sz, KM_SLEEP);
	recids = kmem_alloc((nunits + 1) * sizeof (mddb_recid_t), KM_SLEEP);

	/* copyin minor number array */
	if (err = ddi_copyin((void *)(uintptr_t)msp->minors, minors, sz, mode))
		goto out;

	/* check to make sure all units are valid first */
	for (i = 0; i < nunits; i++) {
		if ((un = sp_getun(minors[i], mdep)) == NULL) {
			err = mdmderror(mdep, MDE_INVAL_UNIT, minors[i]);
			goto out;
		}
	}

	/* update state for all units */
	for (i = 0; i < nunits; i++) {
		un = sp_getun(minors[i], mdep);
		(void) md_ioctl_writerlock(lockp, MDI_UNIT(minors[i]));
		un->un_status = status;
		recids[i] = un->c.un_record_id;
		md_ioctl_writerexit(lockp);
	}

	recids[i] = 0;
	mddb_commitrecs_wrapper(recids);

out:
	kmem_free(minors, sz);
	kmem_free(recids, ((nunits + 1) * sizeof (mddb_recid_t)));
	return (err);
}


/*
 * FUNCTION:	sp_update_watermarks()
 * INPUT:	d	- data ptr passed in from ioctl.
 *		mode	- pass-through to ddi_copyin.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	This implements the MD_IOC_SPUPDATEWM ioctl.
 *              Watermarks are passed in an array.
 */
static int
sp_update_watermarks(void *d, int mode)
{
	minor_t			mnum;
	set_t			setno;
	md_error_t		*mdep;
	mp_unit_t		*un;
	int			err = 0;
	size_t			wsz;
	size_t			osz;
	mp_watermark_t		*watermarks;
	sp_ext_offset_t		*offsets;
	md_dev64_t		device;
	buf_t			*bp;
	int			i;
	md_sp_update_wm_t	*mup = (md_sp_update_wm_t *)d;
	side_t			side;

	mnum = mup->mnum;
	setno = MD_MIN2SET(mnum);
	side = mddb_getsidenum(setno);
	un = MD_UNIT(mnum);

	if (un == NULL)
		return (EFAULT);

	mdep = &mup->mde;

	mdclrerror(mdep);

	/* Validate the set */
	if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
		return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
	if (md_get_setstatus(setno) & MD_SET_STALE)
		return (mdmddberror(mdep, MDE_DB_STALE, mnum, setno));

	wsz = mup->count * sizeof (mp_watermark_t);
	watermarks = kmem_alloc(wsz, KM_SLEEP);

	osz = mup->count * sizeof (sp_ext_offset_t);
	offsets = kmem_alloc(osz, KM_SLEEP);

	/*
	 * Once we're here, we are no longer stateless: we cannot
	 * return without first freeing the watermarks and offset
	 * arrays we just allocated.  So use the "out" label instead
	 * of "return."
	 */

	/* Retrieve the watermark and offset arrays from user land */

	if (ddi_copyin((void *)(uintptr_t)mup->wmp, watermarks, wsz, mode)) {
		err = EFAULT;
		goto out;
	}

	if (ddi_copyin((void *)(uintptr_t)mup->osp, offsets, osz, mode)) {
		err = EFAULT;
		goto out;
	}

	/*
	 * NOTE: For multi-node sets we only commit the watermarks if we are
	 * the master node. This avoids an ioctl-within-ioctl deadlock if the
	 * underlying device is a mirror.
	 */
	if (MD_MNSET_SETNO(setno) && !md_set[setno].s_am_i_master) {
		goto out;
	}

	device = un->un_dev;
	if ((md_getmajor(device) != md_major) &&
	    (md_devid_found(setno, side, un->un_key) == 1)) {
		device = md_resolve_bydevid(mnum, device, un->un_key);
	}
	/*
	 * Flag the fact that we're coming from an ioctl handler to the
	 * underlying device so that it can take appropriate action if needed.
	 * This is necessary for multi-owner mirrors as they may need to
	 * update the metadevice state as a result of the layered open.
	 */
	if (md_layered_open(mnum, &device, MD_OFLG_FROMIOCTL)) {
		err = mdcomperror(mdep, MDE_SP_COMP_OPEN_ERR,
		    mnum, device);
		goto out;
	}

	bp = kmem_alloc(biosize(), KM_SLEEP);
	bioinit(bp);

	for (i = 0; i < mup->count; i++) {

		/*
		 * Even the "constant" fields should be initialized
		 * here, since bioreset() below will clear them.
		 */
		bp->b_flags = B_WRITE;
		bp->b_bcount = sizeof (mp_watermark_t);
		bp->b_bufsize = sizeof (mp_watermark_t);
		bp->b_un.b_addr = (caddr_t)&watermarks[i];
		bp->b_lblkno = offsets[i];
		bp->b_edev = md_dev64_to_dev(device);

		/*
		 * For MN sets only:
		 * Use a special flag MD_STR_WMUPDATE, for the following case:
		 * If the watermarks reside on a mirror disk and a switch
		 * of ownership is triggered by this IO,
		 * the message that is generated by that request must be
		 * processed even if the commd subsystem is currently suspended.
		 *
		 * For non-MN sets or non-mirror metadevices,
		 * this flag has no meaning and is not checked.
		 */

		md_call_strategy(bp, MD_NOBLOCK | MD_STR_WMUPDATE, NULL);

		if (biowait(bp)) {
			err = mdmderror(mdep,
			    MDE_SP_BADWMWRITE, mnum);
			break;
		}

		/* Get the buf_t ready for the next iteration */
		bioreset(bp);
	}

	biofini(bp);
	kmem_free(bp, biosize());

	md_layered_close(device, MD_OFLG_NULL);

out:
	kmem_free(watermarks, wsz);
	kmem_free(offsets, osz);

	return (err);
}


/*
 * FUNCTION:	sp_read_watermark()
 * INPUT:	d	- data ptr passed in from ioctl.
 *		mode	- pass-through to ddi_copyin.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	This implements the MD_IOC_SPREADWM ioctl.
 */
static int
sp_read_watermark(void *d, int mode)
{
	md_error_t		*mdep;
	mp_watermark_t		watermark;
	md_dev64_t		device;
	buf_t			*bp;
	md_sp_read_wm_t		*mrp = (md_sp_read_wm_t *)d;

	mdep = &mrp->mde;

	mdclrerror(mdep);

	device = mrp->rdev;

	/*
	 * Flag the fact that we are being called from ioctl context so that
	 * the underlying device can take any necessary extra steps to handle
	 * this scenario.
	 */
	if (md_layered_open((minor_t)-1, &device, MD_OFLG_FROMIOCTL)) {
		return (mdcomperror(mdep, MDE_SP_COMP_OPEN_ERR,
		    (minor_t)NODEV, device));
	}

	bp = kmem_alloc(biosize(), KM_SLEEP);
	bioinit(bp);

	bp->b_flags = B_READ;
	bp->b_bcount = sizeof (mp_watermark_t);
	bp->b_bufsize = sizeof (mp_watermark_t);
	bp->b_un.b_addr = (caddr_t)&watermark;
	bp->b_lblkno = mrp->offset;
	bp->b_edev = md_dev64_to_dev(device);

	md_call_strategy(bp, MD_NOBLOCK, NULL);

	if (biowait(bp)) {
		/*
		 * Taking advantage of the knowledge that mdmderror()
		 * returns 0, so we don't really need to keep track of
		 * an error code other than in the error struct.
		 */
		(void) mdmderror(mdep, MDE_SP_BADWMREAD,
		    getminor(device));
	}

	biofini(bp);
	kmem_free(bp, biosize());

	md_layered_close(device, MD_OFLG_NULL);

	if (ddi_copyout(&watermark, (void *)(uintptr_t)mrp->wmp,
	    sizeof (mp_watermark_t), mode)) {
		return (EFAULT);
	}

	return (0);
}


/*
 * FUNCTION:	sp_set()
 * INPUT:	d	- data ptr passed in from ioctl.
 *		mode	- pass-through to ddi_copyin.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	Create a soft partition.  The unit structure representing
 *		the soft partiton is passed down from userland.  We allocate
 *		a metadb entry, copyin the unit the structure, handle any
 *		metadevice parenting issues, then commit the record to the
 *		metadb.  Once the record is in the metadb, we must also
 *		build the associated in-core structures.  This is done via
 *		sp_build_incore() (see sp.c).
 */
static int
sp_set(void *d, int mode)
{
	minor_t		mnum;
	mp_unit_t	*un;
	void		*rec_addr;
	mddb_recid_t	recids[3];
	mddb_type_t	rec_type;
	int		err;
	set_t		setno;
	md_error_t	*mdep;
	md_unit_t	*child_un;
	md_set_params_t *msp = (md_set_params_t *)d;

	mnum = msp->mnum;
	setno = MD_MIN2SET(mnum);
	mdep = &msp->mde;

	mdclrerror(mdep);

	/* validate set */

	if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
		return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
	if (md_get_setstatus(setno) & MD_SET_STALE)
		return (mdmddberror(mdep, MDE_DB_STALE, mnum, setno));

	/* get the record type */
	rec_type = (mddb_type_t)md_getshared_key(setno,
	    sp_md_ops.md_driver.md_drivername);

	/* check if there is already a device with this minor number */
	un = MD_UNIT(mnum);
	if (un != NULL)
		return (mdmderror(mdep, MDE_UNIT_ALREADY_SETUP, mnum));

	/* create the db record for this soft partition */

	if (msp->options & MD_CRO_64BIT) {
#if defined(_ILP32)
		return (mdmderror(mdep, MDE_UNIT_TOO_LARGE, mnum));
#else
		recids[0] = mddb_createrec((size_t)msp->size, rec_type, 0,
		    MD_CRO_64BIT | MD_CRO_SOFTPART | MD_CRO_FN, setno);
#endif
	} else {
		recids[0] = mddb_createrec((size_t)msp->size, rec_type, 0,
		    MD_CRO_32BIT | MD_CRO_SOFTPART | MD_CRO_FN, setno);
	}
	/* set initial value for possible child record */
	recids[1] = 0;
	if (recids[0] < 0)
		return (mddbstatus2error(mdep, recids[0], mnum, setno));

	/* get the address of the soft partition db record */
	rec_addr = (void *) mddb_getrecaddr(recids[0]);

	/*
	 * at this point we can happily mess with the soft partition
	 * db record since we haven't committed it to the metadb yet.
	 * if we crash before we commit, the uncommitted record will be
	 * automatically purged.
	 */

	/* copy in the user's soft partition unit struct */
	if (err = ddi_copyin((void *)(uintptr_t)msp->mdp,
	    rec_addr, (size_t)msp->size, mode)) {
		mddb_deleterec_wrapper(recids[0]);
		return (EFAULT);
	}

	/* fill in common unit structure fields which aren't set in userland */
	un = (mp_unit_t *)rec_addr;

	/* All 64 bit metadevices only support EFI labels. */
	if (msp->options & MD_CRO_64BIT) {
		un->c.un_flag |= MD_EFILABEL;
	}

	MD_SID(un) = mnum;
	MD_RECID(un) = recids[0];
	MD_PARENT(un) = MD_NO_PARENT;
	un->c.un_revision |= MD_FN_META_DEV;

	/* if we are parenting a metadevice, set our child's parent field */
	if (md_getmajor(un->un_dev) == md_major) {
		/* it's a metadevice, need to parent it */
		child_un = MD_UNIT(md_getminor(un->un_dev));
		if (child_un == NULL) {
			mddb_deleterec_wrapper(recids[0]);
			return (mdmderror(mdep, MDE_INVAL_UNIT,
			    md_getminor(un->un_dev)));
		}
		md_set_parent(un->un_dev, MD_SID(un));

		/* set child recid and recids end marker */
		recids[1] = MD_RECID(child_un);
		recids[2] = 0;
	}

	/*
	 * build the incore structures.
	 */
	if (err = sp_build_incore(rec_addr, 0)) {
		md_nblocks_set(mnum, -1ULL);
		MD_UNIT(mnum) = NULL;

		mddb_deleterec_wrapper(recids[0]);
		return (err);
	}

	/*
	 * Update unit availability
	 */
	md_set[setno].s_un_avail--;

	/*
	 * commit the record.
	 * if we had to update a child record, it will get commited
	 * as well.
	 */
	mddb_commitrecs_wrapper(recids);

	/* create the mdi_unit struct for this soft partition */
	md_create_unit_incore(mnum, &sp_md_ops, 0);

	SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_CREATE, TAG_METADEVICE, MD_UN2SET(un),
	    MD_SID(un));
	return (0);
}


/*
 * FUNCTION:	sp_get()
 * INPUT:	d	- data ptr.
 *		mode	- pass-through to ddi_copyout.
 *		lock	- lock ptr.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	Get the soft partition unit structure specified by the
 *		minor number.  the in-core unit structure is obtained
 *		and copied into the md_i_get structure passed down from
 *		userland.
 */
static int
sp_get(void *d, int mode, IOLOCK *lock)
{
	minor_t		mnum;
	mdi_unit_t	*ui;
	mp_unit_t	*un;
	md_error_t	*mdep;
	md_i_get_t	*migp = d;


	mnum = migp->id;
	mdep = &migp->mde;

	mdclrerror(mdep);

	/* make sure this is a valid unit structure */
	if ((MD_MIN2SET(mnum) >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
		return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));

	/* get the mdi_unit */
	if ((ui = MDI_UNIT(mnum)) == NULL) {
		return (mdmderror(mdep, MDE_UNIT_NOT_SETUP, mnum));
	}

	/*
	 * md_ioctl_readerlock returns a reference to the in-core
	 * unit structure.  this lock will be dropped by
	 * md_ioctl_lock_exit() before the ioctl returns.
	 */
	un = (mp_unit_t *)md_ioctl_readerlock(lock, ui);

	/* verify the md_i_get structure */
	if (migp->size == 0) {
		migp->size = un->c.un_size;
		return (0);
	}
	if (migp->size < un->c.un_size) {
		return (EFAULT);
	}

	/* copyout unit */
	if (ddi_copyout(un, (void *)(uintptr_t)migp->mdp,
	    un->c.un_size, mode))
		return (EFAULT);
	return (0);
}


/*
 * FUNCTION:	sp_reset()
 * INPUT:	reset_params	- soft partitioning reset parameters.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	Do the setup work needed to delete a soft partition.
 *		note that the actual removal of both in-core and metadb
 *		structures is done in the reset_sp() routine (see sp.c).
 *		In addition, since multiple soft partitions may exist
 *		on top of a single metadevice, the soft partition reset
 *		parameters (md_sp_reset_t) contains information about
 *		how the soft partition should deparent/reparent the
 *		underlying metadevice.  If the underlying metadevice is
 *		to be deparented, the new_parent field will be MD_NO_PARENT,
 *		otherwise it will be contain the minor number of another
 *		soft partition built on top of the underlying metadevice.
 */
static int
sp_reset(md_sp_reset_t *softp)
{
	minor_t		mnum = softp->mnum;
	mdi_unit_t	*ui;
	mp_unit_t	*un;
	md_unit_t	*child_un;
	set_t		setno = MD_MIN2SET(mnum);

	mdclrerror(&softp->mde);

	/* get the unit structure */
	if ((un = sp_getun(mnum, &softp->mde)) == NULL) {
		return (mdmderror(&softp->mde, MDE_INVAL_UNIT, mnum));
	}

	/* don't delete if we have a parent */
	if (MD_HAS_PARENT(un->c.un_parent)) {
		return (mdmderror(&softp->mde, MDE_IN_USE, mnum));
	}

	rw_enter(&md_unit_array_rw.lock, RW_WRITER);

	ui = MDI_UNIT(mnum);
	(void) md_unit_openclose_enter(ui);

	/* don't delete if we are currently open */
	if (md_unit_isopen(ui)) {
		md_unit_openclose_exit(ui);
		rw_exit(&md_unit_array_rw.lock);
		return (mdmderror(&softp->mde, MDE_IS_OPEN, mnum));
	}

	md_unit_openclose_exit(ui);

	/*
	 * if we are built on metadevice, we need to deparent
	 * or reparent that metadevice.
	 */
	if (md_getmajor(un->un_dev) == md_major) {
		child_un = MD_UNIT(md_getminor(un->un_dev));
		md_set_parent(un->un_dev, softp->new_parent);
		mddb_commitrec_wrapper(MD_RECID(child_un));
	}
	/* remove the soft partition */
	reset_sp(un, mnum, 1);

	/*
	 * Update unit availability
	 */
	md_set[setno].s_un_avail++;

	/*
	 * If MN set, reset s_un_next so all nodes can have
	 * the same view of the next available slot when
	 * nodes are -w and -j
	 */
	if (MD_MNSET_SETNO(setno)) {
		md_upd_set_unnext(setno, MD_MIN2UNIT(mnum));
	}

	/* release locks and return */
out:
	rw_exit(&md_unit_array_rw.lock);
	return (0);
}


/*
 * FUNCTION:	sp_grow()
 * INPUT:	d	- data ptr.
 *		mode	- pass-through to ddi_copyin.
 *		lockp	- lock ptr.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	Attach more space to a soft partition.  We are passed in
 *		a new unit structure with the new extents and other updated
 *		information.  The new unit structure essentially replaces
 *		the old unit for this soft partition.  We place the new
 *		unit into the metadb, delete the old metadb record, and
 *		then update the in-core unit structure array to point to
 *		the new unit.
 */
static int
sp_grow(void *d, int mode, IOLOCK *lockp)
{
	minor_t		mnum;
	mp_unit_t	*un, *new_un;
	mdi_unit_t	*ui;
	minor_t		*par = NULL;
	IOLOCK		*plock = NULL;
	int		i;
	mddb_recid_t	recid;
	mddb_type_t	rec_type;
	mddb_recid_t	old_vtoc = 0;
	md_create_rec_option_t options;
	int		err;
	int		rval = 0;
	set_t		setno;
	md_error_t	*mdep;
	int		npar;
	md_grow_params_t *mgp = (md_grow_params_t *)d;

	mnum = mgp->mnum;
	mdep = &mgp->mde;
	setno = MD_MIN2SET(mnum);
	npar = mgp->npar;

	mdclrerror(mdep);

	/* validate set */
	if ((setno >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
		return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
	if (md_get_setstatus(setno) & MD_SET_STALE)
		return (mdmddberror(mdep, MDE_DB_STALE, mnum, setno));

	/* make sure this soft partition already exists */
	ui = MDI_UNIT(mnum);
	if (ui == NULL)
		return (mdmderror(mdep, MDE_UNIT_NOT_SETUP, mnum));

	/* handle any parents */
	if (npar >= 1) {
		ASSERT((minor_t *)(uintptr_t)mgp->par != NULL);
		par = kmem_alloc(npar * sizeof (*par), KM_SLEEP);
		plock = kmem_alloc(npar * sizeof (*plock), KM_SLEEP);
		if (ddi_copyin((void *)(uintptr_t)mgp->par, par,
		    (npar * sizeof (*par)), mode) != 0) {
			kmem_free(par, npar * sizeof (*par));
			kmem_free(plock, npar * sizeof (*plock));
			return (EFAULT);
		}
	}

	/*
	 * handle parent locking.  grab the unit writer lock,
	 * then all parent ioctl locks, and then finally our own.
	 * parents should be sorted to avoid deadlock.
	 */
	rw_enter(&md_unit_array_rw.lock, RW_WRITER);
	for (i = 0; i < npar; ++i) {
		(void) md_ioctl_writerlock(&plock[i],
		    MDI_UNIT(par[i]));
	}
	un = (mp_unit_t *)md_ioctl_writerlock(lockp, ui);

	rec_type = (mddb_type_t)md_getshared_key(setno,
	    sp_md_ops.md_driver.md_drivername);

	/*
	 * Preserve the friendly name nature of the unit that is growing.
	 */
	options = MD_CRO_SOFTPART;
	if (un->c.un_revision & MD_FN_META_DEV)
		options |= MD_CRO_FN;
	if (mgp->options & MD_CRO_64BIT) {
#if defined(_ILP32)
		rval = mdmderror(mdep, MDE_UNIT_TOO_LARGE, mnum);
		goto out;
#else
		recid = mddb_createrec((size_t)mgp->size, rec_type, 0,
		    MD_CRO_64BIT | options, setno);
#endif
	} else {
		recid = mddb_createrec((size_t)mgp->size, rec_type, 0,
		    MD_CRO_32BIT | options, setno);
	}
	if (recid < 0) {
		rval = mddbstatus2error(mdep, (int)recid, mnum, setno);
		goto out;
	}

	/* get the address of the new unit */
	new_un = (mp_unit_t *)mddb_getrecaddr(recid);

	/* copy in the user's unit struct */
	err = ddi_copyin((void *)(uintptr_t)mgp->mdp, new_un,
	    (size_t)mgp->size, mode);
	if (err) {
		mddb_deleterec_wrapper(recid);
		rval = EFAULT;
		goto out;
	}
	if (options & MD_CRO_FN)
		new_un->c.un_revision |= MD_FN_META_DEV;

	/* All 64 bit metadevices only support EFI labels. */
	if (mgp->options & MD_CRO_64BIT) {
		new_un->c.un_flag |= MD_EFILABEL;
		/*
		 * If the device was previously smaller than a terabyte,
		 * and had a vtoc record attached to it, we remove the
		 * vtoc record, because the layout has changed completely.
		 */
		if (((un->c.un_revision & MD_64BIT_META_DEV) == 0) &&
		    (un->c.un_vtoc_id != 0)) {
			old_vtoc = un->c.un_vtoc_id;
			new_un->c.un_vtoc_id =
			    md_vtoc_to_efi_record(old_vtoc, setno);
		}
	}

	/* commit new unit struct */
	MD_RECID(new_un) = recid;
	mddb_commitrec_wrapper(recid);

	/*
	 * delete old unit struct.
	 */
	mddb_deleterec_wrapper(MD_RECID(un));

	/* place new unit in in-core array */
	md_nblocks_set(mnum, new_un->c.un_total_blocks);
	MD_UNIT(mnum) = new_un;

	SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_GROW, TAG_METADEVICE,
	    MD_UN2SET(new_un), MD_SID(new_un));

	/*
	 * If old_vtoc has a non zero value, we know:
	 * - This unit crossed the border from smaller to larger one TB
	 * - There was a vtoc record for the unit,
	 * - This vtoc record is no longer needed, because
	 *   a new efi record has been created for this un.
	 */
	if (old_vtoc != 0) {
		mddb_deleterec_wrapper(old_vtoc);
	}

	/* release locks, return success */
out:
	for (i =  npar - 1; (i >= 0); --i)
		md_ioctl_writerexit(&plock[i]);
	rw_exit(&md_unit_array_rw.lock);
	if (plock != NULL)
		kmem_free(plock, npar * sizeof (*plock));
	if (par != NULL)
		kmem_free(par, npar * sizeof (*par));
	return (rval);
}

/*
 * FUNCTION:	sp_getdevs()
 * INPUT:	d	- data ptr.
 *		mode	- pass-through to ddi_copyout.
 *		lockp	- lock ptr.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	Get the device on which the soft partition is built.
 *		This is simply a matter of copying out the md_dev64_t stored
 *		in the soft partition unit structure.
 */
static int
sp_getdevs(
	void			*d,
	int			mode,
	IOLOCK			*lockp
)
{
	minor_t			mnum;
	mdi_unit_t		*ui;
	mp_unit_t		*un;
	md_error_t		*mdep;
	md_dev64_t		*devsp;
	md_dev64_t		unit_dev;
	md_getdevs_params_t	*mgdp = (md_getdevs_params_t *)d;


	mnum = mgdp->mnum;
	mdep = &(mgdp->mde);

	mdclrerror(mdep);

	/* check set */
	if ((MD_MIN2SET(mnum) >= md_nsets) || (MD_MIN2UNIT(mnum) >= md_nunits))
		return (mdmderror(mdep, MDE_INVAL_UNIT, mnum));
	/* check unit */
	if ((ui = MDI_UNIT(mnum)) == NULL) {
		return (mdmderror(mdep, MDE_UNIT_NOT_SETUP, mnum));
	}
	/* get unit */
	un = (mp_unit_t *)md_ioctl_readerlock(lockp, ui);
	devsp = (md_dev64_t *)(uintptr_t)mgdp->devs;

	/* only ever 1 device for a soft partition */
	if (mgdp->cnt != 0) {
		/* do miniroot->target device translation */
		unit_dev = un->un_dev;
		if (md_getmajor(unit_dev) != md_major) {
			if ((unit_dev = md_xlate_mini_2_targ(unit_dev))
			    == NODEV64)
				return (ENODEV);
		}
		/* copyout dev information */
		if (ddi_copyout(&unit_dev, devsp, sizeof (*devsp), mode) != 0)
			return (EFAULT);
	}
	mgdp->cnt = 1;

	return (0);
}

/*
 * sp_set_capability:
 * ------------------
 * Called to set or clear a capability for a softpart
 * called by the MD_MN_SET_CAP ioctl.
 */
static int
sp_set_capability(md_mn_setcap_params_t *p, IOLOCK *lockp)
{
	set_t		setno;
	mdi_unit_t	*ui;
	mp_unit_t	*un;
	int		err = 0;

	if ((un = sp_getun(p->mnum, &p->mde)) == NULL)
		return (EINVAL);

	/* This function is only valid for a multi-node set */
	setno = MD_MIN2SET(p->mnum);
	if (!MD_MNSET_SETNO(setno)) {
		return (EINVAL);
	}
	ui = MDI_UNIT(p->mnum);
	(void) md_ioctl_readerlock(lockp, ui);

	if (p->sc_set & DKV_ABR_CAP) {
		void (*inc_abr_count)();

		ui->ui_tstate |= MD_ABR_CAP; /* Set ABR capability */
		/* Increment abr count in underlying metadevice */
		inc_abr_count = (void(*)())md_get_named_service(un->un_dev,
		    0, MD_INC_ABR_COUNT, 0);
		if (inc_abr_count != NULL)
			(void) (*inc_abr_count)(un->un_dev);
	} else {
		void (*dec_abr_count)();

		ui->ui_tstate &= ~MD_ABR_CAP; /* Clear ABR capability */
		/* Decrement abr count in underlying metadevice */
		dec_abr_count = (void(*)())md_get_named_service(un->un_dev,
		    0, MD_DEC_ABR_COUNT, 0);
		if (dec_abr_count != NULL)
			(void) (*dec_abr_count)(un->un_dev);
	}
	if (p->sc_set & DKV_DMR_CAP) {
		ui->ui_tstate |= MD_DMR_CAP; /* Set DMR capability */
	} else {
		ui->ui_tstate &= ~MD_DMR_CAP; /* Clear DMR capability */
	}
	md_ioctl_readerexit(lockp);
	return (err);
}


/*
 * FUNCTION:	sp_admin_ioctl().
 * INPUT:	cmd	- ioctl to be handled.
 *		data	- data ptr.
 *		mode	- pass-through to copyin/copyout routines.
 *		lockp	- lock ptr.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	Handle administrative ioctl's.  Essentially a large
 *		switch statement to dispatch the ioctl's to their
 *		handlers.  See comment at beginning of file for specifics
 *		on which ioctl's are handled.
 */
static int
sp_admin_ioctl(int cmd, void *data, int mode, IOLOCK *lockp)
{
	size_t	sz = 0;
	void	*d = NULL;
	int	err = 0;

	/* We can only handle 32-bit clients for internal commands */
	if ((mode & DATAMODEL_MASK) != DATAMODEL_ILP32) {
		return (EINVAL);
	}

	/* handle ioctl */
	switch (cmd) {

	case MD_IOCSET:
	{
		/* create new soft partition */
		if (! (mode & FWRITE))
			return (EACCES);

		sz = sizeof (md_set_params_t);

		d = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_set(d, mode);
		break;
	}

	case MD_IOCGET:
	{
		/* get soft partition unit structure */
		if (! (mode & FREAD))
			return (EACCES);

		sz = sizeof (md_i_get_t);

		d = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_get(d, mode, lockp);
		break;
	}
	case MD_IOCRESET:
	{
		/* delete soft partition */
		if (! (mode & FWRITE))
			return (EACCES);

		sz = sizeof (md_sp_reset_t);
		d = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_reset((md_sp_reset_t *)d);
		break;
	}

	case MD_IOCGROW:
	{
		/* grow soft partition */
		if (! (mode & FWRITE))
			return (EACCES);

		sz = sizeof (md_grow_params_t);
		d  = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_grow(d, mode, lockp);
		break;
	}

	case MD_IOCGET_DEVS:
	{
		/* get underlying device */
		if (! (mode & FREAD))
			return (EACCES);

		sz = sizeof (md_getdevs_params_t);
		d  = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_getdevs(d, mode, lockp);
		break;
	}

	case MD_IOC_SPSTATUS:
	{
		/* set the status field of one or more soft partitions */
		if (! (mode & FWRITE))
			return (EACCES);

		sz = sizeof (md_sp_statusset_t);
		d  = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_setstatus(d, mode, lockp);
		break;
	}

	case MD_IOC_SPUPDATEWM:
	case MD_MN_IOC_SPUPDATEWM:
	{
		if (! (mode & FWRITE))
			return (EACCES);

		sz = sizeof (md_sp_update_wm_t);
		d  = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_update_watermarks(d, mode);
		break;
	}

	case MD_IOC_SPREADWM:
	{
		if (! (mode & FREAD))
			return (EACCES);

		sz = sizeof (md_sp_read_wm_t);
		d  = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_read_watermark(d, mode);
		break;
	}

	case MD_MN_SET_CAP:
	{
		if (! (mode & FWRITE))
			return (EACCES);

		sz = sizeof (md_mn_setcap_params_t);
		d  = kmem_alloc(sz, KM_SLEEP);

		if (ddi_copyin(data, d, sz, mode)) {
			err = EFAULT;
			break;
		}

		err = sp_set_capability((md_mn_setcap_params_t *)d, lockp);
		break;
	}

	default:
		return (ENOTTY);
	}

	/*
	 * copyout and free any args
	 */
	if (sz != 0) {
		if (err == 0) {
			if (ddi_copyout(d, data, sz, mode) != 0) {
				err = EFAULT;
			}
		}
		kmem_free(d, sz);
	}
	return (err);
}


/*
 * FUNCTION:	md_sp_ioctl()
 * INPUT:	dev	- device we are operating on.
 *		cmd	- ioctl to be handled.
 *		data	- data ptr.
 *		mode	- pass-through to copyin/copyout routines.
 *		lockp	- lock ptr.
 * OUTPUT:	none.
 * RETURNS:	0		- success.
 *		non-zero	- error.
 * PURPOSE:	Dispatch ioctl's.  Administrative ioctl's are handled
 *		by sp_admin_ioctl.  All others (see comment at beginning
 *		of this file) are handled in-line here.
 */
int
md_sp_ioctl(dev_t dev, int cmd, void *data, int mode, IOLOCK *lockp)
{
	minor_t		mnum = getminor(dev);
	mp_unit_t	*un;
	mdi_unit_t	*ui;
	int		err = 0;

	/* handle admin ioctls */
	if (mnum == MD_ADM_MINOR)
		return (sp_admin_ioctl(cmd, data, mode, lockp));

	/* check unit */
	if ((MD_MIN2SET(mnum) >= md_nsets) ||
	    (MD_MIN2UNIT(mnum) >= md_nunits) ||
	    ((ui = MDI_UNIT(mnum)) == NULL) ||
	    ((un = MD_UNIT(mnum)) == NULL))
		return (ENXIO);

	/* is this a supported ioctl? */
	err = md_check_ioctl_against_unit(cmd, un->c);
	if (err != 0) {
		return (err);
	}


	/* handle ioctl */
	switch (cmd) {

	case DKIOCINFO:
	{
		/* "disk" info */
		struct dk_cinfo		*p;

		if (! (mode & FREAD))
			return (EACCES);

		p = kmem_alloc(sizeof (*p), KM_SLEEP);

		get_info(p, mnum);
		if (ddi_copyout((caddr_t)p, data, sizeof (*p), mode) != 0)
			err = EFAULT;

		kmem_free(p, sizeof (*p));
		return (err);
	}

	case DKIOCGMEDIAINFO:
	{
		struct dk_minfo	p;

		if (! (mode & FREAD))
			return (EACCES);

		get_minfo(&p, mnum);
		if (ddi_copyout(&p, data, sizeof (struct dk_minfo), mode) != 0)
			err = EFAULT;

		return (err);
	}

	case DKIOCGGEOM:
	{
		/* geometry information */
		struct dk_geom		*p;

		if (! (mode & FREAD))
			return (EACCES);

		p = kmem_alloc(sizeof (*p), KM_SLEEP);

		md_get_geom((md_unit_t *)un, p);
		if (ddi_copyout((caddr_t)p, data, sizeof (*p),
		    mode) != 0)
			err = EFAULT;

		kmem_free(p, sizeof (*p));
		return (err);
	}
	case DKIOCGAPART:
	{
		struct dk_map	dmp;

		err = 0;
		md_get_cgapart((md_unit_t *)un, &dmp);

		if ((mode & DATAMODEL_MASK) == DATAMODEL_NATIVE) {
			if (ddi_copyout((caddr_t)&dmp, data, sizeof (dmp),
			    mode) != 0)
				err = EFAULT;
		}
#ifdef _SYSCALL32
		else {
			struct dk_map32 dmp32;

			dmp32.dkl_cylno = dmp.dkl_cylno;
			dmp32.dkl_nblk = dmp.dkl_nblk;

			if (ddi_copyout((caddr_t)&dmp32, data, sizeof (dmp32),
			    mode) != 0)
				err = EFAULT;
		}
#endif /* _SYSCALL32 */

		return (err);
	}
	case DKIOCGVTOC:
	{
		/* vtoc information */
		struct vtoc	*vtoc;

		if (! (mode & FREAD))
			return (EACCES);

		vtoc = kmem_zalloc(sizeof (*vtoc), KM_SLEEP);
		md_get_vtoc((md_unit_t *)un, vtoc);

		if ((mode & DATAMODEL_MASK) == DATAMODEL_NATIVE) {
			if (ddi_copyout(vtoc, data, sizeof (*vtoc), mode))
				err = EFAULT;
		}
#ifdef _SYSCALL32
		else {
			struct vtoc32	*vtoc32;

			vtoc32 = kmem_zalloc(sizeof (*vtoc32), KM_SLEEP);

			vtoctovtoc32((*vtoc), (*vtoc32));
			if (ddi_copyout(vtoc32, data, sizeof (*vtoc32), mode))
				err = EFAULT;
			kmem_free(vtoc32, sizeof (*vtoc32));
		}
#endif /* _SYSCALL32 */

		kmem_free(vtoc, sizeof (*vtoc));
		return (err);
	}

	case DKIOCSVTOC:
	{
		struct vtoc	*vtoc;

		if (! (mode & FWRITE))
			return (EACCES);

		vtoc = kmem_zalloc(sizeof (*vtoc), KM_SLEEP);
		if ((mode & DATAMODEL_MASK) == DATAMODEL_NATIVE) {
			if (ddi_copyin(data, vtoc, sizeof (*vtoc), mode)) {
				err = EFAULT;
			}
		}
#ifdef _SYSCALL32
		else {
			struct vtoc32	*vtoc32;

			vtoc32 = kmem_zalloc(sizeof (*vtoc32), KM_SLEEP);

			if (ddi_copyin(data, vtoc32, sizeof (*vtoc32), mode)) {
				err = EFAULT;
			} else {
				vtoc32tovtoc((*vtoc32), (*vtoc));
			}
			kmem_free(vtoc32, sizeof (*vtoc32));
		}
#endif /* _SYSCALL32 */

		if (err == 0)
			err = md_set_vtoc((md_unit_t *)un, vtoc);

		kmem_free(vtoc, sizeof (*vtoc));
		return (err);
	}

	case DKIOCGEXTVTOC:
	{
		/* extended vtoc information */
		struct extvtoc	*extvtoc;

		if (! (mode & FREAD))
			return (EACCES);

		extvtoc = kmem_zalloc(sizeof (*extvtoc), KM_SLEEP);
		md_get_extvtoc((md_unit_t *)un, extvtoc);

		if (ddi_copyout(extvtoc, data, sizeof (*extvtoc), mode))
			err = EFAULT;

		kmem_free(extvtoc, sizeof (*extvtoc));
		return (err);
	}

	case DKIOCSEXTVTOC:
	{
		struct extvtoc	*extvtoc;

		if (! (mode & FWRITE))
			return (EACCES);

		extvtoc = kmem_zalloc(sizeof (*extvtoc), KM_SLEEP);
		if (ddi_copyin(data, extvtoc, sizeof (*extvtoc), mode)) {
			err = EFAULT;
		}

		if (err == 0)
			err = md_set_extvtoc((md_unit_t *)un, extvtoc);

		kmem_free(extvtoc, sizeof (*extvtoc));
		return (err);
	}

	case DKIOCGETEFI:
	{
		/*
		 * This one can be done centralized,
		 * no need to put in the same code for all types of metadevices
		 */
		return (md_dkiocgetefi(mnum, data, mode));
	}
	case DKIOCSETEFI:
	{
		/*
		 * This one can be done centralized,
		 * no need to put in the same code for all types of metadevices
		 */
		return (md_dkiocsetefi(mnum, data, mode));
	}

	case DKIOCPARTITION:
	{
		return (md_dkiocpartition(mnum, data, mode));
	}

	case DKIOCGETVOLCAP:
	{
		/*
		 * Return the supported capabilities for the soft-partition.
		 * We can only support those caps that are provided by the
		 * underlying device.
		 */

		volcap_t	vc;

		if (!MD_MNSET_SETNO(MD_MIN2SET(mnum)))
			return (EINVAL);

		if (! (mode & FREAD))
			return (EACCES);

		bzero(&vc, sizeof (vc));

		/* Send ioctl to underlying driver */

		err = md_call_ioctl(un->un_dev, cmd, &vc, (mode | FKIOCTL),
		    lockp);

		if (err == 0)
			ui->ui_capab = vc.vc_info;

		if (ddi_copyout(&vc, data, sizeof (vc), mode))
			err = EFAULT;

		return (err);
	}

	case DKIOCSETVOLCAP:
	{
		/*
		 * Enable a supported capability (as returned by DKIOCGETVOLCAP)
		 * Do not pass the request down as we're the top-level device
		 * handler for the application.
		 * If the requested capability is supported (set in ui_capab),
		 * set the corresponding bit in ui_tstate so that we can pass
		 * the appropriate flag when performing i/o.
		 * This request is propagated to all nodes.
		 */
		volcap_t	vc, vc1;
		volcapset_t	volcap = 0;
		void 		(*check_offline)();
		int		offline_status = 0;

		if (!MD_MNSET_SETNO(MD_MIN2SET(mnum)))
			return (EINVAL);

		if (! (mode & FWRITE))
			return (EACCES);

		if (ddi_copyin(data, &vc, sizeof (vc), mode))
			return (EFAULT);

		/*
		 * Send DKIOCGETVOLCAP to underlying driver to see if
		 * capability supported
		 */

		vc1.vc_info = 0;
		err = md_call_ioctl(un->un_dev, DKIOCGETVOLCAP, &vc1,
		    (mode | FKIOCTL), lockp);
		if (err != 0)
			return (err);

		/* Save capabilities */
		ui->ui_capab = vc1.vc_info;
		/*
		 * Error if required capability not supported by underlying
		 * driver
		 */
		if ((vc1.vc_info & vc.vc_set) == 0)
			return (ENOTSUP);


		/*
		 * Check if underlying mirror has an offline submirror,
		 * fail if there is on offline submirror
		 */
		check_offline = (void(*)())md_get_named_service(un->un_dev,
		    0, MD_CHECK_OFFLINE, 0);
		if (check_offline != NULL)
			(void) (*check_offline)(un->un_dev, &offline_status);
		if (offline_status)
			return (EINVAL);

		if (ui->ui_tstate & MD_ABR_CAP)
			volcap |= DKV_ABR_CAP;

		/* Only send capability message if there is a change */
		if ((vc.vc_set & (DKV_ABR_CAP)) != volcap)
			err = mdmn_send_capability_message(mnum, vc, lockp);
		return (err);
	}

	case DKIOCDMR:
	{
		/*
		 * Only valid for MN sets. We need to pass it down to the
		 * underlying driver if its a metadevice, after we've modified
		 * the offsets to pick up the correct lower-level device
		 * position.
		 */
		vol_directed_rd_t	*vdr;
#ifdef _MULTI_DATAMODEL
		vol_directed_rd32_t	*vdr32;
#endif	/* _MULTI_DATAMODEL */

		if (!MD_MNSET_SETNO(MD_MIN2SET(mnum)))
			return (EINVAL);

		if (! (ui->ui_capab & DKV_DMR_CAP))
			return (EINVAL);

		vdr = kmem_zalloc(sizeof (vol_directed_rd_t), KM_NOSLEEP);
		if (vdr == NULL)
			return (ENOMEM);

		/*
		 * Underlying device supports directed mirror read, so update
		 * the user-supplied offset to pick the correct block from the
		 * partitioned metadevice.
		 */
#ifdef _MULTI_DATAMODEL
		vdr32 = kmem_zalloc(sizeof (vol_directed_rd32_t), KM_NOSLEEP);
		if (vdr32 == NULL) {
			kmem_free(vdr, sizeof (vol_directed_rd_t));
			return (ENOMEM);
		}

		switch (ddi_model_convert_from(mode & FMODELS)) {
		case DDI_MODEL_ILP32:
			if (ddi_copyin(data, vdr32, sizeof (*vdr32), mode)) {
				kmem_free(vdr, sizeof (*vdr));
				return (EFAULT);
			}
			vdr->vdr_flags = vdr32->vdr_flags;
			vdr->vdr_offset = vdr32->vdr_offset;
			vdr->vdr_nbytes = vdr32->vdr_nbytes;
			vdr->vdr_data = (void *)(uintptr_t)vdr32->vdr_data;
			vdr->vdr_side = vdr32->vdr_side;
			break;

		case DDI_MODEL_NONE:
			if (ddi_copyin(data, vdr, sizeof (*vdr), mode)) {
				kmem_free(vdr32, sizeof (*vdr32));
				kmem_free(vdr, sizeof (*vdr));
				return (EFAULT);
			}
			break;

		default:
			kmem_free(vdr32, sizeof (*vdr32));
			kmem_free(vdr, sizeof (*vdr));
			return (EFAULT);
		}
#else	/* ! _MULTI_DATAMODEL */
		if (ddi_copyin(data, vdr, sizeof (*vdr), mode)) {
			kmem_free(vdr, sizeof (*vdr));
			return (EFAULT);
		}
#endif	/* _MULTI_DATA_MODEL */

		err = sp_directed_read(mnum, vdr, mode);


#ifdef _MULTI_DATAMODEL
		switch (ddi_model_convert_from(mode & FMODELS)) {
		case DDI_MODEL_ILP32:
			vdr32->vdr_flags = vdr->vdr_flags;
			vdr32->vdr_offset = vdr->vdr_offset;
			vdr32->vdr_side = vdr->vdr_side;
			vdr32->vdr_bytesread = vdr->vdr_bytesread;
			bcopy(vdr->vdr_side_name, vdr32->vdr_side_name,
			    sizeof (vdr32->vdr_side_name));

			if (ddi_copyout(vdr32, data, sizeof (*vdr32), mode))
				err = EFAULT;
			break;

		case DDI_MODEL_NONE:
			if (ddi_copyout(&vdr, data, sizeof (vdr), mode))
				err = EFAULT;
			break;
		}
#else	/* ! _MULTI_DATA_MODEL */
		if (ddi_copyout(&vdr, data, sizeof (vdr), mode))
			err = EFAULT;
#endif	/* _MULTI_DATA_MODEL */

#ifdef _MULTI_DATAMODEL
		kmem_free(vdr32, sizeof (*vdr32));
#endif	/* _MULTI_DATAMODEL */
		kmem_free(vdr, sizeof (*vdr));

		return (err);
	}

	}

	/* Option not handled */
	return (ENOTTY);
}