7712 mandoc -Tlint does always exit with error code 0

[unleashed.git] / usr / src / lib / lvm / libmeta / common / meta_devadm.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 (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include        <stdio.h>
#include        <stdarg.h>
#include        <ctype.h>
#include        <sys/fcntl.h>
#include        <sys/types.h>
#include        <devid.h>
#include        <ftw.h>
#include        <string.h>
#include        <mdiox.h>
#include        <sys/lvm/mdio.h>
#include        <meta.h>
#include        <syslog.h>
#include        <sdssc.h>
#include        <libdevinfo.h>
#include        "meta_set_prv.h"

/*
 * 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

#define RAW_PATH                0x001   /* rdsk */
#define BLOCK_PATH              0x002   /* dsk */
#define DSK_TYPE                0x004   /* normal /dev/[r]dsk */
#define TEST_TYPE               0x008   /* test driver path */
#define DID_TYPE                0x010   /* cluster did path */
#define AP_TYPE                 0x020   /* should be obsolete */

typedef struct path_list {
        char                    *search_path;
        char                    *search_type;
        int                     path_type;
} path_list_t;

/*
 * A table of the supported path types - this should ideally be generated
 * by reading the /etc/lvm/devpath file
 */
static path_list_t plist[] = {
        {"/dev/rdsk", DEVID_MINOR_NAME_ALL_CHR, RAW_PATH|DSK_TYPE},
        {"/dev/dsk", DEVID_MINOR_NAME_ALL_BLK, BLOCK_PATH|DSK_TYPE},
        {"/dev/did/rdsk", DEVID_MINOR_NAME_ALL_CHR, RAW_PATH|DID_TYPE},
        {"/dev/did/dsk", DEVID_MINOR_NAME_ALL_BLK, BLOCK_PATH|DID_TYPE},
        {"/dev/td/dsk", DEVID_MINOR_NAME_ALL_BLK, BLOCK_PATH|TEST_TYPE},
        {"/dev/td/rdsk", DEVID_MINOR_NAME_ALL_CHR, RAW_PATH|TEST_TYPE},
};
static int num = sizeof (plist)/sizeof (path_list_t);

static mddevopts_t      dev_options = 0;

/* indicate whether to print an error message or not */
static int      firsttime = 1;

#define DEV_MATCH       0x1
#define NAME_MATCH      0x2

#define DEBUGON         1
#define DEBUGOFF        2

/*
 * Debug function: to turn on devadm function debugging include DEVADM
 * in the MD_DEBUG enviroment variable: MD_DEBUG=...,DEVADM...
 */
/*PRINTFLIKE1*/
static void
mda_debug(char *format, ...)
{
        char    *p;
        static int debug_set = 0;
        va_list ap;

        if (debug_set == 0) {
                if (((p = getenv("MD_DEBUG")) != NULL) &&
                    (strstr(p, "DEVADM") != NULL))
                        debug_set = DEBUGON;
                else
                        debug_set = DEBUGOFF;
        }
        if (debug_set == DEBUGON) {
                va_start(ap, format);
                (void) vfprintf(stderr, format, ap);
                va_end(ap);
        }
}

/* print error messages to the terminal or syslog */
/*PRINTFLIKE1*/
static void
mda_print(char *message, ...)
{
        va_list ap;

        va_start(ap, message);
        if (dev_options & DEV_LOG) {
                /*
                 * The program is a daemon in the sense that it
                 * is a system utility.
                 */
                (void) vsyslog((LOG_ERR | LOG_DAEMON), message, ap);
        } else {
                (void) vfprintf(stderr, message, ap);
        }
        va_end(ap);
}

/*
 * Utility to find the correct options to use for the devid search
 * based upon the path of the device.
 *
 * RETURN:
 *      -1      Error, the path passed in is not in the table
 *      >= 0    The element number for the options within the table
 */
static int
mda_findpath(char *path)
{
        int     i = 0;

        for (i = 0; i < num; i++) {
                if (strncmp(plist[i].search_path, path,
                    strlen(plist[i].search_path)) == 0)
                        return (i);
        }
        return (-1);
}

/*
 * Utility to get the path of a device
 */
static char *
mda_getpath(char *devname)
{
        char    *ptr;
        char    *pathname;
        size_t  len;

        if ((ptr = strrchr(devname, '/')) == NULL) {
                mda_debug("Invalid format: %s\n", devname);
                return (NULL);
        }
        ptr++;
        len = strlen(devname) - strlen(ptr);
        pathname = Malloc(len + 1);
        (void) strncpy(pathname, devname, len);
        pathname[len] = '\0';
        return (pathname);
}

/*
 * meta_update_devtree -- Update the /dev/md namespace for metadevices.
 *
 * Only update the specific link if a valid minor(not NODEV) is given.
 * Otherwise, update the entire /dev/md .
 */

int
meta_update_devtree(minor_t mnum)
{
        char    nodename[40];
        di_devlink_handle_t     hdl;

        /*
         * di_devlink_init() returns once the /dev links have been
         * updated(created or removed). If di_devlink_init returns
         * a NULL, the link operation failed.
         *
         * Use the enhanced di_devlink_init interface if the mnum
         * is available.
         */
        if (mnum == NODEV) {
                /*
                 * NOTE: This will take a _long_ time for large numbers
                 * of metadevices.
                 */
                hdl = di_devlink_init("md", DI_MAKE_LINK);
        } else {
                /* Call di_devlink_init twice, for block and raw devices */
                (void) sprintf(nodename, "/pseudo/md@0:%lu,%lu,raw",
                    MD_MIN2SET(mnum), MD_MIN2UNIT(mnum));
                hdl = di_devlink_init(nodename, DI_MAKE_LINK);

                if (hdl == NULL)
                        return (-1);
                else
                        (void) di_devlink_fini(&hdl);

                (void) sprintf(nodename, "/pseudo/md@0:%lu,%lu,blk",
                    MD_MIN2SET(mnum), MD_MIN2UNIT(mnum));
                hdl = di_devlink_init(nodename, DI_MAKE_LINK);
        }

        if (hdl != NULL) {
                (void) di_devlink_fini(&hdl);
                return (0);
        }

        return (-1);
}

/*
 * update_locator_namespace -- Contains the ioctl call that will update
 *              the ctds and pathname (ie. /dev/dsk etc) within the
 *              locator block namespace.
 *
 * RETURN
 *      METADEVADM_ERR          ioctl failed and ep is updated with the error
 *      METADEVADM_SUCCESS      success
 */
static int
update_locator_namespace(
        set_t           setno,
        side_t          sideno,
        char            *devname,
        md_dev64_t      dev,
        char            *pname,
        md_error_t      *ep
)
{
        mdnm_params_t   nm;

        (void) memset(&nm, '\0', sizeof (nm));
        nm.mde = mdnullerror;
        nm.setno = setno;
        nm.side = sideno;
        nm.devname = (uintptr_t)devname;
        nm.devname_len = strlen(devname);
        nm.devt = dev;
        nm.pathname = (uintptr_t)pname;
        nm.pathname_len = strlen(pname);
        if (metaioctl(MD_IOCUPD_LOCNM, &nm, &nm.mde, NULL) != 0) {
                (void) mdstealerror(ep, &nm.mde);
                return (METADEVADM_ERR);
        }
        return (METADEVADM_SUCCESS);
}

/*
 * meta_update_namespace -- Contains the ioctl call that will update the
 *      device name and pathname in the namespace area.
 *
 * RETURN
 *      METADEVADM_ERR          ioctl failed and ep is updated with the error
 *      METADEVADM_SUCCESS      success
 */
int
meta_update_namespace(
        set_t           setno,
        side_t          sideno,
        char            *devname,
        md_dev64_t      dev,
        mdkey_t         key,
        char            *pname,
        md_error_t      *ep
)
{
        mdnm_params_t   nm;

        (void) memset(&nm, '\0', sizeof (nm));
        nm.mde = mdnullerror;
        nm.setno = setno;
        nm.side = sideno;
        nm.devname = (uintptr_t)devname;
        nm.devname_len = strlen(devname);
        nm.mnum = meta_getminor(dev);
        nm.major = meta_getmajor(dev);
        nm.key = key;
        nm.pathname = (uintptr_t)pname;
        nm.pathname_len = strlen(pname);
        if (metaioctl(MD_IOCUPD_NM, &nm, &nm.mde, NULL) != 0) {
                (void) mdstealerror(ep, &nm.mde);
                return (METADEVADM_ERR);
        }
        return (METADEVADM_SUCCESS);
}

/*
 * stripS - Strip s<digits> off the end of the ctds name if it exists
 */
static void
stripS(char *name)
{
        char    *p;

        /* gobble number and 's' */
        p = name + strlen(name) - 1;
        for (; (p > name); --p) {
                if (!isdigit(*p))
                        break;
        }

        if (*p == 's') {
                *p = '\0';
        }
}

/*
 * getdiskname -- to be used when scanning the input from the -u arg.
 *      This routine will strip off input that is anything but cxtxdx.
 *      ie. it will call stripS to get rid of slice info. Will also
 *      strip off /dev/dsk, /dev/rdsk, /dev/ap/dsk, /dev/ap/rdsk,
 *      /dev/did/dsk, or /dev/did/rdsk. The caller will need to free
 *      the return value.
 *
 * RETURN
 *       string that has the disk name in it ie. c0t0d0
 */
static char *
getdiskname(
        char    *name
)
{
        char    *p;
        char    *diskname;

        /* regular device */
        if ((strncmp(name, "/dev/dsk/", strlen("/dev/dsk/")) == 0) &&
            (strchr((p = name + strlen("/dev/dsk/")), '/') == NULL)) {
                diskname = Strdup(p);
                stripS(diskname);
                return (diskname);
        }

        if ((strncmp(name, "/dev/rdsk/", strlen("/dev/rdsk/")) == 0) &&
            (strchr((p = name + strlen("/dev/rdsk/")), '/') == NULL)) {
                diskname = Strdup(p);
                stripS(diskname);
                return (diskname);
        }

        if ((strncmp(name, "/dev/ap/dsk/", strlen("/dev/ap/dsk/")) == 0) &&
            (strchr((p = name + strlen("/dev/ap/dsk/")), '/') == NULL)) {
                diskname = Strdup(p);
                stripS(diskname);
                return (diskname);
        }

        if ((strncmp(name, "/dev/ap/rdsk/", strlen("/dev/ap/rdsk/")) == 0) &&
            (strchr((p = name + strlen("/dev/ap/rdsk/")), '/') == NULL)) {
                diskname = Strdup(p);
                stripS(diskname);
                return (diskname);
        }

        if ((strncmp(name, "/dev/did/dsk/", strlen("/dev/did/dsk/")) == 0) &&
            (strchr((p = name + strlen("/dev/did/dsk/")), '/') == NULL)) {
                diskname = Strdup(p);
                stripS(diskname);
                return (diskname);
        }

        if ((strncmp(name, "/dev/did/rdsk/", strlen("/dev/did/rdsk/")) == 0) &&
            (strchr((p = name + strlen("/dev/did/rdsk/")), '/') == NULL)) {
                diskname = Strdup(p);
                stripS(diskname);
                return (diskname);
        }

        diskname = Strdup(name);
        stripS(diskname);
        return (diskname);
}

/*
 * has_devid -- return the device ID for a given key
 *
 * RETURN
 *      NULL    error
 *      devid   devid found that corresponds to the given key.
 */
static ddi_devid_t
has_devid(set_t setno, side_t sideno,  mdkey_t key, md_error_t *ep)
{
        return (meta_getdidbykey(setno, sideno, key, ep));
}

/*
 * Go through the existing list of replicas and check to see
 * if their disk has moved, if so update the replica list
 *
 * RETURN
 *      -1      error
 *       0      success
 */
static int
fix_replicanames(
        mdsetname_t     *sp,
        md_error_t      *ep
)
{
        md_replicalist_t        *rlp = NULL;
        md_replicalist_t        *rl;
        int                     ret = -1;
        int                     match_type = 0;
        devid_nmlist_t          *disklist = NULL;
        dev_t                   small_dev = (dev_t)NODEV;
        side_t                  sideno;
        set_t                   setno = sp->setno;
        char                    *search_path;
        int                     search_number;
        char                    *ctds_name;
        char                    *path_name;
        int                     i;

        sideno = getmyside(sp, ep);
        if (sideno == MD_SIDEWILD) {
                mda_debug("Failed to find the side number\n");
                return (-1);
        }

        if (metareplicalist(sp, MD_BASICNAME_OK | PRINT_FAST, &rlp, ep) < 0) {
                mda_debug("Unable to get a list of replicas\n");
                return (METADEVADM_ERR);
        }

        for (rl = rlp; (rl != NULL); rl = rl->rl_next) {
                md_replica_t    *r = rl->rl_repp;

                small_dev = meta_cmpldev(r->r_namep->dev);
                search_number = mda_findpath(r->r_namep->bname);
                if (search_number == -1) {
                        mda_debug("replica update: invalid path: %s",
                            r->r_namep->bname);
                        continue;
                } else {
                        search_path = plist[search_number].search_path;
                }

                if (r->r_devid == NULL)
                        continue;

                ret = meta_deviceid_to_nmlist(search_path, r->r_devid,
                    r->r_minor_name, &disklist);

                mda_debug("replica update: search_path %s\n", search_path);

                if (ret != 0) {
                        /*
                         * Failed to find the disk, nothing can be done.
                         * The replica will be marked as bad later.
                         */
                        mda_debug("replica update: failed to find disk %s\n",
                            r->r_namep->cname);
                        continue;
                }
                mda_debug("replica update: current %s (%p)\n",
                    r->r_namep->bname, (void *) small_dev);

                /*
                 * Check to see if the returned disk matches the stored one
                 */
                for (i = 0; disklist[i].dev != NODEV; i++) {
                        match_type = 0;

                        mda_debug("replica update: devid list: %s (%p)\n",
                            disklist[i].devname, (void *) disklist[i].dev);

                        if (disklist[i].dev == small_dev) {
                                match_type |= DEV_MATCH;
                        }

                        if (strncmp(r->r_namep->bname, disklist[i].devname,
                            strlen(r->r_namep->bname)) == 0) {
                                match_type |= NAME_MATCH;
                        }

                        /*
                         * break out if some sort of match is found because
                         * we already match on the devid.
                         */
                        if (match_type != 0)
                                break;
                }

                mda_debug("fix_replicanames: match: %x i: %d\n", match_type, i);

                if (match_type == (DEV_MATCH|NAME_MATCH)) {
                        /* no change */
                        mda_debug("replica update: no change %s\n",
                            disklist[i].devname);
                        devid_free_nmlist(disklist);
                        continue;
                }

                /* No match found - use the first entry in disklist */
                if (disklist[i].dev == NODEV)
                        i = 0;

                mda_debug("replica update: reloading %s %p\n",
                    disklist[i].devname,
                    (void *)(uintptr_t)meta_expldev(disklist[i].dev));

                if (firsttime) {
                        mda_print(dgettext(TEXT_DOMAIN,
                            "Disk movement detected\n"));
                        mda_print(dgettext(TEXT_DOMAIN,
                            "Updating device names in Solaris Volume "
                            "Manager\n"));
                        firsttime = 0;
                }

                if (dev_options & DEV_VERBOSE) {
                        char    *devidstr;

                        devidstr =
                            devid_str_encode(r->r_devid, r->r_minor_name);
                        if (devidstr == NULL) {
                                mda_print(dgettext(TEXT_DOMAIN,
                                    "Failed to encode the devid\n"));
                                continue;
                        }
                        mda_print(dgettext(TEXT_DOMAIN,
                            "%s changed to %s from device relocation "
                            "information %s\n"),
                            (char *)r->r_namep->cname, disklist[i].devname,
                            devidstr);
                }

                if (!(dev_options & DEV_NOACTION)) {
                        mda_debug("Updating locator name\n");
                        ctds_name = strrchr(disklist[i].devname, '/');
                        ctds_name++;
                        if ((path_name = mda_getpath(disklist[i].devname))
                            == NULL) {
                                continue;
                        }
                        if (update_locator_namespace(setno, sideno,
                            ctds_name, meta_expldev(disklist[i].dev),
                            path_name, ep) != 0) {
                                mda_debug("replica update: ioctl failed\n");
                                if (dev_options & DEV_VERBOSE) {
                                        mda_print(dgettext(TEXT_DOMAIN,
                                            "Failed to update locator "
                                            "namespace on change from %s "
                                            "to %s\n"), ctds_name,
                                            disklist[i].devname);
                                }
                        }
                }
                Free(path_name);
                devid_free_nmlist(disklist);
        }
        metafreereplicalist(rlp);
        return (0);
}

/*
 * pathname_reload - main function for the -r option. Will reload the
 *      pathname in both the main namespace and the locator namespace.
 *      Also, checks both areas for invalid device ID's and prints them
 *      out.
 *
 *    If the set is a multi-node diskset that means there are no devid's
 *    so just return.
 *
 * RETURN
 *      METADEVADM_ERR          error
 *      METADEVADM_SUCCESS      success
 *      METADEVADM_DEVIDINVALID success, but invalid devids detected
 */
int
pathname_reload(
        mdsetname_t             **spp,
        set_t                   setno,
        md_error_t              *ep)
{
        char                    *drvnmp;
        minor_t                 mnum = 0;
        md_dev64_t              dev = 0;
        mdnm_params_t           nm;
        char                    *ctds_name;
        ddi_devid_t             devidp;
        md_i_didstat_t          ds;
        side_t                  sideno;
        char                    *search_path = NULL;
        int                     search_number;
        devid_nmlist_t          *disklist = NULL;
        char                    *minor_name = NULL;
        char                    *devidstr = NULL;
        char                    *path = NULL;
        int                     ret;
        dev_t                   small_dev = (dev_t)NODEV;
        int                     match_type;
        char                    *tmp = NULL;
        mdsetname_t             *sp = *spp;
        md_set_desc             *sd;
        int                     i;

        /*
         * Check for multi-node diskset and return if it is one.
         */
        if (!metaislocalset(sp)) {
                if ((sd = metaget_setdesc(sp, ep)) == NULL)
                        return (METADEVADM_ERR);

                if (MD_MNSET_DESC(sd))
                        return (METADEVADM_SUCCESS);
        }

        /*
         * Get the entry of the namespace via the key. To do this
         * call MD_IOCNXTKEY until no more.
         * For each entry in the namespace we want to check
         * for devid and update
         */

        (void) memset(&nm, '\0', sizeof (nm));
        nm.key = MD_KEYWILD;

        sideno = getmyside(*spp, ep);
        if (sideno == MD_SIDEWILD) {
                /* failed to find this node in the set */
                mda_debug("Failed to find the side number\n");
                return (METADEVADM_ERR);
        }

        /* LINTED */
        while (1) {
                nm.mde  = mdnullerror;
                nm.setno = setno;
                nm.side = sideno;
                /* look at each key in the namespace */
                if (metaioctl(MD_IOCNXTKEY_NM, &nm, &nm.mde, NULL) != 0) {
                        (void) mdstealerror(ep, &nm.mde);
                        return (METADEVADM_ERR);
                }

                if (nm.key == MD_KEYWILD) {
                        /* no more entries */
                        break;
                }

                /*
                 * get the nm entry using the key. Then check to see if
                 * there's a devid associated with this entry
                 * If not, go onto next key.
                 */
                if ((nm.devname = (uintptr_t)meta_getnmentbykey(setno, sideno,
                    nm.key, &drvnmp, &mnum, &dev, ep)) == NULL) {
                        mda_debug("pathname_reload: no name for key: %d\n",
                            nm.key);
                        continue;
                }

                mda_debug("pathname_reload: examining %s\n",
                    (char *)(uintptr_t)nm.devname);

                if ((devidp = has_devid(setno, sideno, nm.key, ep)) == NULL) {
                        /* metadevices do not have devid's in them */
                        mda_debug("pathname_reload: no devid for %s\n",
                            (char *)(uintptr_t)nm.devname);
                        /* Clear error if no devid and go to next nm entry */
                        mdclrerror(ep);
                        continue;
                }

                if ((minor_name = meta_getdidminorbykey(setno, sideno,
                    nm.key, ep)) == NULL) {
                        /*
                         * In theory this is impossible because if the
                         * devidp is non-null then the minor_name has
                         * already been looked up.
                         */
                        mda_debug("No minor name for %s\n",
                            (char *)(uintptr_t)nm.devname);
                        free(devidp);
                        continue;
                }
                /*
                 * If there is a devid then we have a real device that
                 * could have moved.
                 */
                devidstr = devid_str_encode(devidp, minor_name);
                if (devidstr == NULL) {
                        mda_debug("Failed to encode the devid\n");
                        free(devidp);
                        continue;
                }
                mda_debug("devid: %s\n", devidstr);

                /*
                 * Find the search path that should be used. This is an
                 * optimization to try and prevent a search for the complete
                 * /dev namespace.
                 */
                search_number = mda_findpath((char *)(uintptr_t)nm.devname);
                if (search_number == -1) {
                        search_path = "/dev";
                } else {
                        search_path = plist[search_number].search_path;
                }

                /* now look for the disk name using the devid */
                ret = meta_deviceid_to_nmlist(search_path, devidp,
                    minor_name, &disklist);
                free(devidp);

                if (ret != 0) {
                        /*
                         * Failed to find the disk
                         */
                        devid_str_free(devidstr);
                        continue;
                }

                small_dev = meta_cmpldev(dev);
                mda_debug("Old device lookup: %s (%p)\n",
                    (char *)(uintptr_t)nm.devname, (void *)small_dev);

                /*
                 * Check to see if the returned disk matches the stored one
                 */
                for (i = 0; disklist[i].dev != NODEV; i++) {
                        match_type = 0;
                        mda_debug("From devid lookup: %s (%p)\n",
                            (char *)disklist[i].devname,
                            (void *)disklist[i].dev);

                        if (disklist[i].dev == small_dev) {
                                match_type |= DEV_MATCH;
                        }

                        if (strncmp((char *)(uintptr_t)nm.devname,
                            disklist[i].devname,
                            strlen((char *)(uintptr_t)nm.devname)) == 0) {
                                mda_debug("Name match: %s and %s (%d)\n",
                                    disklist[i].devname,
                                    (char *)(uintptr_t)nm.devname,
                                    strlen((char *)(uintptr_t)nm.devname));
                                match_type |= NAME_MATCH;
                        }

                        if (match_type == (DEV_MATCH|NAME_MATCH))
                                break;
                }

                if (match_type == (DEV_MATCH|NAME_MATCH)) {
                        /* no change */
                        devid_str_free(devidstr);
                        mda_debug("All matched %s\n", disklist[i].devname);
                        devid_free_nmlist(disklist);
                        continue;
                }

                /* No match found - use the first entry in disklist */
                i = 0;

                if (firsttime) {
                        mda_print(dgettext(TEXT_DOMAIN,
                            "Disk movement detected\n"));
                        mda_print(dgettext(TEXT_DOMAIN,
                            "Updating device names in "
                            "Solaris Volume Manager\n"));
                        firsttime = 0;
                }
                if (dev_options & DEV_VERBOSE) {
                        mda_print(dgettext(TEXT_DOMAIN,
                            "%s changed to %s from device relocation "
                            "information %s\n"),
                            (char *)(uintptr_t)nm.devname, disklist[i].devname,
                            devidstr);
                }
                devid_str_free(devidstr);

                /* need to build up the path of the disk */
                if ((path = Strdup(disklist[i].devname)) == NULL) {
                        mda_debug("Failed to duplicate path: %s\n",
                            disklist[i].devname);
                        devid_free_nmlist(disklist);
                        continue;
                }
                if ((tmp = strrchr(path, '/')) == NULL) {
                        mda_debug("Failed to parse %s\n", path);
                        devid_free_nmlist(disklist);
                        Free(path);
                        continue;
                }
                tmp += sizeof (char);
                *tmp = '\0';

                if ((ctds_name = strrchr(disklist[i].devname, '/')) == NULL) {
                        mda_debug("Failed to parse ctds name: %s\n",
                            disklist[i].devname);
                        devid_free_nmlist(disklist);
                        Free(path);
                        continue;
                }
                ctds_name += sizeof (char);

                mda_debug("Reloading disk %s %s %p\n",
                    ctds_name, path,
                    (void *)(uintptr_t)meta_expldev(disklist[i].dev));

                if (!(dev_options & DEV_NOACTION)) {
                        /* Something has changed so update the namespace */
                        if (meta_update_namespace(setno, sideno, ctds_name,
                            meta_expldev(disklist[i].dev), nm.key, path,
                            ep) != 0) {
                                mda_debug("Failed to update namespace\n");
                                if (dev_options & DEV_VERBOSE) {
                                        mda_print(dgettext(TEXT_DOMAIN,
                                            "Failed to update namespace on "
                                            "change from %s to %s\n"),
                                            ctds_name, disklist[i].devname);
                                }
                        }
                }
                devid_free_nmlist(disklist);
                Free(path);
        }

        if (fix_replicanames(*spp, ep) == -1)
                mda_debug("Failed to update replicas\n");

        /*
         * check for invalid device id's
         */
        (void) memset(&ds, '\0', sizeof (ds));
        ds.setno = setno;
        ds.side = sideno;
        ds.mode = MD_FIND_INVDID;
        /* get count of number of invalid device id's */
        if (metaioctl(MD_IOCDID_STAT, &ds, &ds.mde, NULL) != 0) {
                (void) mdstealerror(ep, &ds.mde);
                return (METADEVADM_ERR);
        }
        if (ds.cnt != 0) {
                char    *ctdptr, *ctdp;
                /*
                 * we have some invalid device id's so we need to
                 * print them out
                 */
                ds.mode = MD_GET_INVDID;
                /* malloc buffer for kernel to place devid list into */
                if ((ctdptr = (char *)Malloc((ds.cnt * ds.maxsz) + 1)) == 0) {
                        return (METADEVADM_ERR);
                }
                ds.ctdp = (uintptr_t)ctdptr;
                /* get actual list of invalid device id's */
                if (metaioctl(MD_IOCDID_STAT, &ds, &ds.mde, NULL) != 0) {
                        Free(ctdptr);
                        (void) mdstealerror(ep, &ds.mde);
                        return (METADEVADM_ERR);
                }

                /* print out the invalid devid's */
                mda_print(dgettext(TEXT_DOMAIN,
                    "Invalid device relocation information "
                    "detected in Solaris Volume Manager\n"));
                mda_print(dgettext(TEXT_DOMAIN,
                    "Please check the status of the following disk(s):\n"));
                ctdp = (char *)(uintptr_t)ds.ctdp;
                while (*ctdp != NULL) {
                        mda_print("\t%s\n", ctdp);
                        ctdp += ds.maxsz;
                }
                Free(ctdptr);
                return (METADEVADM_DEVIDINVALID);
        }
        return (METADEVADM_SUCCESS);
}

/*
 * replica_update_devid - cycle through the replica list, rlp, and
 *  update the device ids on all of the replicas that are on the
 *  device specified by lp. A side effect is to update the value of
 *  cdevidpp to contain the character representation of the device
 *  id before updating if it is not already set.
 *
 * RETURN
 *      METADEVADM_ERR          error
 *      METADEVADM_SUCCESS      success
 */
static int
replica_update_devid(
        md_replicalist_t *rlp,
        mddrivename_t   *dnp,
        set_t           setno,
        char            **cdevidpp,
        md_error_t      *ep
)
{
        mddb_config_t           db_c;
        md_replicalist_t        *rl;
        ddi_devid_t             devidp;
        int                     ret;

        if (cdevidpp == NULL)
                return (METADEVADM_ERR);

        ret = devid_str_decode(dnp->devid, &devidp, NULL);
        if (ret != 0) {
                /* failed to encode the devid */
                mda_debug("Failed to decode %s into a valid devid\n",
                    dnp->devid);
                return (METADEVADM_ERR);
        }

        /* search replica list for give ctd name */
        for (rl = rlp; (rl != NULL); rl = rl->rl_next) {
                md_replica_t    *r = rl->rl_repp;
                mdname_t        *rnp = r->r_namep;

                if (strncmp(rnp->cname, dnp->cname, strlen(dnp->cname)) == 0) {

                        /* found the replica, now grab the devid */
                        if (*cdevidpp == NULL) {
                                *cdevidpp = devid_str_encode(r->r_devid, NULL);
                        }

                        if (*cdevidpp == NULL) {
                                devid_free(devidp);
                                return (METADEVADM_ERR);
                        }

                        mda_debug("Updating replica %s, set %d, old devid %s\n",
                            rnp->cname, setno, *cdevidpp);

                        if (dev_options & DEV_VERBOSE) {
                                mda_print(dgettext(TEXT_DOMAIN,
                                    "Updating replica %s of set number %d from "
                                    "device id %s to device id %s\n"),
                                    rnp->cname, setno, *cdevidpp, dnp->devid);
                        }

                        (void) memset(&db_c, '\0', sizeof (db_c));

                        db_c.c_setno = setno;
                        db_c.c_devt = rnp->dev;

                        if (!(dev_options & DEV_NOACTION)) {

                                mda_debug("Updating replica\n");

                                /*
                                 * call into kernel to update lb
                                 * namespace device id
                                 * of given devt
                                 */
                                if (metaioctl(MD_DB_SETDID, &db_c,
                                    &db_c.c_mde, NULL) != 0) {
                                        devid_free(devidp);
                                        (void) mdstealerror(ep, &db_c.c_mde);
                                        return (METADEVADM_ERR);
                                }
                        }

                }
        }
        devid_free(devidp);
        return (METADEVADM_SUCCESS);
}

/*
 * devid_update -- main routine for the -u option. Will update both the
 *      namespace and the locator block with the correct devid for the
 *      disk specified.
 *
 * RETURN
 *      METADEVADM_ERR          error
 *      METADEVADM_SUCCESS      success
 */
static int
devid_update(
        mdsetname_t     **spp,
        set_t           setno,
        char            *ctd,
        md_error_t      *ep
)
{
        md_drive_desc           *dd, *ddp;
        mddrivename_t           *dnp;
        mdnm_params_t           nm;
        ddi_devid_t             devidp;
        side_t                  side;
        char                    *old_cdevidp = NULL;
        md_replicalist_t        *rlp = NULL;
        int                     rval = METADEVADM_ERR;
        mdname_t                *np = NULL;
        uint_t                  rep_slice;
        char                    *pathname = NULL;
        char                    *diskname = NULL;
        int                     fd = -1;
        int                     len;
        char                    *fp;

        side = getmyside(*spp, ep);
        if (side == MD_SIDEWILD) {
                /* failed to find this node in the set */
                mda_debug("Failed to find the side number\n");
                return (METADEVADM_ERR);
        }

        if ((dnp = metadrivename(spp, ctd, ep)) == NULL) {
                mda_debug("Failed to create a dnp for %s\n", ctd);
                return (METADEVADM_ERR);
        }
        if (dnp->devid == NULL) {
                /*
                 * Disk does not have a devid! So cannot update the
                 * devid within the replica.
                 */
                mda_debug("%s does not have a devid\n", dnp->cname);
                if (dev_options & DEV_VERBOSE) {
                        mda_print(dgettext(TEXT_DOMAIN,
                            "%s does not have a device id. Cannot update "
                            "device id if none exists\n"), ctd);
                }
                return (METADEVADM_ERR);
        }

        mda_debug("Devid update to: %s\n", dnp->devid);

        /*
         * Check if we own the set, if we do then do some processing
         * on the replicas.
         */
        if (meta_check_ownership(*spp, ep) == 0) {

                /* get the replicas */
                if (metareplicalist(*spp, MD_BASICNAME_OK | PRINT_FAST, &rlp,
                    ep) < 0)
                        return (METADEVADM_ERR);

                /* update the devids in the replicas if necessary */
                if (replica_update_devid(rlp, dnp, setno, &old_cdevidp,
                    ep) != METADEVADM_SUCCESS) {
                        metafreereplicalist(rlp);
                        return (METADEVADM_ERR);
                }

                metafreereplicalist(rlp);
        }

        /*
         * If this is not the LOCAL set then need to update the LOCAL
         * replica with the new disk record.
         */

        if (setno != MD_LOCAL_SET) {
                mda_debug("Non-local set: %d side %d\n", setno, side);

                /*
                 * Need to find the disk record within the set and then
                 * update it.
                 */
                if ((dd =
                    metaget_drivedesc(*spp, MD_FULLNAME_ONLY, ep)) == NULL) {
                        if (! mdisok(ep))
                                goto out;
                        /* no disks in the set - no point continuing */
                        mda_debug("No disks in diskset\n");
                        rval = METADEVADM_SUCCESS;
                        goto out;
                }

                for (ddp = dd; ddp != NULL; ddp = ddp->dd_next) {
                        if (strncmp(ddp->dd_dnp->cname, dnp->cname,
                            strlen(dnp->cname)) == 0)
                                break;
                }

                if (ddp == NULL) {
                        /* failed to finddisk in the set */
                        mda_print(dgettext(TEXT_DOMAIN,
                            "%s not found in set %s. Check your syntax\n"),
                            ctd, (*spp)->setname);
                        (void) mddserror(ep, MDE_DS_DRIVENOTINSET, setno, NULL,
                            ctd, (*spp)->setname);
                        goto out;
                }

                /*
                 * Now figure out the correct slice, for a diskset the slice
                 * we care about is always the 'replica' slice.
                 */
                if (meta_replicaslice(dnp, &rep_slice, ep) != 0) {
                        mda_debug("Unable to find replica slice for %s\n",
                            dnp->cname);
                        goto out;
                }

                mda_debug("slice no: %d disk %s\n", rep_slice, dnp->cname);

                if ((np = metaslicename(dnp, rep_slice, ep)) == NULL) {
                        mda_debug("Unable to build namespace\n");
                        goto out;
                }

                mda_debug("check: ctdname: %s\n", np->cname);
                mda_debug("check: ctdname: %s\n", np->rname);
                mda_debug("check: ctdname: %s\n", np->bname);

                if (!(dev_options & DEV_NOACTION)) {

                        mda_debug("Updating record: key %d name %s\n",
                            ddp->dd_dnp->side_names_key, np->cname);

                        pathname = mda_getpath(np->bname);

                        if (meta_update_namespace(MD_LOCAL_SET, side + SKEW,
                            np->cname, np->dev, ddp->dd_dnp->side_names_key,
                            pathname, ep) != 0) {
                                goto out;
                        }

                        /*
                         * Now update the devid entry as well, this works
                         * correctly because the prior call to
                         * meta_update_namespace() above puts the correct dev_t
                         * in the namespace which will then be resolved
                         * to the new devid by the ioctl now called.
                         */
                        nm.mde = mdnullerror;
                        nm.setno = MD_LOCAL_SET;
                        nm.side = side + SKEW;
                        nm.key = ddp->dd_dnp->side_names_key;
                        if (metaioctl(MD_SETNMDID, &nm, &nm.mde, NULL) != 0) {
                                (void) mdstealerror(ep, &nm.mde);
                                goto out;
                        }
                }
        }

        if ((dev_options & DEV_LOCAL_SET) && (setno != MD_LOCAL_SET)) {
                /*
                 * Only want to update the local set so do not continue.
                 */
                rval = METADEVADM_SUCCESS;
                goto out;
        }

        /*
         * Iterate through all of the metadevices looking for the
         * passed in ctd.  If found then update the devid
         */
        (void) memset(&nm, '\0', sizeof (nm));
        nm.key = MD_KEYWILD;
        /* LINTED */
        while (1) {
                nm.mde = mdnullerror;
                nm.setno = setno;
                nm.side = side;

                /* search each namespace entry */
                if (metaioctl(MD_IOCNXTKEY_NM, &nm, &nm.mde, NULL) != 0) {
                        (void) mdstealerror(ep, &nm.mde);
                        rval = METADEVADM_ERR;
                        goto out;
                }
                if (nm.key == MD_KEYWILD) {
                        if (setno != MD_LOCAL_SET) {
                                mda_print(dgettext(TEXT_DOMAIN,
                                    "%s not found in set %s. Check your "
                                    "syntax\n"), ctd, (*spp)->setname);
                                goto out;
                        } else {
                                mda_print(dgettext(TEXT_DOMAIN,
                                    "%s not found in local set. "
                                    "Check your syntax\n"), ctd);
                                goto out;
                        }
                }

                nm.devname = (uintptr_t)meta_getnmentbykey(setno, side, nm.key,
                    NULL, NULL, NULL, ep);
                if (nm.devname == NULL) {
                        rval = METADEVADM_ERR;
                        goto out;
                }

                diskname = getdiskname((char *)(uintptr_t)nm.devname);

                mda_debug("Checking %s with %s\n", diskname, dnp->cname);
                if (strcmp(diskname, dnp->cname) != 0)
                        continue;

                mda_debug("Updating device %s in namespace\n",
                    (char *)(uintptr_t)nm.devname);

                /*
                 * found disk, does it have a devid within the namespace ?
                 * It might not because it does not support devid's or was
                 * put into the namespace when there was no devid support
                 */
                if ((devidp = has_devid(setno, side, nm.key, ep)) == NULL) {
                        mda_debug("%s has no devid in the namespace",
                            (char *)(uintptr_t)nm.devname);
                        if (dev_options & DEV_VERBOSE) {
                                mda_print(dgettext(TEXT_DOMAIN,
                                    "SVM has no device id for "
                                    "%s, cannot update.\n"),
                                    (char *)(uintptr_t)nm.devname);
                        }
                        continue; /* no devid. go on to next */
                }
                if (old_cdevidp == NULL) {
                        old_cdevidp = devid_str_encode(devidp, NULL);
                }
                free(devidp);

                /*
                 * has devid so update namespace, note the key has been set
                 * by the prior MD_IOCNXTKEY_NM ioctl.
                 */
                nm.mde = mdnullerror;
                nm.setno = setno;
                nm.side = side;
                if (!(dev_options & DEV_NOACTION)) {
                        /*
                         * The call below may fail if the -u option is being
                         * used to update a disk that has been replaced.
                         * The -u option to metadevadm should not be used
                         * for this purpose because we trust the dev_t of
                         * the device in the replica and if we have replaced
                         * the device and it is a fibre one then the dev_t
                         * will have changed. This means we end up looking for
                         * the devid of a non-existant disk and we subsequently
                         * fail with NODEVID.
                         */
                        if (metaioctl(MD_SETNMDID, &nm,
                            &nm.mde, NULL) != 0) {
                                if (dev_options & DEV_VERBOSE) {
                                        mda_print(dgettext(TEXT_DOMAIN,
                                            "SVM failed to update the device "
                                            "id for %s probably due to both "
                                            "devt and device id changing.\n"),
                                            (char *)(uintptr_t)nm.devname);
                                }
                                (void) mdstealerror(ep, &nm.mde);
                                mde_perror(ep, "");
                                rval = METADEVADM_ERR;
                                goto out;
                        }
                }
                if (old_cdevidp == NULL) {
                        rval = METADEVADM_ERR;
                        goto out;
                }
                break;
        } /* end while */

        mda_print(dgettext(TEXT_DOMAIN,
            "Updating Solaris Volume Manager device relocation "
            "information for %s\n"), ctd);

        mda_print(dgettext(TEXT_DOMAIN,
            "Old device reloc information:\n\t%s\n"), old_cdevidp);

        len = strlen(dnp->rname) + strlen("s0");
        if ((fp = (char *)Malloc(len + 1)) == NULL) {
                mda_print(dgettext(TEXT_DOMAIN,
                    "insufficient memory, device Reloc info not "
                    "available\n"));
        } else {
                (void) snprintf(fp, len + 1, "%ss0", dnp->rname);
                if ((fd = open(fp, O_RDONLY|O_NDELAY)) < 0) {
                        mda_print(dgettext(TEXT_DOMAIN,
                            "Open of %s failed\n"), fp);
                } else {
                        int             rc = -1;
                        ddi_devid_t     devid1 = NULL;
                        char            *cdevidp;

                        rc = devid_get(fd, &devid1);
                        if (close(fd) < 0) {
                                mda_print(dgettext(TEXT_DOMAIN,
                                    "Close of %s failed\n"), fp);
                        }
                        if (rc != 0) {
                                mda_print(dgettext(TEXT_DOMAIN,
                                    "Unable to obtain device "
                                    "Reloc info for %s\n"), fp);
                        } else {
                                cdevidp = devid_str_encode(devid1, NULL);
                                if (cdevidp == NULL) {
                                        mda_print(dgettext(TEXT_DOMAIN,
                                            "Unable to print "
                                            "device Reloc info for %s\n"), fp);
                                } else {
                                        mda_print(dgettext(TEXT_DOMAIN,
                                            "New device reloc "
                                            "information:\n\t%s\n"), cdevidp);
                                        devid_str_free(cdevidp);
                                }
                                devid_free(devid1);
                        }
                }
                Free(fp);
        }

        rval = METADEVADM_SUCCESS;

out:
        if (diskname)
                Free(diskname);
        if (pathname)
                Free(pathname);
        if (old_cdevidp) {
                devid_str_free(old_cdevidp);
        }
        return (rval);

}

/*
 * Check the ctd name of the disk to see if the disk has moved. If it
 * has moved then the newname is returned in 'newname', it is up to
 * the caller to free the memory associated with it.
 *
 * RETURN
 *      METADEVADM_ERR          error
 *      METADEVADM_SUCCESS      success
 *      METADEVADM_DISKMOVE     success, and the disk has moved
 *      METADEVADM_DSKNAME_ERR  error creating the disk name structures.
 */
int
meta_upd_ctdnames(
        mdsetname_t     **spp,
        set_t           setno,
        side_t          sideno,
        mddrivename_t   *dnp,
        char            **newname,
        md_error_t      *ep
)
{
        char            *drvnmp;
        int             i;
        minor_t         mnum = 0;
        md_dev64_t      dev = 0;
        dev_t           small_dev = (dev_t)NODEV;
        mdnm_params_t   nm;
        char            *pathname;
        char            *minor_name = NULL;
        ddi_devid_t     devidp;
        devid_nmlist_t  *disklist = NULL;
        int             ret = 0;
        mdsidenames_t   *snp;
        int             match_type;
        int             search_number = -1;
        char            *search_type = NULL;
        char            *search_path = NULL;
        uint_t          rep_slice;
        mddrivename_t   *newdnp;
        mdname_t        *np;
        mdsetname_t     *sp = *spp;
        md_set_desc     *sd;

        /*
         * setno should always be 0 but we're going to
         * check for multi-node diskset and return if it is one.
         */
        if (!metaislocalset(sp)) {
                if ((sd = metaget_setdesc(sp, ep)) == NULL)
                        return (METADEVADM_ERR);

                if (MD_MNSET_DESC(sd))
                        return (METADEVADM_SUCCESS);
        }

        if (dnp->devid == NULL) {
                /* no devid, nothing can be done */
                mda_debug("meta_upd_ctdnames: %s has no devid\n", dnp->cname);
                if (dev_options & DEV_VERBOSE) {
                        mda_print(dgettext(TEXT_DOMAIN,
                            "%s has no devid, cannot detect "
                            "disk movement for this disk.\n"), dnp->cname);
                }
                return (ret);
        }

        /*
         * Find the correct side name for the disk. There is a sidename
         * for each host associated with the diskset.
         */
        for (snp = dnp->side_names; snp != NULL; snp = snp->next) {
                mda_debug("meta_upd_ctdnames: %s %d args: setno %d sideno %d\n",
                    snp->cname, snp->sideno, setno, sideno);
                /* only use SKEW for the local replica */
                if (setno == 0) {
                        if (snp->sideno + SKEW == sideno)
                                break;
                } else {
                        if (snp->sideno == sideno)
                                break;
                }
        }

        if (snp == NULL) {
                /*
                 * Failed to find the side name, this should not
                 * be possible. However if it does happen this is an
                 * indication of an inconsistant replica - something
                 * might have gone wrong during an add or a delete of
                 * a host.
                 */
                mda_debug("Unable to find the side information for disk %s",
                    dnp->cname);
                (void) mddserror(ep, MDE_DS_HOSTNOSIDE, (*spp)->setno, mynode(),
                    NULL, dnp->cname);
                return (METADEVADM_ERR);
        }
        /*
         * Find the type of device we are to be searching on
         */
        search_number = mda_findpath(snp->cname);
        if (search_number == -1) {
                search_path = "/dev";
                search_type = DEVID_MINOR_NAME_ALL;
        } else {
                search_path = plist[search_number].search_path;
                search_type = plist[search_number].search_type;
        }

        mda_debug("Search path :%s searth_type: %x\n",
            search_path, (int)search_type);
        (void) memset(&nm, '\0', sizeof (nm));

        nm.mde = mdnullerror;
        nm.setno = setno;
        nm.side = sideno;

        /*
         * Get the devname from the name space.
         */
        if ((nm.devname = (uintptr_t)meta_getnmentbykey(setno, sideno,
            dnp->side_names_key, &drvnmp, &mnum, &dev, ep)) == NULL) {
                return (METADEVADM_ERR);
        }

        ret = devid_str_decode(dnp->devid, &devidp, &minor_name);
        devid_str_free(minor_name);

        if (ret != 0) {
                /*
                 * Failed to encode the devid.
                 */
                devid_free(devidp);
                return (METADEVADM_ERR);
        }

        /*
         * Use the stored devid to find the existing device node and check
         * to see if the disk has moved. Use the raw devices as the name
         * of the disk is stored as the raw device, if this is not done
         * then the disk will not be found.
         */
        ret = meta_deviceid_to_nmlist(search_path, devidp,
            search_type, &disklist);

        if (ret != 0) {
                if (dev_options & DEV_VERBOSE) {
                        mda_print(dgettext(TEXT_DOMAIN,
                            "Device ID %s last associated with "
                            "disk %s no longer found in system\n"),
                            dnp->devid, dnp->cname);
                }
                devid_free(devidp);
                devid_free_nmlist(disklist);
                return (METADEVADM_SUCCESS);
        }

        small_dev = meta_cmpldev(dev);
        mda_debug("Old device lookup: %s (%p)\n",
            (char *)(uintptr_t)nm.devname, (void *)small_dev);
        /*
         * Check to see if the returned disk matches the stored one
         */
        for (i = 0; disklist[i].dev != NODEV; i++) {
                match_type = 0;
                mda_debug("From devid lookup: %s (%p)\n",
                    disklist[i].devname, (void *)disklist[i].dev);

                if (disklist[i].dev == small_dev) {
                        match_type |= DEV_MATCH;
                }

                if (strncmp((char *)(uintptr_t)nm.devname, disklist[i].devname,
                    strlen((char *)(uintptr_t)nm.devname)) == 0) {
                        match_type |= NAME_MATCH;
                }

                if (match_type != 0)
                        break;
        }
        devid_free(devidp);

        mda_debug("meta_upd_ctdnames: match: %x i: %d\n", match_type, i);

        if (match_type == (DEV_MATCH|NAME_MATCH)) {
                /* no change */
                devid_free_nmlist(disklist);
                return (METADEVADM_SUCCESS);
        }

        /* No match found - use the first entry in disklist */
        if (disklist[i].dev == NODEV)
                i = 0;

        if (!(match_type & DEV_MATCH)) {
                /* did not match on the dev, so dev_t has changed */
                mda_debug("Did not match on dev: %p %p\n",
                    (void *) small_dev, (void *) disklist[i].dev);
                dev = meta_expldev(disklist[i].dev);
        }

        if (!(match_type & NAME_MATCH)) {
                mda_debug("Did not match on name: %s (%p)\n",
                    (char *)(uintptr_t)nm.devname, (void *) disklist[i].dev);
        }

        /*
         * If here, then the name in the disklist is the one we
         * want in any case so use it.
         */
        mda_debug("devname: %s\n", disklist[i].devname);
        /*
         * Need to remove the slice as metadrivename() expects a diskname
         */
        stripS(disklist[i].devname);
        /*
         * Build an mddrivename_t to use
         */
        if ((newdnp = metadrivename(spp, disklist[i].devname, ep)) == NULL) {
                mda_debug("Unable to make a dnp out of %s\n",
                    disklist[i].devname);
                return (METADEVADM_DSKNAME_ERR);
        }
        /*
         * Need to find the correct slice used for the replica
         */
        if (meta_replicaslice(newdnp, &rep_slice, ep) != 0) {
                return (METADEVADM_DSKNAME_ERR);
        }

        if ((np = metaslicename(newdnp, rep_slice, ep)) == NULL) {
                mda_debug("Failed to build an np for %s\n", dnp->rname);
                return (METADEVADM_DSKNAME_ERR);
        }
        mda_debug("check: cname: %s\n", np->cname);
        mda_debug("check: rname: %s\n", np->rname);
        mda_debug("check: bname: %s\n", np->bname);

        if (newname != NULL)
                *newname = Strdup(np->bname);

        if (!(dev_options & DEV_NOACTION)) {

                mda_debug("update namespace\n");

                /* get the block path */
                pathname = mda_getpath(np->bname);

                if (meta_update_namespace(setno, sideno, np->cname,
                    dev, dnp->side_names_key, pathname, ep) != 0) {
                        /* finished with the list so return the memory */
                        Free(pathname);
                        devid_free_nmlist(disklist);
                        return (METADEVADM_ERR);
                }
        }
        /* finished with the list so return the memory */
        Free(pathname);
        devid_free_nmlist(disklist);
        ret = METADEVADM_DISKMOVE;
        return (ret);
}

int
meta_fixdevid(
        mdsetname_t     *sp,
        mddevopts_t     options,
        char            *diskname,
        md_error_t      *ep
)
{
        set_t           setno = sp->setno;
        int             ret = 0;
        char            *pathname = NULL;
        mdsetname_t     *local_sp = NULL;
        md_drive_desc   *d = NULL;
        char            *newname = NULL;
        md_drive_desc   *dd;
        side_t          sideno;
        md_set_desc     *sd;

        /* if MN diskset just return */
        if (!metaislocalset(sp)) {
                if ((sd = metaget_setdesc(sp, ep)) == NULL) {
                        return (METADEVADM_ERR);
                }
                if (MD_MNSET_DESC(sd))
                        return (METADEVADM_SUCCESS);
        }

        dev_options |= options;
        mda_debug("dev_options: %x\n", dev_options);
        if (dev_options & DEV_RELOAD) {
                /*
                 * If it's not the local set we need to check the local
                 * namespace to see if disks have moved as it contains
                 * entries for the disks in the set.
                 */
                if (setno != MD_LOCAL_SET) {
                        if ((dd = metaget_drivedesc(sp, MD_BASICNAME_OK |
                            PRINT_FAST, ep)) == NULL) {
                                mde_perror(ep, "");
                                mdclrerror(ep);
                                return (METADEVADM_ERR);
                        }
                        local_sp = metasetname(MD_LOCAL_NAME, ep);
                        sideno = getmyside(sp, ep) + SKEW;
                        for (d = dd; d != NULL; d = d->dd_next) {
                                /*
                                 * Actually do the check of the disks.
                                 */
                                ret = meta_upd_ctdnames(&local_sp, 0, sideno,
                                    d->dd_dnp, &newname, ep);

                                if ((ret == METADEVADM_ERR) ||
                                    (ret == METADEVADM_DSKNAME_ERR)) {
                                        /* check failed in unknown manner */
                                        mda_debug("meta_upd_ctdnames failed\n");
                                        return (METADEVADM_ERR);
                                }
                        }
                }

                /* do a reload of the devid namespace */
                ret = pathname_reload(&sp, setno, ep);
        } else if (dev_options & DEV_UPDATE) {
                pathname = getdiskname(diskname);
                ret = devid_update(&sp, setno, pathname, ep);
                free(pathname);
        }
        return (ret);
}