7712 mandoc -Tlint does always exit with error code 0

[unleashed.git] / usr / src / uts / common / io / 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);
}