xref: /illumos-gate/usr/src/cmd/mpathadm/mpathadm.c (revision ce5e7d21)

/*
 * 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.
 * Copyright (c) 2016 by Delphix. All rights reserved.
 */

/*
 * mpathadm.c : MP API CLI program
 *
 */

#include <libintl.h>

#include <mpapi.h>
#include "cmdparse.h"
#include "mpathadm_text.h"
#include "mpathadm.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <devid.h>
#include <fcntl.h>

/* helper functions */
static char *getExecBasename(char *);

/* object functions per subcommand */
static int listFunc(int, char **, int, cmdOptions_t *, void *);
static int showFunc(int, char **, int, cmdOptions_t *, void *);
static int modifyFunc(int, char **, int, cmdOptions_t *, void *);
static int enableFunc(int, char **, int, cmdOptions_t *, void *);
static int disableFunc(int, char **, int, cmdOptions_t *, void *);
static int failoverFunc(int, char **, int, cmdOptions_t *, void *);
static int overrideFunc(int, char **, int, cmdOptions_t *, void *);

#define	VERSION_STRING_MAX_LEN	10

#define	OPTIONSTRING_NAME	"name"
#define	OPTIONSTRING_TPNAME	"target-port name"
#define	OPTIONSTRING_ONOFF	"on/off"
#define	OPTIONSTRING_LBTYPE	"loadbalance type"
#define	OPTIONSTRING_IPORT	"initiator-port name"
#define	OPTIONSTRING_LUNIT	"logical-unit name"
#define	OPTIONSTRING_CANCEL	"cancel"
#define	OPTIONSTRING_VALUE	"value"

/*
 * Version number: (copied from iscsiadm)
 *  MAJOR - This should only change when there is an incompatible change made
 *  to the interfaces or the output.
 *
 *  MINOR - This should change whenever there is a new command or new feature
 *  with no incompatible change.
 */
#define	VERSION_STRING_MAJOR	    "1"
#define	VERSION_STRING_MINOR	    "0"


/* globals */
static char *cmdName;


/*
 * ****************************************************************************
 *
 * getExecBasename - copied from iscsiadm code
 *
 * input:
 *  execFullName - exec name of program (argv[0])
 *
 * Returns:
 *  command name portion of execFullName
 *
 * ****************************************************************************
 */
static char *
getExecBasename(char *execFullname)
{
	char	*lastSlash, *execBasename;

	/* guard against '/' at end of command invocation */
	for (;;) {
		lastSlash = strrchr(execFullname, '/');
		if (lastSlash == NULL) {
			execBasename = execFullname;
			break;
		} else {
			execBasename = lastSlash + 1;
			if (*execBasename == '\0') {
				*lastSlash = '\0';
				continue;
			}
			break;
		}
	}
	return (execBasename);
}


/*
 * Add new options here
 */

/* tables set up based on cmdparse instructions */
optionTbl_t longOptions[] = {
	{"inqname", required_arg, 'n', OPTIONSTRING_NAME},
	{"target-port", required_arg, 't', OPTIONSTRING_TPNAME},
	{"autofailback", required_arg, 'a', OPTIONSTRING_ONOFF},
	{"autoprobe", required_arg, 'p', OPTIONSTRING_ONOFF},
	{"loadbalance", required_arg, 'b', OPTIONSTRING_LBTYPE},
	{"initiator-port", required_arg, 'i', OPTIONSTRING_IPORT},
	{"logical-unit", required_arg, 'l', OPTIONSTRING_LUNIT},
	{"cancel", no_arg, 'c', OPTIONSTRING_CANCEL},
	{"vendor-id", required_arg, 'd', OPTIONSTRING_VALUE},
	{NULL, 0, 0, 0}
};


/*
 * Add new subcommands here
 */
subcommand_t subcommands[] = {
	{"list", LIST, listFunc},
	{"show", SHOW, showFunc},
	{"modify", MODIFY, modifyFunc},
	{"enable", ENABLE, enableFunc},
	{"disable", DISABLE, disableFunc},
	{"failover", FAILOVER, failoverFunc},
	{"override", OVERRIDE, overrideFunc},
	{NULL, 0, NULL}
};

/*
 * Add objects here
 */
object_t objects[] = {
	{"mpath-support", MPATH_SUPPORT},
	{"logical-unit", LOGICAL_UNIT},
	{"LU", LOGICAL_UNIT},
	{"initiator-port", INITIATOR_PORT},
	{"path", PATH},
	{NULL, 0}
};

/*
 * Rules for subcommands and objects
 *
 * command
 *
 * reqOpCmd -> subcommands that must have an operand
 * optOpCmd -> subcommands that may have an operand
 * noOpCmd -> subcommands that will have no operand
 * invCmd -> subcommands that are invalid
 * multOpCmd -> subcommands that can accept multiple operands
 * operandDefinition -> Usage definition for the operand of this object
 */
objectRules_t objectRules[] = {
	{MPATH_SUPPORT, SHOW|MODIFY|ADD, LIST|REMOVE, 0,
	    ENABLE|DISABLE|FAILOVER|OVERRIDE, LIST|SHOW|MODIFY,
	    "mpath-support name"},
	{INITIATOR_PORT, SHOW, LIST, 0,
	    MODIFY|ENABLE|DISABLE|FAILOVER|OVERRIDE|ADD|REMOVE, LIST|SHOW,
	    "initiator-port name"},
	{LOGICAL_UNIT, SHOW|MODIFY|FAILOVER, LIST, 0,
	    ENABLE|DISABLE|OVERRIDE|ADD|REMOVE, LIST|SHOW|MODIFY,
	    "logical-unit name"},
	{PATH, 0, 0, ENABLE|DISABLE|OVERRIDE,
	    SHOW|LIST|MODIFY|FAILOVER|ADD|REMOVE, 0,
	    "initiator-port name"},
	{0, 0, 0, 0, 0, 0, NULL}
};

/*
 * list of objects, subcommands, valid short options, required flag and
 * exclusive option string
 *
 * If it's not here, there are no options for that object.
 */
optionRules_t optionRules[] = {
	{LOGICAL_UNIT, LIST, "nt", B_FALSE, NULL},
	{LOGICAL_UNIT, MODIFY, "apb", B_TRUE, NULL},
	{MPATH_SUPPORT, MODIFY, "apb", B_TRUE, NULL},
	{MPATH_SUPPORT, ADD, "d", B_TRUE, NULL},
	{MPATH_SUPPORT, REMOVE, "d", B_TRUE, NULL},
	{PATH, ENABLE, "itl", B_TRUE, NULL},
	{PATH, DISABLE, "itl", B_TRUE, NULL},
	{PATH, OVERRIDE, "itlc", B_TRUE, NULL},
	{0, 0, NULL, 0, NULL}
};


/*
 * ****************************************************************************
 *
 * listMpathSupport - mpathadm list mpath-support
 *
 * operandLen	- number of operands user passed into the cli
 * operand	- pointer to operand list from user
 *
 * ****************************************************************************
 */
int
listMpathSupport(int operandLen, char *operand[])
{
	MP_STATUS				mpstatus = MP_STATUS_SUCCESS;
	MP_PLUGIN_PROPERTIES			pluginProps;
	MP_OID_LIST				*pPluginOidList;
	boolean_t				shown = B_FALSE;
	/* number of plugins listed */
	int					i, op;

	if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
	    != MP_STATUS_SUCCESS) {
		(void) fprintf(stderr, "%s: %s\n", cmdName,
		    getTextString(ERR_NO_MPATH_SUPPORT_LIST));
		return (mpstatus);
	}
	if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
		(void) fprintf(stderr, "%s: %s\n", cmdName,
		    getTextString(ERR_NO_MPATH_SUPPORT_LIST));
		return (ERROR_CLI_FAILED);
	}


	/* loop through operands first */
	for (op = 0; (op < operandLen) |
	    ((0 == operandLen) && (B_FALSE == shown)); op++) {
		shown = B_TRUE;
		for (i = 0; i < pPluginOidList->oidCount; i++) {

			(void) memset(&pluginProps, 0,
			    sizeof (MP_PLUGIN_PROPERTIES));
			mpstatus =
			    MP_GetPluginProperties(pPluginOidList->oids[i],
			    &pluginProps);
			if (mpstatus != MP_STATUS_SUCCESS) {
				(void) fprintf(stderr, "%s:  %s\n",
				    cmdName, getTextString(ERR_NO_PROPERTIES));
			} else {
				if (0 == operandLen) {
					/* if no operands, list them all */
					(void) printf("%s  %s\n",
					    getTextString(
					    TEXT_LB_MPATH_SUPPORT),
					    pluginProps.fileName);
				} else {
					/* if there is an operand... */
					/* ... compare and display if match */
					if (0 ==
					    strcmp(operand[op],
					    pluginProps.fileName)) {
						(void) printf("%s  %s\n",
						    getTextString(
						    TEXT_LB_MPATH_SUPPORT),
						    pluginProps.fileName);
					} else {
				/* begin back-up indentation */
				/* LINTED E_SEC_PRINTF_VAR_FMT */
				(void) fprintf(stderr, getTextString(
				    ERR_CANT_FIND_MPATH_SUPPORT_WITH_NAME),
				    operand[op]);
				/* end back-up indentation */
						(void) printf("\n");
					}
				}
			}
		}
	}

	return (mpstatus);
}


/*
 * ****************************************************************************
 *
 * showMpathSupport - mpathadm show mpath-support <mpath-support name>, ...
 *
 * operandLen	- number of operands user passed into the cli
 * operand	- pointer to operand list from user
 *
 * ****************************************************************************
 */
int
showMpathSupport(int operandLen, char *operand[])
{
	MP_STATUS				mpstatus = MP_STATUS_SUCCESS;
	MP_PLUGIN_PROPERTIES			pluginProps;
	MP_OID_LIST				*pPluginOidList;
	MP_OID_LIST				*deviceOidListArray;
	MP_DEVICE_PRODUCT_PROPERTIES		devProps;
	boolean_t				bListIt = B_FALSE;
	int					op, i, j;
	MP_LOAD_BALANCE_TYPE			lb;


	if ((mpstatus = MP_GetPluginOidList(&pPluginOidList)) !=
	    MP_STATUS_SUCCESS) {
		(void) fprintf(stderr, "%s:  %s\n",
		    cmdName, getTextString(ERR_NO_MPATH_SUPPORT_LIST));
		return (mpstatus);
	}
	if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
		(void) fprintf(stderr, "%s:  %s\n",
		    cmdName, getTextString(ERR_NO_MPATH_SUPPORT_LIST));
		return (ERROR_CLI_FAILED);
	}

	for (op = 0; op < operandLen; op++) {
		bListIt = B_FALSE;

		for (i = 0; i < pPluginOidList->oidCount; i++) {

			(void) memset(&pluginProps, 0,
			    sizeof (MP_PLUGIN_PROPERTIES));
			mpstatus =
			    MP_GetPluginProperties(pPluginOidList->oids[i],
			    &pluginProps);
			if (MP_STATUS_SUCCESS != mpstatus) {
				(void) fprintf(stderr, "%s: %s\n",
				    cmdName, getTextString(ERR_NO_PROPERTIES));
				return (mpstatus);
				}

				if (0 == operandLen) {
					/* if no operand, list it */
					bListIt = B_TRUE;
				} else {
					/* ... compare and display if match */
					if (0 ==
					    strcmp(operand[op],
					    pluginProps.fileName)) {
						bListIt = B_TRUE;
				}
			}

			if (B_TRUE != bListIt) {
				break;
			}

			(void) printf("%s  %s\n",
			    getTextString(TEXT_LB_MPATH_SUPPORT),
			    pluginProps.fileName);

			/* display the info for this plugin */
			(void) printf("\t%s  ", getTextString(TEXT_LB_VENDOR));
			displayWideArray(pluginProps.vendor,
			    sizeof (pluginProps.vendor));
			(void) printf("\n\t%s  ",
			    getTextString(TEXT_LB_DRIVER_NAME));
			displayArray(pluginProps.driverName,
			    sizeof (pluginProps.driverName));
			(void) printf("\n\t%s  ",
			    getTextString(TEXT_LB_DEFAULT_LB));
			/* don't ignore load balance type none. */
			if (pluginProps.defaultloadBalanceType == 0) {
				(void) printf("%s",
				    getTextString(TEXT_LBTYPE_NONE));
			} else {
				displayLoadBalanceString(
				    pluginProps.defaultloadBalanceType);
			}
			(void) printf("\n");


			(void) printf("\t%s  \n",
			    getTextString(TEXT_LB_SUPPORTED_LB));
			/* check each bit, display string if found set */
			if (pluginProps.supportedLoadBalanceTypes == 0) {
				(void) printf("\t\t%s\n",
				    getTextString(TEXT_LBTYPE_NONE));
			} else {
				lb = 1;
				do {
					if (0 != (lb & pluginProps.
					    supportedLoadBalanceTypes)) {
						(void) printf("\t\t");
						displayLoadBalanceString(lb &
						    pluginProps.
						    supportedLoadBalanceTypes);
						(void) printf("\n");
					}
					lb = lb<<1;
				} while (lb < 0x80000000);
			}

			(void) printf("\t%s  %s\n",
			    getTextString(TEXT_LB_ALLOWS_ACT_TPG),
			    (MP_TRUE == pluginProps.canSetTPGAccess)?
			    getTextString(TEXT_YES):getTextString(TEXT_NO));
			(void) printf("\t%s  %s\n",
			    getTextString(TEXT_LB_ALLOWS_PATH_OV),
			    (MP_TRUE == pluginProps.canOverridePaths)?
			    getTextString(TEXT_YES):getTextString(TEXT_NO));
			(void) printf("\t%s  %d\n",
			    getTextString(TEXT_LB_SUPP_AUTO_FB),
			    pluginProps.autoFailbackSupport);
			if ((MP_AUTOFAILBACK_SUPPORT_PLUGIN  ==
			    pluginProps.autoFailbackSupport) |
			    (MP_AUTOFAILBACK_SUPPORT_PLUGINANDMPLU
			    == pluginProps.autoFailbackSupport)) {
				(void) printf("\t%s  %s\n",
				    getTextString(TEXT_LB_AUTO_FB),
				    pluginProps.pluginAutoFailbackEnabled?\
				    getTextString(TEXT_ON):
				    getTextString(TEXT_OFF));
				(void) printf("\t%s  %d/%d\n",
				    getTextString(TEXT_LB_FB_POLLING_RATE),
				    pluginProps.currentFailbackPollingRate,
				    pluginProps.failbackPollingRateMax);
			} else {
				(void) printf("\t%s  %s\n",
				    getTextString(TEXT_LB_AUTO_FB),
				    getTextString(TEXT_NA));
				(void) printf("\t%s  %s/%s\n",
				    getTextString(TEXT_LB_FB_POLLING_RATE),
				    getTextString(TEXT_NA),
				    getTextString(TEXT_NA));
			}
			(void) printf("\t%s  %d\n",
			    getTextString(TEXT_LB_SUPP_AUTO_P),
			    pluginProps.autoProbingSupport);
			if ((MP_AUTOPROBING_SUPPORT_PLUGIN  ==
			    pluginProps.autoProbingSupport) |
			    (MP_AUTOPROBING_SUPPORT_PLUGIN ==
			    pluginProps.autoProbingSupport)) {
				(void) printf("\t%s  %s\n",
				    getTextString(TEXT_LB_AUTO_PROB),
				    (MP_TRUE ==
				    pluginProps.pluginAutoProbingEnabled)?\
				    getTextString(TEXT_YES):
				    getTextString(TEXT_NO));
				(void) printf("\t%s  %d/%d\n",
				    getTextString(TEXT_LB_PR_POLLING_RATE),
				    pluginProps.currentProbingPollingRate,
				    pluginProps.probingPollingRateMax);
			} else {
				(void) printf("\t%s  %s\n",
				    getTextString(TEXT_LB_AUTO_PROB),
				    getTextString(TEXT_NA));
				(void) printf("\t%s  %s/%s\n",
				    getTextString(TEXT_LB_PR_POLLING_RATE),
				    getTextString(TEXT_NA),
				    getTextString(TEXT_NA));
			}


			(void) printf("\t%s\n",
			    getTextString(TEXT_LB_SUPP_DEVICES));


			if (MP_TRUE !=
			    pluginProps.onlySupportsSpecifiedProducts) {
				/* LINTED E_SEC_PRINTF_VAR_FMT */
				(void) printf(getTextString(TEXT_ANY_DEVICE));
			} else {
				/* if only supports specific products, */
				/* get device product properties supported */

				mpstatus = MP_GetDeviceProductOidList(\
				    pPluginOidList->oids[i],
				    &deviceOidListArray);
				if (mpstatus != MP_STATUS_SUCCESS) {
					(void) fprintf(stderr, "%s:  %s\n",
					    cmdName, getTextString(
					    ERR_NO_SUPP_DEVICE_INFO));
					/* can't get any more info, */
					/* so we're done with this one */
					break;
				}

				for (j = 0; j < deviceOidListArray->oidCount;
				    j++) {
				/* begin backup indentation */
				(void) memset(&devProps, 0,
				    sizeof (MP_DEVICE_PRODUCT_PROPERTIES));
				/* end backup indentation */
					if ((mpstatus =
					    MP_GetDeviceProductProperties(\
					    deviceOidListArray->oids[j],
					    &devProps)) == MP_STATUS_SUCCESS) {

						(void) printf("\t\t%s  ",
						    getTextString(
						    TEXT_LB_VENDOR));
						displayArray(devProps.vendor,
						    sizeof (devProps.vendor));
						(void) printf("\n\t\t%s  ",
						    getTextString(
						    TEXT_LB_PRODUCT));
						displayArray(devProps.product,
						    sizeof (devProps.product));
						(void) printf("\n\t\t%s  ",
						    getTextString(
						    TEXT_LB_REVISION));
						displayArray(devProps.revision,
						    sizeof (devProps.revision));

						(void) printf("\n\t\t%s\n",
						    getTextString(
						    TEXT_LB_SUPPORTED_LB));
		/* begin back-up indentation */
		if (devProps.supportedLoadBalanceTypes == 0) {
			(void) printf("\t\t\t%s\n",
			    getTextString(TEXT_LBTYPE_NONE));
		} else {
			lb = 1;
			do {
				if (0 != (lb &
				    devProps.supportedLoadBalanceTypes)) {
					(void) printf("\t\t\t");
					displayLoadBalanceString(lb &
					    devProps.supportedLoadBalanceTypes);
					(void) printf("\n");
				}
				lb = lb<<1;
			} while (lb < 0x80000000);
		}
		/* end back-up indentation */
						(void) printf("\n");

					} else {
						(void) fprintf(stderr,
						    "%s:  %s\n", cmdName,
						    getTextString(
						    ERR_NO_SUPP_DEVICE_INFO));
					}
				} /* for j */
			} /* if only supports specified devices */

		} /* for each plugin */

		if (B_FALSE == bListIt) {
			/* LINTED E_SEC_PRINTF_VAR_FMT */
			(void) fprintf(stderr, getTextString(
			    ERR_CANT_FIND_MPATH_SUPPORT_WITH_NAME),
			    operand[op]);
			(void) printf("\n");

		}

	} /* for each operand */


	return (mpstatus);
}


/*
 * ****************************************************************************
 *
 * modifyMpathSupport -
 *	mpathadm modify mpath-support [options] <mpath-support name>, ...
 *
 * operandLen	- number of operands user passed into the cli
 * operand	- pointer to operand list from user
 * options	- pointer to option list from user
 *
 * ****************************************************************************
 */
int
modifyMpathSupport(int operandLen, char *operand[], cmdOptions_t *options)
{
	MP_STATUS		mpstatus = MP_STATUS_SUCCESS;
	MP_PLUGIN_PROPERTIES	pluginProps;
	MP_OID_LIST		*pPluginOidList;
	boolean_t		bFoundIt = B_FALSE;
	MP_OID			pluginOid;
	cmdOptions_t		*optionList = options;
	char			*cmdStr = getTextString(TEXT_UNKNOWN);
	int			op, i, lbValue;

	if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
	    != MP_STATUS_SUCCESS) {
		(void) fprintf(stderr, "%s: %s\n", cmdName,
		    getTextString(ERR_NO_MPATH_SUPPORT_LIST));
		return (mpstatus);
	}
	if ((NULL == pPluginOidList) || (pPluginOidList->oidCount < 1)) {
		(void) fprintf(stderr, "%s: %s\n", cmdName,
		    getTextString(ERR_NO_MPATH_SUPPORT_LIST));
		return (ERROR_CLI_FAILED);
	}

	for (op = 0; op < operandLen; op++) {
		bFoundIt = B_FALSE;
		for (i = 0;
		    (i < pPluginOidList->oidCount) && (B_TRUE != bFoundIt);
		    i++) {

			(void) memset(&pluginProps, 0,
			    sizeof (MP_PLUGIN_PROPERTIES));
			if ((mpstatus =
			    MP_GetPluginProperties(pPluginOidList->oids[i],
			    &pluginProps)) == MP_STATUS_SUCCESS) {

				if (0 == strcmp(operand[op],
				    pluginProps.fileName)) {
					bFoundIt = B_TRUE;
					pluginOid = pPluginOidList->oids[i];
				}
			} else {
				(void) fprintf(stderr, "%s:  %s\n",
				    cmdName, getTextString(ERR_NO_PROPERTIES));
			}

			if (B_FALSE == bFoundIt) {
				break;
			}

/* begin back-up indentation */
	/* we found the plugin oid */
	/* now change the options requested */
	switch (optionList->optval) {
		case 'a':
			/* modify autofailback */
			cmdStr = getTextString(TEXT_AUTO_FAILBACK);
			if (0 == strcasecmp(optionList->optarg,
			    getTextString(TEXT_ON))) {
				mpstatus =
				    MP_EnableAutoFailback(pluginOid);
			} else if (0 ==
			    strcasecmp(optionList->optarg,
			    getTextString(TEXT_OFF))) {
				mpstatus =
				    MP_DisableAutoFailback(pluginOid);
			} else {
				/* LINTED E_SEC_PRINTF_VAR_FMT */
				(void) fprintf(stderr, getTextString(
				    ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
				    cmdStr,
				    getTextString(TEXT_ILLEGAL_ARGUMENT));
				(void) printf("\n");
				return (ERROR_CLI_FAILED);
			}
			break;
		case 'p':
			/* modify autoprobing */
			cmdStr = getTextString(TEXT_AUTO_PROBING);
			if (0 == strcasecmp(optionList->optarg,
			    getTextString(TEXT_ON))) {
				mpstatus =
				    MP_EnableAutoProbing(pluginOid);
			} else if (0 ==
			    strcasecmp(optionList->optarg,
			    getTextString(TEXT_OFF))) {
				mpstatus =
				    MP_DisableAutoProbing(pluginOid);
			} else {
				/* LINTED E_SEC_PRINTF_VAR_FMT */
				(void) fprintf(stderr, getTextString(
				    ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
				    cmdStr,
				    getTextString(TEXT_ILLEGAL_ARGUMENT));
				(void) printf("\n");
				return (ERROR_CLI_FAILED);
			}
			break;
		case 'b':
			/* modify loadbalance type */
			cmdStr = getTextString(TEXT_LOAD_BALANCE);
			/* user of the cli sends text string, we need the int */
			/* value to pass to the mpapi */
			lbValue = getLbValueFromString(optionList->optarg);
			mpstatus =
			    MP_SetPluginLoadBalanceType(pluginOid,
			    lbValue);
			break;

		} /* switch */
		if (MP_STATUS_SUCCESS != mpstatus) {
			/* LINTED E_SEC_PRINTF_VAR_FMT */
			(void) fprintf(stderr,
			    getTextString(
			    ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
			    cmdStr, getMpStatusStr(mpstatus));
			(void) printf("\n");
			return (mpstatus);
		}
/* end back-up indentation */

		} /* for each plugin */

		if (B_FALSE == bFoundIt) {
			/* LINTED E_SEC_PRINTF_VAR_FMT */
			(void) fprintf(stderr,
			    getTextString(
			    ERR_FAILED_TO_CHANGE_OPTION_WITH_REASON),
			    cmdStr,
			    getTextString(TEXT_MPATH_SUPPORT_NOT_FOUND));
			(void) printf("\n");
			return (ERROR_CLI_FAILED);
		}

	} /* for each operand */

	return (mpstatus);
}


/*
 * ****************************************************************************
 *
 * listLogicalUnit -
 *	mpathadm list {logical-unit | LU} [options] [<logical-unit name>, ...]
 *
 * operandLen	- number of operands user passed into the cli
 * operand	- pointer to operand list from user
 * options	- pointer to option list from user
 *
 * ****************************************************************************
 */
int
listLogicalUnit(int operandLen, char *operand[], cmdOptions_t *options)
{
	MP_STATUS mpstatus = MP_STATUS_SUCCESS;
	MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES luProps;
	MP_PLUGIN_PROPERTIES pluginProps;
	MP_TARGET_PORT_PROPERTIES tportProps;
	MP_OID_LIST *pPluginOidList, *pLogicalUnitOidList,
	    *pTpgOidListArray, *pTportOidListArray;
	boolean_t bListIt = B_FALSE, bFoundOperand = B_FALSE,
	    *bFoundOption, bContinue = B_FALSE;
	MP_OID luOid;
	cmdOptions_t *optionList = options;
	int opListCount = 0, i = 0, lu = 0, tpg = 0, opoffset = 0, j = 0,
	    opStart = 0, opEnd = 0, opIndex;

	/* count number of options */
	for (; optionList->optval; optionList++) {
		opListCount++;
	}

	bFoundOption = malloc((sizeof (boolean_t)) * opListCount);
	if (NULL == bFoundOption) {
		(void) fprintf(stdout, "%s\n",
		    getTextString(ERR_MEMORY_ALLOCATION));
		return (ERROR_CLI_FAILED);
	}

	/* list to keep track of multiple options */
	optionList = options;
	for (opIndex = 0; opIndex < opListCount; opIndex++) {
		bFoundOption[opIndex] = B_FALSE;
	}

	optionList = options;

	/* if no operands or options, list everything we find */
	if ((0 == operandLen) && (0 == opListCount)) {
		if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
		    != MP_STATUS_SUCCESS) {
			(void) fprintf(stderr, "%s: %s\n", cmdName,
			    getTextString(ERR_NO_MPATH_SUPPORT_LIST));
			return (mpstatus);
		}
		if ((NULL == pPluginOidList) ||
		    (pPluginOidList->oidCount < 1)) {
			(void) fprintf(stderr, "%s: %s\n", cmdName,
			    getTextString(ERR_NO_MPATH_SUPPORT_LIST));
			return (ERROR_CLI_FAILED);
		}

		for (i = 0; i < pPluginOidList->oidCount; i++) {
			/* get properties so we can list the name */
			(void) memset(&pluginProps, 0,
			    sizeof (MP_PLUGIN_PROPERTIES));
			if ((mpstatus =
			    MP_GetPluginProperties(pPluginOidList->oids[i],
			    &pluginProps)) != MP_STATUS_SUCCESS) {
				(void) fprintf(stderr, "%s:  %s\n",
				    cmdName, getTextString(ERR_NO_PROPERTIES));
				return (mpstatus);
			}

			/* attempt to find this logical unit */
			mpstatus = MP_GetMultipathLus(pPluginOidList->oids[i],
			    &pLogicalUnitOidList);
			if (mpstatus != MP_STATUS_SUCCESS) {
				(void) fprintf(stderr, "%s:  %s\n",
				    cmdName, getTextString(ERR_NO_LU_LIST));
				return (mpstatus);
			}

			for (lu = 0; lu < pLogicalUnitOidList->oidCount; lu++) {
			/* begin backup indentation */
			/* get lu properties so we can check the name */
			(void) memset(&luProps, 0,
			    sizeof (MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES));
			/* end backup indentation */
				mpstatus =
				    MP_GetMPLogicalUnitProperties(
				    pLogicalUnitOidList->oids[lu],
				    &luProps);
				if (mpstatus != MP_STATUS_SUCCESS) {
					(void) fprintf(stderr, "%s:  %s\n",
					    cmdName,
					    getTextString(ERR_NO_PROPERTIES));
					return (mpstatus);
				}

				luOid = pLogicalUnitOidList->oids[lu];
				if (listIndividualLogicalUnit(luOid, luProps)
				    != 0) {
					return (ERROR_CLI_FAILED);
				}
			} /* for each LU */
		} /* for each plugin */
	} else { /* we have operands and/or options */

		/* check if we have operands */
		if (0 == operandLen) {
			/* no operands */
			opStart = -1;
			opEnd = 0;
		} else {
			/* operands */
			opStart = 0;
			opEnd = operandLen;
		}

		if ((mpstatus = MP_GetPluginOidList(&pPluginOidList))
		    != MP_STATUS_SUCCESS) {
			(void) fprintf(stderr, "%s: %s\n", cmdName,
			    getTextString(ERR_NO_MPATH_SUPPORT_LIST));
			return (mpstatus);
		}
		if ((NULL == pPluginOidList) ||
		    (pPluginOidList->oidCount < 1)) {
			(void) fprintf(stderr, "%s: %s\n", cmdName,
			    getTextString(ERR_NO_MPATH_SUPPORT_LIST));
			return (ERROR_CLI_FAILED);
		}

		for (opoffset = opStart; opoffset < opEnd; opoffset++) {
			/* loop through operands */
			bFoundOperand = B_FALSE;

			for (i = 0; i < pPluginOidList->oidCount; i++) {

				/*
				 * loop through plugin, and get properties
				 * so we can list the name
				 */
				(void) memset(&pluginProps, 0,
				    sizeof (MP_PLUGIN_PROPERTIES));
				if ((mpstatus =
				    MP_GetPluginProperties(
				    pPluginOidList->oids[i], &pluginProps))
				    != MP_STATUS_SUCCESS) {
					(void) fprintf(stderr, "%s:  %s\n",
					    cmdName,
					    getTextString(ERR_NO_PROPERTIES));
					return (mpstatus);
				}

				/* attempt to find this logical unit */
				mpstatus =
				    MP_GetMultipathLus(pPluginOidList->oids[i],
				    &pLogicalUnitOidList);
				if (mpstatus != MP_STATUS_SUCCESS) {
					(void) fprintf(stderr, "%s:  %s\n",
					    cmdName,
					    getTextString(ERR_NO_LU_LIST));
					return (mpstatus);
				}

				for (lu = 0;
				    (lu < pLogicalUnitOidList->oidCount);
				    lu++) {
					bListIt = B_FALSE;
			/* begin backup indentation */
			/* get lu props & check the name */
			(void) memset(&luProps, 0,
			    sizeof (MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES));
			/* end backup indentation */
					mpstatus =
					    MP_GetMPLogicalUnitProperties(
					    pLogicalUnitOidList->oids[lu],
					    &luProps);
					if (mpstatus != MP_STATUS_SUCCESS) {
						(void) fprintf(stderr,
						    "%s:  %s\n", cmdName,
						    getTextString(
						    ERR_NO_PROPERTIES));
						return (mpstatus);
					}

					/*
					 * compare operand - is it a match?
					 * If so, continue
					 */

					bContinue = B_TRUE;
					if (operandLen > 0) {
						bContinue =
						    compareLUName(
						    operand[opoffset],
						    luProps.deviceFileName);
					}

					if (B_TRUE == bContinue) {

						if (0 != opListCount) {
							/* check options */


/* begin backup indentation */
optionList = options;

for (opIndex = 0; optionList->optval; optionList++, opIndex++) {
switch (optionList->optval) {
	case 'n':
		if (B_TRUE ==
		    compareLUName(optionList->optarg, luProps.name)) {
			bListIt = B_TRUE;
			bFoundOperand = B_TRUE;
			bFoundOption[opIndex] = B_TRUE;
		}
		break;
	case 't':
		/* get TPG list */
		mpstatus =
		    MP_GetAssociatedTPGOidList(pLogicalUnitOidList->oids[lu],
		    &pTpgOidListArray);
		if (mpstatus !=  MP_STATUS_SUCCESS) {
			(void) fprintf(stderr,  "%s:  %s\n", cmdName,
			    getTextString(ERR_NO_ASSOC_TPGS));
			return (mpstatus);
		}

		/* get target ports */
		for (tpg = 0;
		    (NULL != pTpgOidListArray) &&
		    (tpg < pTpgOidListArray->oidCount) &&
		    (B_FALSE == bListIt); tpg++) {
			mpstatus =
			    MP_GetTargetPortOidList(pTpgOidListArray->oids[tpg],
			    &pTportOidListArray);
			if (mpstatus != MP_STATUS_SUCCESS) {
				(void) fprintf(stderr, "%s:  %s\n",
				    cmdName,
				    getTextString(ERR_NO_ASSOC_TPORTS));
				return (mpstatus);
			}

			/* get target port properties for the name */
			for (j = 0; (NULL != pTportOidListArray) &&
			    (j < pTportOidListArray->oidCount) &&
			    (B_FALSE == bListIt); j++) {
				(void) memset(&tportProps, 0,
				    sizeof (MP_TARGET_PORT_PROPERTIES));
				mpstatus =
				    MP_GetTargetPortProperties(
				    pTportOidListArray->oids[j], &tportProps);
				if (mpstatus != MP_STATUS_SUCCESS) {
					(void) fprintf(stderr, "%s:  %s\n",
					    cmdName,
					    getTextString(ERR_NO_PROPERTIES));
					return (mpstatus);
				}


				/* check the name */
				if (0 == strcmp(optionList->optarg,
				    tportProps.portID)) {
					bListIt = B_TRUE;
					bFoundOperand = B_TRUE;
					bFoundOption[opIndex] = B_TRUE;
				}
			} /* for each target port */
		} /* for each tpg */
	} /* end switch */
} /* loop through options */
/* end back-up indentation */

						} else {
							/*
							 * if no options,
							 * listit
							 */
							bListIt = B_TRUE;
							bFoundOperand = B_TRUE;
						}
					} /* end bContinue check */

		if (bListIt) {
			(void) printf("%s  %s\n",
			    getTextString(TEXT_LB_MPATH_SUPPORT),
			    pluginProps.fileName);
			luOid = pLogicalUnitOidList->oids[lu];
			if (listIndividualLogicalUnit(luOid, luProps)
			    != 0) {
				return (ERROR_CLI_FAILED);
			}

		}

				} /* end LU loop */
			} /* end plugin loop */
			if ((0 == opListCount) && (0 != operandLen)) {
				if (B_FALSE == bFoundOperand) {
					/* option/operand combo not found */
					/* LINTED E_SEC_PRINTF_VAR_FMT */
					(void) fprintf(stderr,
					    getTextString(
				    ERR_LU_NOT_FOUND_WITH_MISSING_LU_STR),
					    operand[opoffset]);
					(void) fprintf(stderr, "\n");
				}
			}

			optionList = options;
			for (opIndex = 0; optionList->optval; optionList++,
			    opIndex++) {
				if (B_FALSE == bFoundOption[opIndex]) {
					/* LINTED E_SEC_PRINTF_VAR_FMT */
					(void) fprintf(stderr,
					    getTextString(
				    ERR_LU_NOT_FOUND_WITH_MISSING_LU_STR),
					    optionList->optarg);
					(void) fprintf(stderr, "\n");
				}
			}



		} /* end loop through operands */
	} /* we have operands and/or options */


	return (mpstatus);
}


/*
 * ****************************************************************************
 *
 * compareLUName -
 *	compare names directly and via devid if no match directly
 *
 * cmpString		- first string to compare
 * deviceProperty	- string from properties
 * sizeToCompare	- size of deviceProperty
 *
 * returns	B_TRUE if the strings match either directly or via devid
 *		B_FALSE otherwise
 *
 * ****************************************************************************
 */
boolean_t
compareLUName(MP_CHAR *cmpString, MP_CHAR *deviceProperty)
{

	boolean_t				isSame = B_FALSE;
	int					fd1, fd2;
	ddi_devid_t				devid1 = NULL, devid2 = NULL;

	if (0 == strcmp(cmpString, deviceProperty)) {
		isSame = B_TRUE;
	} else {
		/* user input didn't match, try via devid */