cmd/stmsboot/stmsboot_util.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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <stropts.h>
#include <strings.h>
#include <sys/param.h>
#include <libdevinfo.h>
#include <locale.h>
#include <libintl.h>
#include <devid.h>
#include <sys/libdevid.h>
#include <sys/modctl.h> /* for MAXMODCONFNAME */
#include <sys/scsi/adapters/scsi_vhci.h>

/*
 * SAVE_DIR is the directory in which system files are saved.
 * SAVE_DIR must be under the root filesystem, as this program is
 * typically run before any other filesystems are mounted.
 */
#define	SAVE_DIR	"/etc/mpxio"
#define	VHCI_CTL_NODE	"/devices/scsi_vhci:devctl"

/* nvlist property names, these are ALL string types */
#define	NVL_DEVID 	"nvl-devid"
#define	NVL_PATH 	"nvl-path"
#define	NVL_PHYSPATH	"nvl-physpath"
#define	NVL_MPXPATH	"nvl-mpxiopath"
#define	NVL_MPXEN	"nvl-mpxioenabled"

#define	MPX_LIST		0x01
#define	MPX_MAP			0x02
#define	MPX_CAPABLE_CTRL	0x04
#define	MPX_INIT		0x08
#define	MPX_PHYSICAL		0x10
#define	MPX_BOOTPATH		0x20
#define	MPX_UPDATEVFSTAB	0x40
#define	MPX_USAGE		0x80
#define	MSG_INFO		0x01
#define	MSG_ERROR		0x02
#define	MSG_PANIC		0x04

#define	BOOT			0x01
#define	NONBOOT			0x00

static di_node_t devinfo_root = DI_NODE_NIL;
static char *ondiskname = "/etc/mpxio/devid_path.cache";

/*
 * We use devid-keyed nvlists to keep track of the guid, traditional and
 * MPxIO-enabled /dev/rdsk paths. Each of these nvlists is eventually
 * added to our global nvlist and our on-disk nvlist.
 */
static nvlist_t *mapnvl;
static int mpxenabled = 0;
static int limctrl = -1;
static int mpxprop = 0;
static int guid = 0;
static char *drvlimit;
static int globarg = 0;
static int debugflag = 0;
static char *devicep;
static int readonlyroot = 0;
static int cap_N_option = 0;

static void print_mpx_capable(di_node_t curnode);
static int popcheck_devnvl(di_node_t thisnode, nvlist_t *devnvl,
    char *strdevid);
static int mpxio_nvl_boilerplate(di_node_t curnode);
static int validate_devnvl();
static void report_map(char *argdev, int physpath);
static void list_devs(int listguids, int ctrl);
static void logmsg(int level, const char *msg, ...);
static char *find_link(di_node_t cnode);
static void usage();
static void parse_args(int argc, char *argv[]);
static void get_devid(di_node_t node, ddi_devid_t *thisdevid);
static int print_bootpath();
static void vhci_to_phci(char *devpath, char *physpath);
static int update_vfstab();

int
main(int argc, char **argv)
{
	struct stat cachestat;
	int mapfd = 0;
	int rv = 0;
	char *ondiskbuf;
	size_t newsz = 0;

	parse_args(argc, argv);
	errno = 0;
	devinfo_root = di_init("/", DINFOCPYALL|DINFOFORCE);
	logmsg(MSG_INFO, "errno = %d after "
	    "di_init(/,DINFOCPYALL|DINFOFORCE)\n", errno);
	if (devinfo_root == NULL) {
		logmsg(MSG_ERROR,
		    gettext("Unable to take device tree snapshot "
		    "(%s: %d)\n"), strerror(errno), errno);
		return (-1);
	}
	logmsg(MSG_INFO, "opened root di_node\n");

	if (globarg == MPX_CAPABLE_CTRL) {
		/* we just want to find MPxIO-capable controllers and exit */
		if (drvlimit != NULL) {
			print_mpx_capable(di_drv_first_node(drvlimit,
			    devinfo_root));
		} else {
			print_mpx_capable(di_drv_first_node("fp",
			    devinfo_root));
			print_mpx_capable(di_drv_first_node("mpt",
			    devinfo_root));
			print_mpx_capable(di_drv_first_node("mpt_sas",
			    devinfo_root));
		}
		di_fini(devinfo_root);
		return (0);
	}

	mapfd = open(ondiskname, O_RDWR|O_CREAT|O_SYNC, S_IRUSR | S_IWUSR);
	if (mapfd < 0) {
		/* we could be in single-user, so try for RO */
		if ((mapfd = open(ondiskname, O_RDONLY)) < 0) {
			logmsg(MSG_ERROR,
			    gettext("Unable to open or create %s:%s\n"),
			    ondiskname, strerror(errno));
			return (errno);
		}
		readonlyroot = 1;
	}

	if (stat(ondiskname, &cachestat) != 0) {
		logmsg(MSG_ERROR,
		    gettext("Unable to stat() %s: %s\n"),
		    ondiskname, strerror(errno));
		return (errno);
	}
	ondiskbuf = calloc(1, cachestat.st_size);
	if (ondiskbuf == NULL) {
		logmsg(MSG_ERROR,
		    gettext("Unable to allocate memory for the devid "
		    "cache file: %s\n"), strerror(errno));
		return (errno);
	}
	rv = read(mapfd, ondiskbuf, cachestat.st_size);
	if (rv != cachestat.st_size) {
		logmsg(MSG_ERROR,
		    gettext("Unable to read all of devid cache file (got %d "
		    "from expected %d bytes): %s\n"),
		    rv, cachestat.st_size, strerror(errno));
		return (errno);
	}
	errno = 0;
	rv = nvlist_unpack(ondiskbuf, cachestat.st_size, &mapnvl, 0);
	if (rv) {
		logmsg(MSG_INFO,
		    "Unable to unpack devid cache file %s: %s (%d)\n",
		    ondiskname, strerror(rv), rv);
		if (nvlist_alloc(&mapnvl, NV_UNIQUE_NAME, 0) != 0) {
			logmsg(MSG_ERROR,
			    gettext("Unable to allocate root property"
			    "list\n"));
			return (errno);
		}
	}
	free(ondiskbuf);

	if (validate_devnvl() < 0) {
		logmsg(MSG_ERROR,
		    gettext("unable to validate kernel with on-disk devid "
		    "cache file\n"));
		return (errno);
	}

	/*
	 * If we're in single-user mode or maintenance mode, we won't
	 * necessarily have a writable root device (ZFSroot; ufs root is
	 * different in that we _do_ have a writable root device.
	 * This causes problems for the devlink calls (see
	 * $SRC/lib/libdevinfo/devinfo_devlink.c) and we do not try to
	 * write out the devnvl if root is readonly.
	 */
	if (!readonlyroot) {
		rv = nvlist_size(mapnvl, &newsz, NV_ENCODE_NATIVE);
		if (rv) {
			logmsg(MSG_ERROR,
			    gettext("Unable to determine size of packed "
			    "on-disk devid cache file %s: %s (%d).\n"),
			    ondiskname, strerror(rv), rv);
			logmsg(MSG_ERROR, gettext("Terminating\n"));
			nvlist_free(mapnvl);
			(void) close(mapfd);
			return (rv);
		}

		if ((ondiskbuf = calloc(1, newsz)) == NULL) {
			logmsg(MSG_ERROR,
			    "Unable to allocate space for writing out new "
			    "on-disk devid cache file: %s\n", strerror(errno));
			(void) close(mapfd);
			nvlist_free(mapnvl);
			return (errno);
		}

		rv = nvlist_pack(mapnvl, &ondiskbuf, &newsz,
		    NV_ENCODE_NATIVE, 0);
		if (rv) {
			logmsg(MSG_ERROR,
			    gettext("Unable to pack on-disk devid cache "
			    "file: %s (%d)\n"), strerror(rv), rv);
			(void) close(mapfd);
			free(ondiskbuf);
			nvlist_free(mapnvl);
			return (rv);
		}

		rv = lseek(mapfd, 0, 0);
		if (rv == -1) {
			logmsg(MSG_ERROR,
			    gettext("Unable to seek to start of devid cache "
			    "file: %s (%d)\n"), strerror(errno), errno);
			(void) close(mapfd);
			free(ondiskbuf);
			nvlist_free(mapnvl);
			return (-1);
		}

		if (write(mapfd, ondiskbuf, newsz) != newsz) {
			logmsg(MSG_ERROR,
			    gettext("Unable to completely write out "
			    "on-disk devid cache file: %s\n"), strerror(errno));
			(void) close(mapfd);
			nvlist_free(mapnvl);
			free(ondiskbuf);
			return (errno);
		}
	} /* !readonlyroot */

	/* Now we can process the command line args */
	if (globarg == MPX_PHYSICAL) {
		report_map(devicep, BOOT);
	} else if (globarg == MPX_BOOTPATH) {
		rv = print_bootpath();
		di_fini(devinfo_root);
		return (rv);
	} else if (globarg == MPX_UPDATEVFSTAB) {
		rv = update_vfstab();
		di_fini(devinfo_root);
		return (rv);
	} else if (globarg != MPX_INIT) {
		if (globarg & MPX_LIST)
			list_devs(guid, limctrl);

		if (globarg == MPX_MAP)
			report_map(devicep, NONBOOT);
	} else {
		logmsg(MSG_INFO, "\nprivate devid cache file initialised\n");
	}

	nvlist_free(mapnvl);
	di_fini(devinfo_root);
	return (0);
}

static void
usage()
{
	(void) fprintf(stderr,
	    gettext("usage: stmsboot_util -b | -m devname | "
	    "-l <ctrl> | -L | [-g] | -n | -N | -i | -p devname\n"));
	(void) fprintf(stderr, "\n\n");
	(void) fprintf(stderr, gettext("\t-h\tprint this usage message\n"));
	(void) fprintf(stderr, gettext("\t-b\tretrieve the system's bootpath "
	    "setting\n"));
	(void) fprintf(stderr, gettext("\t-m devname\n"));
	(void) fprintf(stderr, gettext("\t\tReports the current mapping for "
	    "devname\n"));
	(void) fprintf(stderr, gettext("\t-g\tprint the GUID for MPxIO-capable "
	    "devices. This\n"));
	(void) fprintf(stderr, gettext("\t\toption is only valid with the -L "
	    "or -l options\n"));
	(void) fprintf(stderr, gettext("\t-L | -l <ctrl>\n"));
	(void) fprintf(stderr, gettext("\t\tList the 'native' to 'MPxIO' "
	    "device mappings. If <ctrl>\n"));
	(void) fprintf(stderr, gettext("\t\tis specified, only print mappings "
	    "for those devices\n"));
	(void) fprintf(stderr, gettext("\t\tattached via the specified "
	    "controller.\n"));
	(void) fprintf(stderr, gettext("\t-i\tinitialise the private devid "
	    "cache file and exit\n"));
	(void) fprintf(stderr, gettext("\t\tThis option excludes all "
	    "others.\n"));
	(void) fprintf(stderr, gettext("\t-n\tprint the devfs paths for "
	    "multipath-capable\n"));
	(void) fprintf(stderr, gettext("\t\tcontroller ports.\n"));
	(void) fprintf(stderr, gettext("\t-N\tprint the device aliases of "
	    "multipath-capable\n"));
	(void) fprintf(stderr, gettext("\t\tcontroller ports.\n"));
	(void) fprintf(stderr, gettext("\t-p\tdevname\n"));
	(void) fprintf(stderr, gettext("\t\tThis option provides the physical "
	    "devfs path for\n"));
	(void) fprintf(stderr, gettext("\t\ta specific device (devname). Used "
	    "to set the bootpath\n"));
	(void) fprintf(stderr, gettext("\t\tvariable on x86/x64 systems\n"));
	(void) fprintf(stderr, gettext("\t-u\ttranslates device mappings in "
	    "/etc/vfstab as \n"));
	(void) fprintf(stderr, gettext("\t\trequired. The output is written "
	    "to /etc/mpxio/vfstab.new\n\n"));
	exit(2);
}

static void
parse_args(int argc, char *argv[])
{
	char opt;

	if (argc == 1)
		usage();

	/*
	 * -b	prints the bootpath property
	 * -d	turns on debug mode for this utility (copious output!)
	 * -D drvname
	 *	if supplied, indicates that we're going to operate on
	 *	devices attached to this driver.
	 * -g	if (-l or -L), prints guids for devices rather than paths
	 * -h	prints the usage() help text.
	 * -i	initialises the cache file and exits.
	 * -l controller
	 *	list non-STMS to STMS device name mappings for the specific
	 *	controller, when MPxIO is enabled only.
	 * -L	list non-STMS to STMS device name mappings for all controllers
	 *	when MPxIO is enabled only.
	 * -m devname
	 *	prints the device path (/dev/rdsk) that devname maps to
	 *	in the currently-running system.
	 * -n
	 *	if supplied, returns name of STMS-capable controller nodes.
	 *	If the -D drvname option is specified as well, we only report
	 *	nodes attached with drvname.
	 * -N
	 *	same as the -n option, except that we only print the
	 *	node-name (dev_info :: devi_node_name). Multiple instances
	 *	through the libdevinfo snapshot are uniqified and separated
	 *	by the "|" character for direct use by egrep(1).
	 * -p devname
	 *	prints the physical devfs path for devname. Only used to
	 *	determine the bootpath.
	 * -u
	 *	remaps devices in /etc/vfstab, saving the newly generated
	 *	file to /etc/mpxio/vfstab.new. If we have any remapped
	 *	devices, exit with status 0, otherwise -1 for error.
	 */
	while ((opt = getopt(argc, argv, "bdD:ghil:Lm:nNp:u")) != EOF) {
		switch (opt) {
		case 'b':
			globarg = MPX_BOOTPATH;
			break;
		case 'd':
			debugflag = 1;
			break;
		case 'D':
			if ((drvlimit = calloc(1, MAXMODCONFNAME)) == NULL) {
				logmsg(MSG_ERROR,
				    gettext("Unable to allocate memory for a "
				    "driver name: %s\n"), strerror(errno));
				exit(errno);
			}
			bcopy(optarg, drvlimit, strlen(optarg));
			/* update this if adding support for a new driver */
			if ((strncmp(drvlimit, "fp", 2) == NULL) &&
			    (strncmp(drvlimit, "mpt", 3) == NULL) &&
			    (strncmp(drvlimit, "mpt_sas", 7) == NULL)) {
				logmsg(MSG_ERROR,
				    gettext("invalid parent driver (%s) "
				    "specified"), drvlimit);
				usage();
			}
			break;
		case 'h':
			/* Just drop out and print the usage() output */
			globarg = MPX_USAGE;
			break;
		case 'i':
			globarg = MPX_INIT;
			break;
		case 'l':
			globarg |= MPX_LIST;
			limctrl = (int)atol(optarg);
			if (limctrl < 0) {
				logmsg(MSG_INFO,
				    gettext("invalid controller number "
				    "(%d), checking all controllers\n"),
				    limctrl);
			}
			break;
		case 'L':
			globarg |= MPX_LIST;
			break;
		case 'g':
			guid = 1;
			break;
		case 'm':
			globarg = MPX_MAP;
			if ((devicep = calloc(1, MAXPATHLEN)) == NULL) {
				logmsg(MSG_ERROR,
				    gettext("Unable to allocate space for a "
				    "device name\n"));
				exit(errno);
			}
			devicep = strdup(optarg);
			break;
		case 'N':
			cap_N_option = 1;
			globarg = MPX_CAPABLE_CTRL;
			break;
		case 'n':
			globarg = MPX_CAPABLE_CTRL;
			break;
		case 'p':
			globarg = MPX_PHYSICAL;
			if ((devicep = calloc(1, MAXPATHLEN)) == NULL) {
				logmsg(MSG_ERROR,
				    gettext("Unable to allocate space for a "
				    "device name\n"));
				exit(errno);
			}
			devicep = strdup(optarg);
			break;
		case 'u':
			globarg = MPX_UPDATEVFSTAB;
			break;
		default:
			logmsg(MSG_ERROR,
			    gettext("Invalid command line option (%c)\n"),
			    opt);
			usage();
		}
	}

	if ((globarg >= MPX_USAGE) || (guid && (globarg != MPX_LIST)))
		usage();

	if ((drvlimit != NULL) &&
	    ((globarg != MPX_LIST) &&
	    (globarg != MPX_CAPABLE_CTRL)))
		usage();
}

static void
logmsg(int level, const char *msg, ...)
{
	va_list ap;

	if ((level >= MSG_ERROR) ||
	    ((debugflag > 0) && (level >= MSG_INFO))) {
		(void) fprintf(stdout, "stmsboot: ");
		va_start(ap, msg);
		(void) vfprintf(stdout, msg, ap);
		va_end(ap);
	}
}

/*
 * It's up to the caller to do any sorting or pretty-printing of the device
 * mappings we report. Since we're storing the device links as just the cXtYdZ
 * part, we'll add /dev/rdsk/ back on when we print the listing so we maintain
 * compatibility with previous versions of this tool. There's a little bit
 * of footwork involved to make sure that we show all the paths to a device
 * rather than just the first one we stashed away.
 */
static void
list_devs(int listguids, int ctrl)
{
	nvlist_t *thisdevnvl;
	nvpair_t *pair;
	char *diskpath, *livepath, *key, *querydev;
	char *matchctrl = NULL;
	char checkctrl[MAXPATHLEN];
	int rv;

	if (!mpxenabled) {
		if (mpxprop) {
			logmsg(MSG_ERROR, gettext("MPXIO disabled\n"));
		} else {
			logmsg(MSG_ERROR, gettext("No STMS devices have "
			    "been found\n"));
		}
		return;
	}

	if (listguids) {
		(void) printf(gettext("non-STMS device name\t\t\tGUID\n"
		    "------------------------------------------"
		    "------------------------\n"));
	} else {
		(void) printf(gettext("non-STMS device name\t\t\t"
		    "STMS device name\n"
		    "------------------------------------------"
		    "------------------------\n"));
	}

	bzero(checkctrl, MAXPATHLEN);
	pair = NULL;
	while ((pair = nvlist_next_nvpair(mapnvl, pair))
	    != NULL) {
		boolean_t livescsivhcip = B_FALSE;

		if ((((rv = nvpair_value_string(pair, &querydev)) < 0) ||
		    ((key = nvpair_name(pair)) == NULL)) ||
		    ((strstr(key, "/pci") != NULL) ||
		    (strstr(key, "/sbus") != NULL) ||
		    (strstr(key, "/scsi_vhci") != NULL) ||
		    (strncmp(key, "id1", 3) == 0))) {
			logmsg(MSG_INFO,
			    "list_devs: rv = %d; (%s) is not a devlink, "
			    "continuing.\n", rv,
			    (key != NULL) ? key : "null");
			querydev = NULL;
			continue;
		}

		(void) nvlist_lookup_nvlist(mapnvl, querydev, &thisdevnvl);
		(void) nvlist_lookup_boolean_value(thisdevnvl, NVL_MPXEN,
		    &livescsivhcip);
		(void) nvlist_lookup_string(thisdevnvl, NVL_MPXPATH,
		    &livepath);

		if ((!livescsivhcip) ||
		    (livescsivhcip &&
		    (strncmp(key, livepath, strlen(key)) == 0)))
			continue;

		(void) nvlist_lookup_string(thisdevnvl, NVL_PATH,
		    &diskpath);

		logmsg(MSG_INFO,
		    "list_devs: %s :: %s ::%s :: MPXEN (%s)\n",
		    key, diskpath, livepath,
		    ((livescsivhcip) ? "TRUE" : "FALSE"));

		if (ctrl > -1) {
			(void) sprintf(checkctrl, "c%dt", ctrl);
			matchctrl = strstr(key, checkctrl);
			if (matchctrl == NULL)
				continue;
		}
		if (listguids != 0) {
			char *tempguid;
			ddi_devid_t curdevid;
			int rv;

			rv = devid_str_decode(querydev, &curdevid, NULL);
			if (rv == -1) {
				logmsg(MSG_INFO, "Unable to decode devid %s\n",
				    key);
				continue;
			}
			tempguid = devid_to_guid(curdevid);
			if (tempguid != NULL)
				(void) printf("/dev/rdsk/%s\t%s\n",
				    diskpath, tempguid);

			devid_free_guid(tempguid);
			devid_free(curdevid);
			continue;
		}

		(void) printf("/dev/rdsk/%s\t/dev/rdsk/%s\n",
		    (strstr(key, diskpath) == NULL) ? key : diskpath,
		    livepath);
	}
}

/*
 * We get passed a device name which we search the mapnvl for. If we find
 * it, we print the mapping as it is found. It is up to the caller of this
 * utility to do any pretty-printing of the results. If a device listed on
 * the command line does not exist in the mapnvl, then we print NOT_MAPPED.
 * Otherwise we print the command-line device name as it maps to what is
 * stashed in the mapnvl - even if that's a "no change" device mapping.
 *
 * Example output (-p maps to physpath=BOOT)
 * # /lib/mpxio/stmsboot_util -p \
 *	/pci@0,0/pci1022,7450@2/pci1000,3060@3/sd@1,0:a
 * /scsi_vhci/disk@g500000e011e17720:a
 *
 * Or the reverse:
 * # /lib/mpxio/stmsboot_util -p /scsi_vhci/disk@g500000e011e17720:a
 * /pci@0,0/pci1022,7450@2/pci1000,3060@3/sd@1,0:a
 *
 * For the -m option, used when we're trying to find the root device mapping:
 *
 * # /lib/mpxio/stmsboot_util -m /dev/dsk/c2t0d0s2
 * /dev/dsk/c3t500000E011637CF0d0s2
 */
static void
report_map(char *argdev, int physpath)
{
	nvlist_t *thisdev;
	int rv = 0;
	char *thisdevid;
	char *mpxpath = NULL;
	char *prefixt = NULL;
	char *prefixp = NULL;
	char *stripdev = NULL;
	char *slice = NULL;
	boolean_t mpxenp;
	uint_t slicelen = 0;

	mpxenp = B_FALSE;

	if ((prefixt = calloc(1, strlen(argdev) + 1)) == NULL) {
		logmsg(MSG_INFO, "Unable to allocate memory\n");
		(void) printf("NOT_MAPPED\n");
		return;
	}

	(void) strlcpy(prefixt, argdev, strlen(argdev) + 1);

	slice = strrchr(argdev, (physpath == BOOT) ? ':' : 's');
	if (slice != NULL) {
		slicelen = strlen(slice);
		if (slicelen > 3)
			/* invalid size - max is 3 chars */
			slicelen = 0;
	}

	if ((stripdev = calloc(1, strlen(prefixt) + 1)) == NULL) {
		logmsg(MSG_INFO, "Unable to allocate memory\n");
		(void) printf("NOT_MAPPED\n");
		free(prefixt);
		return;
	}

	if ((strstr(prefixt, "/scsi_vhci") == NULL) &&
	    (strstr(prefixt, "/pci") == NULL) &&
	    (strstr(prefixt, "/sbus") == NULL)) {
		prefixp = strrchr(prefixt, '/');
		(void) strlcpy(stripdev,
		    (prefixp == NULL) ? prefixt : prefixp + 1,
		    (prefixp == NULL) ?
		    strlen(prefixt) + 1: strlen(prefixp) + 1);
		if (prefixp != NULL)
			prefixt[strlen(argdev) - strlen(prefixp) + 1] = '\0';
	} else {
		if (physpath != BOOT) {
			logmsg(MSG_INFO, "Invalid device path provided\n");
			(void) printf("NOT_MAPPED\n");
			free(stripdev);
			free(prefixt);
			return;
		}
		(void) strlcpy(stripdev, argdev, strlen(argdev) + 1);
	}

	logmsg(MSG_INFO,
	    "stripdev (%s), prefixt(%s), prefixp(%s), slice(%s)\n",
	    (stripdev == NULL) ? "null" : stripdev,
	    (prefixt == NULL) ? "null" : prefixt,
	    (prefixp == NULL) ? "null" : prefixp,
	    (slice == NULL) ? "null" : slice);

	if (slicelen > 0)
		stripdev[strlen(stripdev) - slicelen] = '\0';

	/* search for the shortened version */
	rv = nvlist_lookup_string(mapnvl, stripdev, &thisdevid);
	if (rv) {
		if (physpath != BOOT) {
			logmsg(MSG_INFO,
			    "searched mapnvl for '%s', got %s (%d)\n",
			    stripdev, strerror(rv), rv);
			(void) printf("NOT_MAPPED\n");
			free(stripdev);
			free(prefixt);
			return;
		}
	}

	logmsg(MSG_INFO, "device %s has devid %s\n", stripdev, thisdevid);

	if (nvlist_lookup_nvlist(mapnvl, thisdevid, &thisdev) != 0) {
		logmsg(MSG_INFO, "device (%s) in mapnvl but "
		    "not mapped!\n", thisdevid);
		(void) printf("NOT_MAPPED\n");
		free(stripdev);
		free(prefixt);
		return;
	}

	/* quick exit */
	if (!mpxenabled && (strstr(argdev, "/pci") != NULL ||
	    strstr(argdev, "/sbus") != NULL)) {
		(void) printf("%s\n", argdev);
		free(stripdev);
		free(prefixt);
		return;
	}

	(void) nvlist_lookup_boolean_value(thisdev, NVL_MPXEN, &mpxenp);

	if (physpath == BOOT) {
		(void) nvlist_lookup_string(thisdev, NVL_PHYSPATH, &mpxpath);
		if ((strstr(argdev, "/scsi_vhci") != NULL) &&
		    (strncmp(argdev, mpxpath, strlen(mpxpath)) == 0)) {
			/* Need to translate vhci to phci */
			char *realpath;

			if ((realpath = calloc(1, MAXPATHLEN + 1)) == NULL) {
				logmsg(MSG_ERROR,
				    gettext("Unable to allocate "
				    "memory for a path element\n"));
				free(stripdev);
				free(prefixt);
				return;
			}
			vhci_to_phci(stripdev, realpath);
			(void) printf("%s%s\n", realpath,
			    ((slicelen > 0) && slice != NULL) ? slice : "");
			free(realpath);
		} else {
			(void) printf("%s%s\n", mpxpath,
			    ((slicelen > 0) && slice != NULL) ? slice : "");
		}
	} else {
		(void) nvlist_lookup_string(thisdev,
		    ((readonlyroot) ? NVL_PHYSPATH :
		    ((mpxenp == B_TRUE) ? NVL_MPXPATH : NVL_PATH)),
		    &mpxpath);
		logmsg(MSG_INFO, "mpxpath = %s\n",
		    (mpxpath == NULL) ? "null" : mpxpath);
		if (readonlyroot ||
		    (strstr(mpxpath, "/scsi_vhci") != NULL) ||
		    (strstr(mpxpath, "/pci") != NULL) ||
		    (strstr(mpxpath, "/sbus") != NULL)) {
			/*
			 * If we see a physical path here it means that
			 * devlinks aren't fully initialised yet, so we
			 * are still in maintenance/single-user mode.
			 */
			(void) printf("/devices%s:%c\n", mpxpath,
			    slice[1] + '1');
		} else {
			(void) printf("%s%s%s\n",
			    (prefixt[0] == '/') ? prefixt : "",
			    mpxpath,
			    ((slicelen > 0) && slice != NULL) ? slice : "");
		}
	}
	free(prefixt);
	free(stripdev);
}

/*
 * Validate the in-kernel and on-disk forms of our devid cache,
 * returns  -1 for unfixable error and 0 for success.
 */
static int
validate_devnvl()
{
	di_node_t	curnode;
	int		rv1 = -1;
	int		rv2 = -1;

	/*
	 * Method: we walk through the kernel's concept of the device tree
	 * looking for "ssd" then "sd" nodes.
	 * We check to see whether the device's devid is already in our nvlist
	 * (on disk) nvlist cache file. If it is, we check that it's components
	 * match what we've got already and fill any missing fields.
	 * If the devid isn't in our on-disk nvlist already then we add it
	 * and populate the property nvpairs.
	 *
	 * At the end of this function we should have this program's concept
	 * of the devid-keyed nvlist matching what is in the ondisk form which
	 * is ready to be written out.
	 * If we can't do this, then we return -1.
	 */
	curnode = di_drv_first_node("ssd", devinfo_root);
	if (curnode != DI_NODE_NIL)
		rv1 = mpxio_nvl_boilerplate(curnode);

	curnode = di_drv_first_node("sd", devinfo_root);
	if (curnode != DI_NODE_NIL)
		rv2 = mpxio_nvl_boilerplate(curnode);

	if (rv1 + rv2 == -2)
		return (-1);

	return (0);
}

static int
mpxio_nvl_boilerplate(di_node_t curnode)
{
	int		rv;
	char		*strdevid;
	ddi_devid_t	curdevid;
	nvlist_t	*newnvl;

	for (; curnode != DI_NODE_NIL; curnode = di_drv_next_node(curnode)) {
		errno = 0;

		curdevid = NULL;
		get_devid(curnode, &curdevid);
		if (curdevid == NULL)
			/*
			 * There's no devid registered for this device
			 * so it's not cool enough to play with us
			 */
			continue;

		strdevid = devid_str_encode(curdevid, NULL);
		/* does this exist in the on-disk cache? */
		rv = nvlist_lookup_nvlist(mapnvl, strdevid, &newnvl);
		if (rv == ENOENT) {
			logmsg(MSG_INFO, "nvlist for %s not found\n", strdevid);
			/* no, so alloc a new nvl to store it */
			if (nvlist_alloc(&newnvl, NV_UNIQUE_NAME, 0) != 0) {
				logmsg(MSG_ERROR,
				    gettext("Unable to allocate space for "
				    "a devid property list: %s\n"),
				    strerror(errno));
				return (-1);
			}
		} else {
			if ((rv != ENOTSUP) && (rv != EINVAL))
				logmsg(MSG_INFO,
				    "%s exists in ondisknvl, verifying\n",
				    strdevid);
		}

		if (popcheck_devnvl(curnode, newnvl, strdevid) != 0) {
			logmsg(MSG_ERROR,
			    gettext("Unable to populate devid nvpair "
			    "for device with devid %s\n"),
			    strdevid);
			devid_str_free(strdevid);
			nvlist_free(newnvl);
			return (-1);
		}

		/* Now add newnvl into our cache. */
		errno = 0;
		rv = nvlist_add_nvlist(mapnvl, strdevid, newnvl);
		if (rv) {
			logmsg(MSG_ERROR,
			    gettext("Unable to add device (devid %s) "
			    "to in-kernel nvl: %s (%d)\n"),
			    strdevid, strerror(rv), rv);
			devid_str_free(strdevid);
			nvlist_free(newnvl);
			return (-1);
		}
		logmsg(MSG_INFO,
		    gettext("added device (devid %s) to mapnvl\n\n"),
		    strdevid);
		devid_str_free(strdevid);
	}
	return (0);
}

/*
 * Operates on a single di_node_t, collecting all the device properties
 * that we need. devnvl is allocated by the caller, and we add our nvpairs
 * to it if they don't already exist.
 *
 * We are _only_ interested in devices which have a devid. We pull in
 * devices even when they're excluded via stmsboot -D (driver), because
 * we don't want to miss out on any devid data that might be handy later.
 */
static int
popcheck_devnvl(di_node_t thisnode, nvlist_t *devnvl, char *strdevid)
{
	char *path = NULL;
	char *curpath = NULL;
	char *devfspath = NULL;
	char *prop = NULL;
	int scsivhciparent = 0;
	int rv = 0;
	boolean_t mpxenp = B_FALSE;

	errno = 0;
	devfspath = di_devfs_path(thisnode);
	if (devfspath == NULL) {
		logmsg(MSG_ERROR,
		    gettext("Unable to determine devfs path for node: %s\n"),
		    strerror(errno));
		return (-1);
	}

	/* Add a convenient devfspath to devid inverse map */
	if (nvlist_add_string(mapnvl, devfspath, strdevid) != 0) {
		logmsg(MSG_ERROR,
		    gettext("Unable to add device path %s with devid "
		    "%s to mapnvl\n"), devfspath, strdevid);
		return (-1);
	}
	if (di_prop_lookup_strings(DDI_DEV_T_ANY, di_parent_node(thisnode),
	    "mpxio-disable", &prop) >= 0) {
		if (strncmp(prop, "yes", 3) == 0) {
			if (!mpxprop)
				mpxprop++;
		}
	}

	if (strncmp(di_driver_name(di_parent_node(thisnode)),
	    "scsi_vhci", 9) == 0) {
		scsivhciparent = 1;
		if (!mpxenabled)
			mpxenabled++;

		rv = nvlist_lookup_boolean_value(devnvl, NVL_MPXEN, &mpxenp);
		if (rv || (mpxenp == B_FALSE)) {
			rv = nvlist_add_boolean_value(devnvl,
			    NVL_MPXEN, B_TRUE);
			if (rv) {
				logmsg(MSG_ERROR,
				    gettext("Unable to add property %s "
				    "(set to B_TRUE) for device %s: "
				    "%s (%d)\n"),
				    NVL_MPXEN, devfspath,
				    strerror(rv), rv);
				return (-1);
			}
			logmsg(MSG_INFO, "NVL_MPXEN :: (B_FALSE->B_TRUE)\n");
		}
	} else {
		/* turn _off_ the flag if it was enabled */
		rv = nvlist_add_boolean_value(devnvl, NVL_MPXEN, B_FALSE);
		if (rv) {
			logmsg(MSG_ERROR,
			    gettext("Unable to add property %s "
			    "(set to B_FALSE) for device %s: %s (%d)\n"),
			    NVL_MPXEN, devfspath,
			    strerror(rv), rv);
			return (-1);
		}
		logmsg(MSG_INFO, "NVL_MPXEN :: (B_TRUE-> B_FALSE)\n");
	}

	rv = nvlist_add_string(devnvl, NVL_PHYSPATH, devfspath);
	if (rv) {
		logmsg(MSG_ERROR,
		    gettext("Unable to add physical device path (%s) "
		    "property to nvl\n"));
		return (-1);
	}

	if ((curpath = calloc(1, MAXPATHLEN)) == NULL) {
		logmsg(MSG_ERROR,
		    gettext("Unable to allocate space for current path\n"));
		return (-1);
	}
	curpath = find_link(thisnode);
	if (curpath == NULL) {
		if (readonlyroot) {
			return (0);
		}
		logmsg(MSG_ERROR,
		    gettext("Unable to determine device path for node %s\n"),
		    devfspath);
		return (-1);
	}

	rv = nvlist_lookup_string(devnvl, NVL_MPXPATH, &path);

	if (path == NULL && scsivhciparent)
		(void) nvlist_add_string(devnvl, NVL_MPXPATH, curpath);

	if (!scsivhciparent) {
		(void) nvlist_add_string(devnvl, NVL_PATH, curpath);
		path = curpath;
	}

	/*
	 * This next block provides the path to devid inverse mapping
	 * that other functions require
	 */
	if (path != NULL) {
		if (nvlist_add_string(mapnvl, path, strdevid) != 0) {
			logmsg(MSG_ERROR,
			    gettext("Unable to add device %s with devid "
			    "%s to mapnvl\n"), path, strdevid);
			return (-1);
		}
		logmsg(MSG_INFO, "popcheck_devnvl: added path %s :: %s\n",
		    path, strdevid);
		if (nvlist_add_string(mapnvl, curpath, strdevid) != 0) {
			logmsg(MSG_ERROR,
			    gettext("Unable to add device %s with devid "
			    "%s to mapnvl: %s\n"),
			    curpath, strdevid, strerror(errno));
			return (-1);
		}
		logmsg(MSG_INFO, "popcheck_devnvl: added curpath %s :: %s\n",
		    curpath, strdevid);
	}
	if (scsivhciparent) {
		if (nvlist_add_string(devnvl, NVL_MPXPATH, curpath) != 0) {
			logmsg(MSG_ERROR,
			    gettext("Unable to add property %s for device "
			    "%s: %s\n"),
			    NVL_MPXPATH, devfspath, strerror(errno));
			return (-1);
		} else {
			logmsg(MSG_INFO, "added curpath (%s) as NVL_MPXPATH "
			    "to devnvl for devid %s\n", curpath, strdevid);
		}
	}
	return (0);
}

static void
print_mpx_capable(di_node_t curnode)
{
	char *prop;
	char *path;
	char *aliases = NULL;

	if (cap_N_option) {
		aliases = calloc(1, MAXPATHLEN + 1);
		if (aliases == NULL) {
			logmsg(MSG_ERROR,
			    gettext("Unable to allocate memory for a device "
			    "alias list\n"));
			return;
		}
	}

	for (; curnode != DI_NODE_NIL; curnode = di_drv_next_node(curnode)) {
		if (di_prop_lookup_strings(DDI_DEV_T_ANY, curnode,
		    "initiator-port", &prop) >= 0) {
			if ((path = di_devfs_path(curnode)) == NULL) {
				logmsg(MSG_INFO,
				    "Unable to find devfs path for device "
				    "%s: %s\n", &curnode, strerror(errno));
				continue;
			}
			if (cap_N_option) {
				char *nodename = di_node_name(curnode);
				/* nodename is never going to be null */
				if (strstr(aliases, nodename) == NULL)
					/* haven't seen this nodename before */
					(void) snprintf(aliases,
					    MAXPATHLEN + 1, "%s|%s",
					    ((aliases != NULL) ? aliases : ""),
					    nodename);
			} else
				(void) printf("%s\n", path);
		}
	}
	if (cap_N_option)
		(void) printf("%s\n", aliases);
}

static int
link_cb(di_devlink_t devlink, void *arg)
{
	const char *result;

	result = di_devlink_path(devlink);
	if (result == NULL) {
		arg = (void *)"(null)";
	} else {
		(void) strlcpy(arg, result, strlen(result));
	}
	logmsg(MSG_INFO, "\nlink_cb::linkdata->resultstr = %s\n",
	    ((result != NULL) ? result : "(null)"));
	return (DI_WALK_CONTINUE);
}

static char *
find_link(di_node_t cnode)
{
	di_minor_t devminor = DI_MINOR_NIL;
	di_devlink_handle_t	hdl;
	char *devfspath = NULL;
	char *minorpath = NULL;
	char *linkname = NULL;
	char *cbresult = NULL;

	devfspath = di_devfs_path(cnode);
	if (cnode == DI_NODE_NIL) {
		logmsg(MSG_ERROR,
		    gettext("find_ctrl must be called with non-null "
		    "di_node_t\n"));
		return (NULL);
	}
	logmsg(MSG_INFO, "find_link: devfspath %s\n", devfspath);

	if (((cbresult = calloc(1, MAXPATHLEN)) == NULL) ||
	    ((minorpath = calloc(1, MAXPATHLEN)) == NULL) ||
	    ((linkname = calloc(1, MAXPATHLEN)) == NULL)) {
		logmsg(MSG_ERROR, "unable to allocate space for dev link\n");
		return (NULL);
	}

	devminor = di_minor_next(cnode, devminor);
	hdl = di_devlink_init(di_devfs_minor_path(devminor), DI_MAKE_LINK);
	if (hdl == NULL) {
		logmsg((readonlyroot ? MSG_INFO : MSG_ERROR),
		    gettext("unable to take devlink snapshot: %s\n"),
		    strerror(errno));
		return (NULL);
	}

	linkname = "^dsk/";
	(void) snprintf(minorpath, MAXPATHLEN, "%s:c", devfspath);

	errno = 0;
	if (di_devlink_walk(hdl, linkname, minorpath, DI_PRIMARY_LINK,
	    (void *)cbresult, link_cb) < 0) {
		logmsg(MSG_ERROR,
		    gettext("Unable to walk devlink snapshot for %s: %s\n"),
		    minorpath, strerror(errno));
		return (NULL);
	}

	if (di_devlink_fini(&hdl) < 0) {
		logmsg(MSG_ERROR,
		    gettext("Unable to close devlink snapshot: %s\n"),
		    strerror(errno));
	}
	if (strstr(cbresult, "dsk/") == NULL)
		return (devfspath);

	bzero(minorpath, MAXPATHLEN);
	/* strip off the trailing "s2" */
	bcopy(cbresult, minorpath, strlen(cbresult) - 1);
	/* Now strip off the /dev/dsk/ prefix for output flexibility */
	linkname = strrchr(minorpath, '/');
	return (++linkname);
}

/*
 * handle case where device has been probed but its target driver is not
 * attached so enumeration has not quite finished. Opening the /devices
 * pathname will force the kernel to finish the enumeration process and
 * let us get the data we need.
 */
static void
get_devid(di_node_t node, ddi_devid_t *thisdevid)
{
	int fd;
	char realpath[MAXPATHLEN];
	char *openpath = di_devfs_path(node);

	errno = 0;
	bzero(realpath, MAXPATHLEN);
	if (strstr(openpath, "/devices") == NULL) {
		(void) snprintf(realpath, MAXPATHLEN,
		    "/devices%s:c,raw", openpath);
		fd = open(realpath, O_RDONLY|O_NDELAY);
	} else {
		fd = open(openpath, O_RDONLY|O_NDELAY);
	}

	if (fd < 0) {
		logmsg(MSG_INFO, "Unable to open path %s: %s\n",
		    openpath, strerror(errno));
		return;
	}

	if (devid_get(fd, thisdevid) != 0) {
		logmsg(MSG_INFO,
		    "'%s' node (%s) without a devid registered\n",
		    di_driver_name(node), di_devfs_path(node));
	}
	(void) close(fd);
}

static int
print_bootpath()
{
	char *bootprop = NULL;

	if (di_prop_lookup_strings(DDI_DEV_T_ANY, devinfo_root,
	    "bootpath", &bootprop) >= 0) {
		(void) printf("%s\n", bootprop);
		return (0);
	} else if (di_prop_lookup_strings(DDI_DEV_T_ANY, devinfo_root,
	    "boot-path", &bootprop) >= 0) {
		(void) printf("%s\n", bootprop);
		return (0);
	} else {
		(void) printf("ERROR: no bootpath/boot-path property found\n");
		return (ENOENT);
	}
}

static void
get_phci_driver_name(char *phci_path, char **driver_name)
{
	di_node_t phci_node = DI_NODE_NIL;
	char *tmp = NULL;

	phci_node = di_init(phci_path, DINFOCPYONE);
	if (phci_node == DI_NODE_NIL) {
		logmsg(MSG_ERROR,
		    gettext("Unable to take phci snapshot "
		    "(%s: %d)\n"), strerror(errno), errno);
		return;
	}
	tmp = di_driver_name(phci_node);
	if (tmp != NULL) {
		(void) strncpy(*driver_name, tmp, 10);
	}
	di_fini(phci_node);
}
/*
 * We only call this routine if we have a scsi_vhci node and must
 * determine the actual physical path of its first online client
 * path.
 */
static void
vhci_to_phci(char *devpath, char *physpath)
{
	sv_iocdata_t	ioc;
	sv_path_info_t	*pi;
	int		vhci_fd;
	int		rv;
	uint_t		npaths = 0;

	vhci_fd = open(VHCI_CTL_NODE, O_RDWR);
	if (vhci_fd < 0)
		goto failure;

	bzero(&ioc, sizeof (sv_iocdata_t));
	ioc.client = devpath;
	ioc.ret_elem = &npaths;
	rv = ioctl(vhci_fd, SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO, &ioc);
	if (rv || npaths == 0) {
		logmsg(MSG_INFO,
		    "SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO ioctl() failed, "
		    "%s (%d)\n", strerror(rv), rv);
		goto failure;
	}

	bzero(&ioc, sizeof (sv_iocdata_t));
	ioc.client = devpath;
	ioc.buf_elem = npaths;
	ioc.ret_elem = &npaths;
	if ((ioc.ret_buf = calloc(npaths, sizeof (sv_path_info_t)))
	    == NULL)
		goto failure;
	rv = ioctl(vhci_fd, SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO, &ioc);
	if (rv || npaths == 0) {
		logmsg(MSG_INFO,
		    "SCSI_VHCI_GET_CLIENT_MULTIPATH_INFO ioctl() (#2) "
		    "failed, %s (%d)\n", strerror(rv), rv);
		goto failure;
	}

	if (ioc.buf_elem < npaths)
		npaths = ioc.buf_elem;

	pi = (sv_path_info_t *)ioc.ret_buf;
	while (npaths--) {
		if (pi->ret_state == MDI_PATHINFO_STATE_ONLINE) {
			char nodename[5];
			char *phci_driver = NULL;

			bzero(nodename, 5);
			phci_driver = malloc(10);
			if (phci_driver == NULL) {
				logmsg(MSG_INFO,
				    "vhci_to_phci: Memory allocation failed\n");
				goto failure;
			}
			bzero(phci_driver, 10);
			get_phci_driver_name(pi->device.ret_phci,
			    &phci_driver);
			logmsg(MSG_INFO, "phci driver name: %s\n", phci_driver);
			/*
			 * A hack, but nicer than a platform-specific ifdef
			 * fp on SPARC using "ssd" as nodename
			 * mpt use "sd" when mpxio disabled, use "disk" when
			 * mpxio is enabled
			 * for alll other cases, "disk" should be used as the
			 * nodename
			 */
			if (strstr(devpath, "ssd") != NULL) {
				(void) snprintf(nodename, 5, "ssd");
			} else if (strncmp(phci_driver, "mpt", 10) == 0) {
				(void) snprintf(nodename, 5, "sd");
			} else {
				(void) snprintf(nodename, 5, "disk");
			}
			(void) snprintf(physpath, MAXPATHLEN, "%s/%s@%s",
			    pi->device.ret_phci, nodename, pi->ret_addr);
			free(ioc.ret_buf);
			free(phci_driver);
			return;
		}
		pi++;
	}

failure:
	(void) snprintf(physpath, MAXPATHLEN, "NOT_MAPPED");
}

/*
 * Write /etc/vfstab to /etc/vfstab.new, with any remapped device
 * names substituted.
 *
 * Returns:
 *	0	successful operation
 *	-1	failed
 */
static int
update_vfstab()
{
	FILE *fdin, *fdout;
	char *buf, *tmpbuf;
	char fname[MAXPATHLEN];
	int rv = -1, rval = -1;
	char cdev[MAXPATHLEN];
	char bdev[MAXPATHLEN];
	char mntpt[MAXPATHLEN];
	char fstype[512];
	char fsckpass[512];
	char mntboot[512];
	char mntopt[MAXPATHLEN];
	char fmt[80];
	char *prefixt = NULL;
	char *curdev = NULL;
	char *thisdevid = NULL;
	char *slice = NULL;
	nvlist_t *thisdev;
	boolean_t devmpx = B_FALSE;

	buf = calloc(1, MAXPATHLEN);
	tmpbuf = calloc(1, MAXPATHLEN);
	if (buf == NULL || tmpbuf == NULL)
		return (-1);

	(void) snprintf(fname, MAXPATHLEN, "/etc/mpxio/vfstab.new");

	fdin = fopen("/etc/vfstab", "r");
	fdout = fopen(fname, "w+");
	if (fdin == NULL || fdout == NULL) {
		logmsg(MSG_INFO, "Unable to open vfstab or create a backup "
		    "vfstab %s\n");
		return (-1);
	}

	(void) snprintf(fmt, sizeof (fmt),
	    "%%%ds %%%ds %%%ds %%%ds %%%ds %%%ds %%%ds", sizeof (bdev) - 1,
	    sizeof (cdev) - 1, sizeof (mntpt) - 1, sizeof (fstype) - 1,
	    sizeof (fsckpass) - 1, sizeof (mntboot) - 1, sizeof (mntopt) - 1);

	while (fgets(buf, MAXPATHLEN, fdin) != NULL) {
		if (strlen(buf) == (MAXPATHLEN - 1) &&
		    buf[MAXPATHLEN-2] != '\n') {
			logmsg(MSG_ERROR,
			    gettext("/etc/vfstab line length too long, "
			    "exceeded %2$d: \"%3$s\"\n"),
			    MAXPATHLEN - 2, buf);
			goto out;
		}

		prefixt = NULL;
		curdev = NULL;
		slice = NULL;
		thisdevid = NULL;
		thisdev = NULL;

		/* LINTED - variable format specifier */
		rv = sscanf(buf, fmt, bdev, cdev, mntpt, fstype, fsckpass,
		    mntboot, mntopt);

		/*
		 * Walk through the lines in the input file (/etc/vfstab),
		 * skipping anything which is _not_ a COGD (common or garden
		 * disk), ie all the /devices, /system, /dev/md, /dev/vx and
		 * /dev/zvol and so forth.
		 */
		if ((rv == 7) && (bdev[0] == '/') &&
		    (strstr(bdev, "/dev/dsk"))) {
			slice = strrchr(bdev, 's');
			/* take a copy, strip off /dev/dsk/ */
			prefixt = strrchr(bdev, 'c');
			prefixt[strlen(bdev) - 9 - strlen(slice)] = '\0';
			slice++; /* advance past the s */
			rval = nvlist_lookup_string(mapnvl, prefixt,
			    &thisdevid);
			if (rval) {
				/* Whoa, where did this device go?! */
				logmsg(MSG_INFO,
				    "error looking up device %s\n", prefixt);
				/* Comment-out this line in the new version */
				(void) snprintf(tmpbuf, MAXPATHLEN,
				    "# DEVICE NOT FOUND %s", buf);
				(void) fprintf(fdout, "%s", tmpbuf);
				continue;
			} else {
				/* The device exists in our mapnvl */
				(void) nvlist_lookup_nvlist(mapnvl, thisdevid,
				    &thisdev);
				(void) nvlist_lookup_boolean_value(thisdev,
				    NVL_MPXEN, &devmpx);
				(void) nvlist_lookup_string(thisdev,
				    ((devmpx == B_TRUE)
				    ? NVL_MPXPATH : NVL_PATH),
				    &curdev);
			}
		}

		if ((prefixt != NULL) && (curdev != NULL) &&
		    (rv = (strncmp(prefixt, curdev, strlen(prefixt)) != 0))) {
			/* Mapping change for this device */
			if (strcmp(fstype, "swap") == 0) {
				(void) snprintf(tmpbuf, MAXPATHLEN,
				    "/dev/dsk/%ss%s\t-\t-\tswap\t"
				    "%s\t%s\t%s\n",
				    curdev, slice, fsckpass, mntboot, mntopt);
			} else {
				(void) snprintf(tmpbuf, MAXPATHLEN,
				    "/dev/dsk/%ss%s\t/dev/rdsk/%ss%s\t"
				    "%s\t%s\t%s\t%s\t%s\n",
				    curdev, slice, curdev, slice,
				    mntpt, fstype, fsckpass, mntboot, mntopt);
			}
			errno = 0;
			(void) fprintf(fdout, "%s", tmpbuf);
		} else {
			(void) fprintf(fdout, "%s", buf);
		}

		errno = 0;
		if (fflush(fdout) != 0) {
			logmsg(MSG_ERROR,
			    gettext("fprintf failed to write to %s: %s (%d)\n"),
			    fname, strerror(errno), errno);
			goto out;
		}
	}
out:
	(void) fclose(fdin);
	(void) fclose(fdout);
	free(buf);
	free(tmpbuf);
	return (errno);
}