lvm/stripe/stripe.c

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

#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/cmn_err.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/mkdev.h>
#include <sys/stat.h>
#include <sys/open.h>
#include <sys/lvm/mdio.h>
#include <sys/lvm/mdvar.h>
#include <sys/lvm/md_stripe.h>
#include <sys/lvm/md_convert.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/sysevent/eventdefs.h>
#include <sys/sysevent/svm.h>

md_ops_t        stripe_md_ops;
#ifndef lint
char            _depends_on[] = "drv/md";
md_ops_t        *md_interface_ops = &stripe_md_ops;
#endif

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

extern kmutex_t     md_mx;
extern kcondvar_t   md_cv;

extern int      md_status;
extern major_t      md_major;
extern mdq_anchor_t md_done_daemon;

static int      md_stripe_mcs_buf_off;
static kmem_cache_t *stripe_parent_cache = NULL;
static kmem_cache_t *stripe_child_cache = NULL;

/*ARGSUSED1*/
static int
stripe_parent_constructor(void *p, void *d1, int d2)
{
    mutex_init(&((md_sps_t *)p)->ps_mx,
        NULL, MUTEX_DEFAULT, NULL);
    return (0);
}

static void
stripe_parent_init(void *ps)
{
    bzero(ps, offsetof(md_sps_t, ps_mx));
}

/*ARGSUSED1*/
static void
stripe_parent_destructor(void *p, void *d)
{
    mutex_destroy(&((md_sps_t *)p)->ps_mx);
}

/*ARGSUSED1*/
static int
stripe_child_constructor(void *p, void *d1, int d2)
{
    bioinit(&((md_scs_t *)p)->cs_buf);
    return (0);
}

static void
stripe_child_init(md_scs_t *cs)
{
    cs->cs_mdunit = 0;
    cs->cs_ps = NULL;
    cs->cs_comp = NULL;
    md_bioreset(&cs->cs_buf);
}

/*ARGSUSED1*/
static void
stripe_child_destructor(void *p, void *d)
{
    biofini(&((md_scs_t *)p)->cs_buf);
}

/*ARGSUSED*/
static void
stripe_run_queue(void *d)
{
    if (!(md_status & MD_GBL_DAEMONS_LIVE))
        md_daemon(1, &md_done_daemon);
}

static void
stripe_close_all_devs(ms_unit_t *un, int md_cflags)
{
    int     row;
    int     i;
    int     c;
    struct ms_comp  *mdcomp;

    mdcomp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);
    for (row = 0; row < un->un_nrows; row++) {
        struct ms_row *mdr = &un->un_row[row];
        for (i = 0, c = mdr->un_icomp; i < mdr->un_ncomp; i++) {
            struct ms_comp  *mdc;
            mdc = &mdcomp[c++];
            if (md_cflags & MD_OFLG_PROBEDEV) {

            /*
             * It is possible that the md_layered_open
             * failed because the stripe unit structure
             * contained a NODEV.  In such a case since
             * there is nothing to open, there is nothing
             * to close.
             */
                if (mdc->un_dev == NODEV64)
                    continue;
            }
            if ((md_cflags & MD_OFLG_PROBEDEV) &&
                (mdc->un_mirror.ms_flags & MDM_S_PROBEOPEN)) {
                md_layered_close(mdc->un_dev,
                    md_cflags);
                mdc->un_mirror.ms_flags &= ~MDM_S_PROBEOPEN;
            } else if (mdc->un_mirror.ms_flags & MDM_S_ISOPEN) {
                md_layered_close(mdc->un_dev, md_cflags);
                mdc->un_mirror.ms_flags &= ~MDM_S_ISOPEN;
            }
        }
    }
}

static int
stripe_open_all_devs(ms_unit_t *un, int md_oflags)
{
    minor_t     mnum = MD_SID(un);
    int     row;
    int     i;
    int     c;
    struct ms_comp  *mdcomp;
    int     err;
    int     cont_on_errors = (md_oflags & MD_OFLG_CONT_ERRS);
    int     probe_err_cnt = 0;
    int     total_comp_cnt = 0;
    set_t       setno = MD_MIN2SET(MD_SID(un));
    side_t      side = mddb_getsidenum(setno);
    mdkey_t     key;

    mdcomp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);

    /*
     * For a probe call, if any component of a stripe or a concat
     * can be opened, it is considered to be a success. The total number
     * of components in a stripe are computed prior to starting a probe.
     * This number is then compared against the number of components
     * that could be be successfully opened. If none of the components
     * in a stripe can be opened, only then an ENXIO is returned for a
     * probe type open.
     */

    for (row = 0; row < un->un_nrows; row++) {
        struct ms_row *mdr = &un->un_row[row];

        if (md_oflags & MD_OFLG_PROBEDEV)
            total_comp_cnt += mdr->un_ncomp;

        for (i = 0, c = mdr->un_icomp; i < mdr->un_ncomp; i++) {
            struct ms_comp  *mdc;
            md_dev64_t tmpdev;

            mdc = &mdcomp[c++];
            tmpdev = mdc->un_dev;
            /*
             * Do the open by device id
             * Check if this comp is hotspared and
             * if it is then use the key for hotspare.
             * MN disksets don't use devids, so we better don't use
             * md_devid_found/md_resolve_bydevid there. Rather do,
             * what's done in stripe_build_incore()
             */
            if (MD_MNSET_SETNO(setno)) {
                if (mdc->un_mirror.ms_hs_id != 0) {
                    (void) md_hot_spare_ifc(HS_MKDEV, 0, 0,
                        0, &mdc->un_mirror.ms_hs_id, NULL,
                        &tmpdev, NULL);
                }
            } else {
                key = mdc->un_mirror.ms_hs_id ?
                    mdc->un_mirror.ms_hs_key : mdc->un_key;
                if ((md_getmajor(tmpdev) != md_major) &&
                    md_devid_found(setno, side, key) == 1) {
                    tmpdev = md_resolve_bydevid(mnum,
                        tmpdev, key);
                }
            }

            /*
             * For a submirror, we only want to open those devices
             * that are not errored. If the device is errored then
             * then there is no reason to open it and leaving it
             * closed allows the RCM/DR code to work so that the
             * errored device can be replaced.
             */
            if ((md_oflags & MD_OFLG_PROBEDEV) ||
                ! (mdc->un_mirror.ms_state & CS_ERRED)) {

                err = md_layered_open(mnum, &tmpdev, md_oflags);
            } else {
                err = ENXIO;
            }

            /*
             * Only set the un_dev if the tmpdev != NODEV64. If
             * it is NODEV64 then the md_layered_open() will have
             * failed in some manner.
             */
            if (tmpdev != NODEV64)
                mdc->un_dev = tmpdev;

            if (err) {
                if (!cont_on_errors) {
                    stripe_close_all_devs(un, md_oflags);
                    return (ENXIO);
                }

                if (md_oflags & MD_OFLG_PROBEDEV)
                    probe_err_cnt++;
            } else {
                if (md_oflags & MD_OFLG_PROBEDEV) {
                    mdc->un_mirror.ms_flags |=
                        MDM_S_PROBEOPEN;
                } else
                    mdc->un_mirror.ms_flags |= MDM_S_ISOPEN;
            }
        }
    }

    /* If every component in a stripe could not be opened fail */
    if ((md_oflags & MD_OFLG_PROBEDEV) &&
        (probe_err_cnt == total_comp_cnt))
        return (ENXIO);
    else
        return (0);
}

int
stripe_build_incore(void *p, int snarfing)
{
    ms_unit_t *un = (ms_unit_t *)p;
    struct ms_comp  *mdcomp;
    minor_t     mnum;
    int     row;
    int     i;
    int     c;
    int     ncomps;

    mnum = MD_SID(un);

    if (MD_UNIT(mnum) != NULL)
        return (0);

    MD_STATUS(un) = 0;

    /*
     * Reset all the is_open flags, these are probably set
     * cause they just came out of the database.
     */
    mdcomp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);

    ncomps = 0;
    for (row = 0; row < un->un_nrows; row++) {
        struct ms_row *mdr = &un->un_row[row];
        ncomps += mdr->un_ncomp;
    }

    for (row = 0; row < un->un_nrows; row++) {
        struct ms_row *mdr = &un->un_row[row];
        for (i = 0, c = mdr->un_icomp; i < mdr->un_ncomp; i++) {
            struct ms_comp      *mdc;
            set_t           setno;
            md_dev64_t      tmpdev;

            mdc = &mdcomp[c++];
            mdc->un_mirror.ms_flags &=
                ~(MDM_S_ISOPEN | MDM_S_IOERR | MDM_S_RS_TRIED);

            if (!snarfing)
                continue;

            setno = MD_MIN2SET(mnum);

            tmpdev = md_getdevnum(setno, mddb_getsidenum(setno),
                mdc->un_key, MD_NOTRUST_DEVT);
            mdc->un_dev = tmpdev;
            /*
             * Check for hotspares. If the hotspares haven't been
             * snarfed yet, stripe_open_all_devs() will do the
             * remapping of the dev's later.
             */
            if (mdc->un_mirror.ms_hs_id != 0) {
                mdc->un_mirror.ms_orig_dev = mdc->un_dev;
                (void) md_hot_spare_ifc(HS_MKDEV, 0, 0,
                    0, &mdc->un_mirror.ms_hs_id, NULL,
                    &tmpdev, NULL);
                mdc->un_dev = tmpdev;
            }
        }
    }

    /* place various information in the in-core data structures */
    md_nblocks_set(mnum, un->c.un_total_blocks);
    MD_UNIT(mnum) = un;

    return (0);
}

void
reset_stripe(ms_unit_t *un, minor_t mnum, int removing)
{
    ms_comp_t   *mdcomp;
    struct ms_row   *mdr;
    int     i, c;
    int     row;
    int     nsv;
    int     isv;
    sv_dev_t    *sv;
    mddb_recid_t    *recids;
    mddb_recid_t    vtoc_id;
    int     rid = 0;

    md_destroy_unit_incore(mnum, &stripe_md_ops);

    md_nblocks_set(mnum, -1ULL);
    MD_UNIT(mnum) = NULL;

    /*
     * Attempt release of its minor node
     */
    md_remove_minor_node(mnum);

    if (!removing)
        return;

    nsv = 0;
    /* Count the number of devices */
    for (row = 0; row < un->un_nrows; row++) {
        mdr = &un->un_row[row];
        nsv += mdr->un_ncomp;
    }
    sv = (sv_dev_t *)kmem_alloc(sizeof (sv_dev_t) * nsv, KM_SLEEP);

    /*
     * allocate recids array.  since we may have to commit
     * underlying soft partition records, we need an array
     * of size: total number of components in stripe + 3
     * (one for the stripe itself, one for the hotspare, one
     * for the end marker).
     */
    recids = kmem_alloc(sizeof (mddb_recid_t) * (nsv + 3), KM_SLEEP);

    /*
     * Save the md_dev64_t's and driver nm indexes.
     * Because after the mddb_deleterec() we will
     * not be able to access the unit structure.
     *
     * NOTE: Deleting the names before deleting the
     *   unit structure would cause problems if
     *   the machine crashed in between the two.
     */
    isv = 0;
    mdcomp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);

    for (row = 0; row < un->un_nrows; row++) {
        mdr = &un->un_row[row];
        for (i = 0, c = mdr->un_icomp; i < mdr->un_ncomp; i++) {
            struct ms_comp  *mdc;
            md_dev64_t  child_dev;
            md_unit_t   *child_un;

            mdc = &mdcomp[c++];
            if (mdc->un_mirror.ms_hs_id != 0) {
                mdkey_t     hs_key;

                hs_key = mdc->un_mirror.ms_hs_key;

                mdc->un_dev = mdc->un_mirror.ms_orig_dev;
                mdc->un_start_block =
                    mdc->un_mirror.ms_orig_blk;
                mdc->un_mirror.ms_hs_id = 0;
                mdc->un_mirror.ms_hs_key = 0;
                mdc->un_mirror.ms_orig_dev = 0;
                recids[0] = 0;
                recids[1] = 0;  /* recids[1] filled in below */
                recids[2] = 0;
                (void) md_hot_spare_ifc(HS_FREE, un->un_hsp_id,
                    0, 0, &recids[0], &hs_key, NULL, NULL);
                mddb_commitrecs_wrapper(recids);
            }

            /*
             * check if we've got metadevice below us and
             * deparent it if we do.
             * NOTE: currently soft partitions are the
             * the only metadevices stripes can be
             * built on top of.
             */
            child_dev = mdc->un_dev;
            if (md_getmajor(child_dev) == md_major) {
                child_un = MD_UNIT(md_getminor(child_dev));
                md_reset_parent(child_dev);
                recids[rid++] = MD_RECID(child_un);
            }

            sv[isv].setno = MD_MIN2SET(mnum);
            sv[isv++].key = mdc->un_key;
        }
    }

    recids[rid++] = un->c.un_record_id;
    recids[rid] = 0;    /* filled in below */

    /*
     * Decrement the HSP reference count and
     * remove the knowledge of the HSP from the unit struct.
     * This is done atomically to remove a window.
     */
    if (un->un_hsp_id != -1) {
        (void) md_hot_spare_ifc(HSP_DECREF, un->un_hsp_id, 0, 0,
            &recids[rid++], NULL, NULL, NULL);
        un->un_hsp_id = -1;
    }

    /* set end marker and commit records */
    recids[rid] = 0;
    mddb_commitrecs_wrapper(recids);

    vtoc_id = un->c.un_vtoc_id;

    /*
     * Remove self from the namespace
     */
    if (un->c.un_revision & MD_FN_META_DEV) {
        (void) md_rem_selfname(un->c.un_self_id);
    }

    /* Remove the unit structure */
    mddb_deleterec_wrapper(un->c.un_record_id);

    /* Remove the vtoc, if present */
    if (vtoc_id)
        mddb_deleterec_wrapper(vtoc_id);

    SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_DELETE, SVM_TAG_METADEVICE,
        MD_MIN2SET(mnum), MD_MIN2UNIT(mnum));
    md_rem_names(sv, nsv);
    kmem_free(sv, sizeof (sv_dev_t) * nsv);
    kmem_free(recids, sizeof (mddb_recid_t) * (nsv + 3));
}

static void
stripe_error(md_sps_t *ps)
{
    struct buf  *pb = ps->ps_bp;
    mdi_unit_t  *ui = ps->ps_ui;
    md_dev64_t  dev = ps->ps_errcomp->un_dev;
    md_dev64_t  md_dev = md_expldev(pb->b_edev);
    char        *str;

    if (pb->b_flags & B_READ) {
        ps->ps_errcomp->un_mirror.ms_flags |= MDM_S_READERR;
        str = "read";
    } else {
        ps->ps_errcomp->un_mirror.ms_flags |= MDM_S_WRTERR;
        str = "write";
    }
    if (!(ps->ps_flags & MD_SPS_DONTFREE)) {
        if (MUTEX_HELD(&ps->ps_mx)) {
            mutex_exit(&ps->ps_mx);
        }
    } else {
        ASSERT(panicstr);
    }
    SPS_FREE(stripe_parent_cache, ps);
    pb->b_flags |= B_ERROR;

    md_kstat_done(ui, pb, 0);
    md_unit_readerexit(ui);
    md_biodone(pb);

    cmn_err(CE_WARN, "md: %s: %s error on %s",
        md_shortname(md_getminor(md_dev)), str,
        md_devname(MD_DEV2SET(md_dev), dev, NULL, 0));
}

static int
stripe_done(struct buf *cb)
{
    struct buf  *pb;
    mdi_unit_t  *ui;
    md_sps_t    *ps;
    md_scs_t    *cs;

    /*LINTED*/
    cs = (md_scs_t *)((caddr_t)cb - md_stripe_mcs_buf_off);
    ps = cs->cs_ps;
    pb = ps->ps_bp;

    mutex_enter(&ps->ps_mx);
    if (cb->b_flags & B_ERROR) {
        ps->ps_flags |= MD_SPS_ERROR;
        pb->b_error = cb->b_error;
        ps->ps_errcomp = cs->cs_comp;
    }

    if (cb->b_flags & B_REMAPPED)
        bp_mapout(cb);

    ps->ps_frags--;
    if (ps->ps_frags != 0) {
        mutex_exit(&ps->ps_mx);
        kmem_cache_free(stripe_child_cache, cs);
        return (1);
    }
    kmem_cache_free(stripe_child_cache, cs);
    if (ps->ps_flags & MD_SPS_ERROR) {
        stripe_error(ps);
        return (1);
    }
    ui = ps->ps_ui;
    if (!(ps->ps_flags & MD_SPS_DONTFREE)) {
        mutex_exit(&ps->ps_mx);
    } else {
        ASSERT(panicstr);
    }
    SPS_FREE(stripe_parent_cache, ps);
    md_kstat_done(ui, pb, 0);
    md_unit_readerexit(ui);
    md_biodone(pb);
    return (0);
}


/*
 * This routine does the mapping from virtual (dev, blkno) of a metapartition
 * to the real (dev, blkno) of a real disk partition.
 * It goes to the md_conf[] table to find out the correct real partition
 * dev and block number for this buffer.
 *
 * A single buf request can not go across real disk partition boundary.
 * When the virtual request specified by (dev, blkno) spans more than one
 * real partition, md_mapbuf will return 1. Then the caller should prepare
 * another real buf and continue calling md_mapbuf to do the mapping until
 * it returns 0.
 *
 */

static int
md_mapbuf(
    ms_unit_t   *un,
    diskaddr_t  blkno,
    u_longlong_t    bcount,
    buf_t       *bp,    /* if bp==NULL, skip bp updates */
    ms_comp_t   **mdc)  /* if bp==NULL, skip mdc update */
{
    struct ms_row   *mdr;
    struct ms_comp  *mdcomp;
    diskaddr_t  stripe_blk;
    diskaddr_t  fragment, blk_in_row, endblk;
    offset_t    interlace;
    size_t      dev_index;
    int     row_index, more;
    extern unsigned md_maxphys;
    /* Work var's when bp==NULL */
    u_longlong_t    wb_bcount;
    diskaddr_t  wb_blkno;
    md_dev64_t  wb_edev;
    ms_comp_t   *wmdc;

    /*
     * Do a real calculation to derive the minor device of the
     * Virtual Disk, which in turn will let us derive the
     * device/minor of the underlying real device.
     */


    for (row_index = 0; row_index < un->un_nrows; row_index++) {
        mdr = &un->un_row[row_index];
        if (blkno < mdr->un_cum_blocks)
            break;
    }
    ASSERT(row_index != un->un_nrows);

    mdcomp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);

    blk_in_row = blkno - mdr->un_cum_blocks + mdr->un_blocks;
    endblk = (diskaddr_t)(blkno + howmany(bcount, DEV_BSIZE));
    if (mdr->un_ncomp == 1) { /* No striping */
        if (endblk > mdr->un_cum_blocks) {
            wb_bcount = ldbtob(mdr->un_cum_blocks - blkno);
            if ((row_index + 1) == un->un_nrows)
                more = 0;
            else
                more = 1;
        } else {
            wb_bcount = bcount;
            more = 0;
        }
        wmdc = &mdcomp[mdr->un_icomp];
        wb_blkno = blk_in_row;
    } else { /* Have striping */
        interlace = mdr->un_interlace;
        fragment = blk_in_row % interlace;
        if (bcount > ldbtob(interlace - fragment)) {
            more = 1;
            wb_bcount = ldbtob(interlace - fragment);
        } else {
            more = 0;
            wb_bcount = bcount;
        }

        stripe_blk = blk_in_row / interlace;
        dev_index = (size_t)(stripe_blk % mdr->un_ncomp);
        wmdc = &mdcomp[mdr->un_icomp + dev_index];
        wb_blkno = (diskaddr_t)(((stripe_blk / mdr->un_ncomp) *
            interlace) + fragment);
    }

    wb_blkno += wmdc->un_start_block;
    wb_edev = wmdc->un_dev;

    /* only break up the I/O if we're not built on another metadevice */
    if ((md_getmajor(wb_edev) != md_major) && (wb_bcount > md_maxphys)) {
        wb_bcount = md_maxphys;
        more = 1;
    }
    if (bp != (buf_t *)NULL) {
        /*
         * wb_bcount is limited by md_maxphys which is 'int'
         */
        bp->b_bcount = (size_t)wb_bcount;
        bp->b_lblkno = wb_blkno;
        bp->b_edev = md_dev64_to_dev(wb_edev);
        *mdc = wmdc;
    }
    return (more);
}

static void
md_stripe_strategy(buf_t *pb, int flag, void *private)
{
    md_sps_t    *ps;
    md_scs_t    *cs;
    int     doing_writes;
    int     more;
    ms_unit_t   *un;
    mdi_unit_t  *ui;
    size_t      current_count;
    diskaddr_t  current_blkno;
    off_t       current_offset;
    buf_t       *cb;        /* child buf pointer */
    set_t       setno;

    setno = MD_MIN2SET(getminor(pb->b_edev));

    /*
     * When doing IO to a multi owner meta device, check if set is halted.
     * We do this check without the needed lock held, for performance
     * reasons.
     * If an IO just slips through while the set is locked via an
     * MD_MN_SUSPEND_SET, we don't care about it.
     * Only check for a suspended set if we are a top-level i/o request
     * (MD_STR_NOTTOP is cleared in 'flag').
     */
    if ((md_set[setno].s_status & (MD_SET_HALTED | MD_SET_MNSET)) ==
        (MD_SET_HALTED | MD_SET_MNSET)) {
        if ((flag & MD_STR_NOTTOP) == 0) {
            mutex_enter(&md_mx);
            /* Here we loop until the set is no longer halted */
            while (md_set[setno].s_status & MD_SET_HALTED) {
                cv_wait(&md_cv, &md_mx);
            }
            mutex_exit(&md_mx);
        }
    }

    ui = MDI_UNIT(getminor(pb->b_edev));

    md_kstat_waitq_enter(ui);

    un = (ms_unit_t *)md_unit_readerlock(ui);

    if ((flag & MD_NOBLOCK) == 0) {
        if (md_inc_iocount(setno) != 0) {
            pb->b_flags |= B_ERROR;
            pb->b_error = ENXIO;
            pb->b_resid = pb->b_bcount;
            md_kstat_waitq_exit(ui);
            md_unit_readerexit(ui);
            biodone(pb);
            return;
        }
    } else {
        md_inc_iocount_noblock(setno);
    }

    if (!(flag & MD_STR_NOTTOP)) {
        if (md_checkbuf(ui, (md_unit_t *)un, pb) != 0) {
            md_kstat_waitq_exit(ui);
            return;
        }
    }

    ps = kmem_cache_alloc(stripe_parent_cache, MD_ALLOCFLAGS);
    stripe_parent_init(ps);

    /*
     * Save essential information from the original buffhdr
     * in the md_save structure.
     */
    ps->ps_un = un;
    ps->ps_ui = ui;
    ps->ps_bp = pb;
    ps->ps_addr = pb->b_un.b_addr;

    if ((pb->b_flags & B_READ) == 0)
        doing_writes = 1;
    else
        doing_writes = 0;


    current_count = pb->b_bcount;
    current_blkno = pb->b_lblkno;
    current_offset  = 0;

    if (!(flag & MD_STR_NOTTOP) && panicstr)
        ps->ps_flags |= MD_SPS_DONTFREE;

    md_kstat_waitq_to_runq(ui);

    ps->ps_frags++;
    do {
        cs = kmem_cache_alloc(stripe_child_cache, MD_ALLOCFLAGS);
        stripe_child_init(cs);
        cb = &cs->cs_buf;
        cs->cs_ps = ps;
        more = md_mapbuf(un, current_blkno, current_count, cb,
            &cs->cs_comp);

        cb = md_bioclone(pb, current_offset, cb->b_bcount, cb->b_edev,
            cb->b_lblkno, stripe_done, cb, KM_NOSLEEP);
        /*
         * Do these calculations now,
         *  so that we pickup a valid b_bcount from the chld_bp.
         */
        current_offset += cb->b_bcount;
        current_count -=  cb->b_bcount;
        current_blkno +=  (diskaddr_t)(lbtodb(cb->b_bcount));

        if (more) {
            mutex_enter(&ps->ps_mx);
            ps->ps_frags++;
            mutex_exit(&ps->ps_mx);
        }

        if (doing_writes &&
            cs->cs_comp->un_mirror.ms_flags & MDM_S_NOWRITE) {
            (void) stripe_done(cb);
            continue;
        }
        md_call_strategy(cb, flag, private);
    } while (more);

    if (!(flag & MD_STR_NOTTOP) && panicstr) {
        while (!(ps->ps_flags & MD_SPS_DONE)) {
            md_daemon(1, &md_done_daemon);
            drv_usecwait(10);
        }
        kmem_cache_free(stripe_parent_cache, ps);
    }
}

static int
stripe_snarf(md_snarfcmd_t cmd, set_t setno)
{
    ms_unit_t   *un;
    mddb_recid_t    recid;
    int     gotsomething;
    int     all_stripes_gotten;
    mddb_type_t typ1;
    mddb_de_ic_t    *dep;
    mddb_rb32_t *rbp;
    size_t      newreqsize;
    ms_unit_t   *big_un;
    ms_unit32_od_t  *small_un;


    if (cmd == MD_SNARF_CLEANUP)
        return (0);

    all_stripes_gotten = 1;
    gotsomething = 0;

    typ1 = (mddb_type_t)md_getshared_key(setno,
        stripe_md_ops.md_driver.md_drivername);
    recid = mddb_makerecid(setno, 0);

    while ((recid = mddb_getnextrec(recid, typ1, 0)) > 0) {
        if (mddb_getrecprivate(recid) & MD_PRV_GOTIT)
            continue;

        dep = mddb_getrecdep(recid);
        dep->de_flags = MDDB_F_STRIPE;
        rbp = dep->de_rb;

        switch (rbp->rb_revision) {
        case MDDB_REV_RB:
        case MDDB_REV_RBFN:
            if ((rbp->rb_private & MD_PRV_CONVD) == 0) {
                /*
                 * This means, we have an old and small record
                 * and this record hasn't already been
                 * converted.  Before we create an incore
                 * metadevice from this we have to convert it to
                 * a big record.
                 */
                small_un =
                    (ms_unit32_od_t *)mddb_getrecaddr(recid);
                newreqsize = get_big_stripe_req_size(small_un,
                    COMPLETE_STRUCTURE);
                big_un = (ms_unit_t *)kmem_zalloc(newreqsize,
                    KM_SLEEP);
                stripe_convert((caddr_t)small_un,
                    (caddr_t)big_un, SMALL_2_BIG);
                kmem_free(small_un, dep->de_reqsize);
                dep->de_rb_userdata = big_un;
                dep->de_reqsize = newreqsize;
                un = big_un;
                rbp->rb_private |= MD_PRV_CONVD;
            } else {
                /* Small device had already been converted */
                un = (ms_unit_t *)mddb_getrecaddr(recid);
            }
            un->c.un_revision &= ~MD_64BIT_META_DEV;
            break;
        case MDDB_REV_RB64:
        case MDDB_REV_RB64FN:
            /* Big device */
            un = (ms_unit_t *)mddb_getrecaddr(recid);
            un->c.un_revision |= MD_64BIT_META_DEV;
            un->c.un_flag |= MD_EFILABEL;
            break;
        }
        MDDB_NOTE_FN(rbp->rb_revision, un->c.un_revision);

        /* Create minor node for snarfed unit. */
        (void) md_create_minor_node(MD_MIN2SET(MD_SID(un)), MD_SID(un));

        if (MD_UNIT(MD_SID(un)) != NULL) {
            mddb_setrecprivate(recid, MD_PRV_PENDDEL);
            continue;
        }
        all_stripes_gotten = 0;
        if (stripe_build_incore((void *)un, 1) == 0) {
            mddb_setrecprivate(recid, MD_PRV_GOTIT);
            md_create_unit_incore(MD_SID(un), &stripe_md_ops, 0);
            gotsomething = 1;
        }
    }

    if (!all_stripes_gotten)
        return (gotsomething);

    recid = mddb_makerecid(setno, 0);
    while ((recid = mddb_getnextrec(recid, typ1, 0)) > 0)
        if (!(mddb_getrecprivate(recid) & MD_PRV_GOTIT))
            mddb_setrecprivate(recid, MD_PRV_PENDDEL);

    return (0);
}

static int
stripe_halt(md_haltcmd_t cmd, set_t setno)
{
    int     i;
    mdi_unit_t  *ui;
    minor_t     mnum;

    if (cmd == MD_HALT_CLOSE)
        return (0);

    if (cmd == MD_HALT_OPEN)
        return (0);

    if (cmd == MD_HALT_UNLOAD)
        return (0);

    if (cmd == MD_HALT_CHECK) {
        for (i = 0; i < md_nunits; i++) {
            mnum = MD_MKMIN(setno, i);
            if ((ui = MDI_UNIT(mnum)) == NULL)
                continue;
            if (ui->ui_opsindex != stripe_md_ops.md_selfindex)
                continue;
            if (md_unit_isopen(ui))
                return (1);
        }
        return (0);
    }

    if (cmd != MD_HALT_DOIT)
        return (1);

    for (i = 0; i < md_nunits; i++) {
        mnum = MD_MKMIN(setno, i);
        if ((ui = MDI_UNIT(mnum)) == NULL)
            continue;
        if (ui->ui_opsindex != stripe_md_ops.md_selfindex)
            continue;
        reset_stripe((ms_unit_t *)MD_UNIT(mnum), mnum, 0);
    }

    return (0);
}

/*ARGSUSED3*/
static int
stripe_open(dev_t *dev, int flag, int otyp, cred_t *cred_p, int md_oflags)
{
    minor_t     mnum = getminor(*dev);
    mdi_unit_t  *ui = MDI_UNIT(mnum);
    ms_unit_t   *un;
    int     err = 0;
    set_t       setno;

    /*
     * When doing an open of a multi owner metadevice, check to see if this
     * node is a starting node and if a reconfig cycle is underway.
     * If so, the system isn't sufficiently set up enough to handle the
     * open (which involves I/O during sp_validate), so fail with ENXIO.
     */
    setno = MD_MIN2SET(mnum);
    if ((md_set[setno].s_status & (MD_SET_MNSET | MD_SET_MN_START_RC)) ==
        (MD_SET_MNSET | MD_SET_MN_START_RC)) {
            return (ENXIO);
    }

    /* single thread */
    un = (ms_unit_t *)md_unit_openclose_enter(ui);

    /* open devices, if necessary */
    if (! md_unit_isopen(ui) || (md_oflags & MD_OFLG_PROBEDEV)) {
        if ((err = stripe_open_all_devs(un, md_oflags)) != 0) {
            goto out;
        }
    }

    /* count open */
    if ((err = md_unit_incopen(mnum, flag, otyp)) != 0)
        goto out;

    /* unlock, return success */
out:
    md_unit_openclose_exit(ui);
    return (err);
}

/*ARGSUSED1*/
static int
stripe_close(
    dev_t       dev,
    int     flag,
    int     otyp,
    cred_t      *cred_p,
    int     md_cflags
)
{
    minor_t     mnum = getminor(dev);
    mdi_unit_t  *ui = MDI_UNIT(mnum);
    ms_unit_t   *un;
    int     err = 0;

    /* single thread */
    un = (ms_unit_t *)md_unit_openclose_enter(ui);

    /* count closed */
    if ((err = md_unit_decopen(mnum, otyp)) != 0)
        goto out;

    /* close devices, if necessary */
    if (! md_unit_isopen(ui) || (md_cflags & MD_OFLG_PROBEDEV)) {
        stripe_close_all_devs(un, md_cflags);
    }

    /* unlock, return success */
out:
    md_unit_openclose_exit(ui);
    return (err);
}


static struct buf dumpbuf;

/*
 * This routine dumps memory to the disk.  It assumes that the memory has
 * already been mapped into mainbus space.  It is called at disk interrupt
 * priority when the system is in trouble.
 *
 */
static int
stripe_dump(dev_t dev, caddr_t addr, daddr_t blkno, int nblk)
{
    ms_unit_t   *un;
    buf_t       *bp;
    ms_comp_t   *mdc;
    u_longlong_t    nb;
    diskaddr_t  mapblk;
    int     result;
    int     more;
    int     saveresult = 0;

    /*
     * Don't need to grab the unit lock.
     * Cause nothing else is suppose to be happenning.
     * Also dump is not suppose to sleep.
     */
    un = (ms_unit_t *)MD_UNIT(getminor(dev));

    if ((diskaddr_t)blkno >= un->c.un_total_blocks)
        return (EINVAL);

    if ((diskaddr_t)blkno + nblk > un->c.un_total_blocks)
        return (EINVAL);

    bp = &dumpbuf;
    nb = ldbtob(nblk);
    do {
        bzero((caddr_t)bp, sizeof (*bp));
        more = md_mapbuf(un, (diskaddr_t)blkno, nb, bp, &mdc);
        nblk = btodb(bp->b_bcount);
        mapblk = bp->b_lblkno;
        if (!(mdc->un_mirror.ms_flags & MDM_S_NOWRITE)) {
            /*
             * bdev_dump() is currently only able to take
             * 32 bit wide blkno's.
             */
            result = bdev_dump(bp->b_edev, addr, (daddr_t)mapblk,
                nblk);
            if (result)
                saveresult = result;
        }

        nb -= bp->b_bcount;
        addr += bp->b_bcount;
        blkno += nblk;
    } while (more);

    return (saveresult);
}

/*ARGSUSED*/
static intptr_t
stripe_shared_by_blk(
    md_dev64_t dev,
    void *junk,
    diskaddr_t blkno,
    u_longlong_t *cnt)
{
    ms_unit_t   *un;
    buf_t       bp;
    ms_comp_t   *comp;

    un = MD_UNIT(md_getminor(dev));
    (void) md_mapbuf(un, blkno, ldbtob(*cnt), &bp, &comp);
    *cnt = (u_longlong_t)lbtodb(bp.b_bcount);
    return ((intptr_t)&comp->un_mirror);
}

/*
 * stripe_block_count_skip_size() returns the following values
 *  so that the logical to physical block mappings can
 *  be calculated without intimate knowledge of the underpinnings.
 *
 *  block - first logical block number of the device.
 *      block = [ # of blocks before THE row ] +
 *          [ # of blocks in THE row before the component ]
 *  count - # of segments (interlaced size).
 *  skip  - # of logical blocks between segments, or delta to
 *        get to next segment
 *  size  - interlace size used for the block, count, skip.
 */
/*ARGSUSED*/
static intptr_t
stripe_block_count_skip_size(
    md_dev64_t   dev,
    void        *junk,
    int     ci,
    diskaddr_t  *block,
    size_t      *count,
    u_longlong_t    *skip,
    u_longlong_t    *size)
{
    ms_unit_t   *un;
    int     row;
    struct ms_row   *mdr;
    int     cmpcount = 0;

    un = MD_UNIT(md_getminor(dev));

    for (row = 0; row < un->un_nrows; row++) {
        mdr = &un->un_row[row];
        if ((mdr->un_ncomp + cmpcount) > ci)
            break;
        cmpcount += mdr->un_ncomp;
    }
    ASSERT(row != un->un_nrows);

    /*
     * Concatenations are always contiguous blocks,
     * you cannot depend on the interlace being a usable
     * value (except for stripes).
     */
    if (mdr->un_ncomp == 1) {   /* Concats */
        *block = mdr->un_cum_blocks - mdr->un_blocks;
        *count = 1;
        *skip = 0;
        *size = mdr->un_blocks;
    } else {            /* Stripes */
        *block = (mdr->un_cum_blocks - mdr->un_blocks) +
            ((ci - cmpcount) * mdr->un_interlace);
        *count  = (size_t)(mdr->un_blocks / (mdr->un_interlace *
            mdr->un_ncomp));
        *skip = (mdr->un_interlace * mdr->un_ncomp) - mdr->un_interlace;
        *size = mdr->un_interlace;
    }

    return (0);
}

/*ARGSUSED*/
static intptr_t
stripe_shared_by_indx(md_dev64_t dev, void *junk, int indx)
{
    ms_unit_t   *un;
    ms_comp_t   *comp;

    un = MD_UNIT(md_getminor(dev));
    comp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);
    comp += indx;
    return ((intptr_t)&comp->un_mirror);
}

/*ARGSUSED*/
intptr_t
stripe_component_count(md_dev64_t dev, void *junk)
{
    /*
     * See comments for stripe_get_dev
     */

    ms_unit_t   *un;
    int     count = 0;
    int     row;

    un = MD_UNIT(md_getminor(dev));
    for (row = 0; row < un->un_nrows; row++)
        count += un->un_row[row].un_ncomp;
    return (count);
}

/*ARGSUSED*/
intptr_t
stripe_get_dev(md_dev64_t dev, void *junk, int indx, ms_cd_info_t *cd)
{
    /*
     * It should be noted that stripe_replace in stripe_ioctl.c calls this
     * routine using makedevice(0, minor) for the first argument.
     *
     * If this routine at some point in the future needs to use the major
     * number stripe_replace must be changed.
     */

    ms_unit_t   *un;
    ms_comp_t   *comp;
    md_dev64_t  tmpdev;

    un = MD_UNIT(md_getminor(dev));
    comp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);
    comp += indx;
    tmpdev = comp->un_dev;
    /*
     * Try to resolve devt again if NODEV64
     * Check if this comp is hotspared and if it is
     * then use key for hotspare
     */
    if (tmpdev == NODEV64) {
        tmpdev = md_resolve_bydevid(md_getminor(dev), tmpdev,
            comp->un_mirror.ms_hs_id ?
            comp->un_mirror.ms_hs_key :
            comp->un_key);
        comp->un_dev = tmpdev;
    }

    cd->cd_dev = comp->un_dev;
    cd->cd_orig_dev = comp->un_mirror.ms_orig_dev;
    return (0);
}

/*ARGSUSED*/
void
stripe_replace_done(md_dev64_t dev, sv_dev_t *sv)
{
    /*
     * See comments for stripe_get_dev
     */

    minor_t     mnum = md_getminor(dev);

    if (sv != NULL) {
        md_rem_names(sv, 1);
        kmem_free(sv, sizeof (sv_dev_t));
    }

    md_unit_writerexit(MDI_UNIT(mnum));
}

/*ARGSUSED*/
intptr_t
stripe_replace_dev(md_dev64_t dev, void *junk, int ci, ms_new_dev_t *nd,
    mddb_recid_t *recids, int nrecids, void (**replace_done)(),
    void **replace_data)
{
    minor_t     mnum;
    ms_unit_t   *un;
    mdi_unit_t  *ui;
    ms_comp_t   *comp;
    diskaddr_t  dev_size;
    int     row;
    int     ncomps = 0;
    int     cmpcount = 0;
    int     rid = 0;
    struct ms_row   *mdr;
    sv_dev_t    *sv = NULL;
    mddb_recid_t    hs_id = 0;
    set_t       setno;
    side_t      side;
    md_dev64_t  this_dev;

    mnum = md_getminor(dev);
    ui = MDI_UNIT(mnum);
    setno = MD_MIN2SET(mnum);
    side = mddb_getsidenum(setno);

    un = md_unit_writerlock(ui);

    *replace_data = NULL;
    comp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);

    comp += ci;

    /*
     * Count the number of components
     */
    for (row = 0; row < un->un_nrows; row++) {
        struct ms_row *mdr = &un->un_row[row];
        ncomps += mdr->un_ncomp;
    }

    recids[0] = 0;
    /*
     * No need of checking size of new device,
     * when hotsparing (it has already been done), or
     * when enabling the device.
     */
    if ((nd != NULL) && (nd->nd_hs_id == 0)) {
        for (row = 0; row < un->un_nrows; row++) {
            mdr = &un->un_row[row];
            if ((mdr->un_ncomp + cmpcount) > ci)
                break;
            cmpcount += mdr->un_ncomp;
        }
        ASSERT(row != un->un_nrows);

        /* Concatenations have a ncomp = 1 */
        dev_size = mdr->un_blocks / mdr->un_ncomp;

        /*
         * now check to see if new comp can be used in
         * place of old comp
         */
        if ((un->c.un_flag & MD_LABELED) && (ci == 0) &&
            nd->nd_labeled)
            nd->nd_start_blk = 0;
        else
            nd->nd_nblks -= nd->nd_start_blk;

        if (dev_size > nd->nd_nblks) {
            md_unit_writerexit(ui);
            return (MDE_COMP_TOO_SMALL);
        }

        sv = (sv_dev_t *)kmem_alloc(sizeof (sv_dev_t), KM_SLEEP);
        sv->setno = MD_MIN2SET(mnum);
        sv->key = comp->un_key;
    }

    /*
     * Close this component.
     */
    if (comp->un_mirror.ms_flags & MDM_S_ISOPEN) {
        md_layered_close(comp->un_dev, MD_OFLG_NULL);
        comp->un_mirror.ms_flags &= ~MDM_S_ISOPEN;
    }

    /*
     * If the component is hotspared, return to the pool.
     */
    if (comp->un_mirror.ms_hs_id != 0) {
        hs_cmds_t   cmd;
        mdkey_t     hs_key;

        hs_key = comp->un_mirror.ms_hs_key;
        comp->un_dev = comp->un_mirror.ms_orig_dev;
        comp->un_start_block = comp->un_mirror.ms_orig_blk;
        comp->un_mirror.ms_hs_key = 0;
        comp->un_mirror.ms_hs_id = 0;
        comp->un_mirror.ms_orig_dev = 0;

        cmd = HS_FREE;
        if ((comp->un_mirror.ms_state != CS_OKAY) &&
            (comp->un_mirror.ms_state != CS_RESYNC))
            cmd = HS_BAD;
        (void) md_hot_spare_ifc(cmd, un->un_hsp_id, 0, 0, &hs_id,
            &hs_key, NULL, NULL);
    }

    /*
     * Open by device id; for enable (indicated by a NULL
     * nd pointer), use the existing component info.  For
     * replace, use the new device.
     */
    if (nd == NULL) {
        this_dev = md_resolve_bydevid(mnum, comp->un_dev, comp->un_key);
        /*
         * If someone replaced a new disk in the same slot
         * we get NODEV64 since old device id cannot be
         * resolved. The new devt is obtained from the
         * mddb since devt is going to be unchanged for the
         * enable case. No need to check for multiple
         * keys here because the caller (comp_replace)
         * has already sanity checked it for us.
         */
        if (this_dev == NODEV64) {
            this_dev = md_getdevnum(setno, side, comp->un_key,
                MD_TRUST_DEVT);
        }
    } else {
        /*
         * If this is a hotspare, save the original dev_t for later
         * use. If this has occured during boot then the value of
         * comp->un_dev will be NODEV64 because of the failure to look
         * up the devid of the device.
         */
        if (nd->nd_hs_id != 0)
            comp->un_mirror.ms_orig_dev = comp->un_dev;
        this_dev = md_resolve_bydevid(mnum, nd->nd_dev, nd->nd_key);
    }

    comp->un_dev = this_dev;

    /*
     * Now open the new device if required. Note for a single component
     * stripe it will not be open - leave this for the mirror driver to
     * deal with.
     */
    if (md_unit_isopen(ui)) {
        if (md_layered_open(mnum, &this_dev, MD_OFLG_NULL)) {
            mddb_recid_t    ids[3];

            ids[0] = un->c.un_record_id;
            ids[1] = hs_id;
            ids[2] = 0;
            mddb_commitrecs_wrapper(ids);
            if ((nd != NULL) && (nd->nd_hs_id != 0)) {
                /*
                 * Revert back to the original device.
                 */
                comp->un_dev = comp->un_mirror.ms_orig_dev;

                cmn_err(CE_WARN,
                    "md: %s: open error of hotspare %s",
                    md_shortname(mnum),
                    md_devname(MD_MIN2SET(mnum), nd->nd_dev,
                    NULL, 0));
                SE_NOTIFY(EC_SVM_STATE, ESC_SVM_OPEN_FAIL,
                    SVM_TAG_HS, MD_MIN2SET(mnum), nd->nd_dev);
            }
            md_unit_writerexit(ui);
            return (MDE_COMP_OPEN_ERR);
        }
        if (nd != NULL)
            nd->nd_dev = this_dev;

        comp->un_mirror.ms_flags |= MDM_S_ISOPEN;
    }

    if (nd == NULL) {
        recids[0] = un->c.un_record_id;
        recids[1] = hs_id;
        recids[2] = 0;
        *replace_done = stripe_replace_done;
        return (0);
    }

    /* if hot sparing this device */
    if (nd->nd_hs_id != 0) {
        char    devname[MD_MAX_CTDLEN];
        char    hs_devname[MD_MAX_CTDLEN];
        set_t   setno;

        comp->un_mirror.ms_hs_id = nd->nd_hs_id;
        comp->un_mirror.ms_hs_key = nd->nd_key;

        comp->un_mirror.ms_orig_blk = comp->un_start_block;

        setno = MD_MIN2SET(mnum);

        (void) md_devname(setno, comp->un_mirror.ms_orig_dev, devname,
            sizeof (devname));
        (void) md_devname(setno, nd->nd_dev, hs_devname,
            sizeof (hs_devname));

        cmn_err(CE_NOTE, "md: %s: hotspared device %s with %s",
            md_shortname(mnum), devname, hs_devname);

    } else {    /* replacing the device */
        comp->un_key = nd->nd_key;
        *replace_data = (void *)sv;

        /*
         * For the old device, make sure to reset the parent
         * if it's a  metadevice.
         */
        if (md_getmajor(comp->un_dev) == md_major) {
            minor_t   comp_mnum = md_getminor(comp->un_dev);
            md_unit_t *comp_un = MD_UNIT(comp_mnum);

            md_reset_parent(comp->un_dev);
            recids[rid++] = MD_RECID(comp_un);
        }
    }

    comp->un_dev = nd->nd_dev;
    comp->un_start_block = nd->nd_start_blk;

    /*
     * For the new device, make sure to set the parent if it's a
     * metadevice.
     *
     * If we ever support using metadevices as hot spares, this
     * will need to be tested, and possibly moved into the
     * preceding "else" clause, immediately following the parent
     * reset block.  For now, it's convenient to leave it here and
     * only compress nd->nd_dev once.
     */
    if (md_getmajor(comp->un_dev) == md_major) {
        minor_t     comp_mnum = md_getminor(comp->un_dev);
        md_unit_t   *comp_un = MD_UNIT(comp_mnum);

        md_set_parent(comp->un_dev, MD_SID(un));
        recids[rid++] = MD_RECID(comp_un);
    }

    recids[rid++] = un->c.un_record_id;
    recids[rid++] = hs_id;
    recids[rid] = 0;
    *replace_done = stripe_replace_done;
    return (0);
}

/*ARGSUSED*/
static intptr_t
stripe_hotspare_dev(
    md_dev64_t  dev,
    void        *junk,
    int     ci,
    mddb_recid_t    *recids,
    int     nrecids,
    void        (**replace_done)(),
    void        **replace_data)
{
    ms_unit_t   *un;
    mdi_unit_t  *ui;
    ms_comp_t   *comp;
    int     row;
    struct ms_row   *mdr;
    ms_new_dev_t    nd;
    int     err;
    int     i;
    minor_t     mnum;
    set_t       setno;
    int     cmpcount = 0;

    mnum = md_getminor(dev);
    ui = MDI_UNIT(mnum);
    un = MD_UNIT(mnum);
    setno = MD_MIN2SET(mnum);

    if (md_get_setstatus(setno) & MD_SET_STALE)
        return (1);

    if (un->un_hsp_id == -1)
        return (1);

    for (row = 0; row < un->un_nrows; row++) {
        mdr = &un->un_row[row];
        if ((mdr->un_ncomp + cmpcount) > ci)
            break;
        cmpcount += mdr->un_ncomp;
    }
    ASSERT(row != un->un_nrows);

    comp = (struct ms_comp *)((void *)&((char *)un)[un->un_ocomp]);
    comp += ci;
    /* Concatenations have a ncomp = 1 */
    nd.nd_nblks = mdr->un_blocks / mdr->un_ncomp;

    if ((un->c.un_flag & MD_LABELED) && (ci == 0))
        nd.nd_labeled = 1;
    else
        nd.nd_labeled = 0;

again:
    err = md_hot_spare_ifc(HS_GET, un->un_hsp_id, nd.nd_nblks,
        nd.nd_labeled, &nd.nd_hs_id, &nd.nd_key, &nd.nd_dev,
        &nd.nd_start_blk);

    if (err) {
        if (!stripe_replace_dev(dev, junk, ci, NULL, recids, nrecids,
            replace_done, replace_data)) {
            mddb_commitrecs_wrapper(recids);
            md_unit_writerexit(ui);
        }
        recids[0] = 0;
        return (1);
    }

    if (stripe_replace_dev(dev, junk, ci, &nd, recids, nrecids,
        replace_done, replace_data)) {

        (void) md_hot_spare_ifc(HS_BAD, un->un_hsp_id, 0, 0,
            &nd.nd_hs_id, &nd.nd_key, NULL, NULL);
        mddb_commitrec_wrapper(nd.nd_hs_id);
        goto again;
    }

    /* Leave a slot for the null recid */
    for (i = 0; i < (nrecids - 1); i++) {
        if (recids[i] == 0) {
            recids[i++] = nd.nd_hs_id;
            recids[i] = 0;
        }
    }
    return (0);
}

static int
stripe_imp_set(
    set_t   setno
)
{

    mddb_recid_t    recid;
    int     i, row, c, gotsomething;
    mddb_type_t typ1;
    mddb_de_ic_t    *dep;
    mddb_rb32_t *rbp;
    ms_unit32_od_t  *un32;
    ms_unit_t   *un64;
    md_dev64_t  self_devt;
    minor_t     *self_id;   /* minor needs to be updated */
    md_parent_t *parent_id; /* parent needs to be updated */
    mddb_recid_t    *record_id; /* record id needs to be updated */
    mddb_recid_t    *hsp_id;
    ms_comp32_od_t  *comp32;
    ms_comp_t   *comp64;


    gotsomething = 0;

    typ1 = (mddb_type_t)md_getshared_key(setno,
        stripe_md_ops.md_driver.md_drivername);
    recid = mddb_makerecid(setno, 0);

    while ((recid = mddb_getnextrec(recid, typ1, 0)) > 0) {
        if (mddb_getrecprivate(recid) & MD_PRV_GOTIT)
            continue;

        dep = mddb_getrecdep(recid);
        rbp = dep->de_rb;

        switch (rbp->rb_revision) {
        case MDDB_REV_RB:
        case MDDB_REV_RBFN:
            /*
             * Small device
             */
            un32 = (ms_unit32_od_t *)mddb_getrecaddr(recid);
            self_id = &(un32->c.un_self_id);
            parent_id = &(un32->c.un_parent);
            record_id = &(un32->c.un_record_id);
            hsp_id = &(un32->un_hsp_id);

            comp32 = (ms_comp32_od_t *)
                ((void *)&((char *)un32)[un32->un_ocomp]);
            for (row = 0; row < un32->un_nrows; row++) {
                struct ms_row32_od *mdr = &un32->un_row[row];
                for (i = 0, c = mdr->un_icomp;
                    i < mdr->un_ncomp; i++) {
                    ms_comp32_od_t *mdc;

                    mdc = &comp32[c++];

                    if (!md_update_minor(setno,
                        mddb_getsidenum(setno),
                        mdc->un_key))
                        goto out;

                    if (mdc->un_mirror.ms_hs_id != 0)
                        mdc->un_mirror.ms_hs_id =
                            MAKERECID(setno,
                            mdc->un_mirror.ms_hs_id);
                }
            }
            break;
        case MDDB_REV_RB64:
        case MDDB_REV_RB64FN:
            un64 = (ms_unit_t *)mddb_getrecaddr(recid);
            self_id = &(un64->c.un_self_id);
            parent_id = &(un64->c.un_parent);
            record_id = &(un64->c.un_record_id);
            hsp_id = &(un64->un_hsp_id);

            comp64 = (ms_comp_t *)
                ((void *)&((char *)un64)[un64->un_ocomp]);
            for (row = 0; row < un64->un_nrows; row++) {
                struct ms_row *mdr = &un64->un_row[row];

                for (i = 0, c = mdr->un_icomp;
                    i < mdr->un_ncomp; i++) {
                    ms_comp_t *mdc;

                    mdc = &comp64[c++];

                    if (!md_update_minor(setno,
                        mddb_getsidenum(setno),
                        mdc->un_key))
                        goto out;

                    if (mdc->un_mirror.ms_hs_id != 0)
                        mdc->un_mirror.ms_hs_id =
                            MAKERECID(setno,
                            mdc->un_mirror.ms_hs_id);
                }
            }
            break;
        }

        /*
         * If this is a top level and a friendly name metadevice,
         * update its minor in the namespace.
         */
        if ((*parent_id == MD_NO_PARENT) &&
            ((rbp->rb_revision == MDDB_REV_RBFN) ||
            (rbp->rb_revision == MDDB_REV_RB64FN))) {

            self_devt = md_makedevice(md_major, *self_id);
            if (!md_update_top_device_minor(setno,
                mddb_getsidenum(setno), self_devt))
                goto out;
        }

        /*
         * Update unit with the imported setno
         *
         */
        mddb_setrecprivate(recid, MD_PRV_GOTIT);

        *self_id = MD_MKMIN(setno, MD_MIN2UNIT(*self_id));

        if (*hsp_id != -1)
            *hsp_id = MAKERECID(setno, DBID(*hsp_id));

        if (*parent_id != MD_NO_PARENT)
            *parent_id = MD_MKMIN(setno, MD_MIN2UNIT(*parent_id));
        *record_id = MAKERECID(setno, DBID(*record_id));

        gotsomething = 1;
    }

out:
    return (gotsomething);
}

static md_named_services_t stripe_named_services[] = {
    {stripe_shared_by_blk,          "shared by blk"         },
    {stripe_shared_by_indx,         "shared by indx"        },
    {stripe_component_count,        "get component count"       },
    {stripe_block_count_skip_size,      "get block count skip size" },
    {stripe_get_dev,            "get device"            },
    {stripe_replace_dev,            "replace device"        },
    {stripe_hotspare_dev,           "hotspare device"       },
    {stripe_rename_check,           MDRNM_CHECK         },
    {NULL,                  0}
};

md_ops_t stripe_md_ops = {
    stripe_open,        /* open */
    stripe_close,       /* close */
    md_stripe_strategy, /* strategy */
    NULL,           /* print */
    stripe_dump,        /* dump */
    NULL,           /* read */
    NULL,           /* write */
    md_stripe_ioctl,    /* stripe_ioctl, */
    stripe_snarf,       /* stripe_snarf */
    stripe_halt,        /* stripe_halt */
    NULL,           /* aread */
    NULL,           /* awrite */
    stripe_imp_set,     /* import set */
    stripe_named_services
};

static void
init_init()
{
    md_stripe_mcs_buf_off = sizeof (md_scs_t) - sizeof (buf_t);

    stripe_parent_cache = kmem_cache_create("md_stripe_parent",
        sizeof (md_sps_t), 0, stripe_parent_constructor,
        stripe_parent_destructor, stripe_run_queue, NULL, NULL,
        0);
    stripe_child_cache = kmem_cache_create("md_stripe_child",
        sizeof (md_scs_t) - sizeof (buf_t) + biosize(), 0,
        stripe_child_constructor, stripe_child_destructor,
        stripe_run_queue, NULL, NULL, 0);
}

static void
fini_uninit()
{
    kmem_cache_destroy(stripe_parent_cache);
    kmem_cache_destroy(stripe_child_cache);
    stripe_parent_cache = stripe_child_cache = NULL;
}

/* define the module linkage */
MD_PLUGIN_MISC_MODULE("stripes module", init_init(), fini_uninit())