xref: /titanic_50/usr/src/cmd/luxadm/fchba.c (revision fcf3ce441efd61da9bb2884968af01cb7c1452cc)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */



#include	<hbaapi.h>
#include	<stdio.h>
#include	<unistd.h>
#include	<stdlib.h>
#include	<sys/param.h>
#include	<sys/types.h>
#include	<sys/stat.h>
#include	<string.h>
#include	<strings.h>
#include	<ctype.h>
#include	<sys/scsi/generic/sense.h>
#include	<sys/scsi/generic/mode.h>
#include	<sys/scsi/generic/inquiry.h>
#include	<errno.h>
#include	<libdevice.h>
#include	<config_admin.h>
#include	<sys/byteorder.h>
#include	<sys/fibre-channel/fcio.h>
#include	"common.h"
#include	"sun_fc_version.h"

#define	DEFAULT_LUN_COUNT	1024
#define	LUN_SIZE		8
#define	LUN_HEADER_SIZE		8
#define	DEFAULT_LUN_LENGTH	DEFAULT_LUN_COUNT   *	\
				LUN_SIZE	    +	\
				LUN_HEADER_SIZE
struct lun_val {
	uchar_t val[8];
};
struct rep_luns_rsp {
	uint32_t    length;
	uint32_t    rsrvd;
	struct lun_val  lun[1];
};

/* Extracted from the old scsi.h file */
struct  capacity_data_struct {
	uint_t  last_block_addr;
	uint_t  block_size;
};


/* Structure to handle the inq. page 0x80 serial number */
struct page80 {
	uchar_t inq_dtype;
	uchar_t inq_page_code;
	uchar_t reserved;
	uchar_t inq_page_len;
	uchar_t inq_serial[251];
};

extern char		*dtype[];
extern int		Options;
extern const int	OPTION_P;

int skip_hba(int i);
int find_supported_inq_page(HBA_HANDLE handle, HBA_WWN hwwn, HBA_WWN pwwn,
    uint64_t lun, int page_num);
/*
 * The routines within this file operate against the T11
 * HBA API interface.  In some cases, proprietary Sun driver
 * interface are also called to add additional information
 * above what the standard library supports.
 */

uint64_t
wwnConversion(uchar_t *wwn) {
	uint64_t tmp;
	(void) memcpy(&tmp, wwn, sizeof (uint64_t));
	return (ntohll(tmp));
}

void printStatus(HBA_STATUS status) {
	switch (status) {
	case HBA_STATUS_OK:
	    printf(MSGSTR(2410, "OK"));
	    return;
	case HBA_STATUS_ERROR:
	    printf(MSGSTR(2411, "ERROR"));
	    return;
	case HBA_STATUS_ERROR_NOT_SUPPORTED:
	    printf(MSGSTR(2412, "NOT SUPPORTED"));
	    return;
	case HBA_STATUS_ERROR_INVALID_HANDLE:
	    printf(MSGSTR(2413, "INVALID HANDLE"));
	    return;
	case HBA_STATUS_ERROR_ARG:
	    printf(MSGSTR(2414, "ERROR ARG"));
	    return;
	case HBA_STATUS_ERROR_ILLEGAL_WWN:
	    printf(MSGSTR(2415, "ILLEGAL WWN"));
	    return;
	case HBA_STATUS_ERROR_ILLEGAL_INDEX:
	    printf(MSGSTR(2416, "ILLEGAL INDEX"));
	    return;
	case HBA_STATUS_ERROR_MORE_DATA:
	    printf(MSGSTR(2417, "MORE DATA"));
	    return;
	case HBA_STATUS_ERROR_STALE_DATA:
	    printf(MSGSTR(2418, "STALE DATA"));
	    return;
	case HBA_STATUS_SCSI_CHECK_CONDITION:
	    printf(MSGSTR(2419, "SCSI CHECK CONDITION"));
	    return;
	case HBA_STATUS_ERROR_BUSY:
	    printf(MSGSTR(2420, "BUSY"));
	    return;
	case HBA_STATUS_ERROR_TRY_AGAIN:
	    printf(MSGSTR(2421, "TRY AGAIN"));
	    return;
	case HBA_STATUS_ERROR_UNAVAILABLE:
	    printf(MSGSTR(2422, "UNAVAILABLE"));
	    return;
	default:
	    printf(MSGSTR(2423, "UNKNOWN ERROR TYPE %d"), status);
	    return;
	    }
}

uint32_t
getNumberOfAdapters() {
	uint32_t count = HBA_GetNumberOfAdapters();
	if (count == 0) {
		fprintf(stderr, MSGSTR(2405,
			"\nERROR: No Fibre Channel Adapters found.\n"));
	}
	return (count);
}

#define	MAX_RETRIES	10

/*
 * Returns non-zero on failure (aka, HBA_STATUS_ERROR_*
 * Will handle retries if applicable.
 */
int
getAdapterAttrs(HBA_HANDLE handle, char *name, HBA_ADAPTERATTRIBUTES *attrs) {
	int count = 0;
	HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */

	/* Loop as long as we have a retryable error */
	while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
		status == HBA_STATUS_ERROR_BUSY) && count++ < MAX_RETRIES) {
		status = HBA_GetAdapterAttributes(handle, attrs);
		if (status == HBA_STATUS_OK) {
			break;
		}
		(void) sleep(1);
	}
	if (status != HBA_STATUS_OK) {
		/* We encountered a non-retryable error */
		fprintf(stderr, MSGSTR(2501,
		"\nERROR: Unable to retrieve adapter port details (%s)"),
		name);
		printStatus(status);
		fprintf(stderr, "\n");
	}
	return (status);
}

/*
 * Returns non-zero on failure (aka, HBA_STATUS_ERROR_*
 * Will handle retries if applicable.
 */
int
getAdapterPortAttrs(HBA_HANDLE handle, char *name, int portIndex,
	    HBA_PORTATTRIBUTES *attrs) {
	int count = 0;
	HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */

	/* Loop as long as we have a retryable error */
	while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
		status == HBA_STATUS_ERROR_BUSY) && count++ < MAX_RETRIES) {
		status = HBA_GetAdapterPortAttributes(handle, portIndex, attrs);
		if (status == HBA_STATUS_OK) {
			break;
		}

		/* The odds of this occuring are very slim, but possible. */
		if (status == HBA_STATUS_ERROR_STALE_DATA) {
			/*
			 * If we hit a stale data scenario,
			 * we'll just tell the user to try again.
			 */
			status = HBA_STATUS_ERROR_TRY_AGAIN;
			break;
		}
		sleep(1);
	}
	if (status != HBA_STATUS_OK) {
		/* We encountered a non-retryable error */
		fprintf(stderr, MSGSTR(2501,
		"\nERROR: Unable to retrieve adapter port details (%s)"),
		name);
		printStatus(status);
		fprintf(stderr, "\n");
	}
	return (status);
}

/*
 * Returns non-zero on failure (aka, HBA_STATUS_ERROR_*
 * Will handle retries if applicable.
 */
int
getDiscPortAttrs(HBA_HANDLE handle, char *name, int portIndex, int discIndex,
	    HBA_PORTATTRIBUTES *attrs) {
	int count = 0;
	HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */

	/* Loop as long as we have a retryable error */
	while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
		status == HBA_STATUS_ERROR_BUSY) && count++ < MAX_RETRIES) {
		status = HBA_GetDiscoveredPortAttributes(handle, portIndex,
				discIndex, attrs);
		if (status == HBA_STATUS_OK) {
			break;
		}

		/* The odds of this occuring are very slim, but possible. */
		if (status == HBA_STATUS_ERROR_STALE_DATA) {
			/*
			 * If we hit a stale data scenario, we'll just tell the
			 * user to try again.
			 */
			status = HBA_STATUS_ERROR_TRY_AGAIN;
			break;
		}
		sleep(1);
	}
	if (status != HBA_STATUS_OK) {
		/* We encountered a non-retryable error */
		fprintf(stderr, MSGSTR(2504,
		"\nERROR: Unable to retrieve target port details (%s)"),
		name);
		printStatus(status);
		fprintf(stderr, "\n");
	}
	return (status);
}


/*ARGSUSED*/
int
fchba_display_port(int verbose)
{
	int retval = 0;
	HBA_HANDLE handle;
	HBA_ADAPTERATTRIBUTES hbaAttrs;
	HBA_PORTATTRIBUTES portAttrs;
	HBA_STATUS status;
	int count, adapterIndex, portIndex;
	char name[256];
	char *physical = NULL;
	char path[MAXPATHLEN];

	if ((retval = loadLibrary())) {
	    return (retval);
	}

	count = getNumberOfAdapters();

	for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
	    if (skip_hba(adapterIndex)) {
		continue;
	    }
	    status = HBA_GetAdapterName(adapterIndex, (char *)&name);
	    if (status != HBA_STATUS_OK) {
		/* Just skip it, maybe it was DR'd */
		continue;
	    }
	    handle = HBA_OpenAdapter(name);
	    if (handle == 0) {
		/* Just skip it, maybe it was DR'd */
		continue;
	    }

	    if (getAdapterAttrs(handle, name, &hbaAttrs)) {
		/* This should never happen, we'll just skip the adapter */
		HBA_CloseAdapter(handle);
		continue;
	    }

	    for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
		    portIndex++) {
		if (getAdapterPortAttrs(handle, name, portIndex,
			&portAttrs)) {
		    continue;
		}
		physical = get_slash_devices_from_osDevName(
				portAttrs.OSDeviceName,
				STANDARD_DEVNAME_HANDLING);
		if (physical) {
			char *tmp = strstr(physical, ":fc");
			if (tmp) {
				*tmp = '\0';
				(void) snprintf(path, MAXPATHLEN, "%s:devctl",
					physical);
			} else {
				(void) snprintf(path, MAXPATHLEN, "%s",
					physical);
			}
			free(physical);
			physical = NULL;
			(void) printf("%-65s  ", path);
		} else {
			(void) printf("%-65s  ", portAttrs.OSDeviceName);
		}
		if (portAttrs.NumberofDiscoveredPorts > 0) {
		    printf(MSGSTR(2233, "CONNECTED\n"));
		} else {
		    printf(MSGSTR(2234, "NOT CONNECTED\n"));
		}
	    }
	}
	(void) HBA_FreeLibrary();
	return (retval);
}

/*
 * Internal routines/structure to deal with a path list
 * so we can ensure uniqueness
 */
struct path_entry {
	char path[MAXPATHLEN];
	HBA_UINT8 wwn[8];
	uchar_t dtype;
	struct path_entry *next;
};
void add_path(struct path_entry *head, struct path_entry *cur) {
	struct path_entry *tmp;
	for (tmp = head; tmp->next != NULL; tmp = tmp->next) { }
		tmp->next = cur;
}
struct path_entry *is_duplicate_path(struct path_entry *head, char *path) {
	struct path_entry *tmp;
	for (tmp = head; tmp != NULL; tmp = tmp->next) {
		if (strncmp(tmp->path, path, sizeof (tmp->path)) == 0) {
			return (tmp);
		}
	}
	return (NULL);
}
void free_path_list(struct path_entry *head) {
	struct path_entry *tmp;
	struct path_entry *tmp2;
	for (tmp = head; tmp != NULL; ) {
		tmp2 = tmp->next;
		free(tmp);
		tmp = tmp2;
	}
}


int
is_wwn(char *arg) {
	int i;
	if (strlen(arg) == 16) {
		for (i = 0; i < 16; i++) {
			if (!isxdigit(arg[i])) {
				return (0);
			}
		}
		return (1);
	}
	return (0);
}

int
is_path(char *arg) {
	struct stat buf;
	if (stat(arg, &buf)) {
		return (0);
	}
	return (1);
}

/* We take a wild guess for our first get target mappings call */
#define	MAP_GUESS	50

HBA_STATUS
fetch_mappings(HBA_HANDLE handle, HBA_WWN pwwn, HBA_FCPTARGETMAPPINGV2 **map) {
	int loop = 0;
	int count = 0;
	HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */
	*map = (HBA_FCPTARGETMAPPINGV2 *) calloc(1,
		(sizeof (HBA_FCPSCSIENTRYV2)* (MAP_GUESS-1)) +
		sizeof (HBA_FCPTARGETMAPPINGV2));

	/* Loop as long as we have a retryable error */
	while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
		status == HBA_STATUS_ERROR_BUSY ||
		status == HBA_STATUS_ERROR_MORE_DATA) && loop++ < MAX_RETRIES) {
	    status = HBA_GetFcpTargetMappingV2(handle, pwwn, *map);
	    if (status == HBA_STATUS_OK) {
		break;
	    } else if (status == HBA_STATUS_ERROR_MORE_DATA) {
		count = (*map)->NumberOfEntries;
		free(*map);
		*map = (HBA_FCPTARGETMAPPINGV2 *) calloc(1,
		    (sizeof (HBA_FCPSCSIENTRYV2)* (count-1)) +
		    sizeof (HBA_FCPTARGETMAPPINGV2));
		(*map)->NumberOfEntries = count;
		continue;
	    }
	    sleep(1);
	}
	if (status != HBA_STATUS_OK) {
	    /* We encountered a non-retryable error */
	    fprintf(stderr, MSGSTR(2502,
		    "\nERROR: Unable to retrieve SCSI device paths "
		    "(HBA Port WWN %016llx)"),
		    wwnConversion(pwwn.wwn));
	    printStatus(status);
	    fprintf(stderr, "\n");
	}
	return (status);
}

/*
 * Returns the index of the first match, or -1 if no match
 */
int
match_mappings(char *compare, HBA_FCPTARGETMAPPINGV2 *map) {
	int		mapIndex;
	char	*physical = NULL;
	char	*tmp;
	int		wwnCompare = 0;
	uint64_t	wwn;

	if (map == NULL || compare == NULL) {
	    return (-1);
	}

	if (is_wwn(compare)) {
	    wwnCompare = 1;
	    (void) sscanf(compare, "%016llx", &wwn);
	} else {
	    /* Convert the paths to phsyical paths */
	    physical = get_slash_devices_from_osDevName(compare,
			STANDARD_DEVNAME_HANDLING);
	}

	for (mapIndex = 0; mapIndex < map->NumberOfEntries; mapIndex ++) {
	    if (wwnCompare) {
		if (wwn == wwnConversion(
			map->entry[mapIndex].FcpId.NodeWWN.wwn) ||
			wwn == wwnConversion(
			map->entry[mapIndex].FcpId.PortWWN.wwn)) {
		    return (mapIndex);
		}
	    } else {
		if (physical != NULL) {
		    tmp = get_slash_devices_from_osDevName(
			map->entry[mapIndex].ScsiId.OSDeviceName,
			STANDARD_DEVNAME_HANDLING);
		    if ((tmp != NULL) &&
			strncmp(physical, tmp, MAXPATHLEN) == 0) {
			free(physical);
			return (mapIndex);
		    }
		}
	    }
	}
	if (physical) {
	    free(physical);
	}
	return (-1);
}


/*
 * returns non-zero on failure (aka HBA_STATUS_ERROR_*
 */
int
loadLibrary() {
	int status = HBA_LoadLibrary();
	if (status != HBA_STATUS_OK) {
		fprintf(stderr, MSGSTR(2505,
			"ERROR: Unable to load HBA API library: "));
		printStatus(status);
		fprintf(stderr, "\n");
	}
	return (status);
}

int
fchba_non_encl_probe() {
	HBA_HANDLE handle;
	HBA_ADAPTERATTRIBUTES hbaAttrs;
	HBA_PORTATTRIBUTES portAttrs;
	HBA_FCPTARGETMAPPINGV2    *map;
	HBA_STATUS status;
	int count, adapterIndex, portIndex, mapIndex;
	char name[256];
	struct path_entry *head = NULL;
	uint64_t	lun = 0;
	L_inquiry	inq;
	struct scsi_extended_sense sense;
	HBA_UINT8	scsiStatus;
	uint32_t	inquirySize = sizeof (inq), senseSize = sizeof (sense);

	if (loadLibrary()) {
	    return (-1);
	}

	count = getNumberOfAdapters();

	/* Loop over all HBAs */
	for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
	    if (skip_hba(adapterIndex)) {
		continue;
	    }
	    status = HBA_GetAdapterName(adapterIndex, (char *)&name);
	    if (status != HBA_STATUS_OK) {
		/* May have been DR'd */
		continue;
	    }
	    handle = HBA_OpenAdapter(name);
	    if (handle == 0) {
		/* May have been DR'd */
		continue;
	    }

	    if (getAdapterAttrs(handle, name, &hbaAttrs)) {
		/* Should not happen, just skip it */
		HBA_CloseAdapter(handle);
		continue;
	    }


	    /* Loop over all HBA Ports */
	    for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
		    portIndex++) {
		if (getAdapterPortAttrs(handle, name, portIndex,
			&portAttrs)) {
		    continue;
		}

		if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
		    continue;
		}

		/* Loop over all target Mapping entries */
		for (mapIndex = 0; mapIndex < map->NumberOfEntries;
		    mapIndex ++) {
			struct path_entry *tmpPath = NULL;
			int doInquiry = 0;
			if (!head) {
			head = (struct path_entry *)calloc(1,
				sizeof (struct path_entry));
			tmpPath = head;
			strncpy(head->path,
			    map->entry[mapIndex].ScsiId.OSDeviceName,
			    sizeof (map->entry[mapIndex].ScsiId.OSDeviceName));
			(void) memcpy(tmpPath->wwn,
			    map->entry[mapIndex].FcpId.NodeWWN.wwn,
			    sizeof (HBA_UINT8) * 8);
			doInquiry = 1;
			} else if (tmpPath = is_duplicate_path(head,
				map->entry[mapIndex].ScsiId.OSDeviceName)) {
				if (tmpPath->dtype != 0x1f) {
					doInquiry = 0;
				} else {
					doInquiry = 1;
				}
			} else {
			tmpPath = (struct path_entry *)
				calloc(1, sizeof (struct path_entry));
			strncpy(tmpPath->path,
			    map->entry[mapIndex].ScsiId.OSDeviceName,
			    sizeof (map->entry[mapIndex].ScsiId.OSDeviceName));
			(void) memcpy(tmpPath->wwn,
			    map->entry[mapIndex].FcpId.NodeWWN.wwn,
			    sizeof (HBA_UINT8) * 8);
			add_path(head, tmpPath);
			doInquiry = 1;
			}

			if (doInquiry) {
				lun = map->entry[mapIndex].FcpId.FcpLun;
				memset(&inq, 0, sizeof (inq));
				memset(&sense, 0, sizeof (sense));
				status = HBA_ScsiInquiryV2(handle,
				    portAttrs.PortWWN,
				    map->entry[mapIndex].FcpId.PortWWN,
				    lun, 0, 0,
				    &inq, &inquirySize,
				    &scsiStatus,
				    &sense, &senseSize);
				if (status != HBA_STATUS_OK) {
					inq.inq_dtype = 0x1f;
				}
				tmpPath->dtype = inq.inq_dtype;
			}
		}
	}
	}
	if (head) {
		struct path_entry *tmp;
		printf(MSGSTR(2098, "\nFound Fibre Channel device(s):\n"));
		for (tmp = head; tmp != NULL; tmp = tmp->next) {
			printf("  ");
			printf(MSGSTR(90, "Node WWN:"));
			printf("%016llx  ", wwnConversion(tmp->wwn));
			fprintf(stdout, MSGSTR(35, "Device Type:"));
			(void) fflush(stdout);

			if ((tmp->dtype & DTYPE_MASK) < 0x10) {
				fprintf(stdout, "%s",
				    dtype[tmp->dtype & DTYPE_MASK]);
			} else if ((tmp->dtype & DTYPE_MASK) < 0x1f) {
				fprintf(stdout, MSGSTR(2406,
				    "Reserved"));
			} else {
				fprintf(stdout, MSGSTR(2407,
				    "Unknown"));
			}

			printf("\n    ");
			printf(MSGSTR(31, "Logical Path:%s"), tmp->path);
			printf("\n");

		/* We probably shouldn't be using a g_fc interface here */
			if (Options & OPTION_P) {
				char *phys_path =
				get_slash_devices_from_osDevName(
				    tmp->path,
				    STANDARD_DEVNAME_HANDLING);
				if (phys_path != NULL) {
				fprintf(stdout, "    ");
				fprintf(stdout, MSGSTR(5, "Physical Path:"));
				fprintf(stdout, "\n     %s\n", phys_path);
				free(phys_path);
				}
			}
		}
		free_path_list(head);
	}
	HBA_FreeLibrary();
	return (0);
}


int
fchba_inquiry(char **argv)
{
	int		path_index = 0, found = 0;
	uint64_t	wwn;
	uint64_t	lun = 0;
	HBA_HANDLE handle;
	HBA_ADAPTERATTRIBUTES hbaAttrs;
	HBA_PORTATTRIBUTES portAttrs;
	HBA_FCPTARGETMAPPINGV2    *map;
	HBA_STATUS status;
	int count, adapterIndex, portIndex, mapIndex;
	char name[256];
	L_inquiry	inq;
	struct page80	serial;
	uint32_t	serialSize = sizeof (serial);
	struct scsi_extended_sense sense;
	HBA_UINT8	scsiStatus;
	uint32_t	inquirySize = sizeof (inq), senseSize = sizeof (sense);
	boolean_t	goodPath = B_FALSE;
	int		matched = 0, wwnCompare = 0;
	char		*tmp, *physical = NULL;
	int		ret = 0;

	if (loadLibrary()) {
	    return (-1);
	}
	for (path_index = 0; argv[path_index] != NULL; path_index++) {
	    goodPath = B_FALSE;
	    found = 0;

	    if (is_wwn(argv[path_index])) {
		(void) sscanf(argv[path_index], "%016llx", &wwn);
		wwnCompare = 1;
	    } else if (!is_path(argv[path_index])) {
		fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
			argv[path_index]);
		fprintf(stderr, "\n");
		ret = -1;
		continue;
	    }
	    if (!wwnCompare) {
		/* Convert the paths to phsyical paths */
		physical = get_slash_devices_from_osDevName(argv[path_index],
			STANDARD_DEVNAME_HANDLING);
		if (!physical) {
		    fprintf(stderr, MSGSTR(112,
			"Error: Invalid pathname (%s)"),
			argv[path_index]);
		    fprintf(stderr, "\n");
		    ret = -1;
		    continue;
		}
	    }

	    count = getNumberOfAdapters();

	    /* Loop over all HBAs */
	    for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
		if (skip_hba(adapterIndex)) {
		    continue;
		}
		status = HBA_GetAdapterName(adapterIndex, (char *)&name);
		if (status != HBA_STATUS_OK) {
		    /* May have been DR'd */
		    continue;
		}
		handle = HBA_OpenAdapter(name);
		if (handle == 0) {
		    /* May have been DR'd */
		    continue;
		}

		if (getAdapterAttrs(handle, name, &hbaAttrs)) {
		    /* Should never happen */
		    HBA_CloseAdapter(handle);
		    continue;
		}


		/* Loop over all HBA Ports */
		for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
			portIndex++) {
		    if (getAdapterPortAttrs(handle, name, portIndex,
			    &portAttrs)) {
			continue;
		    }

		    if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
			continue;
		    }

		    for (mapIndex = 0; mapIndex < map->NumberOfEntries;
			    mapIndex ++) {
			matched = 0;
			if (wwnCompare) {
			    if (wwn == wwnConversion(
				    map->entry[mapIndex].FcpId.NodeWWN.wwn) ||
				    wwn == wwnConversion(
				    map->entry[mapIndex].FcpId.PortWWN.wwn)) {
				lun = map->entry[mapIndex].FcpId.FcpLun;
				matched = 1;
			    }
			} else {
			    tmp = get_slash_devices_from_osDevName(
				    map->entry[mapIndex].ScsiId.OSDeviceName,
				    STANDARD_DEVNAME_HANDLING);
			    if ((tmp != NULL) && (strncmp(physical, tmp,
				    MAXPATHLEN) == 0)) {
				lun = map->entry[mapIndex].FcpId.FcpLun;
				matched = 1;
				free(tmp);
			    }
			}

			if (matched) {
			    memset(&inq, 0, sizeof (inq));
			    memset(&sense, 0, sizeof (sense));
			    status = HBA_ScsiInquiryV2(handle,
				portAttrs.PortWWN,
				map->entry[mapIndex].FcpId.PortWWN,
				lun, 0, 0,
				&inq, &inquirySize,
				&scsiStatus,
				&sense, &senseSize);
			    if (status == HBA_STATUS_OK) {
				goodPath = B_TRUE;
				/*
				 * Call the inquiry cmd on page 0x80 only if
				 * the vendor supports page 0x80
				 */
				memset(&serial, 0, sizeof (serial));
				if ((find_supported_inq_page(handle,
					    portAttrs.PortWWN,
					    map->entry[mapIndex].FcpId.PortWWN,
					    lun, 0x80))) {
					status = HBA_ScsiInquiryV2(handle,
					    portAttrs.PortWWN,
					    map->entry[mapIndex].FcpId.PortWWN,
					    lun, 1, 0x80,
					    &serial, &serialSize,
					    &scsiStatus,
					    &sense, &senseSize);
					if (status != HBA_STATUS_OK) {
						strncpy(
						    (char *)serial.inq_serial,
						    "Unavailable",
						    sizeof (serial.inq_serial));
					}
				} else {
					strncpy((char *)serial.inq_serial,
					    "Unsupported",
					    sizeof (serial.inq_serial));
				}
				/*
				 * we are adding serial number information
				 * from 0x80.  If length is less than 39,
				 * then we want to increase length to 52 to
				 * reflect the fact that we have serial number
				 * information
				 */
				if (inq.inq_len < 39) {
					inq.inq_len = 52;
				}
				print_inq_data(argv[path_index],
				    map->entry[mapIndex].ScsiId.OSDeviceName,
				    inq, serial.inq_serial,
				    sizeof (serial.inq_serial));
				if (! wwnCompare) {
					found = 1;
					break;
				}
			    } else {
				fprintf(stderr, MSGSTR(2430,
				"Error: I/O failure communicating with %s  "),
				map->entry[mapIndex].ScsiId.OSDeviceName);
				printStatus(status);
				fprintf(stderr, "\n");
			    }
			}
		    }
		    if (found == 1) {
			    break;
		    }
		}
		if (found == 1) {
			break;
		}
	    }

	    if (physical) {
		free(physical);
	    }

	    if (!goodPath) {
		fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
			argv[path_index]);
		fprintf(stderr, "\n");
		ret = -1;
	    }
	}
	return (ret);
}



int
fchba_dump_map(char **argv)
{
	int		path_index = 0;
	uint64_t	wwn;
	uint64_t	lun = 0;
	HBA_HANDLE handle;
	HBA_ADAPTERATTRIBUTES hbaAttrs;
	HBA_PORTATTRIBUTES portAttrs;
	HBA_PORTATTRIBUTES discPortAttrs;
	HBA_FCPTARGETMAPPINGV2    *map;
	HBA_STATUS status;
	int count, adapterIndex, portIndex, mapIndex, discIndex;
	char name[256], *physical, *comp_phys;
	L_inquiry	inq;
	struct scsi_extended_sense sense;
	HBA_UINT8	scsiStatus;
	int		matched;
	int		done;
	uint32_t	inquirySize = sizeof (inq), senseSize = sizeof (sense);
	boolean_t	goodPath = B_FALSE;
	int		ret = 0;
	uint32_t	responseSize = DEFAULT_LUN_LENGTH;
	uchar_t		raw_luns[DEFAULT_LUN_LENGTH];
	struct rep_luns_rsp	*lun_resp;


	if (loadLibrary()) {
	    return (-1);
	}
	for (path_index = 0; argv[path_index] != NULL; path_index++) {
	    goodPath = B_FALSE;

	    if (is_wwn(argv[path_index])) {
		(void) sscanf(argv[path_index], "%016llx", &wwn);
	    } else if (!is_path(argv[path_index])) {
		fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
			argv[path_index]);
		fprintf(stderr, "\n");
		ret = -1;
		continue;
	    }

	    count = getNumberOfAdapters();

	    done = 0;
	    /* Loop over all HBAs */
	    for (adapterIndex = 0; adapterIndex < count && !done;
		    adapterIndex ++) {
		if (skip_hba(adapterIndex)) {
		    continue;
		}
		status = HBA_GetAdapterName(adapterIndex, (char *)&name);
		if (status != HBA_STATUS_OK) {
		    /* May have been DR'd */
		    continue;
		}
		handle = HBA_OpenAdapter(name);
		if (handle == 0) {
		    /* May have been DR'd */
		    continue;
		}

		if (getAdapterAttrs(handle, name, &hbaAttrs)) {
		    /* Should never happen */
		    HBA_CloseAdapter(handle);
		    continue;
		}


		/* Loop over all HBA Ports */
		for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts && !done;
			portIndex++) {
		    if (getAdapterPortAttrs(handle, name, portIndex,
			    &portAttrs)) {
			continue;
		    }


		    matched = 0;
		    if (is_wwn(argv[path_index])) {
			if (wwn == wwnConversion(
				portAttrs.NodeWWN.wwn) ||
				wwn == wwnConversion(
				portAttrs.PortWWN.wwn)) {
			    matched = 1;
			}
		    } else {
			if (is_path(argv[path_index]) &&
			    ((physical = get_slash_devices_from_osDevName(
				argv[path_index],
				STANDARD_DEVNAME_HANDLING)) != NULL) &&
			    ((comp_phys = get_slash_devices_from_osDevName(
				portAttrs.OSDeviceName,
				STANDARD_DEVNAME_HANDLING)) != NULL)) {
			    char *tmp = strstr(physical, ":devctl");
			    if (tmp) {
				*tmp = '\0';
			    } else {
				tmp = strstr(physical, ":fc");
				if (tmp) {
					*tmp = '\0';
				}
			    }
			    if (strstr(comp_phys, physical)) {
				matched = 1;
			    }
			}
			if (physical) {
			    free(physical);
			    physical = NULL;
			}
			if (comp_phys) {
			    free(comp_phys);
			    comp_phys = NULL;
			}
		    }

		    if (!fetch_mappings(handle, portAttrs.PortWWN, &map)) {
			mapIndex = match_mappings(argv[path_index], map);
			if (mapIndex >= 0) {
			    matched = 1;
			}
		    } else {
			continue;
		    }

		    if (matched) {
			goodPath = B_TRUE;
			printf(MSGSTR(2095,
				"Pos  Port_ID Hard_Addr Port WWN"
				"         Node WWN         Type\n"));
			for (discIndex = 0;
				discIndex < portAttrs.NumberofDiscoveredPorts;
				discIndex++) {
			    if (getDiscPortAttrs(handle, name, portIndex,
				    discIndex, &discPortAttrs)) {
				/* Move on to the next target */
				continue;
			    }

			    printf("%-4d %-6x  %-6x   %016llx %016llx",
				    discIndex,
				    discPortAttrs.PortFcId, 0,
				    wwnConversion(discPortAttrs.PortWWN.wwn),
				    wwnConversion(discPortAttrs.NodeWWN.wwn));

				/*
				 * devices are not all required to respond to
				 * Scsi Inquiry calls sent to LUN 0.  We must
				 * fisrt issue a ReportLUN and then send the
				 * SCSI Inquiry call to the first LUN Returned
				 * from the ReportLUN call
				 */
			    memset(&sense, 0, sizeof (sense));
			    status = HBA_ScsiReportLUNsV2(handle,
				portAttrs.PortWWN,
				discPortAttrs.PortWWN,
				(void *)raw_luns, &responseSize, &scsiStatus,
				(void *)&sense, &senseSize);
			    if (status == HBA_STATUS_OK) {
				    lun_resp =
					(struct rep_luns_rsp *)
					(unsigned long)raw_luns;
				    lun = ntohll(
					wwnConversion(lun_resp->lun[0].val));
			    } else {
				/*
				 * in case we are unable to retrieve report
				 * LUN data, we will blindly try sending the
				 * INQUIRY to lun 0.
				 */
				lun = 0;
			    }
			    memset(&sense, 0, sizeof (sense));
			    status = HBA_ScsiInquiryV2(handle,
				    portAttrs.PortWWN,
				    discPortAttrs.PortWWN,
				    lun, 0, 0,
				    &inq, &inquirySize,
				    &scsiStatus,
				    &sense, &senseSize);
			    if (status != HBA_STATUS_OK) {
				inq.inq_dtype = 0x1f;
			    }
			    print_fabric_dtype_prop(portAttrs.PortWWN.wwn,
				map->entry[mapIndex].FcpId.PortWWN.wwn,
				inq.inq_dtype);
			}
			/* Now dump this HBA's stats */
			printf("%-4d %-6x  %-6x   %016llx %016llx",
			    discIndex,
			    portAttrs.PortFcId, 0,
			    wwnConversion(portAttrs.PortWWN.wwn),
			    wwnConversion(portAttrs.NodeWWN.wwn));
			print_fabric_dtype_prop(portAttrs.PortWWN.wwn,
			    portAttrs.PortWWN.wwn, 0x1f);
			done = 1;
		    }
		}
	    }
	    if (!goodPath) {
		fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
			argv[path_index]);
		fprintf(stderr, "\n");
		ret = -1;
	    }
	}
	return (ret);
}

int
fchba_display_link_status(char **argv)
{
	int		path_index = 0;
	uint64_t	wwn;
	HBA_HANDLE handle;
	HBA_ADAPTERATTRIBUTES hbaAttrs;
	HBA_PORTATTRIBUTES portAttrs;
	HBA_PORTATTRIBUTES discPortAttrs;
	HBA_FCPTARGETMAPPINGV2    *map;
	HBA_STATUS status;
	int count, adapterIndex, portIndex, discIndex;
	char name[256], *physical, *comp_phys;
	int		matched;
	struct fc_rls_acc_params	rls;
	uint32_t	rls_size = sizeof (rls);
	boolean_t	goodPath = B_FALSE;
	int		ret = 0;

	if (loadLibrary()) {
	    return (-1);
	}
	for (path_index = 0; argv[path_index] != NULL; path_index++) {
	    goodPath = B_FALSE;

	    if (is_wwn(argv[path_index])) {
		(void) sscanf(argv[path_index], "%016llx", &wwn);
	    } else if (!is_path(argv[path_index])) {
		fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
			argv[path_index]);
		fprintf(stderr, "\n");
		ret = -1;
		continue;
	    }

	    count = getNumberOfAdapters();

	    /* Loop over all HBAs */
	    for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
		if (skip_hba(adapterIndex)) {
		    continue;
		}
		status = HBA_GetAdapterName(adapterIndex, (char *)&name);
		if (status != HBA_STATUS_OK) {
		    /* May have been DR'd */
		    continue;
		}
		handle = HBA_OpenAdapter(name);
		if (handle == 0) {
		    /* May have been DR'd */
		    continue;
		}

		if (getAdapterAttrs(handle, name, &hbaAttrs)) {
		    /* Should never happen */
		    HBA_CloseAdapter(handle);
		    continue;
		}


		/* Loop over all HBA Ports */
		for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
			portIndex++) {
		    if (getAdapterPortAttrs(handle, name, portIndex,
			    &portAttrs)) {
			continue;
		    }

		    matched = 0;
		    if (is_wwn(argv[path_index])) {
			if (wwn == wwnConversion(
				portAttrs.NodeWWN.wwn) ||
				wwn == wwnConversion(
				portAttrs.PortWWN.wwn)) {
			    matched = 1;
			}
		    } else {
			if (is_path(argv[path_index]) &&
			    ((physical = get_slash_devices_from_osDevName(
				argv[path_index],
				STANDARD_DEVNAME_HANDLING)) != NULL) &&
			    ((comp_phys = get_slash_devices_from_osDevName(
				portAttrs.OSDeviceName,
				STANDARD_DEVNAME_HANDLING)) != NULL)) {
			    char *tmp = strstr(physical, ":devctl");
			    if (tmp) {
				*tmp = '\0';
			    } else {
				tmp = strstr(physical, ":fc");
				if (tmp) {
					*tmp = '\0';
				}
			    }
			    if (strstr(comp_phys, physical)) {
				matched = 1;
			    }
			}
			if (physical) {
			    free(physical);
			    physical = NULL;
			}
			if (comp_phys) {
			    free(comp_phys);
			    comp_phys = NULL;
			}
		    }

		    if (!matched) {
			if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
			    continue;
			}
		    }

		    if (matched || match_mappings(argv[path_index], map) >= 0) {
			goodPath = B_TRUE;
			fprintf(stdout,
				MSGSTR(2007, "\nLink Error Status "
				"information for loop:%s\n"), argv[path_index]);
			fprintf(stdout, MSGSTR(2008, "al_pa   lnk fail "
				"   sync loss   signal loss   sequence err"
				"   invalid word   CRC\n"));

			for (discIndex = 0;
				discIndex < portAttrs.NumberofDiscoveredPorts;
				discIndex++) {


			    if (getDiscPortAttrs(handle, name, portIndex,
				    discIndex, &discPortAttrs)) {
				continue;
			    }

			    status = HBA_SendRLS(handle, portAttrs.PortWWN,
					discPortAttrs.PortWWN,
					&rls, &rls_size);
			    if (status != HBA_STATUS_OK) {
				memset(&rls, 0xff, sizeof (rls));
			    }

			    if ((rls.rls_link_fail == 0xffffffff) &&
				(rls.rls_sync_loss == 0xffffffff) &&
				(rls.rls_sig_loss == 0xffffffff) &&
				(rls.rls_prim_seq_err == 0xffffffff) &&
				(rls.rls_invalid_word == 0xffffffff) &&
				(rls.rls_invalid_crc == 0xffffffff)) {
				    fprintf(stdout,
					"%x\t%-12d%-12d%-14d%-15d%-15d%-12d\n",
					    discPortAttrs.PortFcId,
					    rls.rls_link_fail,
					    rls.rls_sync_loss,
					    rls.rls_sig_loss,
					    rls.rls_prim_seq_err,
					    rls.rls_invalid_word,
					    rls.rls_invalid_crc);
			    } else {
				    fprintf(stdout,
					"%x\t%-12u%-12u%-14u%-15u%-15u%-12u\n",
					    discPortAttrs.PortFcId,
					    rls.rls_link_fail,
					    rls.rls_sync_loss,
					    rls.rls_sig_loss,
					    rls.rls_prim_seq_err,
					    rls.rls_invalid_word,
					    rls.rls_invalid_crc);
			    }


			}
			/* Now dump this HBA's stats */
			status = HBA_SendRLS(handle, portAttrs.PortWWN,
				portAttrs.PortWWN,
				&rls, &rls_size);
			if (status != HBA_STATUS_OK) {
			    memset(&rls, 0xff, sizeof (rls));
			}

			if ((rls.rls_link_fail == 0xffffffff) &&
				(rls.rls_sync_loss == 0xffffffff) &&
				(rls.rls_sig_loss == 0xffffffff) &&
				(rls.rls_prim_seq_err == 0xffffffff) &&
				(rls.rls_invalid_word == 0xffffffff) &&
				(rls.rls_invalid_crc == 0xffffffff)) {
			    fprintf(stdout,
				    "%x\t%-12d%-12d%-14d%-15d%-15d%-12d\n",
				    portAttrs.PortFcId,
				    rls.rls_link_fail,
				    rls.rls_sync_loss,
				    rls.rls_sig_loss,
				    rls.rls_prim_seq_err,
				    rls.rls_invalid_word,
				    rls.rls_invalid_crc);
			} else {
			    fprintf(stdout,
				    "%x\t%-12u%-12u%-14u%-15u%-15u%-12u\n",
				    portAttrs.PortFcId,
				    rls.rls_link_fail,
				    rls.rls_sync_loss,
				    rls.rls_sig_loss,
				    rls.rls_prim_seq_err,
				    rls.rls_invalid_word,
				    rls.rls_invalid_crc);
			}
		    }
		}
	    }
	    if (!goodPath) {
		fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
			argv[path_index]);
		fprintf(stderr, "\n");
		ret = -1;
	    }
	}
	(void) fprintf(stdout,
		MSGSTR(2009, "NOTE: These LESB counts are not"
		" cleared by a reset, only power cycles.\n"
		"These counts must be compared"
		" to previously read counts.\n"));
	return (ret);
}

typedef struct _PathInformation {
	char	pathClass[MAXPATHLEN];
	char	pathState[MAXPATHLEN];
	int32_t	pathInfoState;
	int32_t	pathInfoExternalState;
} PathInformation;

struct lun_tracking {
	HBA_FCPSCSIENTRYV2  map;
	HBA_WWN	hba_pwwn;
	char	hba_path[MAXPATHLEN];
	PathInformation info;

	/* Points to another lun_tracking instance with the same map->LUID */
	struct lun_tracking	*next_path;

	/* Points to next lun_tracking with a different map->LUID */
	struct lun_tracking *next_lun;
};


static const char VHCI_COMPONENT[] = "scsi_vhci";
static void
scsi_vhci_details(struct lun_tracking *lun)
{
	HBA_FCPSCSIENTRYV2 entry = lun->map;
	int		retval = 0;
	int		pathcnt, i, count, found = 0;
	char		temppath[MAXPATHLEN];
	char		buf[MAXPATHLEN];
	char	*path_state[5];

	char	*phys_path = get_slash_devices_from_osDevName(
				entry.ScsiId.OSDeviceName,
				STANDARD_DEVNAME_HANDLING);
	char	*devPath = NULL;
	char	*trailingCruft = NULL;
	char	devaddr[MAXPATHLEN];
	sv_iocdata_t	ioc;
	int	prop_buf_size = SV_PROP_MAX_BUF_SIZE;
	char	*path_class_val = NULL;
	char	client_path[MAXPATHLEN];
	char	phci_path[MAXPATHLEN];

	/* Only proceed if we are an mpxio path */
	if (phys_path == NULL || strstr(phys_path, VHCI_COMPONENT) == NULL) {
	    return;
	}

	path_state[0] = MSGSTR(2400, "INIT");
	path_state[1] = MSGSTR(2401, "ONLINE");
	path_state[2] = MSGSTR(2402, "STANDBY");
	path_state[3] = MSGSTR(2403, "FAULT");
	path_state[4] = MSGSTR(2404, "OFFLINE");

	sprintf(devaddr, "%016llx,%x", wwnConversion(
		entry.FcpId.PortWWN.wwn),
		entry.ScsiId.ScsiOSLun);

	/* First get the controller path */
	sprintf(temppath, "/dev/cfg/c%d", entry.ScsiId.ScsiBusNumber);
	if ((count = readlink(temppath, buf, sizeof (buf)))) {
	    buf[count] = '\0';
	    /* Now skip over the leading "../.." */
	    devPath = strstr(buf, "/devices/");
	    if (devPath == NULL) {
		strcpy(lun->info.pathClass, "Unavailable");
		strcpy(lun->info.pathState, "Unavailable");
		free(phys_path);
		return;
	    }

	    /* Now chop off the trailing ":xxx" portion if present */
	    trailingCruft = strrchr(buf, ':');
	    if (trailingCruft) {
		trailingCruft[0] = '\0';
	    }
	} else {
	    strcpy(lun->info.pathClass, "Unavailable");
	    strcpy(lun->info.pathState, "Unavailable");
	    free(phys_path);
	    return;
	}

	ioc.client = client_path;
	ioc.phci = phci_path;

	retval = get_scsi_vhci_pathinfo(phys_path, &ioc, &pathcnt);
	if (retval != 0) {
	    print_errString(retval, NULL);
	    exit(-1);
	}

	for (i = 0; i < pathcnt; i++) {
	    nvlist_t *nvl;
	    if (strstr(devPath, ioc.ret_buf[i].device.ret_phci)) {
		/* This could break someday if MPxIO changes devaddr */
		if (strstr(ioc.ret_buf[i].ret_addr, devaddr)) {
		    retval = nvlist_unpack(ioc.ret_buf[i].ret_prop.buf,
			prop_buf_size, &nvl, 0);
		    if (retval != 0) {
			strcpy(lun->info.pathClass,
			    "UNKNOWN PROB");
		    } else {
			strcpy(lun->info.pathState,
			    path_state[ioc.ret_buf[i].ret_state]);
			lun->info.pathInfoState = ioc.ret_buf[i].ret_state;
			lun->info.pathInfoExternalState =
			    ioc.ret_buf[i].ret_ext_state;
			if (nvlist_lookup_string(nvl, "path-class",
				&path_class_val) == 0) {
			    strcpy(lun->info.pathClass, path_class_val);
			} else {
			    strcpy(lun->info.pathClass, "UNKNOWN");
			}
		    }
		    nvlist_free(nvl);
		    found++;
		    break;
		}
	    }

	}

	if (!found) {
	    strcpy(lun->info.pathClass, "Unavailable");
	    strcpy(lun->info.pathState, "Unavailable");
	}
	free(phys_path);

	/* free everything we alloced */
	for (i = 0; i < ioc.buf_elem; i++) {
		free(ioc.ret_buf[i].ret_prop.buf);
		free(ioc.ret_buf[i].ret_prop.ret_buf_size);
	}
	free(ioc.ret_buf);

}

/* Utility routine to add new entries to the list (ignores dups) */
static void
add_lun_path(struct lun_tracking *head, HBA_FCPSCSIENTRYV2  *map,
	    HBA_WWN pwwn, char *path)
{
	struct lun_tracking *tmp = NULL, *cmp = NULL;

	for (tmp = head; tmp != NULL; tmp = tmp->next_lun) {
	    if (memcmp(&tmp->map.LUID, &map->LUID,
		    sizeof (HBA_LUID)) == 0) {

		/* Ensure this isn't a duplicate */
		for (cmp = tmp; cmp->next_path != NULL;
			    cmp = cmp->next_path) {
		    if (memcmp(&cmp->map, map, sizeof (cmp->map)) == 0) {
			return;
		    }
		}
		if (memcmp(&cmp->map, map, sizeof (cmp->map)) == 0) {
		    return;
		}

		/* We have a new entry to add */
		cmp->next_path = (struct lun_tracking *)calloc(1,
		    sizeof (struct lun_tracking));
		cmp = cmp->next_path;
		(void) memcpy(&cmp->map, map,
		    sizeof (cmp->map));
		(void) memcpy(&cmp->hba_pwwn, &pwwn,
			sizeof (cmp->hba_pwwn));
		(void) snprintf(cmp->hba_path, MAXPATHLEN,
		    path);
		scsi_vhci_details(cmp);
		return;
	    }
	}
	/* Append a new LUN at the end of the list */
	for (tmp = head; tmp->next_lun != NULL; tmp = tmp->next_lun) {}
	tmp->next_lun = (struct lun_tracking *)calloc(1,
		sizeof (struct lun_tracking));
	tmp = tmp->next_lun;
	(void) memcpy(&tmp->map, map,
		sizeof (tmp->map));
	(void) memcpy(&tmp->hba_pwwn, &pwwn,
		sizeof (tmp->hba_pwwn));
	(void) snprintf(tmp->hba_path, MAXPATHLEN,
		path);
	scsi_vhci_details(tmp);
}

/*ARGSUSED*/
int
fchba_display_config(char **argv, int option_t_input, int argc)
{
	int		path_index = 0;
	uint64_t	wwn;
	uint64_t	lun = 0;
	HBA_HANDLE handle;
	HBA_ADAPTERATTRIBUTES hbaAttrs;
	HBA_PORTATTRIBUTES portAttrs;
	HBA_FCPTARGETMAPPINGV2    *map;
	HBA_STATUS status;
	int count, adapterIndex, portIndex;
	char name[256];
	L_inquiry	inq;
	struct scsi_extended_sense sense;
	struct page80	serial;
	HBA_UINT8	scsiStatus;
	uint32_t	inquirySize = sizeof (inq), senseSize = sizeof (sense);
	uint32_t	serialSize = sizeof (serial);
	struct mode_page	*pg_hdr;
	uchar_t		*pg_buf;
	float		lunMbytes;
	struct capacity_data_struct cap_data;
	uint32_t	    cap_data_size = sizeof (cap_data);
	struct mode_header_g1	*mode_header_ptr;
	int		offset;
	char *phys_path = NULL;
	int		mpxio = 0;
	int		wwnCompare = 0;
	char	    *physical = NULL;
	struct lun_tracking	*head = NULL;
	boolean_t	goodPath = B_FALSE;
	int		ret = 0;



	if ((status = loadLibrary())) {
	    return (-1);
	}
	for (path_index = 0; argv[path_index] != NULL; path_index++) {
	    goodPath = B_FALSE;

	    if (is_wwn(argv[path_index])) {
		(void) sscanf(argv[path_index], "%016llx", &wwn);
		wwnCompare = 1;
	    } else if (!is_path(argv[path_index])) {
		fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
			argv[path_index]);
		fprintf(stderr, "\n");
		ret = -1;
		continue;
	    }
	    if (!wwnCompare) {
		/* Convert the paths to phsyical paths */
		physical = get_slash_devices_from_osDevName(argv[path_index],
			STANDARD_DEVNAME_HANDLING);
		if (!physical) {
		    fprintf(stderr, MSGSTR(112,
			"Error: Invalid pathname (%s)"),
			argv[path_index]);
		    fprintf(stderr, "\n");
		    ret = -1;
		    continue;
		}
	    }

	    count = getNumberOfAdapters();


		/*
		 * We have to loop twice to ensure we don't miss any
		 * extra paths for other targets in a multi-target device
		 */

	    /* First check WWN/path comparisons */
	    for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
		if (skip_hba(adapterIndex)) {
		    continue;
		}
		status = HBA_GetAdapterName(adapterIndex, (char *)&name);
		if (status != HBA_STATUS_OK) {
		    /* May have been DR'd */
		    continue;
		}
		handle = HBA_OpenAdapter(name);
		if (handle == 0) {
		    /* May have been DR'd */
		    continue;
		}
		if (getAdapterAttrs(handle, name, &hbaAttrs)) {
		    /* Should never happen */
		    HBA_CloseAdapter(handle);
		    continue;
		}

		/* Loop over all HBA Ports */
		for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
			portIndex++) {
		    int	    matched = 0;
		    int	    mapIndex;
		    char	    *tmp;
		    if (getAdapterPortAttrs(handle, name, portIndex,
			    &portAttrs)) {
			continue;
		    }

		    if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
			continue;
		    }



		    for (mapIndex = 0; mapIndex < map->NumberOfEntries;
			    mapIndex ++) {
			matched = 0;
			if (wwnCompare) {
			    if (wwn == wwnConversion(
				    map->entry[mapIndex].FcpId.NodeWWN.wwn) ||
				    wwn == wwnConversion(
				    map->entry[mapIndex].FcpId.PortWWN.wwn)) {
				matched = 1;
			    }
			} else {
			    tmp = get_slash_devices_from_osDevName(
				    map->entry[mapIndex].ScsiId.OSDeviceName,
				    STANDARD_DEVNAME_HANDLING);
			    if ((tmp != NULL) && (strncmp(physical, tmp,
				    MAXPATHLEN) == 0)) {
				matched = 1;
				free(tmp);
			    }
			}
			if (matched && head == NULL) {
			    goodPath = B_TRUE;
			    head  = (struct lun_tracking *)calloc(1,
				    sizeof (struct lun_tracking));
			    (void) memcpy(&head->map, &map->entry[mapIndex],
				    sizeof (head->map));
			    (void) memcpy(&head->hba_pwwn, &portAttrs.PortWWN,
				    sizeof (head->hba_pwwn));
			    (void) snprintf(head->hba_path, MAXPATHLEN,
				portAttrs.OSDeviceName);
			    scsi_vhci_details(head);
			} else if (matched) {
			    goodPath = B_TRUE;
			    add_lun_path(head, &map->entry[mapIndex],
				portAttrs.PortWWN, portAttrs.OSDeviceName);
			}
		    }
		}
	    }

	    if (physical) {
		free(physical);
	    }

	    /* Now do it again and look for matching LUIDs (aka GUIDs) */
	    for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
		if (skip_hba(adapterIndex)) {
		    continue;
		}
		status = HBA_GetAdapterName(adapterIndex, (char *)&name);
		if (status != HBA_STATUS_OK) {
		    /* May have been DR'd */
		    continue;
		}
		handle = HBA_OpenAdapter(name);
		if (handle == 0) {
		    /* May have been DR'd */
		    continue;
		}

		if (getAdapterAttrs(handle, name, &hbaAttrs)) {
		    /* Should never happen */
		    HBA_CloseAdapter(handle);
		    continue;
		}


		/* Loop over all HBA Ports */
		for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
			portIndex++) {
		    int	    matched = 0;
		    int	    mapIndex;
		    if (getAdapterPortAttrs(handle, name, portIndex,
			    &portAttrs)) {
			continue;
		    }

		    if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
			continue;
		    }


		    for (mapIndex = 0; mapIndex < map->NumberOfEntries;
			    mapIndex ++) {
			struct lun_tracking *outer;
			matched = 0;
			for (outer = head; outer != NULL;
				    outer = outer->next_lun) {
			    struct lun_tracking *inner;
			    for (inner = outer; inner != NULL;
				    inner = inner->next_path) {
				if (memcmp(&inner->map.LUID,
					&map->entry[mapIndex].LUID,
					sizeof (HBA_LUID)) == 0) {
				    matched = 1;
				    break;
				}
			    }
			    if (matched) {
				break;
			    }
			}
			if (matched && head == NULL) {
			    goodPath = B_TRUE;
			    head  = (struct lun_tracking *)calloc(1,
				    sizeof (struct lun_tracking));
			    (void) memcpy(&head->map, &map->entry[mapIndex],
				    sizeof (head->map));
			    (void) memcpy(&head->hba_pwwn, &portAttrs.PortWWN,
				    sizeof (head->hba_pwwn));
			    (void) snprintf(head->hba_path, MAXPATHLEN,
				portAttrs.OSDeviceName);
			    scsi_vhci_details(head);
			} else if (matched) {
			    goodPath = B_TRUE;
			    add_lun_path(head, &map->entry[mapIndex],
				portAttrs.PortWWN, portAttrs.OSDeviceName);
			}
		    }
		}
	    }
	    if (!goodPath) {
		fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
			argv[path_index]);
		fprintf(stderr, "\n");
		ret = -1;
		/* Just bomb out instead of going on */
		return (ret);
	    }
	}

	/* Now display all the LUNs that we found that matched */
	{
	    struct lun_tracking *first_time;
	    struct lun_tracking *tmp_path;
	    for (first_time = head; first_time != NULL;
		    first_time = first_time->next_lun) {
		struct lun_tracking *path;
		phys_path = get_slash_devices_from_osDevName(
		    first_time->map.ScsiId.OSDeviceName,
		    STANDARD_DEVNAME_HANDLING);
		/* Change behavior if this is an MPxIO device */
		if (phys_path != NULL) {
		    if (strstr(phys_path, VHCI_COMPONENT) != NULL) {
			mpxio = 1;
		    }
		}

		for (tmp_path = first_time; tmp_path != NULL;
			tmp_path = tmp_path->next_path) {
			if (mpxio && (strncmp(tmp_path->info.pathState,
			    "ONLINE", strlen(tmp_path->info.pathState)))) {
				/* continue to next online path */
				continue;
			}
			status = HBA_OpenAdapterByWWN(&handle,
			    tmp_path->hba_pwwn);
			if (status != HBA_STATUS_OK) {
				fprintf(stderr, MSGSTR(2431,
				    "Error: Failed to get handle for %s  "),
				    tmp_path->hba_path);
				printStatus(status);
				fprintf(stderr, "\n");
				/* continue to next path */
				continue;
			}

			lun = tmp_path->map.FcpId.FcpLun;
			memset(&inq, 0, sizeof (inq));
			memset(&sense, 0, sizeof (sense));

			status = HBA_ScsiInquiryV2(handle,
				tmp_path->hba_pwwn,
				tmp_path->map.FcpId.PortWWN,
				lun, 0, 0,
				&inq, &inquirySize,
				&scsiStatus,
				&sense, &senseSize);

			if (status == HBA_STATUS_OK) {
				break;
			}
			HBA_CloseAdapter(handle);
		}

		if (tmp_path == NULL) {
			fprintf(stderr, MSGSTR(2430,
			    "Error: I/O failure communicating with %s  "),
			    first_time->map.ScsiId.OSDeviceName);
			printStatus(status);
			fprintf(stderr, "\n");
			continue;
		}

		switch ((inq.inq_dtype & DTYPE_MASK)) {
		case DTYPE_DIRECT:
		    fprintf(stdout, MSGSTR(121,
			    "DEVICE PROPERTIES for disk: %s\n"),
			    first_time->map.ScsiId.OSDeviceName);
		    break;
		case DTYPE_SEQUENTIAL: /* Tape */
		    fprintf(stdout, MSGSTR(2249,
			    "DEVICE PROPERTIES for tape: %s\n"),
			    first_time->map.ScsiId.OSDeviceName);
		    break;
		default:
		    fprintf(stdout, MSGSTR(2250,
			    "DEVICE PROPERTIES for: %s\n"),
			    first_time->map.ScsiId.OSDeviceName);
		    break;
		}
		fprintf(stdout, "  ");
		fprintf(stdout, MSGSTR(3, "Vendor:"));
		fprintf(stdout, "\t\t");
		print_chars(inq.inq_vid, sizeof (inq.inq_vid), 0);
		fprintf(stdout, MSGSTR(2115, "\n  Product ID:\t\t"));
		print_chars(inq.inq_pid, sizeof (inq.inq_pid), 0);

		fprintf(stdout, "\n  ");
		fprintf(stdout, MSGSTR(2119, "Revision:"));
		fprintf(stdout, "\t\t");
		print_chars(inq.inq_revision, sizeof (inq.inq_revision), 0);

		fprintf(stdout, "\n  ");
		fprintf(stdout, MSGSTR(17, "Serial Num:"));
		fprintf(stdout, "\t\t");
		(void) fflush(stdout);
		/*
		 * Call the inquiry cmd on page 0x80 only if the vendor
		 * supports page 0x80.
		 */
		if ((find_supported_inq_page(handle, first_time->hba_pwwn,
		    first_time->map.FcpId.PortWWN, lun, 0x80))) {
			memset(&serial, 0, sizeof (serial));
			status = HBA_ScsiInquiryV2(handle,
			    first_time->hba_pwwn,
			    first_time->map.FcpId.PortWWN,
			    lun, 1, 0x80,
			    &serial, &serialSize,
			    &scsiStatus,
			    &sense, &senseSize);
			if (status == HBA_STATUS_OK) {
				print_chars(serial.inq_serial,
				    sizeof (serial.inq_serial), 0);
			} else {
				fprintf(stdout, MSGSTR(2506, "Unsupported"));
			}
		} else {
			fprintf(stdout, MSGSTR(2506, "Unsupported"));
		}
		HBA_CloseAdapter(handle);
		if ((inq.inq_dtype & DTYPE_MASK) == DTYPE_DIRECT) {
		/* Read capacity wont work on standby paths, so try till OK */
		    for (tmp_path = first_time; tmp_path != NULL;
			tmp_path = tmp_path->next_path) {
			if (mpxio && (strncmp(tmp_path->info.pathState,
			    "ONLINE", strlen(tmp_path->info.pathState)))) {
			    /* continue to next online path */
			    continue;
			}
			status = HBA_OpenAdapterByWWN(&handle,
						tmp_path->hba_pwwn);
			if (status != HBA_STATUS_OK) {
			    /* continue to next path */
			    continue;
			}

			status = HBA_ScsiReadCapacityV2(handle,
			    tmp_path->hba_pwwn,
			    tmp_path->map.FcpId.PortWWN,
			    tmp_path->map.FcpId.FcpLun,
			    &cap_data, &cap_data_size,
			    &scsiStatus,
			    &sense, &senseSize);
			if (status == HBA_STATUS_OK) {
			    break;
			} else if (status == HBA_STATUS_SCSI_CHECK_CONDITION &&
			    sense.es_key == KEY_UNIT_ATTENTION) {
			/*
			 * retry for check-condition state when unit attention
			 * condition has been established
			 */
			    status =  HBA_ScsiReadCapacityV2(handle,
				tmp_path->hba_pwwn,
				tmp_path->map.FcpId.PortWWN,
				tmp_path->map.FcpId.FcpLun,
				&cap_data, &cap_data_size,
				&scsiStatus,
				&sense, &senseSize);
			    if (status == HBA_STATUS_OK) {
				break;
			    }
			}
			HBA_CloseAdapter(handle);
		    }
		}
		if (handle != HBA_HANDLE_INVALID) {
			HBA_CloseAdapter(handle);
		}
		if (status != HBA_STATUS_OK) {
		    /* Make sure we don't display garbage */
		    cap_data.block_size = 0;
		    cap_data.last_block_addr = 0;
		}

		if (cap_data.block_size > 0 &&
			cap_data.last_block_addr > 0) {
		    lunMbytes = ntohl(cap_data.last_block_addr) + 1;
		    lunMbytes *= ntohl(cap_data.block_size);
		    lunMbytes /= (float)(1024*1024);
		    fprintf(stdout, "\n  ");
		    fprintf(stdout, MSGSTR(60,
			    "Unformatted capacity:\t%6.3f MBytes"), lunMbytes);
		}
		fprintf(stdout, "\n");

		/*
		 * get mode page information for FC device.
		 * do not do mode sense if this is a tape device.
		 * mode sense will rewind the tape
		 */
		if ((inq.inq_dtype & DTYPE_MASK) != DTYPE_SEQUENTIAL) {
		    if (get_mode_page(first_time->map.ScsiId.OSDeviceName,
			&pg_buf) == 0) {
			mode_header_ptr = (struct mode_header_g1 *)
				(void *)pg_buf;
			offset = sizeof (struct mode_header_g1) +
			    ntohs(mode_header_ptr->bdesc_length);
			pg_hdr = (struct mode_page *)&pg_buf[offset];

			while (offset < (ntohs(mode_header_ptr->length) +
			    sizeof (mode_header_ptr->length))) {
			    if (pg_hdr->code == MODEPAGE_CACHING) {
				struct	mode_caching	*pg8_buf;
				pg8_buf = (struct mode_caching *)
				    (void *)pg_hdr;
				if (pg8_buf->wce) {
				    fprintf(stdout, MSGSTR(2122,
					"  Write Cache:\t\t"
					"Enabled\n"));
				}
				if (pg8_buf->rcd == 0) {
				    fprintf(stdout, MSGSTR(2123,
					"  Read Cache:\t\t"
					"Enabled\n"));
				    fprintf(stdout, MSGSTR(2509,
					"    Minimum prefetch:\t0x%x\n"
					"    Maximum prefetch:\t0x%x\n"),
					pg8_buf->min_prefetch,
					pg8_buf->max_prefetch);
				}
				break;
			    }
			    offset += pg_hdr->length +
				sizeof (struct mode_page);
			    pg_hdr = (struct mode_page *)&pg_buf[offset];
			}
		    }
		}

		fprintf(stdout, "  %s\t\t", MSGSTR(35, "Device Type:"));
		if ((inq.inq_dtype & DTYPE_MASK) < 0x10) {
			fprintf(stdout, "%s\n",
			    dtype[inq.inq_dtype & DTYPE_MASK]);
		} else if ((inq.inq_dtype & DTYPE_MASK) < 0x1f) {
			fprintf(stdout, MSGSTR(2432, "Reserved"));
		} else {
			/* dtype of 0x1f is returned */
			fprintf(stdout, MSGSTR(2433, "Unknown"));
		}

		fprintf(stdout, MSGSTR(2128, "  Path(s):\n"));
		fprintf(stdout, "\n");
		fprintf(stdout, "  %s\n",
		    first_time->map.ScsiId.OSDeviceName);
		if (phys_path != NULL) {
		    fprintf(stdout, "  %s\n", phys_path);
		}

		/* Now display all paths to this LUN */
		for (path = first_time; path != NULL;
		    path = path->next_path) {
		    /* Display the controller information */
		    fprintf(stdout, MSGSTR(2303, "   Controller      \t%s\n"),
			    path->hba_path);

		    fprintf(stdout, MSGSTR(2507,
			    "    Device Address\t\t%016llx,%x\n"),
			    wwnConversion(
			    path->map.FcpId.PortWWN.wwn),
			    path->map.ScsiId.ScsiOSLun);

		    fprintf(stdout, MSGSTR(2508,
			    "    Host controller port WWN\t%016llx\n"),
			    wwnConversion(path->hba_pwwn.wwn));

		    if (mpxio) {
			fprintf(stdout, MSGSTR(2305,
				"    Class\t\t\t%s\n"), path->info.pathClass);
			fprintf(stdout, MSGSTR(2306,
				"    State\t\t\t%s\n"), path->info.pathState);
		    }
		    if (phys_path != NULL) {
			free(phys_path);
			phys_path = NULL;
		    }
		}
		printf("\n");
	    }
	}
	return (ret);
}

/*
 * handle expert-mode hotplug commands
 *
 * return 0 iff all is okay
 */
int
fchba_hotplug_e(int todo, char **argv, int verbose_flag, int force_flag)
{
char		*path_phys = NULL;
int		exit_code;
devctl_hdl_t	dcp;

	if (todo != DEV_ONLINE &&
	    todo != DEV_OFFLINE) {
	    fprintf(stderr, "%s\n", strerror(ENOTSUP));
	    return (-1);
	}

	/* Convert the paths to phsyical paths */
	path_phys = get_slash_devices_from_osDevName(argv[0],
		NOT_IGNORE_DANGLING_LINK);
	if (!path_phys) {
	    fprintf(stderr, MSGSTR(112,
		"Error: Invalid pathname (%s)"),
		argv[0]);
	    fprintf(stderr, "\n");
	    return (-1);
	}
	if (verbose_flag) {
		(void) fprintf(stdout,
				MSGSTR(5516,
				"phys path = \"%s\"\n"),
				path_phys);
	}
	/* acquire rights to hack on device */
	if ((dcp = devctl_device_acquire(path_phys,
		force_flag ? 0 : DC_EXCL)) == NULL) {

		(void) fprintf(stderr, MSGSTR(5517,
		    "Error: can't acquire \"%s\": %s\n"),
		    path_phys, strerror(errno));
		return (1);
	}

	switch (todo) {
	case DEV_ONLINE:
		exit_code = devctl_device_online(dcp);
		break;
	case DEV_OFFLINE:
		exit_code = devctl_device_offline(dcp);
		break;
	}

	if (exit_code != 0) {
		perror(MSGSTR(5518, "devctl"));
	}

	/* all done now -- release device */
	devctl_release(dcp);

	if (path_phys) {
	    free(path_phys);
	}

	return (exit_code);
}

/*
 * Returns non zero if we should use FC-HBA.
 * For x86, luxadm uses FC-HBA.
 */
int
use_fchba()
{

#ifdef __x86
	return (1);
#else
	return (0);
#endif

}

/*
 * Returns non-zero if we should skip the HBA at index "i"
 */
int
skip_hba(int i) {
	HBA_LIBRARYATTRIBUTES lib_attrs;
	(void) HBA_GetVendorLibraryAttributes(i, &lib_attrs);
	if (strncmp(lib_attrs.VName, VSL_NAME,
		sizeof (lib_attrs.VName)) == 0) {
	    return (0);
	}
	return (1);
}

/*
 * Function to determine if the given page is supported by vendor.
 */
int
find_supported_inq_page(HBA_HANDLE handle, HBA_WWN hwwn, HBA_WWN pwwn,
    uint64_t lun, int page_num)
{
	struct	scsi_extended_sense	sense;
	L_inquiry00			inq00;
	uchar_t				*data;
	HBA_STATUS			status = HBA_STATUS_ERROR;
	int				index;
	HBA_UINT8			scsiStatus;
	uint32_t			inqSize = sizeof (inq00);
	uint32_t			senseSize = sizeof (sense);

	status = HBA_ScsiInquiryV2(handle, hwwn, pwwn, lun, 1, 0x00,
	    &inq00, &inqSize, &scsiStatus, &sense, &senseSize);

	if (status == HBA_STATUS_OK) {
		data = (uchar_t *)&inq00;
		for (index = 4; (index <= inq00.len+3)&&
		    (data[index] <= page_num); index ++) {
			if (data[index] == page_num) {
				return (1);
			}
		}
	}
	return (0);
}