libmeta/common/meta_db.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.
 */

/*
 * Just in case we're not in a build environment, make sure that
 * TEXT_DOMAIN gets set to something.
 */
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif

/*
 * Metadevice database interfaces.
 */

#define MDDB

#include <meta.h>
#include <sys/lvm/md_mddb.h>
#include <sys/lvm/md_crc.h>
#include <sys/lvm/mdio.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>

struct svm_daemon {
    char *svmd_name;
    char *svmd_kill_val;
};

/*
 * This is a list of the daemons that are not stopped by the SVM smf(5)
 * services. The mdmonitord is started via svc:/system/mdmonitor:default
 * but no contract(4) is constructed and so it is not stopped by smf(5).
 */
struct svm_daemon svmd_kill_list[] = {
        {"mdmonitord", "HUP"},
        {"mddoors", "KILL"},
    };

#define DAEMON_COUNT (sizeof (svmd_kill_list)/ sizeof (struct svm_daemon))

extern int procsigs(int block, sigset_t *oldsigs, md_error_t *ep);

/*
 * Are the locator blocks for the replicas using devids
 */
static int  devid_in_use = FALSE;

static char *
getlongname(
    struct mddb_config  *c,
    md_error_t      *ep
)
{
    char        *diskname = NULL;
    char        *devid_str;
    devid_nmlist_t  *disklist = NULL;

    c->c_locator.l_devid_flags = MDDB_DEVID_GETSZ;
    if (metaioctl(MD_DB_ENDDEV, c, &c->c_mde, NULL) != 0) {
        (void) mdstealerror(ep, &c->c_mde);
        return (NULL);
    }

    if (c->c_locator.l_devid_flags & MDDB_DEVID_SZ) {
        c->c_locator.l_devid = (uintptr_t)
            Malloc(c->c_locator.l_devid_sz);
        c->c_locator.l_devid_flags =
            MDDB_DEVID_SPACE | MDDB_DEVID_SZ;
    } else {
        (void) mderror(ep, MDE_NODEVID, "");
        goto out;
    }

    if (metaioctl(MD_DB_ENDDEV, c, &c->c_mde, NULL) != 0) {
        (void) mdstealerror(ep, &c->c_mde);
        goto out;
    }

    if (c->c_locator.l_devid_flags & MDDB_DEVID_NOSPACE) {
        (void) mderror(ep, MDE_NODEVID, "");
        goto out;
    }

    if (metaioctl(MD_DB_GETDEV, c, &c->c_mde, NULL) != 0) {
        (void) mdstealerror(ep, &c->c_mde);
        goto out;
    }

    if (c->c_locator.l_devid != NULL) {
        if (meta_deviceid_to_nmlist("/dev/dsk",
            (ddi_devid_t)(uintptr_t)c->c_locator.l_devid,
            c->c_locator.l_minor_name, &disklist) != 0) {
            devid_str = devid_str_encode(
                (ddi_devid_t)(uintptr_t)c->c_locator.l_devid, NULL);
            (void) mderror(ep, MDE_MISSING_DEVID_DISK, "");
            mderrorextra(ep, devid_str);
            if (devid_str != NULL)
                devid_str_free(devid_str);
            goto out;
        }
        diskname = Strdup(disklist[0].devname);
    }

out:
    if (disklist != NULL)
        devid_free_nmlist(disklist);

    if (c->c_locator.l_devid != NULL)
        Free((void *)(uintptr_t)c->c_locator.l_devid);

    return (diskname);
}

/*
 * meta_get_lb_inittime sends a request for the lb_inittime to the kernel
 */
md_timeval32_t
meta_get_lb_inittime(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    mddb_config_t   c;

    (void) memset(&c, 0, sizeof (c));

    /* Fill in setno, setname, and sideno */
    c.c_setno = sp->setno;

    if (metaioctl(MD_DB_LBINITTIME, &c, &c.c_mde, NULL) != 0) {
        (void) mdstealerror(ep, &c.c_mde);
    }

    return (c.c_timestamp);
}

/*
 * mkmasterblks writes out the master blocks of the mddb to the replica.
 *
 * In a MN diskset, this is called by the node that is adding this replica
 * to the diskset.
 */

#define MDDB_VERIFY_SIZE    8192

static int
mkmasterblks(
    mdsetname_t *sp,
    mdname_t    *np,
    int     fd,
    daddr_t     firstblk,
    int     dbsize,
    md_timeval32_t  inittime,
    md_error_t  *ep
)
{
    int     consecutive;
    md_timeval32_t  tp;
    struct mddb_mb  *mb;
    char        *buffer;
    int     iosize;
    md_set_desc *sd;
    int     mn_set = 0;
    daddr_t     startblk;
    int     cnt;
    ddi_devid_t devid;

    if (! metaislocalset(sp)) {
        if ((sd = metaget_setdesc(sp, ep)) == NULL)
            return (-1);

        if (MD_MNSET_DESC(sd)) {
            mn_set = 1;     /* Used later */
        }
    }

    /*
     * Loop to verify the entire mddb region on disk is read/writable.
     * buffer is used to write/read in at most MDDB_VERIFY_SIZE block
     * chunks.
     *
     * A side-effect of this loop is to zero out the entire mddb region
     */
    if ((buffer = Zalloc(MDDB_VERIFY_SIZE * DEV_BSIZE)) == NULL)
        return (mdsyserror(ep, ENOMEM, np->rname));

    startblk = firstblk;
    for (cnt = dbsize; cnt > 0; cnt -= consecutive) {

        if (cnt > MDDB_VERIFY_SIZE)
            consecutive = MDDB_VERIFY_SIZE;
        else
            consecutive = cnt;

        if (lseek(fd, (off_t)(startblk * DEV_BSIZE), SEEK_SET) < 0) {
            Free(buffer);
            return (mdsyserror(ep, errno, np->rname));
        }

        iosize = DEV_BSIZE * consecutive;
        if (write(fd, buffer, iosize) != iosize) {
            Free(buffer);
            return (mdsyserror(ep, errno, np->rname));
        }

        if (lseek(fd, (off_t)(startblk * DEV_BSIZE), SEEK_SET) < 0) {
            Free(buffer);
            return (mdsyserror(ep, errno, np->rname));
        }

        if (read(fd, buffer, iosize) != iosize) {
            Free(buffer);
            return (mdsyserror(ep, errno, np->rname));
        }

        startblk += consecutive;
    }

    Free(buffer);
    if ((mb = Zalloc(DEV_BSIZE)) == NULL)
        return (mdsyserror(ep, ENOMEM, np->rname));

    if (meta_gettimeofday(&tp) == -1) {
        Free(mb);
        return (mdsyserror(ep, errno, np->rname));
    }

    mb->mb_magic = MDDB_MAGIC_MB;
    /*
     * If a MN diskset, set master block revision for a MN set.
     * Even though the master block structure is no different
     * for a MN set, setting the revision field to a different
     * number keeps any pre-MN_diskset code from accessing
     * this diskset.  It also allows for an early determination
     * of a MN diskset when reading in from disk so that the
     * proper size locator block and locator names structure
     * can be read in thus saving time on diskset startup.
     */
    if (mn_set)
        mb->mb_revision = MDDB_REV_MNMB;
    else
        mb->mb_revision = MDDB_REV_MB;
    mb->mb_timestamp = tp;
    mb->mb_setno = sp->setno;
    mb->mb_blkcnt = dbsize - 1;
    mb->mb_blkno = firstblk;
    mb->mb_nextblk = 0;

    mb->mb_blkmap.m_firstblk = firstblk + 1;
    mb->mb_blkmap.m_consecutive = dbsize - 1;
    if (! metaislocalset(sp)) {
        mb->mb_setcreatetime = inittime;
    }

    /*
     * We try to save the disks device ID into the remaining bytes in
     * the master block. The saved devid is used to provide a mapping
     * between this disk's devid and the devid stored into the master
     * block. This allows the disk image to be self-identifying
     * if it gets copied (e.g. SNDR, True Copy, etc.).  This is used
     * when we try to import these disks on the remote copied image.
     * If we cannot save the disks device ID onto the master block that is
     * ok.  The disk is just not self-identifying and won't be importable
     * in the remote copy scenario.
     */
    if (devid_get(fd, &devid) == 0) {
        size_t len;

        len = devid_sizeof(devid);
        if (len <= DEV_BSIZE - sizeof (*mb)) {
            /* there is enough space to store the devid */
            mb->mb_devid_magic = MDDB_MAGIC_DE;
            mb->mb_devid_len = len;
            (void) memcpy(mb->mb_devid, devid, len);
        }
        devid_free(devid);
    }

    crcgen((uchar_t *)mb, (uint_t *)&mb->mb_checksum, (uint_t)DEV_BSIZE,
        (crc_skip_t *)NULL);

    if (lseek(fd, (off_t)(firstblk * DEV_BSIZE), SEEK_SET) < 0) {
        Free(mb);
        return (mdsyserror(ep, errno, np->rname));
    }

    if (write(fd, mb, DEV_BSIZE) != DEV_BSIZE) {
        Free(mb);
        return (mdsyserror(ep, errno, np->rname));
    }

    if (lseek(fd, (off_t)(firstblk * DEV_BSIZE), SEEK_SET) < 0) {
        Free(mb);
        return (mdsyserror(ep, errno, np->rname));
    }

    if (read(fd, mb, DEV_BSIZE) != DEV_BSIZE) {
        Free(mb);
        return (mdsyserror(ep, errno, np->rname));
    }

    if (crcchk((uchar_t *)mb, (uint_t *)&mb->mb_checksum,
        (uint_t)DEV_BSIZE, (crc_skip_t *)NULL)) {
        Free(mb);
        return (mdmddberror(ep, MDE_NOTVERIFIED,
            meta_getminor(np->dev), sp->setno, 0, np->rname));
    }

    Free(mb);
    return (0);
}

void
meta_mkdummymaster(
    mdsetname_t *sp,
    int     fd,
    daddr_t     firstblk
)
{
    md_timeval32_t  tp;
    struct mddb_mb  *mb;
    ddi_devid_t devid;
    md_set_desc *sd;
    md_error_t  ep = mdnullerror;
    md_timeval32_t  inittime;

    /*
     * No dummy master blocks are written for a MN diskset since devids
     * are not supported in MN disksets.
     */
    if (! metaislocalset(sp)) {
        if ((sd = metaget_setdesc(sp, &ep)) == NULL)
            return;

        if (MD_MNSET_DESC(sd))
            return;
    }

    if ((mb = Zalloc(DEV_BSIZE)) == NULL)
        return;

    mb->mb_magic = MDDB_MAGIC_DU;
    mb->mb_revision = MDDB_REV_MB;
    mb->mb_setno = sp->setno;
    inittime = meta_get_lb_inittime(sp, &ep);
    mb->mb_setcreatetime = inittime;

    if (meta_gettimeofday(&tp) != -1)
        mb->mb_timestamp = tp;

    /*
     * We try to save the disks device ID into the remaining bytes in
     * the master block.  This allows the disk image to be self-identifying
     * if it gets copied (e.g. SNDR, True Copy, etc.).  This is used
     * when we try to import these disks on the remote copied image.
     * If we cannot save the disks device ID onto the master block that is
     * ok.  The disk is just not self-identifying and won't be importable
     * in the remote copy scenario.
     */
    if (devid_get(fd, &devid) == 0) {
        int len;

        len = devid_sizeof(devid);
        if (len <= DEV_BSIZE - sizeof (*mb)) {
            /* there is enough space to store the devid */
            mb->mb_devid_magic = MDDB_MAGIC_DE;
            mb->mb_devid_len = len;
            (void) memcpy(mb->mb_devid, (char *)devid, len);
        }
        devid_free(devid);
    }

    crcgen((uchar_t *)mb, (uint_t *)&mb->mb_checksum, (uint_t)DEV_BSIZE,
        (crc_skip_t *)NULL);

    /*
     * If any of these operations fail, we need to inform the
     * user that the disk won't be self identifying. When support
     * for importing remotely replicated disksets is added, we
     * want to add the error messages here.
     */
    if (lseek(fd, (off_t)(firstblk * DEV_BSIZE), SEEK_SET) < 0)
        goto out;

    if (write(fd, mb, DEV_BSIZE) != DEV_BSIZE)
        goto out;

    if (lseek(fd, (off_t)(firstblk * DEV_BSIZE), SEEK_SET) < 0)
        goto out;

    if (read(fd, mb, DEV_BSIZE) != DEV_BSIZE)
        goto out;

    if (crcchk((uchar_t *)mb, (uint_t *)&mb->mb_checksum,
        (uint_t)DEV_BSIZE, (crc_skip_t *)NULL))
        goto out;

out:
    Free(mb);
}

static int
buildconf(mdsetname_t *sp, md_error_t *ep)
{
    md_replicalist_t    *rlp = NULL;
    md_replicalist_t    *rl;
    FILE            *cfp = NULL;
    FILE            *mfp = NULL;
    struct stat     sbuf;
    int         rval = 0;
    int         in_miniroot = 0;
    char            line[MDDB_BOOTLIST_MAX_LEN];
    char            *tname = NULL;

    /* get list of local replicas */
    if (! metaislocalset(sp))
        return (0);

    if (metareplicalist(sp, MD_BASICNAME_OK, &rlp, ep) < 0)
        return (-1);

    /* open tempfile, copy permissions of original file */
    if ((cfp = fopen(META_DBCONFTMP, "w+")) == NULL) {
        /*
         * On the miniroot tmp files must be created in /var/tmp.
         * If we get a EROFS error, we assume that we are in the
         * miniroot.
         */
        if (errno != EROFS)
            goto error;
        in_miniroot = 1;
        errno = 0;
        tname = tempnam("/var/tmp", "slvm_");
        if (tname == NULL && errno == EROFS) {
            /*
             * If we are booted on a read-only root because
             * of mddb quorum problems we don't want to emit
             * any scary error messages.
             */
            errno = 0;
            goto out;
        }

        /* open tempfile, copy permissions of original file */
        if ((cfp = fopen(tname, "w+")) == NULL)
            goto error;
    }
    if (stat(META_DBCONF, &sbuf) == 0) {
        if (fchmod(fileno(cfp), (sbuf.st_mode & 0666)) != 0)
            goto error;
        if (fchown(fileno(cfp), sbuf.st_uid, sbuf.st_gid) != 0)
            goto error;
    }

    /* print header */
    if (fprintf(cfp, "#metadevice database location file ") == EOF)
        goto error;
    if (fprintf(cfp, "do not hand edit\n") < 0)
        goto error;
    if (fprintf(cfp,
        "#driver\tminor_t\tdaddr_t\tdevice id\tchecksum\n") < 0)
        goto error;

    /* dump replicas */
    for (rl = rlp; (rl != NULL); rl = rl->rl_next) {
        md_replica_t    *r = rl->rl_repp;
        int     checksum = 42;
        int     i;
        char        *devidp;
        minor_t     min;

        devidp = devid_str_encode(r->r_devid, r->r_minor_name);
        /* If devid code can't encode devidp - skip entry */
        if (devidp == NULL) {
            continue;
        }

        /* compute checksum */
        for (i = 0; ((r->r_driver_name[i] != '\0') &&
            (i < sizeof (r->r_driver_name))); i++) {
            checksum -= r->r_driver_name[i];
        }
        min = meta_getminor(r->r_namep->dev);
        checksum -= min;
        checksum -= r->r_blkno;

        for (i = 0; i < strlen(devidp); i++) {
            checksum -= devidp[i];
        }
        /* print info */
        if (fprintf(cfp, "%s\t%lu\t%ld\t%s\t%d\n",
            r->r_driver_name, min, r->r_blkno, devidp, checksum) < 0) {
            goto error;
        }

        devid_str_free(devidp);
    }

    /* close and rename to real file */
    if (fflush(cfp) != 0)
        goto error;
    if (fsync(fileno(cfp)) != 0)
        goto error;
    if (fclose(cfp) != 0) {
        cfp = NULL;
        goto error;
    }
    cfp = NULL;

    /*
     * Renames don't work in the miniroot since tmpfiles are
     * created in /var/tmp. Hence we copy the data out.
     */

    if (! in_miniroot) {
        if (rename(META_DBCONFTMP, META_DBCONF) != 0)
            goto error;
    } else {
        if ((cfp = fopen(tname, "r")) == NULL)
            goto error;
        if ((mfp = fopen(META_DBCONF, "w+")) == NULL)
            goto error;
        while (fgets(line, MDDB_BOOTLIST_MAX_LEN, cfp) != NULL) {
            if (fputs(line, mfp) == NULL)
                goto error;
        }
        (void) fclose(cfp);
        cfp = NULL;
        if (fflush(mfp) != 0)
            goto error;
        if (fsync(fileno(mfp)) != 0)
            goto error;
        if (fclose(mfp) != 0) {
            mfp = NULL;
            goto error;
        }
        /* delete the tempfile */
        (void) unlink(tname);
    }
    /* success */
    rval = 0;
    goto out;

    /* tempfile error */
error:
    rval = (in_miniroot) ? mdsyserror(ep, errno, tname):
        mdsyserror(ep, errno, META_DBCONFTMP);


    /* cleanup, return success */
out:
    if (rlp != NULL)
        metafreereplicalist(rlp);
    if ((cfp != NULL) && (fclose(cfp) != 0) && (rval == 0)) {
        rval = (in_miniroot) ? mdsyserror(ep, errno, tname):
            mdsyserror(ep, errno, META_DBCONFTMP);
    }
    free(tname);
    return (rval);
}

/*
 * check replica for dev
 */
static int
in_replica(
    mdsetname_t *sp,
    md_replica_t    *rp,
    mdname_t    *np,
    diskaddr_t  slblk,
    diskaddr_t  nblks,
    md_error_t  *ep
)
{
    mdname_t    *repnp = rp->r_namep;
    diskaddr_t  rep_sblk = rp->r_blkno;
    diskaddr_t  rep_nblks = rp->r_nblk;

    /* should be in the same set */
    assert(sp != NULL);

    /* if error in master block, assume whole partition */
    if ((rep_sblk == MD_DISKADDR_ERROR) ||
        (rep_nblks == MD_DISKADDR_ERROR)) {
        rep_sblk = 0;
        rep_nblks = MD_DISKADDR_ERROR;
    }

    /* check overlap */
    if (meta_check_overlap(
        MDB_STR, np, slblk, nblks, repnp, rep_sblk, rep_nblks, ep) != 0) {
        return (-1);
    }

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

/*
 * check to see if we're in a replica
 */
int
meta_check_inreplica(
    mdsetname_t     *sp,
    mdname_t        *np,
    diskaddr_t      slblk,
    diskaddr_t      nblks,
    md_error_t      *ep
)
{
    md_replicalist_t    *rlp = NULL;
    md_replicalist_t    *rl;
    int         rval = 0;

    /* should have a set */
    assert(sp != NULL);

    /* for each replica */
    if (metareplicalist(sp, MD_BASICNAME_OK, &rlp, ep) < 0)
        return (-1);
    for (rl = rlp; (rl != NULL); rl = rl->rl_next) {
        md_replica_t    *rp = rl->rl_repp;

        /* check replica */
        if (in_replica(sp, rp, np, slblk, nblks, ep) != 0) {
            rval = -1;
            break;
        }
    }

    /* cleanup, return success */
    metafreereplicalist(rlp);
    return (rval);
}

/*
 * check replica
 */
int
meta_check_replica(
    mdsetname_t *sp,        /* set to check against */
    mdname_t    *np,        /* component to check against */
    mdchkopts_t options,    /* option flags */
    diskaddr_t  slblk,      /* start logical block */
    diskaddr_t  nblks,      /* number of blocks (-1,rest of them) */
    md_error_t  *ep     /* error packet */
)
{
    mdchkopts_t chkoptions = MDCHK_ALLOW_REPSLICE;

    /* make sure we have a disk */
    if (metachkcomp(np, ep) != 0)
        return (-1);

    /* check to ensure that it is not already in use */
    if (meta_check_inuse(sp, np, MDCHK_INUSE, ep) != 0) {
        return (-1);
    }

    if (options & MDCHK_ALLOW_NODBS)
        return (0);

    if (options & MDCHK_DRVINSET)
        return (0);

    /* make sure it is in the set */
    if (meta_check_inset(sp, np, ep) != 0)
        return (-1);

    /* make sure its not in a metadevice */
    if (meta_check_inmeta(sp, np, chkoptions, slblk, nblks, ep) != 0)
        return (-1);

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

static int
update_dbinfo_on_drives(
    mdsetname_t *sp,
    md_drive_desc   *dd,
    int     set_locked,
    int     force,
    md_error_t  *ep
)
{
    md_set_desc     *sd;
    int         i;
    md_setkey_t     *cl_sk;
    int         rval = 0;
    md_mnnode_desc      *nd;

    if ((sd = metaget_setdesc(sp, ep)) == NULL)
        return (-1);

    if (! set_locked) {
        if (MD_MNSET_DESC(sd)) {
            md_error_t xep = mdnullerror;
            sigset_t sigs;
            /* Make sure we are blocking all signals */
            if (procsigs(TRUE, &sigs, &xep) < 0)
                mdclrerror(&xep);

            nd = sd->sd_nodelist;
            while (nd) {
                if (force && strcmp(nd->nd_nodename,
                    mynode()) != 0) {
                    nd = nd->nd_next;
                    continue;
                }

                if (!(nd->nd_flags & MD_MN_NODE_ALIVE)) {
                    nd = nd->nd_next;
                    continue;
                }

                if (clnt_lock_set(nd->nd_nodename, sp, ep))
                    return (-1);
                nd = nd->nd_next;
            }
        } else {
            for (i = 0; i < MD_MAXSIDES; i++) {
                /* Skip empty slots */
                if (sd->sd_nodes[i][0] == '\0')
                    continue;

                if (force && strcmp(sd->sd_nodes[i],
                    mynode()) != 0)
                    continue;

                if (clnt_lock_set(sd->sd_nodes[i], sp, ep))
                    return (-1);
            }
        }
    }

    if (MD_MNSET_DESC(sd)) {
        nd = sd->sd_nodelist;
        while (nd) {
            if (force && strcmp(nd->nd_nodename, mynode()) != 0) {
                nd = nd->nd_next;
                continue;
            }

            if (!(nd->nd_flags & MD_MN_NODE_ALIVE)) {
                nd = nd->nd_next;
                continue;
            }

            if (clnt_upd_dr_dbinfo(nd->nd_nodename, sp, dd, ep)
                == -1) {
                rval = -1;
                break;
            }
            nd = nd->nd_next;
        }
    } else {
        for (i = 0; i < MD_MAXSIDES; i++) {
            /* Skip empty slots */
            if (sd->sd_nodes[i][0] == '\0')
                continue;

            if (force && strcmp(sd->sd_nodes[i], mynode()) != 0)
                continue;

            if (clnt_upd_dr_dbinfo(sd->sd_nodes[i], sp, dd, ep)
                == -1) {
                rval = -1;
                break;
            }
        }
    }

    if (! set_locked) {
        cl_sk = cl_get_setkey(sp->setno, sp->setname);
        if (MD_MNSET_DESC(sd)) {
            nd = sd->sd_nodelist;
            while (nd) {
                if (force &&
                    strcmp(nd->nd_nodename, mynode()) != 0) {
                    nd = nd->nd_next;
                    continue;
                }

                if (!(nd->nd_flags & MD_MN_NODE_ALIVE)) {
                    nd = nd->nd_next;
                    continue;
                }

                if (clnt_unlock_set(nd->nd_nodename, cl_sk,
                    ep)) {
                    rval = -1;
                    break;
                }
                nd = nd->nd_next;
            }
        } else {
            for (i = 0; i < MD_MAXSIDES; i++) {
                /* Skip empty slots */
                if (sd->sd_nodes[i][0] == '\0')
                    continue;

                if (force &&
                    strcmp(sd->sd_nodes[i], mynode()) != 0)
                    continue;

                if (clnt_unlock_set(sd->sd_nodes[i], cl_sk,
                    ep)) {
                    rval = -1;
                    break;
                }
            }

        }
        cl_set_setkey(NULL);
    }

    return (rval);
}

int
meta_db_addsidenms(
    mdsetname_t *sp,
    mdname_t    *np,
    daddr_t     blkno,
    int     bcast,
    md_error_t  *ep
)
{
    side_t      sideno;
    char        *bname = NULL;
    char        *dname = NULL;
    minor_t     mnum;
    mddb_config_t   c;
    int     done;
    int     rval = 0;
    md_set_desc *sd;

    sideno = MD_SIDEWILD;
    /*CONSTCOND*/
    while (1) {
        if (bname != NULL) {
            Free(bname);
            bname = NULL;
        }
        if (dname != NULL) {
            Free(dname);
            dname = NULL;
        }
        if ((done = meta_getnextside_devinfo(sp, np->bname,
            &sideno, &bname, &dname, &mnum, ep)) == -1) {
            rval = -1;
            break;
        }

        if (done == 0)
            break;

        if (! metaislocalset(sp)) {
            if ((sd = metaget_setdesc(sp, ep)) == NULL) {
                rval = -1;
                break;
            }
        }

        /*
         * Send addsidenms to all nodes using rpc.mdcommd if
         * sidename is being added to MN diskset.
         *
         *   It's ok to broadcast this call to other nodes.
         *
         *   Note: The broadcast to other nodes isn't needed during
         *   the addition of the first mddbs to the set since the
         *   other nodes haven't been joined to the set yet.  All
         *   nodes in a MN diskset are (implicitly) joined to the set
         *   on the addition of the first mddb.
         */
        if ((! metaislocalset(sp)) && MD_MNSET_DESC(sd) &&
            (bcast == DB_ADDSIDENMS_BCAST)) {
            md_mn_result_t          *resultp = NULL;
            md_mn_msg_meta_db_newside_t db_ns;
            int             send_rval;

            db_ns.msg_l_dev = np->dev;
            db_ns.msg_sideno = sideno;
            db_ns.msg_blkno = blkno;
            (void) strncpy(db_ns.msg_dname, dname,
                sizeof (db_ns.msg_dname));
            (void) splitname(np->bname, &db_ns.msg_splitname);
            db_ns.msg_mnum = mnum;

            /* Set devid to NULL until devids are supported */
            db_ns.msg_devid[0] = NULL;

            /*
             * If reconfig cycle has been started, this node is
             * stuck in in the return step until this command has
             * completed.  If mdcommd is suspended, ask
             * send_message to fail (instead of retrying)
             * so that metaset can finish allowing the reconfig
             * cycle to proceed.
             */
            send_rval = mdmn_send_message(sp->setno,
                MD_MN_MSG_META_DB_NEWSIDE, MD_MSGF_FAIL_ON_SUSPEND |
                MD_MSGF_PANIC_WHEN_INCONSISTENT, 0, (char *)&db_ns,
                sizeof (md_mn_msg_meta_db_newside_t),
                &resultp, ep);
            if (send_rval != 0) {
                rval = -1;
                if (resultp == NULL)
                    (void) mddserror(ep,
                        MDE_DS_COMMD_SEND_FAIL,
                        sp->setno, NULL, NULL,
                        sp->setname);
                else {
                    (void) mdstealerror(ep,
                        &(resultp->mmr_ep));
                    if (mdisok(ep)) {
                        (void) mddserror(ep,
                            MDE_DS_COMMD_SEND_FAIL,
                            sp->setno, NULL, NULL,
                            sp->setname);
                    }
                    free_result(resultp);
                }
                break;
            }
            if (resultp)
                free_result(resultp);
        } else {
            /*
             * Let this side's  device name, minor # and driver name
             * be known to the database replica.
             */
            (void) memset(&c, 0, sizeof (c));

            /* Fill in device/replica info */
            c.c_locator.l_dev = meta_cmpldev(np->dev);
            c.c_locator.l_blkno = blkno;
            (void) strncpy(c.c_locator.l_driver, dname,
                sizeof (c.c_locator.l_driver));
            if (splitname(np->bname, &c.c_devname) ==
                METASPLIT_LONGDISKNAME && devid_in_use == FALSE) {
                rval = mddeverror(ep, MDE_DISKNAMETOOLONG,
                    NODEV64, np->rname);
                break;
            }

            c.c_locator.l_mnum = mnum;

            /* Fill in setno, setname, and sideno */
            c.c_setno = sp->setno;
            (void) strncpy(c.c_setname, sp->setname,
                sizeof (c.c_setname));
            c.c_sideno = sideno;

            /*
             * Don't need device id information from this ioctl
             * Kernel determines device id from dev_t, which
             * is just what this code would do.
             */
            c.c_locator.l_devid = (uint64_t)0;
            c.c_locator.l_devid_flags = 0;

            if (metaioctl(MD_DB_NEWSIDE, &c, &c.c_mde, NULL) != 0) {
                rval = mdstealerror(ep, &c.c_mde);
                break;
            }
        }
    }

    /* cleanup, return success */
    if (bname != NULL) {
        Free(bname);
        bname = NULL;
    }
    if (dname != NULL) {
        Free(dname);
        dname = NULL;
    }
    return (rval);
}


int
meta_db_delsidenm(
    mdsetname_t *sp,
    side_t      sideno,
    mdname_t    *np,
    daddr_t     blkno,
    md_error_t  *ep
)
{
    mddb_config_t   c;
    md_set_desc *sd;

    if (! metaislocalset(sp)) {
        if ((sd = metaget_setdesc(sp, ep)) == NULL)
            return (-1);
    }
    /* Use rpc.mdcommd to delete mddb side from all nodes */
    if ((! metaislocalset(sp)) && MD_MNSET_DESC(sd) &&
        (sd->sd_mn_mynode->nd_flags & MD_MN_NODE_OWN)) {
        md_mn_result_t          *resultp = NULL;
        md_mn_msg_meta_db_delside_t db_ds;
        int             send_rval;

        db_ds.msg_l_dev = np->dev;
        db_ds.msg_blkno = blkno;
        db_ds.msg_sideno = sideno;

        /* Set devid to NULL until devids are supported */
        db_ds.msg_devid[0] = NULL;

        /*
         * If reconfig cycle has been started, this node is
         * stuck in in the return step until this command has
         * completed.  If mdcommd is suspended, ask
         * send_message to fail (instead of retrying)
         * so that metaset can finish allowing the reconfig
         * cycle to proceed.
         */
        send_rval = mdmn_send_message(sp->setno,
            MD_MN_MSG_META_DB_DELSIDE, MD_MSGF_FAIL_ON_SUSPEND |
            MD_MSGF_PANIC_WHEN_INCONSISTENT, 0, (char *)&db_ds,
            sizeof (md_mn_msg_meta_db_delside_t), &resultp, ep);
        if (send_rval != 0) {
            if (resultp == NULL)
                (void) mddserror(ep,
                    MDE_DS_COMMD_SEND_FAIL,
                    sp->setno, NULL, NULL,
                    sp->setname);
            else {
                (void) mdstealerror(ep, &(resultp->mmr_ep));
                if (mdisok(ep)) {
                    (void) mddserror(ep,
                        MDE_DS_COMMD_SEND_FAIL,
                        sp->setno, NULL, NULL,
                        sp->setname);
                }
                free_result(resultp);
            }
            return (-1);
        }
        if (resultp)
            free_result(resultp);

    } else {
        /*
         * Let this side's  device name, minor # and driver name
         * be known to the database replica.
         */
        (void) memset(&c, 0, sizeof (c));

        /* Fill in device/replica info */
        c.c_locator.l_dev = meta_cmpldev(np->dev);
        c.c_locator.l_blkno = blkno;

        /* Fill in setno, setname, and sideno */
        c.c_setno = sp->setno;
        (void) strcpy(c.c_setname, sp->setname);
        c.c_sideno = sideno;

        /*
         * Don't need device id information from this ioctl
         * Kernel determines device id from dev_t, which
         * is just what this code would do.
         */
        c.c_locator.l_devid = (uint64_t)0;
        c.c_locator.l_devid_flags = 0;

        if (metaioctl(MD_DB_DELSIDE, &c, &c.c_mde, NULL) != 0)
            return (mdstealerror(ep, &c.c_mde));
    }
    return (0);
}


static int
mdnamesareunique(mdnamelist_t *nlp, md_error_t *ep)
{
    mdnamelist_t        *dnp1, *dnp2;

    for (dnp1 = nlp; dnp1 != NULL; dnp1 = dnp1->next) {
        for (dnp2 = dnp1->next; dnp2 != NULL; dnp2 = dnp2->next) {
            if (strcmp(dnp1->namep->cname, dnp2->namep->cname) == 0)
                return (mderror(ep, MDE_DUPDRIVE,
                    dnp1->namep->cname));
        }
    }
    return (0);
}


/*
 * Return 1 if files are different, else return 0
 */
static int
filediff(char *tsname, char *sname)
{
    int ret = 1, fd;
    size_t tsz, sz;
    struct stat sbuf;
    char *tbuf, *buf;

    if (stat(tsname, &sbuf) != 0)
        return (1);
    tsz = sbuf.st_size;
    if (stat(sname, &sbuf) != 0)
        return (1);
    sz = sbuf.st_size;
    if (tsz != sz)
        return (1);

    /* allocate memory and read both files into buffer */
    tbuf = malloc(tsz);
    buf = malloc(sz);
    if (tbuf == NULL || buf == NULL)
        goto out;

    fd = open(tsname, O_RDONLY);
    if (fd == -1)
        goto out;
    sz = read(fd, tbuf, tsz);
    (void) close(fd);
    if (sz != tsz)
        goto out;

    fd = open(sname, O_RDONLY);
    if (fd == -1)
        goto out;
    sz = read(fd, buf, tsz);
    (void) close(fd);
    if (sz != tsz)
        goto out;

    /* compare content */
    ret = bcmp(tbuf, buf, tsz);
out:
    if (tbuf)
        free(tbuf);
    if (buf)
        free(buf);
    return (ret);
}

/*
 * patch md.conf file with mddb locations
 */
int
meta_db_patch(
    char        *sname,     /* system file name */
    char        *cname,     /* mddb.cf file name */
    int     patch,      /* patching locally */
    md_error_t  *ep
)
{
    char        *tsname = NULL;
    char        line[MDDB_BOOTLIST_MAX_LEN];
    FILE        *tsfp = NULL;
    FILE        *mfp = NULL;
    int     rval = -1;

    /* check names */
    if (sname == NULL) {
        if (patch)
            sname = "md.conf";
        else
            sname = "/kernel/drv/md.conf";
    }
    if (cname == NULL)
        cname = META_DBCONF;

    /*
     * edit file
     */
    if (meta_systemfile_copy(sname, 0, 1, 1, 0, &tsname, &tsfp, ep) != 0) {
        if (mdissyserror(ep, EROFS)) {
            /*
             * If we are booted on a read-only root because
             * of mddb quorum problems we don't want to emit
             * any scary error messages.
             */
            mdclrerror(ep);
            rval = 0;
        }
        goto out;
    }

    if (meta_systemfile_append_mddb(cname, sname, tsname, tsfp, 1, 0, 0,
        ep) != 0)
        goto out;

    /* if file content is identical, skip rename */
    if (filediff(tsname, sname) == 0) {
        rval = 0;
        goto out;
    }

    if ((fflush(tsfp) != 0) || (fsync(fileno(tsfp)) != 0) ||
        (fclose(tsfp) != 0)) {
        (void) mdsyserror(ep, errno, tsname);
        goto out;
    }

    tsfp = NULL;

    /*
     * rename file. If we get a Cross Device error then it
     * is because we are in the miniroot.
     */
    if (rename(tsname, sname) != 0 && errno != EXDEV) {
        (void) mdsyserror(ep, errno, sname);
        goto out;
    }

    if (errno == EXDEV) {
        if ((tsfp = fopen(tsname, "r")) == NULL)
            goto out;
        if ((mfp = fopen(sname, "w+")) == NULL)
            goto out;
        while (fgets(line, sizeof (line), tsfp) != NULL) {
            if (fputs(line, mfp) == NULL)
                goto out;
        }
        (void) fclose(tsfp);
        tsfp = NULL;
        if (fflush(mfp) != 0)
            goto out;
        if (fsync(fileno(mfp)) != 0)
            goto out;
        if (fclose(mfp) != 0) {
            mfp = NULL;
            goto out;
        }
    }

    Free(tsname);
    tsname = NULL;
    rval = 0;

    /* cleanup, return error */
out:
    if (tsfp != NULL)
        (void) fclose(tsfp);
    if (tsname != NULL) {
        (void) unlink(tsname);
        Free(tsname);
    }
    return (rval);
}

/*
 * Add replicas to set.  This happens as a result of:
 *  - metadb [-s set_name] -a
 *  - metaset -s set_name -a disk
 *  - metaset -s set_name -d disk    (causes a rebalance of mddbs)
 *  - metaset -s set_name -b
 *
 * For a local set, this routine is run on the local set host.
 *
 * For a traditional diskset, this routine is run on the node that
 * is running the metaset command.
 *
 * For a multinode diskset, this routine is run by the node that is
 * running the metaset command.  If this is the first mddb added to
 * the MN diskset, then no communication is made to other nodes via commd
 * since the other nodes will be in-sync with respect to the mddbs when
 * those other nodes join the set and snarf in the newly created mddb.
 * If this is not the first mddb added to the MN diskset, then this
 * attach command is sent to all of the nodes using commd.  This keeps
 * the nodes in-sync.
 */
int
meta_db_attach(
    mdsetname_t     *sp,
    mdnamelist_t        *db_nlp,
    mdchkopts_t     options,
    md_timeval32_t      *timeval,
    int         dbcnt,
    int         dbsize,
    char            *sysfilename,
    md_error_t      *ep
)
{
    struct mddb_config  c;
    mdnamelist_t        *nlp;
    mdname_t        *np;
    md_drive_desc       *dd = NULL;
    md_drive_desc       *p;
    int         i;
    int         fd;
    side_t          sideno;
    daddr_t         blkno;
    int         replicacount = 0;
    int         start_svmdaemons = 0;
    int         rval = 0;
    md_error_t      status = mdnullerror;
    md_set_desc     *sd;
    int         stale_bool = FALSE;
    int         flags;
    int         firstmddb = 1;
    md_timeval32_t      inittime = {0, 0};

    /*
     * Error if we don't get some work to do.
     */
    if (db_nlp == NULL)
        return (mdsyserror(ep, EINVAL, NULL));

    if (mdnamesareunique(db_nlp, ep) != 0)
        return (-1);
    (void) memset(&c, 0, sizeof (c));
    c.c_id = 0;
    c.c_setno = sp->setno;

    /* Don't need device id information from this ioctl */
    c.c_locator.l_devid = (uint64_t)0;
    c.c_locator.l_devid_flags = 0;
    if (metaioctl(MD_DB_GETDEV, &c, &c.c_mde, NULL) != 0) {
        if (metaislocalset(sp)) {
            if (mdismddberror(&c.c_mde, MDE_DB_INVALID))
                mdclrerror(&c.c_mde);
            else if (! mdismddberror(&c.c_mde, MDE_DB_NODB) ||
                (! (options & MDCHK_ALLOW_NODBS)))
                return (mdstealerror(ep, &c.c_mde));
        } else {
            if (! mdismddberror(&c.c_mde, MDE_DB_NOTOWNER))
                return (mdstealerror(ep, &c.c_mde));
        }
        mdclrerror(&c.c_mde);
    }
    /*
     * Is current set STALE?
     */
    if (c.c_flags & MDDB_C_STALE) {
        stale_bool = TRUE;
    }

    assert(db_nlp != NULL);

    /* if these are the first replicas then the SVM daemons need to run */
    if (c.c_dbcnt == 0)
        start_svmdaemons = 1;

    /*
     * check to see if we will go over the total possible number
     * of data bases
     */
    nlp = db_nlp;
    while (nlp) {
        replicacount += dbcnt;
        nlp = nlp->next;
    }

    if ((replicacount + c.c_dbcnt) > c.c_dbmax)
        return (mdmddberror(ep, MDE_TOOMANY_REPLICAS, NODEV32,
            sp->setno, c.c_dbcnt + replicacount, NULL));

    /*
     * go through and check to make sure all locations specified
     * are legal also pick out driver name;
     */
    for (nlp = db_nlp; nlp != NULL; nlp = nlp->next) {
        diskaddr_t devsize;

        np = nlp->namep;

        if (! metaislocalset(sp)) {
            uint_t  partno;
            uint_t  rep_partno;
            mddrivename_t   *dnp = np->drivenamep;

            /*
             * make sure that non-local database replicas
             * are always on the replica slice.
             */
            if (meta_replicaslice(dnp,
                &rep_partno, ep) != 0)
                return (-1);
            if (metagetvtoc(np, FALSE, &partno, ep) == NULL)
                return (-1);
            if (partno != rep_partno)
                return (mddeverror(ep, MDE_REPCOMP_ONLY,
                    np->dev, sp->setname));
        }

        if (meta_check_replica(sp, np, options, 0, (dbcnt * dbsize),
            ep)) {
            return (-1);
        }

        if ((devsize = metagetsize(np, ep)) == -1)
            return (-1);

        if (devsize < (diskaddr_t)((dbcnt * dbsize) + 16))
            return (mdmddberror(ep, MDE_REPLICA_TOOSMALL,
                meta_getminor(np->dev), sp->setno, devsize,
                np->cname));
    }

    /*
     * If first disk in set we don't have lb_inittime yet for use as
     * mb_setcreatetime so don't go looking for it. WE'll come back
     * later and update after the locator block has been created.
     * If this isn't the first disk in the set, we have a locator
     * block and thus we have lb_inittime. Set mb_setcreatetime to
     * lb_inittime.
     */
    if (! metaislocalset(sp)) {
        if (c.c_dbcnt != 0) {
            firstmddb = 0;
            inittime = meta_get_lb_inittime(sp, ep);
        }
    }

    /*
     * go through and write all master blocks
     */

    for (nlp = db_nlp; nlp != NULL; nlp = nlp->next) {
        np = nlp->namep;

        if ((fd = open(np->rname, O_RDWR)) < 0)
            return (mdsyserror(ep, errno, np->rname));

        for (i = 0; i < dbcnt; i++) {
            if (mkmasterblks(sp, np, fd, (i * dbsize + 16), dbsize,
                inittime, ep)) {
                (void) close(fd);
                return (-1);
            }
        }
        (void) close(fd);
    }

    if ((sideno = getmyside(sp, ep)) == MD_SIDEWILD)
        return (-1);

    if (! metaislocalset(sp)) {
        dd = metaget_drivedesc_fromnamelist(sp, db_nlp, ep);
        if (! mdisok(ep))
            return (-1);
        if ((sd = metaget_setdesc(sp, ep)) == NULL)
            return (-1);

    }

    /*
     * go through and tell kernel to add them
     */
    for (nlp = db_nlp; nlp != NULL; nlp = nlp->next) {
        mdcinfo_t   *cinfo;

        np = nlp->namep;

        if ((cinfo = metagetcinfo(np, ep)) == NULL) {
            rval = -1;
            goto out;
        }

        /*
         * If mddb is being added to MN diskset and there already
         * exists a valid mddb in the set (which equates to this
         * node being an owner of the set) then use rpc.mdcommd
         * mechanism to add mddb(s) so that all nodes stay in sync.
         * If set is stale, don't log the message since rpc.mdcommd
         * can't write the message to the mddb.
         *
         * Otherwise, just add mddb to this node.
         */
        if ((! metaislocalset(sp)) && MD_MNSET_DESC(sd) &&
            (sd->sd_mn_mynode->nd_flags & MD_MN_NODE_OWN)) {
            md_mn_result_t          *resultp = NULL;
            md_mn_msg_meta_db_attach_t  attach;
            int                 send_rval;

            /*
             * In a scenario where new replicas had been added on
             * the master, and then all of the old replicas failed
             * before the slaves had knowledge of the new replicas,
             * the slaves are unable to re-parse in the mddb
             * from the new replicas since the slaves have no
             * knowledge of the new replicas.  The following
             * algorithm solves this problem:
             *  - META_DB_ATTACH message generates submsgs
             *      - BLOCK parse (master)
             *      - MDDB_ATTACH new replicas
             *      - UNBLOCK parse (master) causing parse
             *      information to be sent from master
             *      to slaves at a higher class than the
             *      unblock so the parse message will
             *      reach slaves before unblock message.
             */
            attach.msg_l_dev = np->dev;
            attach.msg_cnt = dbcnt;
            attach.msg_dbsize = dbsize;
            (void) strncpy(attach.msg_dname, cinfo->dname,
                sizeof (attach.msg_dname));
            (void) splitname(np->bname, &attach.msg_splitname);
            attach.msg_options = options;

            /* Set devid to NULL until devids are supported */
            attach.msg_devid[0] = NULL;

            /*
             * If reconfig cycle has been started, this node is
             * stuck in in the return step until this command has
             * completed.  If mdcommd is suspended, ask
             * send_message to fail (instead of retrying)
             * so that metaset can finish allowing the reconfig
             * cycle to proceed.
             */
            flags = MD_MSGF_FAIL_ON_SUSPEND;
            if (stale_bool == TRUE)
                flags |= MD_MSGF_NO_LOG;
            send_rval = mdmn_send_message(sp->setno,
                MD_MN_MSG_META_DB_ATTACH,
                flags, 0, (char *)&attach,
                sizeof (md_mn_msg_meta_db_attach_t),
                &resultp, ep);
            if (send_rval != 0) {
                rval = -1;
                if (resultp == NULL)
                    (void) mddserror(ep,
                        MDE_DS_COMMD_SEND_FAIL,
                        sp->setno, NULL, NULL,
                        sp->setname);
                else {
                    (void) mdstealerror(ep,
                        &(resultp->mmr_ep));
                    if (mdisok(ep)) {
                        (void) mddserror(ep,
                            MDE_DS_COMMD_SEND_FAIL,
                            sp->setno, NULL, NULL,
                            sp->setname);
                    }
                    free_result(resultp);
                }
                goto out;
            }
            if (resultp)
                free_result(resultp);
        } else {
            /* Adding mddb(s) to just this node */
            for (i = 0; i < dbcnt; i++) {
                (void) memset(&c, 0, sizeof (c));
                /* Fill in device/replica info */
                c.c_locator.l_dev = meta_cmpldev(np->dev);
                c.c_locator.l_blkno = i * dbsize + 16;
                blkno = c.c_locator.l_blkno;
                (void) strncpy(c.c_locator.l_driver,
                    cinfo->dname,
                    sizeof (c.c_locator.l_driver));

                if (splitname(np->bname, &c.c_devname) ==
                    METASPLIT_LONGDISKNAME && devid_in_use ==
                    FALSE) {
                    rval = mddeverror(ep,
                        MDE_DISKNAMETOOLONG,
                        NODEV64, np->rname);
                    goto out;
                }

                c.c_locator.l_mnum = meta_getminor(np->dev);

                /* Fill in setno, setname, and sideno */
                c.c_setno = sp->setno;
                if (! metaislocalset(sp)) {
                    if (MD_MNSET_DESC(sd)) {
                        c.c_multi_node = 1;
                    }
                }
                (void) strcpy(c.c_setname, sp->setname);
                c.c_sideno = sideno;

                /*
                 * Don't need device id information from this
                 * ioctl Kernel determines device id from
                 * dev_t, which is just what this code would do.
                 */
                c.c_locator.l_devid = (uint64_t)0;
                c.c_locator.l_devid_flags = 0;

                if (timeval != NULL)
                    c.c_timestamp = *timeval;

                if (setup_med_cfg(sp, &c,
                    (options & MDCHK_SET_FORCE), ep)) {
                    rval = -1;
                    goto out;
                }

                if (metaioctl(MD_DB_NEWDEV, &c, &c.c_mde,
                    NULL) != 0) {
                    rval = mdstealerror(ep, &c.c_mde);
                    goto out;
                }
                /*
                 * This is either a traditional diskset OR this
                 * is the first replica added to a MN diskset.
                 * In either case, set broadcast to NO_BCAST so
                 * that message won't go through rpc.mdcommd.
                 * If this is a traditional diskset, the bcast
                 * flag is ignored since traditional disksets
                 * don't use the rpc.mdcommd.
                 */
                if (meta_db_addsidenms(sp, np, blkno,
                    DB_ADDSIDENMS_NO_BCAST, ep))
                    goto out;
            }
        }
        if (! metaislocalset(sp)) {
            /* update the dbcnt and size in dd */
            for (p = dd; p != NULL; p = p->dd_next)
                if (p->dd_dnp == np->drivenamep) {
                    p->dd_dbcnt = dbcnt;
                    p->dd_dbsize  = dbsize;
                    break;
                }
        }

        /*
         * If this was the first addition of disks to the
         * diskset you now need to update the mb_setcreatetime
         * which needed lb_inittime which wasn't there until now.
         */
        if (firstmddb) {
            if (meta_update_mb(sp, dd, ep) != 0) {
                return (-1);
            }
        }
        (void) close(fd);
    }

out:
    if (metaislocalset(sp)) {

        /* everything looks fine. Start mdmonitord */
        if (rval == 0 && start_svmdaemons == 1) {
            if (meta_smf_enable(META_SMF_CORE, &status) == -1) {
                mde_perror(&status, "");
                mdclrerror(&status);
            }
        }

        if (buildconf(sp, &status)) {
            /* Don't mask any previous errors */
            if (rval == 0)
                rval = mdstealerror(ep, &status);
            return (rval);
        }

        if (meta_db_patch(sysfilename, NULL, 0, &status)) {
            /* Don't mask any previous errors */
            if (rval == 0)
                rval = mdstealerror(ep, &status);
        }
    } else {
        if (update_dbinfo_on_drives(sp, dd,
            (options & MDCHK_SET_LOCKED),
            (options & MDCHK_SET_FORCE),
            &status)) {
            /* Don't mask any previous errors */
            if (rval == 0)
                rval = mdstealerror(ep, &status);
            else
                mdclrerror(&status);
        }
        metafreedrivedesc(&dd);
    }
    /*
     * For MN disksets that already had already had nodes joined
     * before the attach of this mddb(s), the name invalidation is
     * done by the commd handler routine.  Otherwise, if this
     * is the first attach of a MN diskset mddb, the invalidation
     * must be done here since the first attach cannot be sent
     * via the commd since there are no nodes joined to the set yet.
     */
    if ((metaislocalset(sp)) || (!MD_MNSET_DESC(sd)) ||
        (MD_MNSET_DESC(sd) &&
        (!(sd->sd_mn_mynode->nd_flags & MD_MN_NODE_OWN)))) {
        for (nlp = db_nlp; (nlp != NULL); nlp = nlp->next) {
            meta_invalidate_name(nlp->namep);
        }
    }
    return (rval);
}

/*
 * deletelist_length
 *
 *  return the number of slices that have been specified for deletion
 *  on the metadb command line.  This does not calculate the number
 *  of replicas because there may be multiple replicas per slice.
 */
static int
deletelist_length(mdnamelist_t *db_nlp)
{

    mdnamelist_t        *nlp;
    int         list_length = 0;

    for (nlp = db_nlp; nlp != NULL; nlp = nlp->next) {
        list_length++;
    }

    return (list_length);
}

static int
in_deletelist(char *devname, mdnamelist_t *db_nlp)
{

    mdnamelist_t        *nlp;
    mdname_t        *np;
    int         index = 0;

    for (nlp = db_nlp; nlp != NULL; nlp = nlp->next) {
        np = nlp->namep;

        if (strcmp(devname, np->bname) == 0)
            return (index);
        index++;
    }

    return (-1);
}

/*
 * Delete replicas from set.  This happens as a result of:
 *  - metadb [-s set_name] -d
 *  - metaset -s set_name -a disk   (causes a rebalance of mddbs)
 *  - metaset -s set_name -d disk
 *  - metaset -s set_name -b
 *
 * For a local set, this routine is run on the local set host.
 *
 * For a traditional diskset, this routine is run on the node that
 * is running the metaset command.
 *
 * For a multinode diskset, this routine is run by the node that is
 * running the metaset command.  This detach routine is sent to all
 * of the joined nodes in the diskset using commd.  This keeps
 * the nodes in-sync.
 */
int
meta_db_detach(
    mdsetname_t     *sp,
    mdnamelist_t        *db_nlp,
    mdforceopts_t       force_option,
    char            *sysfilename,
    md_error_t      *ep
)
{
    struct mddb_config  c;
    mdnamelist_t        *nlp;
    mdname_t        *np;
    md_drive_desc       *dd = NULL;
    md_drive_desc       *p;
    int         replicacount;
    int         replica_delete_count;
    int         nr_replica_slices;
    int         i;
    int         stop_svmdaemons = 0;
    int         rval = 0;
    int         index;
    int         valid_replicas_nottodelete = 0;
    int         invalid_replicas_nottodelete = 0;
    int         invalid_replicas_todelete = 0;
    int         errored = 0;
    int         *tag_array;
    int         fd = -1;
    md_error_t      status = mdnullerror;
    md_set_desc     *sd;
    int         stale_bool = FALSE;
    int         flags;

    /*
     * Error if we don't get some work to do.
     */
    if (db_nlp == NULL)
        return (mdsyserror(ep, EINVAL, NULL));

    if (mdnamesareunique(db_nlp, ep) != 0)
        return (-1);

    (void) memset(&c, 0, sizeof (c));
    c.c_id = 0;
    c.c_setno = sp->setno;

    /* Don't need device id information from this ioctl */
    c.c_locator.l_devid = (uint64_t)0;
    c.c_locator.l_devid_flags = 0;

    if (metaioctl(MD_DB_GETDEV, &c, &c.c_mde, NULL) != 0)
        return (mdstealerror(ep, &c.c_mde));

    /*
     * Is current set STALE?
     */
    if (c.c_flags & MDDB_C_STALE) {
        stale_bool = TRUE;
    }

    replicacount = c.c_dbcnt;

    assert(db_nlp != NULL);

    /*
     * go through and gather how many data bases are on each
     * device specified.
     */

    nr_replica_slices = deletelist_length(db_nlp);
    tag_array = (int *)calloc(nr_replica_slices, sizeof (int));

    replica_delete_count = 0;
    for (i = 0; i < replicacount; i++) {
        char    *devname;
        int found = 0;

        c.c_id = i;

        /* Don't need device id information from this ioctl */
        c.c_locator.l_devid = (uint64_t)0;
        c.c_locator.l_devid_flags = 0;

        if (metaioctl(MD_DB_GETDEV, &c, &c.c_mde, NULL) != 0)
            return (mdstealerror(ep, &c.c_mde));

        devname = splicename(&c.c_devname);

        if (strstr(devname, META_LONGDISKNAME_STR) != NULL) {
            Free(devname);
            devname = getlongname(&c, ep);
            if (devname == NULL) {
                return (-1);
            }
        }

        if ((index = in_deletelist(devname, db_nlp)) != -1) {
            found = 1;
            tag_array[index] = 1;
            replica_delete_count++;
        }

        errored = c.c_locator.l_flags & (MDDB_F_EREAD |
            MDDB_F_EWRITE | MDDB_F_TOOSMALL | MDDB_F_EFMT |
            MDDB_F_EDATA | MDDB_F_EMASTER);

        /*
         * There are four combinations of "errored" and "found"
         * and they are used to find the number of
         * (a) valid/invalid replicas that are not in the delete
         * list and are available in the system.
         * (b) valid/invalid replicas that are to be deleted.
         */

        if (errored && !found)      /* errored and !found */
            invalid_replicas_nottodelete++;
        else if (!found)        /* !errored and !found */
            valid_replicas_nottodelete++;
        else if (errored)       /* errored and found */
            invalid_replicas_todelete++;
        /*
         * else it is !errored and found. This means
         * valid_replicas_todelete++; But this variable will not
         * be used anywhere
         */

        Free(devname);
    }

    index = 0;
    for (nlp = db_nlp; nlp != NULL; nlp = nlp->next) {
        np = nlp->namep;
        if (tag_array[index++] != 1) {
            Free(tag_array);
            return (mddeverror(ep, MDE_NO_DB, np->dev, np->cname));
        }
    }

    Free(tag_array);


    /* if all replicas are deleted stop mdmonitord */
    if ((replicacount - replica_delete_count) == 0)
        stop_svmdaemons = 1;

    if (((replicacount - replica_delete_count) < MD_MINREPLICAS)) {
        if (force_option & MDFORCE_NONE)
            return (mderror(ep, MDE_NOTENOUGH_DB, sp->setname));
        if (! metaislocalset(sp) && ! (force_option & MDFORCE_DS))
            return (mderror(ep, MDE_DELDB_NOTALLOWED, sp->setname));
    }

    /*
     * The following algorithms are followed to check for deletion:
     * (a) If the delete list(db_nlp) has all invalid replicas and no valid
     * replicas, then deletion should be allowed.
     * (b) Deletion should be allowed only if valid replicas that are "not"
     * to be deleted is always greater than the invalid replicas that
     * are "not" to be deleted.
     * (c) If the user uses -f option, then deletion should be allowed.
     */

    if ((invalid_replicas_todelete != replica_delete_count) &&
        (invalid_replicas_nottodelete > valid_replicas_nottodelete) &&
        (force_option != MDFORCE_LOCAL))
        return (mderror(ep, MDE_DEL_VALIDDB_NOTALLOWED, sp->setname));

    /*
     * go through and tell kernel to delete them
     */

    /* Don't need device id information from this ioctl */
    c.c_locator.l_devid = (uint64_t)0;
    c.c_locator.l_devid_flags = 0;

    if (metaioctl(MD_DB_GETDEV, &c, &c.c_mde, NULL) != 0)
        return (mdstealerror(ep, &c.c_mde));

    if (! metaislocalset(sp)) {
        dd = metaget_drivedesc_fromnamelist(sp, db_nlp, ep);
        if (! mdisok(ep))
            return (-1);
        if ((sd = metaget_setdesc(sp, ep)) == NULL)
            return (-1);
    }

    for (nlp = db_nlp; nlp != NULL; nlp = nlp->next) {
        np = nlp->namep;

        /*
         * If mddb is being deleted from MN diskset and node is
         * an owner of the diskset then use rpc.mdcommd
         * mechanism to add mddb(s) so that all nodes stay in sync.
         * If set is stale, don't log the message since rpc.mdcommd
         * can't write the message to the mddb.
         *
         * When mddbs are first being added to set, a detach can
         * be called before any node has joined the diskset, so
         * must check to see if node is an owner of the diskset.
         *
         * Otherwise, just delete mddb from this node.
         */

        if ((! metaislocalset(sp)) && MD_MNSET_DESC(sd) &&
            (sd->sd_mn_mynode->nd_flags & MD_MN_NODE_OWN)) {
            md_mn_result_t          *resultp;
            md_mn_msg_meta_db_detach_t  detach;
            int             send_rval;

            /*
             * The following algorithm is used to detach replicas.
             *  - META_DB_DETACH message generates submsgs
             *      - BLOCK parse (master)
             *      - MDDB_DETACH replicas
             *      - UNBLOCK parse (master) causing parse
             *      information to be sent from master
             *      to slaves at a higher class than the
             *      unblock so the parse message will
             *      reach slaves before unblock message.
             */
            (void) splitname(np->bname, &detach.msg_splitname);

            /* Set devid to NULL until devids are supported */
            detach.msg_devid[0] = NULL;

            /*
             * If reconfig cycle has been started, this node is
             * stuck in in the return step until this command has
             * completed.  If mdcommd is suspended, ask
             * send_message to fail (instead of retrying)
             * so that metaset can finish allowing the reconfig
             * cycle to proceed.
             */
            flags = MD_MSGF_FAIL_ON_SUSPEND;
            if (stale_bool == TRUE)
                flags |= MD_MSGF_NO_LOG;
            send_rval = mdmn_send_message(sp->setno,
                MD_MN_MSG_META_DB_DETACH,
                flags, 0, (char *)&detach,
                sizeof (md_mn_msg_meta_db_detach_t),
                &resultp, ep);
            if (send_rval != 0) {
                rval = -1;
                if (resultp == NULL)
                    (void) mddserror(ep,
                        MDE_DS_COMMD_SEND_FAIL,
                        sp->setno, NULL, NULL,
                        sp->setname);
                else {
                    (void) mdstealerror(ep,
                        &(resultp->mmr_ep));
                    if (mdisok(ep)) {
                        (void) mddserror(ep,
                            MDE_DS_COMMD_SEND_FAIL,
                            sp->setno, NULL, NULL,
                            sp->setname);
                    }
                    free_result(resultp);
                }
                goto out;
            }
            if (resultp)
                free_result(resultp);
        } else {
            i = 0;
            while (i < c.c_dbcnt) {
                char    *devname;

                c.c_id = i;

                /* Don't need devid info from this ioctl */
                c.c_locator.l_devid = (uint64_t)0;
                c.c_locator.l_devid_flags = 0;

                if (metaioctl(MD_DB_GETDEV, &c,
                    &c.c_mde, NULL)) {
                    rval = mdstealerror(ep, &c.c_mde);
                    goto out;
                }

                devname = splicename(&c.c_devname);

                if (strstr(devname, META_LONGDISKNAME_STR)
                    != NULL) {
                    Free(devname);
                    devname = getlongname(&c, ep);
                    if (devname == NULL) {
                        return (-1);
                    }
                }

                if (strcmp(devname, np->bname) != 0) {
                    Free(devname);
                    i++;
                    continue;
                }
                Free(devname);

                /* Don't need devid info from this ioctl */
                c.c_locator.l_devid = (uint64_t)0;
                c.c_locator.l_devid_flags = 0;

                if (metaioctl(MD_DB_DELDEV, &c,
                    &c.c_mde, NULL) != 0) {
                    rval = mdstealerror(ep, &c.c_mde);
                    goto out;
                }

                /* Not incrementing "i" intentionally */
            }
        }
        if (! metaislocalset(sp)) {
            /* update the dbcnt and size in dd */
            for (p = dd; p != NULL; p = p->dd_next) {
                if (p->dd_dnp == np->drivenamep) {
                    p->dd_dbcnt = 0;
                    p->dd_dbsize  = 0;
                    break;
                }
            }

            /*
             * Slam a dummy master block and make it self
             * identifying
             */
            if ((fd = open(np->rname, O_RDWR)) >= 0) {
                meta_mkdummymaster(sp, fd, 16);
                (void) close(fd);
            }
        }
    }
out:
    if (metaislocalset(sp)) {
        /*
         * Stop all the daemons if there are
         * no more replicas so that the module can be
         * unloaded.
         */
        if (rval == 0 && stop_svmdaemons == 1) {
            char buf[MAXPATHLEN];
            int i;

            for (i = 0; i < DAEMON_COUNT; i++) {
                (void) snprintf(buf, MAXPATHLEN,
                    "/usr/bin/pkill -%s -x %s",
                    svmd_kill_list[i].svmd_kill_val,
                    svmd_kill_list[i].svmd_name);
                if (pclose(popen(buf, "w")) == -1)
                    md_perror(buf);
            }

            if (meta_smf_disable(META_SMF_ALL, &status) == -1) {
                mde_perror(&status, "");
                mdclrerror(&status);
            }
        }
        if (buildconf(sp, &status)) {
            /* Don't mask any previous errors */
            if (rval == 0)
                rval = mdstealerror(ep, &status);
            else
                mdclrerror(&status);
            return (rval);
        }

        if (meta_db_patch(sysfilename, NULL, 0, &status)) {
            /* Don't mask any previous errors */
            if (rval == 0)
                rval = mdstealerror(ep, &status);
            else
                mdclrerror(&status);
        }
    } else {
        if (update_dbinfo_on_drives(sp, dd,
            (force_option & MDFORCE_SET_LOCKED),
            ((force_option & MDFORCE_LOCAL) |
            (force_option & MDFORCE_DS)), &status)) {
            /* Don't mask any previous errors */
            if (rval == 0)
                rval = mdstealerror(ep, &status);
            else
                mdclrerror(&status);
        }
        metafreedrivedesc(&dd);
    }
    if ((metaislocalset(sp)) || (!(MD_MNSET_DESC(sd)))) {
        for (nlp = db_nlp; (nlp != NULL); nlp = nlp->next) {
            meta_invalidate_name(nlp->namep);
        }
    }
    return (rval);
}

static md_replica_t *
metareplicaname(
    mdsetname_t     *sp,
    int         flags,
    struct mddb_config  *c,
    md_error_t      *ep
)
{
    md_replica_t    *rp;
    char        *devname;
    size_t      sz;
    devid_nmlist_t  *disklist = NULL;
    char        *devid_str;

    /* allocate replicaname */
    rp = Zalloc(sizeof (*rp));

    /* get device name */
    devname = splicename(&c->c_devname);

    /*
     * Check if the device has a long name (>40 characters) and
     * if so then we have to use devids to get the device name.
     * If this cannot be done then we have to fail the request.
     */
    if (strstr(devname, META_LONGDISKNAME_STR) != NULL) {
        if (c->c_locator.l_devid != NULL) {
            if (meta_deviceid_to_nmlist("/dev/dsk",
                (ddi_devid_t)(uintptr_t)c->c_locator.l_devid,
                c->c_locator.l_minor_name, &disklist) != 0) {
                devid_str = devid_str_encode(
                    (ddi_devid_t)(uintptr_t)
                    c->c_locator.l_devid, NULL);
                (void) mderror(ep, MDE_MISSING_DEVID_DISK, "");
                mderrorextra(ep, devid_str);
                if (devid_str != NULL)
                    devid_str_free(devid_str);
                Free(rp);
                Free(devname);
                return (NULL);
            }
        } else {
            (void) mderror(ep, MDE_NODEVID, "");
            Free(rp);
            Free(devname);
            return (NULL);
        }
        Free(devname);
        devname = disklist[0].devname;
    }

    if (flags & PRINT_FAST) {
        if ((rp->r_namep = metaname_fast(&sp, devname,
            LOGICAL_DEVICE, ep)) == NULL) {
            Free(devname);
            Free(rp);
            return (NULL);
        }
    } else {
        if ((rp->r_namep = metaname(&sp, devname,
            LOGICAL_DEVICE, ep)) == NULL) {
            Free(devname);
            Free(rp);
            return (NULL);
        }
    }
    Free(devname);

    /* make sure it's OK */
    if ((! (flags & MD_BASICNAME_OK)) &&
        (metachkcomp(rp->r_namep, ep) != 0)) {
        Free(rp);
        return (NULL);
    }

    rp->r_blkno = (daddr_t)MD_DISKADDR_ERROR;
    rp->r_nblk = (daddr_t)MD_DISKADDR_ERROR;
    rp->r_flags = c->c_locator.l_flags | MDDB_F_NODEVID;
    if (c->c_locator.l_devid_flags & MDDB_DEVID_VALID) {
        sz = devid_sizeof((ddi_devid_t)(uintptr_t)
            (c->c_locator.l_devid));
        if ((rp->r_devid = (ddi_devid_t)malloc(sz)) ==
            (ddi_devid_t)NULL) {
            Free(rp);
            return (NULL);
        }
        (void) memcpy((void *)rp->r_devid,
            (void *)(uintptr_t)c->c_locator.l_devid, sz);
        (void) strcpy(rp->r_minor_name, c->c_locator.l_minor_name);
        rp->r_flags &= ~MDDB_F_NODEVID;
        /* Overwrite dev derived from name with dev from devid */
        rp->r_namep->dev = meta_expldev(c->c_locator.l_dev);
    }
    (void) strcpy(rp->r_driver_name, c->c_locator.l_driver);

    rp->r_blkno = c->c_locator.l_blkno;
    if (c->c_dbend != 0)
        rp->r_nblk = c->c_dbend - c->c_locator.l_blkno + 1;

    /* return replica */
    return (rp);
}

/*
 * free replica list
 */
void
metafreereplicalist(
    md_replicalist_t    *rlp
)
{
    md_replicalist_t    *rl = NULL;

    for (/* void */; (rlp != NULL); rlp = rl) {
        rl = rlp->rl_next;
        if (rlp->rl_repp->r_devid != (ddi_devid_t)0) {
            free(rlp->rl_repp->r_devid);
        }
        Free(rlp->rl_repp);
        Free(rlp);
    }
}

/*
 * return list of all replicas in set
 */
int
metareplicalist(
    mdsetname_t     *sp,
    int         flags,
    md_replicalist_t    **rlpp,
    md_error_t      *ep
)
{
    md_replicalist_t    **tail = rlpp;
    int         count = 0;
    struct mddb_config  c;
    int         i;
    char            *devid;

    /* for each replica */
    i = 0;
    do {
        md_replica_t    *rp;

        /* get next replica */
        (void) memset(&c, 0, sizeof (c));
        c.c_id = i;
        c.c_setno = sp->setno;

        c.c_locator.l_devid_flags = MDDB_DEVID_GETSZ;
        if (metaioctl(MD_DB_ENDDEV, &c, &c.c_mde, NULL) != 0) {
            if (mdismddberror(&c.c_mde, MDE_DB_INVALID)) {
                mdclrerror(&c.c_mde);
                break;  /* handle none at all */
            }
            (void) mdstealerror(ep, &c.c_mde);
            goto out;
        }

        if (c.c_locator.l_devid_flags & MDDB_DEVID_SZ) {
            if ((devid = malloc(c.c_locator.l_devid_sz)) == NULL) {
                (void) mdsyserror(ep, ENOMEM, META_DBCONF);
                goto out;
            }
            c.c_locator.l_devid = (uintptr_t)devid;
            /*
             * Turn on space and sz flags since 'sz' amount of
             * space has been alloc'd.
             */
            c.c_locator.l_devid_flags =
                MDDB_DEVID_SPACE | MDDB_DEVID_SZ;
        }

        if (metaioctl(MD_DB_ENDDEV, &c, &c.c_mde, NULL) != 0) {
            if (mdismddberror(&c.c_mde, MDE_DB_INVALID)) {
                mdclrerror(&c.c_mde);
                break;  /* handle none at all */
            }
            (void) mdstealerror(ep, &c.c_mde);
            goto out;
        }

        /*
         * Paranoid check - shouldn't happen, but is left as
         * a place holder for changes that will be needed after
         * dynamic reconfiguration changes are added to SVM (to
         * support movement of disks at any point in time).
         */
        if (c.c_locator.l_devid_flags & MDDB_DEVID_NOSPACE) {
            (void) fprintf(stderr,
                dgettext(TEXT_DOMAIN,
                "Error: Relocation Information "
                "(drvnm=%s, mnum=0x%lx) \n"
                "relocation information size changed - \n"
                "rerun command\n"),
                c.c_locator.l_driver, c.c_locator.l_mnum);
            (void) mderror(ep, MDE_DEVID_TOOBIG, NULL);
            goto out;
        }

        if (c.c_dbcnt == 0)
            break;      /* handle none at all */

        /* get info */
        if ((rp = metareplicaname(sp, flags, &c, ep)) == NULL)
            goto out;

        /* append to list */
        *tail = Zalloc(sizeof (**tail));
        (*tail)->rl_repp = rp;
        tail = &(*tail)->rl_next;
        ++count;

        if (c.c_locator.l_devid_flags & MDDB_DEVID_SPACE) {
            free(devid);
            c.c_locator.l_devid_flags = 0;
        }

    } while (++i < c.c_dbcnt);

    if (c.c_locator.l_devid_flags & MDDB_DEVID_SPACE) {
        free(devid);
    }

    /* return count */
    return (count);

    /* cleanup, return error */
out:
    if (c.c_locator.l_devid_flags & MDDB_DEVID_SPACE) {
        free(devid);
    }
    metafreereplicalist(*rlpp);
    *rlpp = NULL;
    return (-1);
}

/*
 * meta_sync_db_locations - get list of replicas from kernel and write
 *  out to mddb.cf and md.conf.  'Syncs up' the replica list in
 *  the kernel with the replica list in the conf files.
 *
 */
void
meta_sync_db_locations(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    char        *sname = 0;     /* system file name */
    char        *cname = 0;     /* config file name */

    if (!metaislocalset(sp))
        return;

    /* Updates backup of configuration file (aka mddb.cf) */
    if (buildconf(sp, ep) != 0)
        return;

    /* Updates system configuration file (aka md.conf) */
    (void) meta_db_patch(sname, cname, 0, ep);
}

/*
 * setup_db_locations - parse the mddb.cf file and
 *          tells the driver which db locations to use.
 */
int
meta_setup_db_locations(
    md_error_t  *ep
)
{
    mddb_config_t   c;
    FILE        *fp;
    char        inbuff[1024];
    char        *buff;
    uint_t      i;
    size_t      sz;
    int     rval = 0;
    char        *devidp;
    uint_t      devid_size;
    char        *minor_name = NULL;
    ddi_devid_t devid_decode;
    int     checksum;

    /* do mddb.cf file */
    (void) memset(&c, '\0', sizeof (c));
    if ((fp = fopen(META_DBCONF, "r")) == NULL) {
        if (errno != ENOENT)
            return (mdsyserror(ep, errno, META_DBCONF));
    }
    while ((fp != NULL) && ((buff = fgets(inbuff, (sizeof (inbuff) - 1),
        fp)) != NULL)) {

        /* ignore comments */
        if (*buff == '#')
            continue;

        /* parse locator */
        (void) memset(&c, 0, sizeof (c));
        c.c_setno = MD_LOCAL_SET;
        i = strcspn(buff, " \t");
        if (i > sizeof (c.c_locator.l_driver))
            i = sizeof (c.c_locator.l_driver);
        (void) strncpy(c.c_locator.l_driver, buff, i);
        buff += i;
        c.c_locator.l_dev =
            makedev((major_t)0, (minor_t)strtol(buff, &buff, 10));
        c.c_locator.l_blkno = (daddr_t)strtol(buff, &buff, 10);
        c.c_locator.l_mnum = minor(c.c_locator.l_dev);

        /* parse out devid */
        while (isspace((int)(*buff)))
            buff += 1;
        i = strcspn(buff, " \t");
        if ((devidp = (char *)malloc(i+1)) == NULL)
            return (mdsyserror(ep, ENOMEM, META_DBCONF));

        (void) strncpy(devidp, buff, i);
        devidp[i] = '\0';
        if (devid_str_decode(devidp, &devid_decode,
            &minor_name) == -1) {
            free(devidp);
            continue;
        }

        /* Conf file must have minor name associated with devid */
        if (minor_name == NULL) {
            free(devidp);
            devid_free(devid_decode);
            continue;
        }

        sz = devid_sizeof(devid_decode);
        /* Copy to devid size buffer that ioctl expects */
        if ((c.c_locator.l_devid = (uintptr_t)malloc(sz)) == NULL) {
            devid_free(devid_decode);
            free(minor_name);
            free(devidp);
            return (mdsyserror(ep, ENOMEM, META_DBCONF));
        }

        (void) memcpy((void *)(uintptr_t)c.c_locator.l_devid,
            (void *)devid_decode, sz);

        devid_free(devid_decode);

        if (strlen(minor_name) > MDDB_MINOR_NAME_MAX) {
            free(minor_name);
            free(devidp);
            free((void *)(uintptr_t)c.c_locator.l_devid);
            return (mdsyserror(ep, ENOMEM, META_DBCONF));
        }
        (void) strcpy(c.c_locator.l_minor_name, minor_name);
        free(minor_name);
        c.c_locator.l_devid_flags = MDDB_DEVID_VALID |
            MDDB_DEVID_SPACE | MDDB_DEVID_SZ;
        c.c_locator.l_devid_sz = sz;

        devid_size = strlen(devidp);
        buff += devid_size;

        checksum = strtol(buff, &buff, 10);
        for (i = 0; c.c_locator.l_driver[i] != 0; i++)
            checksum += c.c_locator.l_driver[i];
        for (i = 0; i < devid_size; i++) {
            checksum += devidp[i];
        }
        free(devidp);

        checksum += minor(c.c_locator.l_dev);
        checksum += c.c_locator.l_blkno;
        if (checksum != 42) {
            /* overwritten later for more serious problems */
            rval = mderror(ep, MDE_MDDB_CKSUM, META_DBCONF);
            free((void *)(uintptr_t)c.c_locator.l_devid);
            continue;
        }
        c.c_locator.l_flags = 0;

        /* use db location */
        if (metaioctl(MD_DB_USEDEV, &c, &c.c_mde, NULL) != 0) {
            free((void *)(uintptr_t)c.c_locator.l_devid);
            return (mdstealerror(ep, &c.c_mde));
        }

        /* free up devid if in use */
        free((void *)(uintptr_t)c.c_locator.l_devid);
        c.c_locator.l_devid = (uint64_t)0;
        c.c_locator.l_devid_flags = 0;
    }
    if ((fp) && (fclose(fp) != 0))
        return (mdsyserror(ep, errno, META_DBCONF));

    /* check for stale database */
    (void) memset((char *)&c, 0, sizeof (struct mddb_config));
    c.c_id = 0;
    c.c_setno = MD_LOCAL_SET;

    /*
     * While we do not need the devid here we may need to
     * know if devid's are being used by the kernel for
     * the replicas. This is because under some circumstances
     * we can only manipulate the SVM configuration if the
     * kernel is using devid's.
     */
    c.c_locator.l_devid = (uint64_t)0;
    c.c_locator.l_devid_flags = MDDB_DEVID_GETSZ;
    c.c_locator.l_devid_sz = 0;

    if (metaioctl(MD_DB_GETDEV, &c, &c.c_mde, NULL) != 0) {
        if (! mdismddberror(&c.c_mde, MDE_DB_INVALID))
            return (mdstealerror(ep, &c.c_mde));
        mdclrerror(&c.c_mde);
    }

    if (c.c_flags & MDDB_C_STALE)
        return (mdmddberror(ep, MDE_DB_STALE, NODEV32, MD_LOCAL_SET,
            0, NULL));

    if (c.c_locator.l_devid_sz != 0) {
        /*
         * Devid's are being used to track the replicas because
         * there is space for a devid.
         */
        devid_in_use = TRUE;
    }

    /* success */
    return (rval);
}

/*
 * meta_db_minreplica - returns the minimum size replica currently in use.
 */
daddr_t
meta_db_minreplica(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    md_replica_t        *r;
    md_replicalist_t    *rl, *rlp = NULL;
    daddr_t         nblks = 0;

    if (metareplicalist(sp, (MD_BASICNAME_OK | PRINT_FAST), &rlp, ep) < 0)
        return (-1);

    if (rlp == NULL)
        return (-1);

    /* find the smallest existing replica */
    for (rl = rlp; rl != NULL; rl = rl->rl_next) {
        r = rl->rl_repp;
        nblks = ((nblks == 0) ? r->r_nblk : min(r->r_nblk, nblks));
    }

    metafreereplicalist(rlp);
    return (nblks);
}

/*
 * meta_get_replica_names
 *  returns an mdnamelist_t of replica slices
 */
/*ARGSUSED*/
int
meta_get_replica_names(
    mdsetname_t *sp,
    mdnamelist_t    **nlpp,
    int     options,
    md_error_t  *ep
)
{
    md_replicalist_t    *rlp = NULL;
    md_replicalist_t    *rl;
    mdnamelist_t        **tailpp = nlpp;
    int         cnt = 0;

    assert(nlpp != NULL);

    if (!metaislocalset(sp))
        goto out;

    /* get replicas */
    if (metareplicalist(sp, MD_BASICNAME_OK, &rlp, ep) < 0) {
        cnt = -1;
        goto out;
    }

    /* build name list */
    for (rl = rlp; (rl != NULL); rl = rl->rl_next) {
        /*
         * Add the name struct to the end of the
         * namelist but keep a pointer to the last
         * element so that we don't incur the overhead
         * of traversing the list each time
         */
        tailpp = meta_namelist_append_wrapper(
            tailpp, rl->rl_repp->r_namep);
        ++cnt;
    }

    /* cleanup, return count or error */
out:
    metafreereplicalist(rlp);
    return (cnt);
}