xref: /onnv-gate/usr/src/lib/lvm/libmeta/common/meta_devadm.c (revision 12678:79fad257c978)

/*
 * 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);
}