lvm/trans/mdtrans.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/debug.h>
#include <sys/file.h>
#include <sys/user.h>
#include <sys/uio.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/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/disp.h>
#include <sys/buf.h>

#include <sys/lvm/mdvar.h>
#include <sys/lvm/md_trans.h>
#include <sys/lvm/md_notify.h>
#include <sys/lvm/md_convert.h>

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

md_ops_t        trans_md_ops;
#ifndef lint
md_ops_t        *md_interface_ops = &trans_md_ops;
#endif  /* lint */

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

extern int      md_trans_ioctl(dev_t, int, void *, int, IOLOCK *);
extern md_krwlock_t md_unit_array_rw;

extern mdq_anchor_t md_done_daemon;

extern  int     md_in_upgrade;

static kmem_cache_t *trans_parent_cache = NULL;
kmem_cache_t        *trans_child_cache = NULL;

#ifdef  DEBUG
/*
 * ROUTINES FOR TESTING:
 */
static int
_init_debug()
{
    extern int  _init_ioctl();

    return (_init_ioctl());
}
static int
_fini_debug()
{
    extern int  _fini_ioctl();
    int err = 0;

    err = _fini_ioctl();
    return (err);
}

#endif  /* DEBUG */

/*
 * BEGIN RELEASE DEBUG
 *  The following routines remain in the released product for testability
 */
int
trans_done_shadow(buf_t *bp)
{
    buf_t       *pb;
    md_tps_t    *ps = (md_tps_t *)bp->b_chain;
    int     rv = 0;

    pb = ps->ps_bp;
    mutex_enter(&ps->ps_mx);
    ps->ps_count--;
    if (ps->ps_count > 0) {
        if ((bp->b_flags & B_ERROR) != 0) {
            pb->b_flags |= B_ERROR;
            pb->b_error = bp->b_error;
        }
        mutex_exit(&ps->ps_mx);
        kmem_cache_free(trans_child_cache, bp);
    } else {
        mutex_exit(&ps->ps_mx);
        mutex_destroy(&ps->ps_mx);
        rv = trans_done(bp);
    }
    return (rv);
}

static void
shadow_debug(mt_unit_t  *un,        /* trans unit info */
        buf_t   *pb,        /* primary buffer */
        md_tps_t    *ps,        /* trans parent save */
        buf_t   *cb,        /* buffer for writing to master */
        int flag,
        void    *private)
{
    buf_t       *sb;        /* Shadow buffer */

    mutex_init(&ps->ps_mx, NULL, MUTEX_DEFAULT, NULL);
    ps->ps_count = 2;       /* Write child buffer & shadow */
    cb->b_iodone = trans_done_shadow;
    sb = kmem_cache_alloc(trans_child_cache, MD_ALLOCFLAGS);
    trans_child_init(sb);
    sb = bioclone(pb, 0, pb->b_bcount, md_dev64_to_dev(un->un_s_dev),
        pb->b_blkno, trans_done_shadow, sb, KM_NOSLEEP);

    sb->b_flags |= B_ASYNC;
    sb->b_chain = (void *)ps;
    md_call_strategy(sb, flag | MD_STR_MAPPED, private);
}
/*
 * END RELEASE DEBUG
 */

/*
 * COMMON MEMORY ALLOCATION ROUTINES (so that we can discover leaks)
 */
void *
md_trans_zalloc(size_t nb)
{
    TRANSSTATS(ts_trans_zalloc);
    TRANSSTATSADD(ts_trans_alloced, nb);
    return (kmem_zalloc(nb, KM_SLEEP));
}
void *
md_trans_alloc(size_t nb)
{
    TRANSSTATS(ts_trans_alloc);
    TRANSSTATSADD(ts_trans_alloced, nb);
    return (kmem_alloc(nb, KM_SLEEP));
}
void
md_trans_free(void *va, size_t nb)
{
    TRANSSTATS(ts_trans_free);
    TRANSSTATSADD(ts_trans_freed, nb);
    if (nb)
        kmem_free(va, nb);
}

static void
trans_parent_init(md_tps_t *ps)
{
    bzero(ps, sizeof (md_tps_t));
}

/*ARGSUSED1*/
int
trans_child_constructor(void *p, void *d1, int d2)
{
    bioinit(p);
    return (0);
}

void
trans_child_init(struct buf *bp)
{
    md_bioreset(bp);
}

/*ARGSUSED1*/
void
trans_child_destructor(void *p, void *d)
{
    biofini(p);
}

void
trans_commit(mt_unit_t *un, int domstr)
{
    mddb_recid_t    recids[4];
    md_unit_t   *su;
    int     ri = 0;

    if (md_get_setstatus(MD_UN2SET(un)) & MD_SET_STALE)
        return;

    recids[ri++] = un->c.un_record_id;

    if (domstr)
        if (md_getmajor(un->un_m_dev) == md_major) {
            su = MD_UNIT(md_getminor(un->un_m_dev));
            recids[ri++] = su->c.un_record_id;
        }

    if (ri == 0)
        return;
    recids[ri] = 0;

    uniqtime32(&un->un_timestamp);
    mddb_commitrecs_wrapper(recids);
}

void
trans_close_all_devs(mt_unit_t *un)
{
    if ((un->un_flags & TRANS_NEED_OPEN) == 0) {
        md_layered_close(un->un_m_dev, MD_OFLG_NULL);
        if (un->un_l_unit)
            ldl_close_dev(un->un_l_unit);
        un->un_flags |= TRANS_NEED_OPEN;
    }
}

int
trans_open_all_devs(mt_unit_t *un)
{
    int     err;
    minor_t     mnum = MD_SID(un);
    md_dev64_t  tmpdev = un->un_m_dev;
    set_t       setno = MD_MIN2SET(MD_SID(un));
    side_t      side = mddb_getsidenum(setno);

    /*
     * Do the open by device id if it is regular device
     */
    if ((md_getmajor(tmpdev) != md_major) &&
        md_devid_found(setno, side, un->un_m_key) == 1) {
        tmpdev = md_resolve_bydevid(mnum, tmpdev, un->un_m_key);
    }
    err = md_layered_open(mnum, &tmpdev, MD_OFLG_NULL);
    un->un_m_dev = tmpdev;

    if (err)
        return (ENXIO);

    if (un->un_l_unit) {
        err = ldl_open_dev(un, un->un_l_unit);
        if (err) {
            md_layered_close(tmpdev, MD_OFLG_NULL);
            return (ENXIO);
        }
    }
    return (0);
}

uint_t  mt_debug    = 0;

int
trans_build_incore(void *p, int snarfing)
{
    mt_unit_t   *un = (mt_unit_t *)p;
    minor_t     mnum;
    set_t       setno;

    /*
     * initialize debug mode and always start with no shadowing.
     */
    if (!snarfing)
        un->un_debug = mt_debug;
    un->un_s_dev = NODEV64;

    mnum = MD_SID(un);

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

    setno = MD_MIN2SET(mnum);

    /*
     * If snarfing the metatrans device,
     *  then remake the device number
     */
    if (snarfing) {
        un->un_m_dev =  md_getdevnum(setno, mddb_getsidenum(setno),
            un->un_m_key, MD_NOTRUST_DEVT);
    }

    /*
     * db rec is partially deleted; finish the db delete later
     */
    if (MD_STATUS(un) & MD_UN_BEING_RESET) {
        mddb_setrecprivate(un->c.un_record_id, MD_PRV_PENDCLEAN);
        return (1);
    }

    /*
     * With the current device id implementation there is possibility
     * that we may have NODEV if the underlying can't be resolved at
     * snarf time.  If this is the case we want to be consistent with
     * the normal behavior and continue to allow the snarf of unit
     * and resolve the devt at the open time
     */
    if ((md_getmajor(un->un_m_dev) == md_major) &&
        (md_dev_exists(un->un_m_dev) == 0)) {
        return (1);
    }

    /*
     * retain the detach status; reset open status
     */
    un->un_flags &= (TRANS_DETACHING | TRANS_DETACHED);
    un->un_flags |= TRANS_NEED_OPEN;
    if ((un->un_flags & TRANS_DETACHED) == 0)
        un->un_flags |= TRANS_ATTACHING;

    /*
     * log device not set up yet; try again later
     */
    if ((un->un_flags & TRANS_DETACHED) == 0)
        if (ldl_findlog(un->un_l_recid) == NULL)
            return (1);

    /*
     * initialize incore fields
     */
    un->un_next = NULL;
    un->un_l_unit = NULL;
    un->un_deltamap = NULL;
    un->un_udmap = NULL;
    un->un_logmap = NULL;
    un->un_matamap = NULL;
    un->un_shadowmap = NULL;
    un->un_ut = NULL;
    un->un_logreset = 0;
    un->un_dev = md_makedevice(md_major, mnum);
    MD_STATUS(un) = 0;

    /* necessary because capability didn't exist pre-4.1 */
    MD_CAPAB(un) = (MD_CAN_META_CHILD & ~MD_CAN_PARENT);

    /*
     * attach the log
     */
    trans_attach(un, 0);

    /*
     * check for master dev dynconcat
     */
    if (md_getmajor(un->un_m_dev) == md_major) {
        struct mdc_unit *c;

        c = MD_UNIT(md_getminor(un->un_m_dev));
        un->c.un_total_blocks = c->un_total_blocks;
    }

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

    return (0);
}

int
trans_detach(mt_unit_t *un, int force)
{
    mdi_unit_t  *ui = MDI_UNIT(MD_SID(un));
    int     error   = 0;

    /*
     * The caller is responsible for single-threading this routine.
     */

    if (ui == NULL)
        return (0);

    /*
     * already detached or the log isn't attached yet; do nothing
     */
    if (un->un_flags & (TRANS_DETACHED | TRANS_ATTACHING))
        return (0);

    /*
     * set state to detaching
     */
    if (force || !md_unit_isopen(ui)) {
        un->un_flags |= TRANS_DETACHING;
        if (!MD_UPGRADE) {
            trans_commit(un, 0);
        }
        SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_DETACHING, TAG_METADEVICE,
            MD_UN2SET(un), MD_SID(un));
    }

    /*
     * device is busy
     */
    if (md_unit_isopen(ui))
        return (EBUSY);

    /*
     * detach the log
     *  if successful
     *      flags committed to TRANS_DETACHED in database
     *      un->un_l_unit set to NULL
     *      no error returned
     */
    error = ldl_reset(un, 1, force);
    if (error)
        return (error);

    /*
     * commit to database
     */
    if (!MD_UPGRADE) {
        trans_commit(un, 0);
    }
    SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_DETACH, TAG_METADEVICE, MD_UN2SET(un),
        MD_SID(un));

    return (0);
}

void
trans_attach(mt_unit_t *un, int attaching)
{
    mdi_unit_t  *ui = MDI_UNIT(MD_SID(un));
    ml_unit_t   *ul;

    /*
     * called from snarf, set, and attach.  Hence, the attaching param
     * The caller is responsible for single-threading this routine.
     */

    /*
     * not attaching; do nothing
     */
    if ((un->un_flags & TRANS_ATTACHING) == 0)
        return;

    /*
     * find log unit struct
     */
    ul = ldl_findlog(un->un_l_recid);
    if (ul == NULL)
        return;
    un->un_l_dev = ul->un_dev;

    /*
     * device is busy; do nothing
     */
    if (attaching && md_unit_isopen(ui))
        return;
    /*
     * other functions use non-NULL un_l_unit as detach/attach flag
     */
    un->un_l_unit = ul;

    /*
     *   add metatrans device to the log's list of mt devices
     */
    ldl_utadd(un);

    /*
     * attached
     */
    un->un_flags &= ~TRANS_ATTACHING;

}

int
trans_reset(mt_unit_t *un, minor_t mnum, int removing, int force)
{
    sv_dev_t    sv;
    mddb_recid_t    vtoc_id;
    int     error   = 0;

    /*
     * reset log, maps, and ufs interface
     */
    error = ldl_reset(un, removing, force);
    if (error)
        return (error);

    /*
     * done with underyling devices
     */
    trans_close_all_devs(un);

    md_destroy_unit_incore(mnum, &trans_md_ops);

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

    if (!removing)
        return (0);

    md_reset_parent(un->un_m_dev);
    MD_STATUS(un) |= MD_UN_BEING_RESET;
    trans_commit(un, 1);
    SE_NOTIFY(EC_SVM_CONFIG, ESC_SVM_DELETE, TAG_METADEVICE, MD_UN2SET(un),
        MD_SID(un));

    /* Save the mstr key */
    sv.setno = MD_MIN2SET(mnum);
    sv.key = un->un_m_key;

    vtoc_id = un->c.un_vtoc_id;

    mddb_deleterec_wrapper(un->c.un_record_id);

    /* Remove the vtoc, if present */
    if (vtoc_id)
        mddb_deleterec_wrapper(vtoc_id);
    md_rem_names(&sv, 1);
    return (0);
}

static void
trans_wait_panic(struct buf *cb)
{
    while ((cb->b_flags & B_DONE) == 0) {
        md_daemon(1, &md_done_daemon);
        drv_usecwait(10);
    }
}

static void
trans_error(md_tps_t *ps)
{
    md_dev64_t  md_dev;
    md_dev64_t  m_dev;
    char        *str;
    struct buf  *pb;
    mdi_unit_t  *ui;

    pb = ps->ps_bp;
    ui = ps->ps_ui;

    /*
     * gather up params for cmn_err
     */
    if (pb->b_flags & B_READ)
        str = "read";
    else
        str = "write";
    md_dev = md_expldev(pb->b_edev);
    m_dev = ps->ps_un->un_m_dev;

    /*
     * free up the resources for this request and done the errored buf
     */
    md_kstat_done(ui, pb, 0);
    kmem_cache_free(trans_parent_cache, ps);
    md_unit_readerexit(ui);
    md_biodone(pb);

    /*
     * print pretty error message
     */
    cmn_err(CE_WARN, "md: %s: %s error on %s",
        md_shortname(md_getminor(md_dev)), str,
        md_devname(MD_DEV2SET(md_dev), m_dev, NULL, 0));
}

int
trans_done(struct buf *cb)
{
    struct buf  *pb;
    mdi_unit_t  *ui;
    md_tps_t    *ps;

    ps = (md_tps_t *)cb->b_chain;
    pb = ps->ps_bp;
    ui = ps->ps_ui;

    if (cb->b_flags & B_ERROR) {
        pb->b_flags |= B_ERROR;
        pb->b_error = cb->b_error;
        /*
         * device not in hard error state; report error
         */
        if (!ldl_isherror(ps->ps_un->un_l_unit)) {
            daemon_request(&md_done_daemon, trans_error,
                (daemon_queue_t *)ps, REQ_OLD);

            if (cb->b_flags & B_REMAPPED)
                bp_mapout(cb);
            if (panicstr)
                cb->b_flags |= B_DONE;
            else
                kmem_cache_free(trans_child_cache, cb);

            return (1);
        }
    }

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

    if (panicstr)
        cb->b_flags |= B_DONE;
    else
        kmem_cache_free(trans_child_cache, cb);
    kmem_cache_free(trans_parent_cache, ps);
    md_kstat_done(ui, pb, 0);
    md_unit_readerexit(ui);
    md_biodone(pb);

    return (0);
}

static void
md_trans_strategy(buf_t *pb, int flag, void *private)
{
    md_tps_t    *ps;
    buf_t       *cb;        /* child buf pointer */
    mt_unit_t   *un;
    mdi_unit_t  *ui;

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

    md_kstat_waitq_enter(ui);

    un = (mt_unit_t *)md_unit_readerlock(ui);

    if (md_inc_iocount(MD_MIN2SET(getminor(pb->b_edev))) != 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;
    }

    ASSERT(!(flag & MD_STR_NOTTOP));

    /* check and map */
    if (md_checkbuf(ui, (md_unit_t *)un, pb) != 0) {
        md_kstat_waitq_exit(ui);
        return;
    }

    bp_mapin(pb);

    ps = kmem_cache_alloc(trans_parent_cache, MD_ALLOCFLAGS);
    trans_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;

    cb = kmem_cache_alloc(trans_child_cache, MD_ALLOCFLAGS);
    trans_child_init(cb);

    cb = bioclone(pb, 0, pb->b_bcount, md_dev64_to_dev(un->un_m_dev),
        pb->b_blkno, trans_done, cb, KM_NOSLEEP);

    cb->b_chain = (void *)ps;

    /*
     * RELEASE DEBUG
     * The following calls shadow debug for testing purposes if we are
     * writing and if shadowing is turned on.
     */
    if ((un->un_s_dev != NODEV64) &&
        ((pb->b_flags & B_READ) == 0))
        shadow_debug(un, pb, ps, cb, flag, private);

    md_kstat_waitq_to_runq(ui);

    (void) md_call_strategy(cb, flag | MD_STR_MAPPED | MD_NOBLOCK, private);

    /*
     * panic in progress; process daemon queues
     */
    if (panicstr) {
        trans_wait_panic(cb);
        kmem_cache_free(trans_child_cache, cb);
    }
}

/* ARGSUSED */
static int
md_trans_read(dev_t dev, struct uio *uio, cred_t *credp)
{
    int         error;

    if ((error = md_chk_uio(uio)) != 0)
        return (error);

    return (physio(mdstrategy, NULL, dev, B_READ, minphys, uio));
}

/* ARGSUSED */
static int
md_trans_aread(dev_t dev, struct aio_req *aio, cred_t *credp)
{
    int         error;

    if ((error = md_chk_uio(aio->aio_uio)) != 0)
        return (error);

    return (aphysio(mdstrategy, anocancel, dev, B_READ, minphys, aio));
}

/* ARGSUSED */
static int
md_trans_write(dev_t dev, struct uio *uio, cred_t *credp)
{
    int error;

    if ((error = md_chk_uio(uio)) != 0)
        return (error);

    return (physio(mdstrategy, NULL, dev, B_WRITE, minphys, uio));
}

/* ARGSUSED */
static int
md_trans_awrite(dev_t dev, struct aio_req *aio, cred_t *credp)
{
    int error;

    if ((error = md_chk_uio(aio->aio_uio)) != 0)
        return (error);

    return (aphysio(mdstrategy, anocancel, dev, B_WRITE, minphys, aio));
}

static void
trans_cleanup(mt_unit_t *un)
{
    sv_dev_t    sv;

    MD_STATUS(un) |= MD_UN_LOG_DELETED;
    trans_commit(un, 0);

    /* Save the mstr key */
    sv.setno = MD_UN2SET(un);
    sv.key = un->un_m_key;

    mddb_deleterec_wrapper(un->c.un_record_id);

    md_rem_names(&sv, 1);
}

static int
trans_snarf(md_snarfcmd_t cmd, set_t setno)
{
    mt_unit_t   *un;
    ml_unit_t   *ul;
    mddb_recid_t    recid;
    int     gotsomething;
    mddb_type_t typ1;
    int     all_trans_gotten;
    mddb_de_ic_t    *dep;
    mddb_rb32_t *rbp;
    size_t      newreqsize;
    static int  trans_found = 0;


    if (cmd == MD_SNARF_CLEANUP) {

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

        /*
         * clean up partially cleared trans devices
         */
        typ1 = (mddb_type_t)md_getshared_key(setno,
            trans_md_ops.md_driver.md_drivername);
        recid = mddb_makerecid(setno, 0);
        while ((recid = mddb_getnextrec(recid, typ1, TRANS_REC)) > 0) {
            un = (mt_unit_t *)mddb_getrecaddr(recid);
            (void) trans_detach(un, 1);
            if (mddb_getrecprivate(recid) & MD_PRV_CLEANUP) {
                trans_cleanup(un);
                recid = mddb_makerecid(setno, 0);
            }
        }
        /*
         * clean up partially cleared log devices
         */
        recid = mddb_makerecid(setno, 0);
        while ((recid = mddb_getnextrec(recid, typ1, LOG_REC)) > 0) {
            if (mddb_getrecprivate(recid) & MD_PRV_CLEANUP) {
                ul = (ml_unit_t *)mddb_getrecaddr(recid);
                ldl_cleanup(ul);
                recid = mddb_makerecid(setno, 0);
            }
        }

        return (0);
    }

    /*
     * must snarf up the log devices first
     */
    gotsomething = 0;
    all_trans_gotten = 1;
    typ1 = (mddb_type_t)md_getshared_key(setno,
        trans_md_ops.md_driver.md_drivername);
    recid = mddb_makerecid(setno, 0);
    while ((recid = mddb_getnextrec(recid, typ1, LOG_REC)) > 0) {
        ml_unit_t   *big_ul;
        ml_unit32_od_t  *small_ul;

        if (mddb_getrecprivate(recid) & MD_PRV_GOTIT)
            continue;

        small_ul = (ml_unit32_od_t *)mddb_getrecaddr(recid);
        dep = mddb_getrecdep(recid);
        dep->de_flags = MDDB_F_TRANS_LOG;
        rbp = dep->de_rb;
        /*
         * As trans records are always old records,
         * we have to check if this record already has been converted.
         * We don't want to do that work twice.
         */
        if ((rbp->rb_private & MD_PRV_CONVD) == 0) {
            newreqsize = sizeof (ml_unit_t);
            big_ul = (ml_unit_t *)kmem_zalloc(newreqsize, KM_SLEEP);
            trans_log_convert((caddr_t)small_ul, (caddr_t)big_ul,
                SMALL_2_BIG);
            kmem_free(small_ul, dep->de_reqsize);
            /*
             * Update userdata and incore userdata
             * incores are at the end of ul
             */
            dep->de_rb_userdata_ic = big_ul;
            dep->de_rb_userdata = big_ul;
            dep->de_icreqsize = newreqsize;
            rbp->rb_private |= MD_PRV_CONVD;
            ul = big_ul;
        } else {
            /* already converted, just set the pointer */
            ul = dep->de_rb_userdata;
        }
        all_trans_gotten = 0;
        if (ldl_build_incore(ul, 1) == 0) {
            mddb_setrecprivate(recid, MD_PRV_GOTIT);
            gotsomething = 1;
        }
    }

    /*
     * now snarf up metatrans devices
     */
    gotsomething = 0;
    recid = mddb_makerecid(setno, 0);
    while ((recid = mddb_getnextrec(recid, typ1, TRANS_REC)) > 0) {
        mt_unit_t   *big_un;
        mt_unit32_od_t  *small_un;

        if (mddb_getrecprivate(recid) & MD_PRV_GOTIT)
            continue;

        if ((trans_found == 0) && (!MD_UPGRADE)) {
            cmn_err(CE_WARN, MD_EOF_TRANS_MSG MD_EOF_TRANS_WARNING);
            trans_found = 1;
        }

        small_un = (mt_unit32_od_t *)mddb_getrecaddr(recid);

        dep = mddb_getrecdep(recid);
        dep->de_flags = MDDB_F_TRANS_MASTER;
        rbp = dep->de_rb;
        /*
         * As trans records are always old records,
         * we have to check if this record already has been converted.
         * We don't want to do that work twice.
         */
        if ((rbp->rb_private & MD_PRV_CONVD) == 0) {
            newreqsize = sizeof (mt_unit_t);
            big_un = (mt_unit_t *)kmem_zalloc(newreqsize, KM_SLEEP);
            trans_master_convert((caddr_t)small_un, (caddr_t)big_un,
                SMALL_2_BIG);
            kmem_free(small_un, dep->de_reqsize);
            /*
             * Update userdata and incore userdata
             * incores are at the end of ul
             */
            dep->de_rb_userdata_ic = big_un;
            dep->de_rb_userdata = big_un;
            dep->de_icreqsize = newreqsize;
            rbp->rb_private |= MD_PRV_CONVD;
            un = big_un;
            un->c.un_revision &= ~MD_64BIT_META_DEV;
        } else {
            /* already converted, just set the pointer */
            un = dep->de_rb_userdata;
        }

        /*
         * Create minor node for snarfed entry.
         */
        (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_trans_gotten = 0;
        if (trans_build_incore(un, 1) == 0) {
            mddb_setrecprivate(recid, MD_PRV_GOTIT);
            md_create_unit_incore(MD_SID(un), &trans_md_ops, 0);
            gotsomething = 1;
        }
    }

    if (!all_trans_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
trans_halt(md_haltcmd_t cmd, set_t setno)
{
    unit_t      i;
    mdi_unit_t  *ui;
    minor_t     mnum;
    mt_unit_t   *un;

    if (cmd == MD_HALT_CLOSE) {
        for (i = 0; i < md_nunits; i++) {
            mnum = MD_MKMIN(setno, i);
            if ((ui = MDI_UNIT(mnum)) == NULL)
                continue;
            if (ui->ui_opsindex != trans_md_ops.md_selfindex)
                continue;
            if (md_unit_isopen(ui)) {
                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 != trans_md_ops.md_selfindex)
                continue;
            un = (mt_unit_t *)MD_UNIT(mnum);
            if ((un->un_flags & TRANS_NEED_OPEN) == 0) {
                trans_close_all_devs(un);
            }
        }
        return (0);
    }

    if (cmd == MD_HALT_OPEN) {
        for (i = 0; i < md_nunits; i++) {
            mnum = MD_MKMIN(setno, i);
            if ((ui = MDI_UNIT(mnum)) == NULL)
                continue;
            if (ui->ui_opsindex != trans_md_ops.md_selfindex)
                continue;
            ldl_open_underlying((mt_unit_t *)MD_UNIT(mnum));
        }
        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 != trans_md_ops.md_selfindex)
                continue;
            if (md_unit_isopen(ui)) {
                return (1);
            }
        }
        return (0);
    }
    if (cmd == MD_HALT_DOIT) {
        for (i = 0; i < md_nunits; i++) {
            mnum = MD_MKMIN(setno, i);
            if ((ui = MDI_UNIT(mnum)) == NULL)
                continue;
            if (ui->ui_opsindex != trans_md_ops.md_selfindex)
                continue;
            (void) trans_reset((mt_unit_t *)MD_UNIT(mnum), mnum,
                0, 1);
        }
        return (0);
    }
    if (cmd == MD_HALT_UNLOAD)
        return (0);

    return (1);
}

/*ARGSUSED3*/
static int
trans_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);
    mt_unit_t   *un;
    int     err;

    /* disallow layered opens (e.g., PrestoServe) */
    if (otyp == OTYP_LYR)
        return (EINVAL);

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

    /* if already open, count open, return success */
    if (md_unit_isopen(ui)) {
        err = md_unit_incopen(mnum, flag, otyp);
        md_unit_openclose_exit(ui);
        if (err != 0)
            return (err);
        return (0);
    }

    /*
     * For some reason, not all of the metatrans devices attached to
     * this log were openable at snarf;  try again now.  All of the
     * underlying devices have to be openable for the roll thread to work.
     */
    if (un->un_flags & TRANS_NEED_OPEN) {
        md_unit_openclose_exit(ui);
        ldl_open_underlying(un);
        if (un->un_flags & TRANS_NEED_OPEN)
            return (EINVAL);
        un = (mt_unit_t *)md_unit_openclose_enter(ui);
    }

    /* count open */
    err = md_unit_incopen(mnum, flag, otyp);
    md_unit_openclose_exit(ui);
    if (err != 0)
        return (err);

    /* return success */
    return (0);
}

/*ARGSUSED1*/
static int
trans_close(
    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);
    mt_unit_t   *un;
    int     err = 0;

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

    /* count closed */
    if ((err = md_unit_decopen(mnum, otyp)) != 0) {
        md_unit_openclose_exit(ui);
        return (err);
    }

    /* if still open */
    if (md_unit_isopen(ui)) {
        md_unit_openclose_exit(ui);
        return (0);
    }
    md_unit_openclose_exit(ui);

    if (un->un_flags & TRANS_DETACHING) {
        /*
         * prevent new opens and try to detach the log
         */
        rw_enter(&md_unit_array_rw.lock, RW_WRITER);
        (void) trans_detach(un, 0);
        rw_exit(&md_unit_array_rw.lock);
    }
    if (un->un_flags & TRANS_ATTACHING) {
        /*
         * prevent new opens and try to attach the log
         */
        rw_enter(&md_unit_array_rw.lock, RW_WRITER);
        trans_attach(un, 1);
        rw_exit(&md_unit_array_rw.lock);
    }

    return (0);
}

static int
trans_imp_set(
    set_t   setno
)
{
    mt_unit32_od_t  *un32;
    ml_unit32_od_t  *ul32;
    mddb_recid_t    recid;
    int     gotsomething = 0;
    mddb_type_t typ1;
    minor_t     *self_id;   /* minor needs to be updated */
    mddb_recid_t    *record_id; /* record id needs to be updated */

    /*
     * Do log first if there is any
     * Note that trans record is always 32 bit
     */
    typ1 = (mddb_type_t)md_getshared_key(setno,
        trans_md_ops.md_driver.md_drivername);
    recid = mddb_makerecid(setno, 0);

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

        ul32 = (ml_unit32_od_t *)mddb_getrecaddr(recid);

        /*
         * Trans log record always is old format
         * Go ahead update the record with the new set info
         */
        record_id = &(ul32->un_recid);

        /*
         * Mark the record and update it
         */
        *record_id = MAKERECID(setno, DBID(*record_id));
        if (!md_update_minor(setno, mddb_getsidenum
            (setno), ul32->un_key))
            goto out;
        mddb_setrecprivate(recid, MD_PRV_GOTIT);
    }


    /*
     * Now do the master
     */
    recid = mddb_makerecid(setno, 0);
    while ((recid = mddb_getnextrec(recid, typ1, TRANS_REC)) > 0) {
        if (mddb_getrecprivate(recid) & MD_PRV_GOTIT)
            continue;

        un32 = (mt_unit32_od_t *)mddb_getrecaddr(recid);

        /*
         * Trans master record always is old format
         */
        self_id = &(un32->c.un_self_id);
        record_id = &(un32->c.un_record_id);

        /*
         * Mark the record and update it
         */
        *record_id = MAKERECID(setno, DBID(*record_id));
        *self_id = MD_MKMIN(setno, MD_MIN2UNIT(*self_id));
        if (!md_update_minor(setno, mddb_getsidenum
            (setno), un32->un_m_key))
            goto out;
        mddb_setrecprivate(recid, MD_PRV_GOTIT);

        gotsomething = 1;
    }

out:
    return (gotsomething);
}

static md_named_services_t  trans_named_services[] = {
    {(intptr_t (*)()) trans_rename_listkids,    MDRNM_LIST_URKIDS   },
    {(intptr_t (*)()) trans_rename_check,       MDRNM_CHECK     },
    {(intptr_t (*)()) trans_renexch_update_kids,    MDRNM_UPDATE_KIDS   },
    {(intptr_t (*)()) trans_rename_update_self, MDRNM_UPDATE_SELF   },
    {(intptr_t (*)()) trans_exchange_self_update_from_down,
                        MDRNM_SELF_UPDATE_FROM_DOWN },
    {(intptr_t (*)()) trans_exchange_parent_update_to,
                        MDRNM_PARENT_UPDATE_TO      },
    {NULL,                      0           }
};

md_ops_t trans_md_ops = {
    trans_open,     /* open */
    trans_close,        /* close */
    md_trans_strategy,  /* strategy */
    NULL,           /* print */
    NULL,           /* dump */
    md_trans_read,      /* read */
    md_trans_write,     /* write */
    md_trans_ioctl,     /* trans ioctl */
    trans_snarf,        /* trans_snarf */
    trans_halt,     /* halt */
    md_trans_aread,     /* aread */
    md_trans_awrite,    /* awrite */
    trans_imp_set,      /* import set */
    trans_named_services
};

static void
init_init(void)
{
    _init_ldl();
    ASSERT(_init_debug());
    trans_parent_cache = kmem_cache_create("md_trans_parent",
        sizeof (md_tps_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
    trans_child_cache = kmem_cache_create("md_trans_child", biosize(), 0,
        trans_child_constructor, trans_child_destructor,
        NULL, NULL, NULL, 0);
}

static void
fini_uninit(void)
{
    ASSERT(_fini_debug());
    _fini_ldl();
    kmem_cache_destroy(trans_parent_cache);
    kmem_cache_destroy(trans_child_cache);
    trans_parent_cache = trans_child_cache = NULL;
}

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