xref: /illumos-gate/usr/src/lib/cfgadm_plugins/fp/common/cfga_list.c (revision 21f023df)

/*
 * 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 "cfga_fp.h"
#include <sys/fibre-channel/impl/fc_error.h>

/* Structure for walking the tree */
typedef struct {
	apid_t		*apidp;
	char		*xport_logp;
	ldata_list_t	*listp;
	fpcfga_cmd_t	cmd;
	cfga_stat_t	chld_config;
	cfga_type_t	xport_type;
	cfga_stat_t	xport_rstate;
	fpcfga_ret_t	ret;
	int		l_errno;
} fpcfga_list_t;

typedef struct {
	uint_t itype;
	const char *ntype;
	const char *name;
} fpcfga_devtype_t;

#define	ERR_INQ_DTYPE	0xff

/* The TYPE field is parseable and should not contain spaces */
#define	FP_FC_PORT_TYPE		"fc"
#define	FP_FC_PORT_ERROR	"fc-error"
#define	FP_FC_FABRIC_PORT_TYPE	"fc-fabric"
#define	FP_FC_PUBLIC_PORT_TYPE	"fc-public"
#define	FP_FC_PRIVATE_PORT_TYPE	"fc-private"
#define	FP_FC_PT_TO_PT_PORT_TYPE	"fc-pt_to_pt"

/* Indicates no plag passing */
#define	NO_FLAG			0

/* defines for retry algorithm */
#define	OPEN_RETRY_COUNT	5
#define	OPEN_RETRY_INTERVAL	10000 /* 1/100 of a sec. */
#define	IOCTL_RETRY_COUNT	5
#define	IOCTL_RETRY_INTERVAL	5000000 /* 5 sec */

/* define for fcp scsi passthru wait */
#define	FCP_SCSI_CMD_TIMEOUT	10

/* define for fcp pseudo node */
#define	FCP_PATH	"/devices/pseudo/fcp@0:fcp"

/* Function prototypes */
static fpcfga_ret_t postprocess_list_data(const ldata_list_t *listp,
    fpcfga_cmd_t cmd, cfga_stat_t chld_config, int *np, uint_t flags);
static int stat_fc_dev(di_node_t node, void *arg);
static int stat_FCP_dev(di_node_t node, void *arg);
static fpcfga_ret_t do_stat_fca_xport(fpcfga_list_t *lap, int limited_stat,
	HBA_PORTATTRIBUTES portAttrs);
static int get_xport_state(di_node_t node, void *arg);

static fpcfga_ret_t do_stat_fc_dev(const di_node_t node, const char *nodepath,
    fpcfga_list_t *lap, int limited_stat);
static fpcfga_ret_t do_stat_FCP_dev(const di_node_t node, const char *nodepath,
    fpcfga_list_t *lap, int limited_stat);
static cfga_stat_t xport_devinfo_to_recep_state(uint_t xport_di_state);
static cfga_stat_t dev_devinfo_to_occupant_state(uint_t dev_di_state);
static void get_hw_info(di_node_t node, cfga_list_data_t *clp);
static const char *get_device_type(di_node_t);
static fpcfga_ret_t init_ldata_for_accessible_dev(const char *dyncomp,
	uchar_t inq_type, fpcfga_list_t *lap);
static fpcfga_ret_t init_ldata_for_accessible_FCP_dev(const char *port_wwn,
	int num_luns, struct report_lun_resp *resp_buf,
	fpcfga_list_t *larg, int *l_errnop);
static fpcfga_ret_t is_dyn_ap_on_ldata_list(const char *port_wwn,
	const ldata_list_t *listp, ldata_list_t **matchldpp, int *l_errno);
static fpcfga_ret_t is_FCP_dev_ap_on_ldata_list(const char *port_wwn,
	const int lun_num, ldata_list_t *ldatap, ldata_list_t **matchldpp);

static fpcfga_ret_t init_ldata_for_mpath_dev(di_path_t path, char *port_wwn,
	int *l_errnop, fpcfga_list_t *lap);
static fpcfga_ret_t insert_ldata_to_ldatalist(const char *port_wwn,
	int *lun_nump, ldata_list_t *listp, ldata_list_t **ldatapp);
static fpcfga_ret_t insert_fc_dev_ldata(const char *port_wwn,
	ldata_list_t *listp, ldata_list_t **ldatapp);
static fpcfga_ret_t insert_FCP_dev_ldata(const char *port_wwn, int lun_num,
	ldata_list_t *listp, ldata_list_t **ldatapp);
static int stat_path_info_fc_dev(di_node_t root, fpcfga_list_t	*lap,
	int *l_errnop);
static int stat_path_info_FCP_dev(di_node_t root, fpcfga_list_t	*lap,
	int *l_errnop);
static fpcfga_ret_t get_accessible_FCP_dev_ldata(const char *dyncomp,
	fpcfga_list_t *lap, int *l_errnop);
static fpcfga_ret_t get_standard_inq_data(const char *xport_phys,
	const char *dyncomp, uchar_t *lun_num, struct scsi_inquiry **inq_buf,
	int *l_errnop);
static void init_fcp_scsi_cmd(struct fcp_scsi_cmd *fscsi, uchar_t *lun_num,
	la_wwn_t *pwwn, void *scmdbuf, size_t scmdbuf_len, void *respbuf,
	size_t respbuf_len, void *sensebuf, size_t sensebuf_len);
static fpcfga_ret_t issue_fcp_scsi_cmd(const char *xport_phys,
	struct fcp_scsi_cmd *fscsi, int *l_errnop);
static uchar_t get_inq_dtype(char *xport_phys, char *dyncomp, HBA_HANDLE handle,
    HBA_PORTATTRIBUTES *portAttrs, HBA_PORTATTRIBUTES *discPortAttrs);

static fpcfga_devtype_t device_list[] = {
	{ DTYPE_DIRECT,		DDI_NT_BLOCK_CHAN,	"disk"},
	{ DTYPE_DIRECT,		DDI_NT_BLOCK,		"disk"},
	{ DTYPE_DIRECT,		DDI_NT_BLOCK_WWN,	"disk"},
	{ DTYPE_DIRECT,		DDI_NT_BLOCK_FABRIC,	"disk"},
	{ DTYPE_SEQUENTIAL,	DDI_NT_TAPE,		"tape"},
	{ DTYPE_PRINTER,	NULL,			"printer"},
	{ DTYPE_PROCESSOR,	NULL,			"processor"},
	{ DTYPE_WORM,		NULL,			"WORM"},
	{ DTYPE_RODIRECT,	DDI_NT_CD_CHAN,		"CD-ROM"},
	{ DTYPE_RODIRECT,	DDI_NT_CD,		"CD-ROM"},
	{ DTYPE_SCANNER,	NULL,			"scanner"},
	{ DTYPE_OPTICAL,	NULL,			"optical"},
	{ DTYPE_CHANGER,	NULL,			"med-changer"},
	{ DTYPE_COMM,		NULL,			"comm-device"},
	{ DTYPE_ARRAY_CTRL,	NULL,			"array-ctrl"},
	{ DTYPE_ESI,		NULL,			"ESI"},
	/*
	 * This has to be the LAST entry for DTYPE_UNKNOWN_INDEX.
	 * Add entries before this.
	 */
	{ DTYPE_UNKNOWN,	NULL,			"unknown"}
};

#define	N_DEVICE_TYPES	(sizeof (device_list) / sizeof (device_list[0]))

#define	DTYPE_UNKNOWN_INDEX	(N_DEVICE_TYPES - 1)

/*
 * Main routine for list operation.
 * It calls various routines to consturct ldata list and
 * postprocess the list data.
 *
 * Overall algorithm:
 * Get the device list on input hba port and construct ldata list for
 * accesible devices.
 * Stat hba port and devices through walking the device tree.
 * Verify the validity of the list data.
 */
fpcfga_ret_t
do_list(
	apid_t *apidp,
	fpcfga_cmd_t cmd,
	ldata_list_t **llpp,
	int *nelemp,
	char **errstring)
{
	int		n = -1, l_errno = 0, limited_stat;
	walkarg_t	walkarg;
	fpcfga_list_t	larg = {NULL};
	fpcfga_ret_t	ret;
	la_wwn_t	pwwn;
	char		*dyncomp = NULL;
	HBA_HANDLE	handle;
	HBA_PORTATTRIBUTES	portAttrs;
	HBA_PORTATTRIBUTES	discPortAttrs;
	HBA_STATUS		status;
	int			portIndex, discIndex;
	int			retry;
	uchar_t			inq_dtype;

	if (*llpp != NULL || *nelemp != 0) {
		return (FPCFGA_ERR);
	}

	/* Create the hba logid (also base component of logical ap_id) */
	ret = make_xport_logid(apidp->xport_phys, &larg.xport_logp, &l_errno);
	if (ret != FPCFGA_OK) {
		cfga_err(errstring, l_errno, ERR_LIST, 0);
		return (FPCFGA_ERR);
	}

	assert(larg.xport_logp != NULL);

	larg.cmd = cmd;
	larg.apidp = apidp;
	larg.xport_rstate = CFGA_STAT_NONE;

	if ((ret = findMatchingAdapterPort(larg.apidp->xport_phys, &handle,
	    &portIndex, &portAttrs, errstring)) != FPCFGA_OK) {
	    S_FREE(larg.xport_logp);
	    return (ret);
	}

	/*
	 * If stating a specific device, we will do limited stat on fca port.
	 * otherwise full stat on fca part is required.
	 * If stating a specific device we don't know if it exists or is
	 * configured yet.  larg.ret is set to apid noexist for do_stat_dev.
	 * otherwise larg.ret is set to ok initially.
	 */
	if (larg.cmd == FPCFGA_STAT_FC_DEV) {
		limited_stat = 1;		/* for do_stat_fca_xport */
		larg.ret = FPCFGA_APID_NOEXIST; /* for stat_fc_dev	*/
	} else {
		limited_stat = 0;		/* for do_stat_fca_xport */
		larg.ret = FPCFGA_OK;		/* for stat_fc_dev	*/
	}

	/* For all list commands, the fca port needs to be stat'ed */
	if ((ret = do_stat_fca_xport(&larg, limited_stat,
		portAttrs)) != FPCFGA_OK) {
		cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
		list_free(&larg.listp);
		S_FREE(larg.xport_logp);
		HBA_CloseAdapter(handle);
		HBA_FreeLibrary();
		return (ret);
	}

#ifdef DEBUG
	if (limited_stat) {
		assert(larg.listp == NULL);
	} else {
		assert(larg.listp != NULL);
	}
#endif
	/*
	 * If stat'ing a FCA port or ALL, we have the bus stat data at
	 * this point.
	 * Assume that the bus has no configured children.
	 */
	larg.chld_config = CFGA_STAT_UNCONFIGURED;

	switch (larg.cmd) {
	case FPCFGA_STAT_FC_DEV:
		/* la_wwn_t has uchar_t raw_wwn[8] thus no need to free. */
		if (cvt_dyncomp_to_lawwn(apidp->dyncomp, &pwwn) != 0) {
			cfga_err(errstring, 0, ERR_LIST, 0);
			list_free(&larg.listp);
			S_FREE(larg.xport_logp);
			HBA_CloseAdapter(handle);
			HBA_FreeLibrary();
			return (FPCFGA_LIB_ERR);
		}
		/*
		 * if the dyncomp exists on disco ports construct list_data
		 * otherwise return FPCFGA_APID_NOEXIST.
		 */
		retry = 0;
		do {
		    status = getPortAttrsByWWN(handle,
			*((HBA_WWN *)(&pwwn)), &discPortAttrs);
		    if (status == HBA_STATUS_ERROR_STALE_DATA) {
			/* get Port Attributes again after refresh. */
			HBA_RefreshInformation(handle);
		    } else {
			break; /* either okay or some other error */
		    }
		} while (retry++ < HBA_MAX_RETRIES);

		if (status == HBA_STATUS_OK) {
			/*
			 * if dyncomp found in disco ports
			 * construct  ldata_list and return.
			 * otherwise continue to stat on dev tree with
			 * larg.ret set to access_ok which informs stat_fc_dev
			 * the existence of device on disco ports.
			 *
			 * if path is null that guatantees the node is not
			 * configured.  if node is detached the path
			 * is incomplete and not usable for further
			 * operations like uscsi_inq so take care of it here.
			 */
			inq_dtype = get_inq_dtype(apidp->xport_phys,
			    apidp->dyncomp, handle, &portAttrs, &discPortAttrs);

			if (init_ldata_for_accessible_dev(apidp->dyncomp,
				inq_dtype, &larg) != FPCFGA_OK) {
				cfga_err(errstring, larg.l_errno,
					ERR_LIST, 0);
				list_free(&larg.listp);
				S_FREE(larg.xport_logp);
				HBA_CloseAdapter(handle);
				HBA_FreeLibrary();
				return (FPCFGA_LIB_ERR);
			}
			if (apidp->lunlist == NULL) {
				n = 0;
				if (postprocess_list_data(
					larg.listp, cmd,
					larg.chld_config, &n, NO_FLAG) !=
					FPCFGA_OK) {
					cfga_err(errstring,
					larg.l_errno, ERR_LIST, 0);
					list_free(&larg.listp);
					S_FREE(larg.xport_logp);
					HBA_CloseAdapter(handle);
					HBA_FreeLibrary();
					return (FPCFGA_LIB_ERR);
				}
				*nelemp = n;
				*llpp = larg.listp;
				S_FREE(larg.xport_logp);
				HBA_CloseAdapter(handle);
				HBA_FreeLibrary();
				return (FPCFGA_OK);
			}
			larg.ret = FPCFGA_ACCESS_OK;
		} else if (status == HBA_STATUS_ERROR_ILLEGAL_WWN) {
			/*
			 * path indicates if the node exists in dev tree.
			 * if not found in dev tree return apid no exist.
			 * otherwise continue to stat with larg.ret set to
			 * apid_noexist.
			 */
			if (apidp->lunlist == NULL) {
				list_free(&larg.listp);
				S_FREE(larg.xport_logp);
				HBA_CloseAdapter(handle);
				HBA_FreeLibrary();
				return (FPCFGA_APID_NOEXIST);
			}
		} else { /* any error */
			/*
			 * path indicates if the node exists in dev tree.
			 * if not found in dev tree return lib error.
			 * otherwise continue to stat with larg.ret set to
			 * apid_noexist.
			 */
			if (apidp->lunlist == NULL) {
				cfga_err(errstring, 0, ERR_FC_GET_DEVLIST, 0);
				list_free(&larg.listp);
				S_FREE(larg.xport_logp);
				HBA_CloseAdapter(handle);
				HBA_FreeLibrary();
				return (FPCFGA_LIB_ERR);
			}
		}
		break;
	case FPCFGA_STAT_ALL:
		/*
		 * for each dev in disco ports, create a ldata_list element.
		 * if if no disco ports found, continue to stat on devinfo tree
		 * to see if any node exist on the fca port.
		 */
		for (discIndex = 0;
			discIndex < portAttrs.NumberofDiscoveredPorts;
			discIndex++) {
		    if (getDiscPortAttrs(handle, portIndex,
			discIndex, &discPortAttrs)) {
			/* Move on to the next target */
			continue;
		    }
		    memcpy(&pwwn, &discPortAttrs.PortWWN, sizeof (la_wwn_t));
		    cvt_lawwn_to_dyncomp(&pwwn, &dyncomp, &l_errno);
		    if (dyncomp == NULL) {
			cfga_err(errstring, l_errno, ERR_LIST, 0);
			list_free(&larg.listp);
			S_FREE(larg.xport_logp);
			HBA_CloseAdapter(handle);
			HBA_FreeLibrary();
			return (FPCFGA_LIB_ERR);
		    }
		    inq_dtype = get_inq_dtype(apidp->xport_phys, dyncomp,
			handle, &portAttrs, &discPortAttrs);

		    if ((ret = init_ldata_for_accessible_dev(
			    dyncomp, inq_dtype, &larg)) != FPCFGA_OK) {
			S_FREE(dyncomp);
			cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
				list_free(&larg.listp);
			S_FREE(larg.xport_logp);
			HBA_CloseAdapter(handle);
			HBA_FreeLibrary();
			return (FPCFGA_LIB_ERR);
		    }
		    S_FREE(dyncomp);
		}
		break;
	default:
		break;
	}

	/* we need to stat at least 1 device for all commands */
	if (apidp->flags == FLAG_DEVINFO_FORCE) {
		walkarg.flags = FLAG_DEVINFO_FORCE;
	} else {
		walkarg.flags = 0;
	}

	walkarg.flags |= FLAG_PATH_INFO_WALK;
	walkarg.walkmode.node_args.flags = DI_WALK_CLDFIRST;
	walkarg.walkmode.node_args.fcn = stat_fc_dev;

	/*
	 * Subtree is ALWAYS rooted at the HBA (not at the device) as
	 * otherwise deadlock may occur if bus is disconnected.
	 *
	 * DINFOPROP was sufficient on apidp->xport_phys prior to the support
	 * on scsi_vhci child node.  In order to get the link between
	 * scsi_vhci node and path info node the snap shot of the
	 * the whole device tree is required with DINFOCPYALL | DINFOPATH flag.
	 */
	ret = walk_tree(apidp->xport_phys, &larg, DINFOCPYALL | DINFOPATH,
			&walkarg, FPCFGA_WALK_NODE, &larg.l_errno);

	/*
	 * ret from walk_tree is either FPCFGA_OK or FPCFGA_ERR.
	 * larg.ret is used to detect other errors. Make sure larg.ret
	 * is set to a correct error.
	 */
	if (ret != FPCFGA_OK || (ret = larg.ret) != FPCFGA_OK) {
		if (ret != FPCFGA_APID_NOEXIST) {
			cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
		}
		/* if larg.ret = FPCFGA_APID_NOEXIST; */
		goto out;
	}

	assert(larg.listp != NULL);

	n = 0;
	ret = postprocess_list_data(larg.listp, cmd, larg.chld_config, &n,
		NO_FLAG);
	if (ret != FPCFGA_OK) {
		cfga_err(errstring, 0, ERR_LIST, 0);
		ret = FPCFGA_LIB_ERR;
		goto out;
	}

	*nelemp = n;
	*llpp = larg.listp;
	ret = FPCFGA_OK;
	/* FALLTHROUGH */
out:
	if (ret != FPCFGA_OK) list_free(&larg.listp);
	S_FREE(larg.xport_logp);
	HBA_CloseAdapter(handle);
	HBA_FreeLibrary();
	return (ret);
}

/*
 * Main routine for list operation when show_FCP_dev option is given.
 * It calls various routines to consturct ldata list and
 * postprocess the list data.
 *
 * The difference between do_list() and do_list_FCP_dev() is to
 * process FCP SCSI LUN data list via uscsi report lun operation and
 * stat lun level instead of port WWN based target level.
 * The rest of logic is same.
 *
 * Overall algorithm:
 * Get the device list on input hba port and construct ldata list for
 * accesible devices.
 * For each configured device, USCSI report lun is issued and ldata list
 * with FCP device level(LUN) information is created.
 * Stat hba port and LUN devices through walking the device tree.
 * Verify the validity of the list data.
 */
fpcfga_ret_t
do_list_FCP_dev(
	const char *ap_id,
	uint_t flags,
	fpcfga_cmd_t cmd,
	ldata_list_t **llpp,
	int *nelemp,
	char **errstring)
{
	int		n = -1, l_errno = 0, limited_stat, len;
	walkarg_t	walkarg;
	fpcfga_list_t	larg = {NULL};
	fpcfga_ret_t	ret;
	la_wwn_t	pwwn;
	char		*xport_phys = NULL, *dyn = NULL, *dyncomp = NULL,
			*lun_dyn = NULL;
	apid_t		apid_con = {NULL};
	HBA_HANDLE	handle;
	HBA_PORTATTRIBUTES	portAttrs;
	HBA_PORTATTRIBUTES	discPortAttrs;
	HBA_STATUS		status;
	int			portIndex, discIndex;
	int			retry;
	uint64_t		lun = 0;
	struct scsi_inquiry inq;
	struct scsi_extended_sense sense;
	HBA_UINT8		scsiStatus;
	uint32_t		inquirySize = sizeof (inq),
				senseSize = sizeof (sense);

	if (*llpp != NULL || *nelemp != 0) {
		return (FPCFGA_ERR);
	}

	if ((xport_phys = pathdup(ap_id, &l_errno)) == NULL) {
		cfga_err(errstring, l_errno, ERR_OP_FAILED, 0);
		return (FPCFGA_LIB_ERR);
	}

	/* Extract the base(hba) and dynamic(device) component if any */
	if ((dyn = GET_DYN(xport_phys)) != NULL) {
		len = strlen(DYN_TO_DYNCOMP(dyn)) + 1;
		dyncomp = calloc(1, len);
		if (dyncomp == NULL) {
			cfga_err(errstring, errno, ERR_OP_FAILED, 0);
			S_FREE(xport_phys);
			return (FPCFGA_LIB_ERR);
		}

		(void) strcpy(dyncomp, DYN_TO_DYNCOMP(dyn));
		/* Remove the dynamic component from the base. */
		*dyn = '\0';
		/* if lun dyncomp exists delete it */
		if ((lun_dyn = GET_LUN_DYN(dyncomp)) != NULL) {
			*lun_dyn = '\0';
		}
	}

	apid_con.xport_phys = xport_phys;
	apid_con.dyncomp = dyncomp;
	apid_con.flags = flags;

	larg.apidp = &apid_con;

	/* Create the hba logid (also base component of logical ap_id) */
	ret = make_xport_logid(larg.apidp->xport_phys, &larg.xport_logp,
		&l_errno);
	if (ret != FPCFGA_OK) {
		cfga_err(errstring, l_errno, ERR_LIST, 0);
		S_FREE(larg.apidp->xport_phys);
		S_FREE(larg.apidp->dyncomp);
		return (FPCFGA_ERR);
	}

	assert(larg.xport_logp != NULL);

	larg.cmd = cmd;
	larg.xport_rstate = CFGA_STAT_NONE;

	if ((ret = findMatchingAdapterPort(larg.apidp->xport_phys, &handle,
	    &portIndex, &portAttrs, errstring)) != FPCFGA_OK) {
	    S_FREE(larg.xport_logp);
	    S_FREE(larg.apidp->dyncomp);
	    return (ret);
	}

	/*
	 * If stating a specific device, we will do limited stat on fca port.
	 * otherwise full stat on fca part is required.
	 * If stating a specific device we don't know if it exists or is
	 * configured yet.  larg.ret is set to apid noexist for do_stat_dev.
	 * otherwise larg.ret is set to ok initially.
	 */
	if (larg.cmd == FPCFGA_STAT_FC_DEV) {
		limited_stat = 1;		/* for do_stat_fca_xport */
		larg.ret = FPCFGA_APID_NOEXIST; /* for stat_fc_dev	*/
	} else {
		limited_stat = 0;		/* for do_stat_fca_xport */
		larg.ret = FPCFGA_OK;		/* for stat_fc_dev	*/
	}

	/* For all list commands, the fca port needs to be stat'ed */
	if ((ret = do_stat_fca_xport(&larg, limited_stat,
		portAttrs)) != FPCFGA_OK) {
		cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
		list_free(&larg.listp);
		S_FREE(larg.xport_logp);
		S_FREE(larg.apidp->xport_phys);
		S_FREE(larg.apidp->dyncomp);
		HBA_CloseAdapter(handle);
		HBA_FreeLibrary();
		return (ret);
	}

	/*
	 * If stat'ing a FCA port or ALL, we have the bus stat data at
	 * this point.
	 * Assume that the bus has no configured children.
	 */
	larg.chld_config = CFGA_STAT_UNCONFIGURED;

	switch (larg.cmd) {
	case FPCFGA_STAT_FC_DEV:
		/* la_wwn_t has uchar_t raw_wwn[8] thus no need to free. */
		if (cvt_dyncomp_to_lawwn(larg.apidp->dyncomp, &pwwn) != 0) {
			cfga_err(errstring, 0, ERR_LIST, 0);
			list_free(&larg.listp);
			S_FREE(larg.xport_logp);
			S_FREE(larg.apidp->xport_phys);
			S_FREE(larg.apidp->dyncomp);
			HBA_CloseAdapter(handle);
			HBA_FreeLibrary();
			return (FPCFGA_LIB_ERR);
		}
		/*
		 * if the dyncomp exists on disco ports construct list_data
		 * otherwise return FPCFGA_APID_NOEXIST.
		 */
		retry = 0;
		do {
		    status = getPortAttrsByWWN(handle,
			*((HBA_WWN *)(&pwwn)), &discPortAttrs);
		    if (status == HBA_STATUS_ERROR_STALE_DATA) {
			/* get Port Attributes again after refresh. */
			HBA_RefreshInformation(handle);
		    } else {
			break; /* either okay or some other error */
		    }
		} while (retry++ < HBA_MAX_RETRIES);

		if (status == HBA_STATUS_OK) {
			/*
			 * if dyncomp exists only in dev list
			 * construct  ldata_list and return.
			 * otherwise continue to stat on dev tree with
			 * larg.ret set to access_ok which informs stat_fc_dev
			 * the existence of device on dev_list.
			 *
			 * if path is null that guatantees the node is not
			 * configured.  if node is detached the path
			 * is incomplete and not usable for further
			 * operations like uscsi_inq so take care of it here.
			 */
			status = HBA_ScsiInquiryV2(handle, portAttrs.PortWWN,
				    discPortAttrs.PortWWN, lun, 0, 0,
				    &inq, &inquirySize, &scsiStatus,
				    &sense, &senseSize);
			if (status == HBA_STATUS_OK) {
				inq.inq_dtype = inq.inq_dtype & DTYPE_MASK;
			} else if (status == HBA_STATUS_ERROR_NOT_A_TARGET) {
				inq.inq_dtype = DTYPE_UNKNOWN;
			} else {
			    inq.inq_dtype = ERR_INQ_DTYPE;
			}

			if (init_ldata_for_accessible_dev(larg.apidp->dyncomp,
				inq.inq_dtype, &larg) != FPCFGA_OK) {
				cfga_err(errstring, larg.l_errno,
					ERR_LIST, 0);
				list_free(&larg.listp);
				S_FREE(larg.xport_logp);
				S_FREE(larg.apidp->xport_phys);
				S_FREE(larg.apidp->dyncomp);
				HBA_CloseAdapter(handle);
				HBA_FreeLibrary();
				return (FPCFGA_LIB_ERR);
			}
			if ((ret = get_accessible_FCP_dev_ldata(
					larg.apidp->dyncomp, &larg, &l_errno))
					!= FPCFGA_OK) {
				cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
				list_free(&larg.listp);
				S_FREE(larg.xport_logp);
				S_FREE(larg.apidp->xport_phys);
				S_FREE(larg.apidp->dyncomp);
				HBA_CloseAdapter(handle);
				HBA_FreeLibrary();
				return (FPCFGA_LIB_ERR);
			} else {
				/* continue to stat dev with access okay. */
				larg.ret = FPCFGA_ACCESS_OK;
			}
		} else if (status == HBA_STATUS_ERROR_ILLEGAL_WWN) {
			/*
			 * path indicates if the node exists in dev tree.
			 * if not found in dev tree return apid no exist.
			 * otherwise continue to stat with larg.ret set to
			 * apid_noexist.
			 */
			if (larg.apidp->lunlist == NULL) {
				list_free(&larg.listp);
				S_FREE(larg.xport_logp);
				HBA_CloseAdapter(handle);
				HBA_FreeLibrary();
				return (FPCFGA_APID_NOEXIST);
			}
		} else {	/* not found or any error */
			/*
			 * continue to stat dev with larg.ret set to
			 * apid_noexist.
			 */
			larg.ret = FPCFGA_APID_NOEXIST;
		}
		break;
	case FPCFGA_STAT_ALL:
		/*
		 * for each dev in disco ports, create a ldata_list element.
		 * if if no disco ports found, continue to stat on devinfo tree
		 * to see if any node exist on the fca port.
		 */
		for (discIndex = 0;
			discIndex < portAttrs.NumberofDiscoveredPorts;
			discIndex++) {
		    if (getDiscPortAttrs(handle, portIndex,
			discIndex, &discPortAttrs)) {
			/* Move on to the next target */
			continue;
		    }
		    memcpy(&pwwn, &discPortAttrs.PortWWN, sizeof (la_wwn_t));
		    cvt_lawwn_to_dyncomp(&pwwn, &dyncomp, &l_errno);
		    if (dyncomp == NULL) {
			cfga_err(errstring, l_errno, ERR_LIST, 0);
			list_free(&larg.listp);
			S_FREE(larg.xport_logp);
			S_FREE(larg.apidp->xport_phys);
			S_FREE(larg.apidp->dyncomp);
			HBA_CloseAdapter(handle);
			HBA_FreeLibrary();
			return (FPCFGA_LIB_ERR);
		    }
		    status = HBA_ScsiInquiryV2(handle, portAttrs.PortWWN,
			    discPortAttrs.PortWWN, lun, 0, 0,
			    &inq, &inquirySize, &scsiStatus,
			    &sense, &senseSize);
		    if (status == HBA_STATUS_OK) {
			    inq.inq_dtype = inq.inq_dtype & DTYPE_MASK;
		    } else if (status == HBA_STATUS_ERROR_NOT_A_TARGET) {
			    inq.inq_dtype = DTYPE_UNKNOWN;
		    } else {
			    inq.inq_dtype = ERR_INQ_DTYPE;
		    }
		    if ((ret = init_ldata_for_accessible_dev(
			    dyncomp, inq.inq_dtype, &larg)) != FPCFGA_OK) {
			S_FREE(dyncomp);
			cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
			list_free(&larg.listp);
			S_FREE(larg.xport_logp);
			S_FREE(larg.apidp->xport_phys);
			S_FREE(larg.apidp->dyncomp);
			HBA_CloseAdapter(handle);
			HBA_FreeLibrary();
			return (FPCFGA_LIB_ERR);
		    }
		    if ((ret = get_accessible_FCP_dev_ldata(
			dyncomp, &larg, &l_errno)) != FPCFGA_OK) {
			S_FREE(dyncomp);
			cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
			list_free(&larg.listp);
			S_FREE(larg.xport_logp);
			S_FREE(larg.apidp->xport_phys);
			S_FREE(larg.apidp->dyncomp);
			HBA_CloseAdapter(handle);
			HBA_FreeLibrary();
			return (ret);
		    }
		    S_FREE(dyncomp);
		}
		break;
	/* default: continue */
	}

	/* we need to stat at least 1 device for all commands */
	if ((larg.apidp->flags & FLAG_DEVINFO_FORCE) == FLAG_DEVINFO_FORCE) {
		walkarg.flags = FLAG_DEVINFO_FORCE;
	} else {
		walkarg.flags = 0;
	}

	walkarg.flags |= FLAG_PATH_INFO_WALK;
	walkarg.walkmode.node_args.flags = DI_WALK_CLDFIRST;
	walkarg.walkmode.node_args.fcn = stat_FCP_dev;

	/*
	 * Subtree is ALWAYS rooted at the HBA (not at the device) as
	 * otherwise deadlock may occur if bus is disconnected.
	 *
	 * DINFOPROP was sufficient on apidp->xport_phys prior to the support
	 * on scsi_vhci child node.  In order to get the link between
	 * scsi_vhci node and path info node the snap shot of the
	 * the whole device tree is required with DINFOCPYALL | DINFOPATH flag.
	 */
	ret = walk_tree(larg.apidp->xport_phys, &larg, DINFOCPYALL | DINFOPATH,
			&walkarg, FPCFGA_WALK_NODE, &larg.l_errno);

	/*
	 * ret from walk_tree is either FPCFGA_OK or FPCFGA_ERR.
	 * larg.ret is used to detect other errors. Make sure larg.ret
	 * is set to a correct error.
	 */
	if (ret != FPCFGA_OK || (ret = larg.ret) != FPCFGA_OK) {
		if (ret != FPCFGA_APID_NOEXIST) {
			cfga_err(errstring, larg.l_errno, ERR_LIST, 0);
		}
		/* if larg.ret = FPCFGA_APID_NOEXIST return. */
		list_free(&larg.listp);
		S_FREE(larg.xport_logp);
		S_FREE(larg.apidp->xport_phys);
		S_FREE(larg.apidp->dyncomp);
		HBA_CloseAdapter(handle);
		HBA_FreeLibrary();
		return (ret);
	}

	assert(larg.listp != NULL);

	n = 0;
	ret = postprocess_list_data(larg.listp, cmd, larg.chld_config, &n,
			flags);
	if (ret != FPCFGA_OK) {
		cfga_err(errstring, 0, ERR_LIST, 0);
		list_free(&larg.listp);
		S_FREE(larg.xport_logp);
		S_FREE(larg.apidp->xport_phys);
		S_FREE(larg.apidp->dyncomp);
		HBA_CloseAdapter(handle);
		HBA_FreeLibrary();
		return (FPCFGA_LIB_ERR);
	}

	*nelemp = n;
	*llpp = larg.listp;
	ret = FPCFGA_OK;
	S_FREE(larg.xport_logp);
	S_FREE(larg.apidp->xport_phys);
	S_FREE(larg.apidp->dyncomp);
	HBA_CloseAdapter(handle);
	HBA_FreeLibrary();
	return (FPCFGA_OK);
}

/*
 * This routine returns initialize struct fcp_ioctl.
 */
static void
init_fcp_scsi_cmd(
	struct fcp_scsi_cmd *fscsi,
	uchar_t *lun_num,
	la_wwn_t *pwwn,
	void *scmdbuf,
	size_t scmdbuf_len,
	void *respbuf,
	size_t respbuf_len,
	void *sensebuf,
	size_t sensebuf_len)
{
	memset(fscsi, 0, sizeof (struct fcp_scsi_cmd));
	memset(scmdbuf, 0, scmdbuf_len);
	memcpy(fscsi->scsi_fc_pwwn.raw_wwn, pwwn, sizeof (u_longlong_t));
	fscsi->scsi_fc_rspcode = 0;
	fscsi->scsi_flags = FCP_SCSI_READ;
	fscsi->scsi_timeout = FCP_SCSI_CMD_TIMEOUT;  /* second */
	fscsi->scsi_cdbbufaddr = (caddr_t)scmdbuf;
	fscsi->scsi_cdblen = scmdbuf_len;
	fscsi->scsi_bufaddr = (caddr_t)respbuf;
	fscsi->scsi_buflen = respbuf_len;
	fscsi->scsi_bufresid = 0;
	fscsi->scsi_bufstatus = 0;
	fscsi->scsi_rqbufaddr = (caddr_t)sensebuf;
	fscsi->scsi_rqlen = sensebuf_len;
	fscsi->scsi_rqresid = 0;
	memcpy(&fscsi->scsi_lun, lun_num, sizeof (fscsi->scsi_lun));
}

/*
 * This routine returns issues FCP_TGT_SEND_SCSI
 */
static fpcfga_ret_t
issue_fcp_scsi_cmd(
	const char *xport_phys,
	struct fcp_scsi_cmd *fscsi,
	int *l_errnop)
{
	struct stat	stbuf;
	int fcp_fd, retry, rv;

	if (stat(xport_phys, &stbuf) < 0) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	fscsi->scsi_fc_port_num = (uint32_t)minor(stbuf.st_rdev);
	fcp_fd = open(FCP_PATH, O_RDONLY | O_NDELAY);
	retry = 0;
	while (fcp_fd < 0 && retry++ < OPEN_RETRY_COUNT && (
		errno == EBUSY || errno == EAGAIN)) {
		(void) usleep(OPEN_RETRY_INTERVAL);
		fcp_fd = open(FCP_PATH, O_RDONLY|O_NDELAY);
	}
	if (fcp_fd < 0) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	rv = ioctl(fcp_fd, FCP_TGT_SEND_SCSI, fscsi);
	retry = 0;
	while ((rv != 0 && retry++ < IOCTL_RETRY_COUNT &&
			(errno == EBUSY || errno == EAGAIN)) ||
			(retry++ < IOCTL_RETRY_COUNT &&
			((uchar_t)fscsi->scsi_bufstatus & STATUS_MASK)
			== STATUS_BUSY)) {
		(void) usleep(IOCTL_RETRY_INTERVAL);
		rv = ioctl(fcp_fd, FCP_TGT_SEND_SCSI, fscsi);
	}
	close(fcp_fd);

	if (fscsi->scsi_fc_status == FC_DEVICE_NOT_TGT) {
		return (FPCFGA_FCP_SEND_SCSI_DEV_NOT_TGT);
	} else if (rv != 0 || fscsi->scsi_bufstatus != 0) {
		*l_errnop = errno;
		return (FPCFGA_FCP_TGT_SEND_SCSI_FAILED);
	}
	return (FPCFGA_OK);
}

/*
 * This routine returns standard inq data for
 * a target represented by dyncomp.
 *
 * Calls FCP passthru ioctl FCP_TGT_SEND_SCSI to get inquiry data.
 *
 * Caller should free the *inq_buf.
 */
static fpcfga_ret_t
get_standard_inq_data(
	const char *xport_phys,
	const char *dyncomp,
	uchar_t *lun_num,
	struct scsi_inquiry **inq_buf,
	int *l_errnop)
{
	struct fcp_scsi_cmd	fscsi;
	struct scsi_extended_sense sensebuf;
	union scsi_cdb  scsi_inq_req;
	la_wwn_t	pwwn;
	int 	alloc_len;
	fpcfga_ret_t ret;


	alloc_len = sizeof (struct scsi_inquiry);
	if ((*inq_buf = (struct scsi_inquiry *)calloc(1, alloc_len)) == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	if (cvt_dyncomp_to_lawwn(dyncomp, &pwwn) != 0) {
		return (FPCFGA_LIB_ERR);
	}

	init_fcp_scsi_cmd(&fscsi, lun_num, &pwwn, &scsi_inq_req,
		sizeof (scsi_inq_req), *inq_buf, alloc_len, &sensebuf,
		sizeof (struct scsi_extended_sense));
	scsi_inq_req.scc_cmd = SCMD_INQUIRY;
	scsi_inq_req.g0_count0 = sizeof (struct scsi_inquiry);

	if ((ret = issue_fcp_scsi_cmd(xport_phys, &fscsi, l_errnop))
			!= FPCFGA_OK) {
		S_FREE(*inq_buf);
		return (ret);
	}

	return (FPCFGA_OK);
}

/*
 * This routine returns report lun data and number of luns found
 * on a target represented by dyncomp.
 *
 * Calls FCP passthru ioctl FCP_TGT_SEND_SCSI to get report lun data.
 *
 * Caller should free the *resp_buf when FPCFGA_OK is returned.
 */
fpcfga_ret_t
get_report_lun_data(
	const char *xport_phys,
	const char *dyncomp,
	int *num_luns,
	report_lun_resp_t **resp_buf,
	struct scsi_extended_sense *sensebuf,
	int *l_errnop)
{
	struct fcp_scsi_cmd	fscsi;
	union scsi_cdb  scsi_rl_req;
	la_wwn_t	pwwn;
	int 	alloc_len;
	fpcfga_ret_t 	ret;
	uchar_t		lun_data[SAM_LUN_SIZE];

	alloc_len = sizeof (struct report_lun_resp);
	if ((*resp_buf = (report_lun_resp_t *)calloc(1, alloc_len)) == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	if (cvt_dyncomp_to_lawwn(dyncomp, &pwwn) != 0) {
		S_FREE(*resp_buf);
		return (FPCFGA_LIB_ERR);
	}

	/* sending to LUN 0 so initializing lun_data buffer to be 0 */
	memset(lun_data, 0, sizeof (lun_data));
	init_fcp_scsi_cmd(&fscsi, lun_data, &pwwn, &scsi_rl_req,
	    sizeof (scsi_rl_req), *resp_buf, alloc_len, sensebuf,
	    sizeof (struct scsi_extended_sense));
	scsi_rl_req.scc_cmd = FP_SCMD_REPORT_LUN;
	FORMG5COUNT(&scsi_rl_req, alloc_len);

	if ((ret = issue_fcp_scsi_cmd(xport_phys, &fscsi, l_errnop))
			!= FPCFGA_OK) {
		S_FREE(*resp_buf);
		return (ret);
	}

	if (ntohl((*resp_buf)->num_lun) >
		(sizeof (struct report_lun_resp) - REPORT_LUN_HDR_SIZE)) {
		alloc_len = (*resp_buf)->num_lun + REPORT_LUN_HDR_SIZE;
		S_FREE(*resp_buf);
		if ((*resp_buf = (report_lun_resp_t *)calloc(1, alloc_len))
		    == NULL) {
			*l_errnop = errno;
			return (FPCFGA_LIB_ERR);
		}
		(void) memset((char *)*resp_buf, 0, alloc_len);
		FORMG5COUNT(&scsi_rl_req, alloc_len);

		fscsi.scsi_bufaddr = (caddr_t)*resp_buf;
		fscsi.scsi_buflen = alloc_len;

		if ((ret = issue_fcp_scsi_cmd(xport_phys, &fscsi, l_errnop))
				!= FPCFGA_OK) {
			S_FREE(*resp_buf);
			return (ret);
		}
	}

	/* num_lun represent number of luns * 8. */
	*num_luns = ntohl((*resp_buf)->num_lun) >> 3;

	return (FPCFGA_OK);
}

/*
 * Routine for consturct ldata list for each FCP SCSI LUN device
 * for a discovered target device.
 * It calls get_report_lun_data to get report lun data and
 * construct ldata list per each lun.
 *
 * It is called only when show_FCP_dev option is given.
 *
 * Overall algorithm:
 * Get the report lun data thru FCP passthru ioctl.
 * Call init_ldata_for_accessible_FCP_dev to process the report LUN data.
 * For each LUN found standard inquiry is issued to get device type.
 */
static fpcfga_ret_t
get_accessible_FCP_dev_ldata(
	const char *dyncomp,
	fpcfga_list_t *lap,
	int *l_errnop)
{
	report_lun_resp_t	    *resp_buf;
	struct scsi_extended_sense  sense;
	int			    num_luns;
	fpcfga_ret_t		    ret;

	memset(&sense, 0, sizeof (sense));
	if ((ret = get_report_lun_data(lap->apidp->xport_phys, dyncomp,
		&num_luns, &resp_buf, &sense, l_errnop)) != FPCFGA_OK) {
		/*
		 * when report lun data fails then return FPCFGA_OK thus
		 * keep the ldata for the target which is acquired previously.
		 * For remote hba node this will be normal.
		 * For a target error may already be detected through
		 * FCP_TGT_INQ.
		 */
		if ((ret == FPCFGA_FCP_TGT_SEND_SCSI_FAILED) ||
		    (ret == FPCFGA_FCP_SEND_SCSI_DEV_NOT_TGT)) {
			ret = FPCFGA_OK;
		}
		return (ret);
	}

	if (num_luns > 0) {
		ret = init_ldata_for_accessible_FCP_dev(
			dyncomp, num_luns, resp_buf, lap, l_errnop);
	} else {
		/*
		 * proceed with to stat if no lun found.
		 * This will make the target apid will be kept.
		 */
		ret = FPCFGA_OK;
	}

	S_FREE(resp_buf);
	return (ret);
}

/*
 * Routine for checking validity of ldata list based on input argumemnt.
 * Set the occupant state of hba port if the list is valid.
 */
static fpcfga_ret_t
postprocess_list_data(
	const ldata_list_t *listp,
	fpcfga_cmd_t cmd,
	cfga_stat_t chld_config,
	int *np,
	uint_t flags)
{
	ldata_list_t *tmplp = NULL;
	cfga_list_data_t *xport_ldatap = NULL;
	int i;


	*np = 0;

	if (listp == NULL) {
		return (FPCFGA_ERR);
	}

	tmplp = (ldata_list_t *)listp;
	for (i = 0; tmplp != NULL; tmplp = tmplp->next) {
		i++;
		if (GET_DYN(tmplp->ldata.ap_phys_id) == NULL) {
			/* A bus stat data */
			assert(GET_DYN(tmplp->ldata.ap_log_id) == NULL);
			xport_ldatap = &tmplp->ldata;
#ifdef DEBUG
		} else {
			assert(GET_DYN(tmplp->ldata.ap_log_id) != NULL);
#endif
		}
	}

	switch (cmd) {
	case FPCFGA_STAT_FC_DEV:
		if ((flags & FLAG_FCP_DEV) == FLAG_FCP_DEV) {
			if (i < 1 || xport_ldatap != NULL) {
				return (FPCFGA_LIB_ERR);
			}
		} else {
			if (i != 1 || xport_ldatap != NULL) {
				return (FPCFGA_LIB_ERR);
			}
		}
		break;
	case FPCFGA_STAT_FCA_PORT:
		if (i != 1 || xport_ldatap == NULL) {
			return (FPCFGA_LIB_ERR);
		}
		break;
	case FPCFGA_STAT_ALL:
		if (i < 1 || xport_ldatap == NULL) {
			return (FPCFGA_LIB_ERR);
		}
		break;
	default:
		return (FPCFGA_LIB_ERR);
	}

	*np = i;

	/* Fill in the occupant (child) state. */
	if (xport_ldatap != NULL) {
		xport_ldatap->ap_o_state = chld_config;
	}
	return (FPCFGA_OK);
}

/*
 * Routine for checking each target device found in device tree.
 * When the matching port WWN dev is found from the accessble ldata list
 * the target device is updated with configured ostate.
 *
 * Overall algorithm:
 * Parse the device tree to find configured devices which matches with
 * list argument.  If cmd is stat on a specific target device it
 * matches port WWN and continues to further processing.  If cmd is
 * stat on hba port all the device target under the hba are processed.
 */
static int
stat_fc_dev(di_node_t node, void *arg)
{
	fpcfga_list_t *lap = NULL;
	char *devfsp = NULL, *nodepath = NULL;
	size_t len = 0;
	int limited_stat = 0, match_minor, rv;
	fpcfga_ret_t ret;
	di_prop_t prop = DI_PROP_NIL;
	uchar_t	*port_wwn_data;
	char	port_wwn[WWN_SIZE*2+1];
	int	count;

	lap = (fpcfga_list_t *)arg;

	/*
	 * Skip partial nodes
	 *
	 * This checking is from the scsi plug-in and will be deleted for
	 * fp plug-in. The node will be processed for fp even if it is
	 * in driver detached state. From fp perspective the node is configured
	 * as long as the node is not in offline or down state.
	 * scsi plug-in considers the known state when it is offlined
	 * regradless of driver detached state or when it is not in driver
	 * detached state like normal state.
	 * If the node is only in driver detached state it is considered as
	 * unknown state.
	 *
	 * if (!known_state(node) && (lap->cmd != FPCFGA_STAT_FC_DEV)) {
	 *	return (DI_WALK_CONTINUE);
	 *
	 */

	devfsp = di_devfs_path(node);
	if (devfsp == NULL) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	len = strlen(DEVICES_DIR) + strlen(devfsp) + 1;

	nodepath = calloc(1, len);
	if (nodepath == NULL) {
		lap->l_errno = errno;
		lap->ret = FPCFGA_LIB_ERR;
		rv = DI_WALK_TERMINATE;
		goto out;
	}

	(void) snprintf(nodepath, len, "%s%s", DEVICES_DIR, devfsp);

	/* Skip node if it is HBA */
	match_minor = 0;
	if (!dev_cmp(lap->apidp->xport_phys, nodepath, match_minor)) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	/* If stat'ing a specific device, is this node that device */
	if (lap->cmd == FPCFGA_STAT_FC_DEV) {
		/* checks port wwn property to find a match */
		while ((prop = di_prop_next(node, prop))
					!= DI_PROP_NIL) {
			if ((strcmp(PORT_WWN_PROP,
				di_prop_name(prop)) == 0) &&
				(di_prop_type(prop) ==
					DI_PROP_TYPE_BYTE)) {
				break;
			}
		}

		if (prop != DI_PROP_NIL) {
			count = di_prop_bytes(prop, &port_wwn_data);
			if (count != WWN_SIZE) {
				lap->ret = FPCFGA_LIB_ERR;
				rv = DI_WALK_TERMINATE;
				goto out;
			}
			(void) sprintf(port_wwn, "%016llx",
				(wwnConversion(port_wwn_data)));
			/*
			 * port wwn doesn't match contine to walk
			 * if match call do_stat_fc_dev.
			 */
			if (strncmp(port_wwn, lap->apidp->dyncomp,
					WWN_SIZE*2)) {
				rv = DI_WALK_CONTINUE;
				goto out;
			}
		} else {
			rv = DI_WALK_CONTINUE;
			goto out;
		}
	}

	/*
	 * If stat'ing a xport only, we look at device nodes only to get
	 * xport configuration status. So a limited stat will suffice.
	 */
	if (lap->cmd == FPCFGA_STAT_FCA_PORT) {
		limited_stat = 1;
	} else {
		limited_stat = 0;
	}

	/*
	 * Ignore errors if stat'ing a bus or listing all
	 */
	ret = do_stat_fc_dev(node, nodepath, lap, limited_stat);
	if (ret != FPCFGA_OK) {
		if (lap->cmd == FPCFGA_STAT_FC_DEV) {
			lap->ret = ret;
			rv = DI_WALK_TERMINATE;
		} else {
			rv = DI_WALK_CONTINUE;
		}
		goto out;
	}

	/* Are we done ? */
	rv = DI_WALK_CONTINUE;
	if (lap->cmd == FPCFGA_STAT_FCA_PORT &&
	    lap->chld_config == CFGA_STAT_CONFIGURED) {
		rv = DI_WALK_TERMINATE;
	} else if (lap->cmd == FPCFGA_STAT_FC_DEV) {
		/*
		 * If stat'ing a specific device, we are done at this point.
		 */
		rv = DI_WALK_TERMINATE;
	}

	/*FALLTHRU*/
out:
	S_FREE(nodepath);
	if (devfsp != NULL) di_devfs_path_free(devfsp);
	return (rv);
}

/*
 * Routine for checking each FCP SCSI LUN device found in device tree.
 * When the matching port WWN and LUN are found from the accessble ldata list
 * the FCP SCSI LUN is updated with configured ostate.
 *
 * Overall algorithm:
 * Parse the device tree to find configured devices which matches with
 * list argument.  If cmd is stat on a specific target device it
 * matches port WWN and continues to further processing.  If cmd is
 * stat on hba port all the FCP SCSI LUN under the hba are processed.
 */
static int
stat_FCP_dev(di_node_t node, void *arg)
{
	fpcfga_list_t *lap = NULL;
	char *devfsp = NULL, *nodepath = NULL;
	size_t len = 0;
	int limited_stat = 0, match_minor, rv, di_ret;
	fpcfga_ret_t ret;
	uchar_t	*port_wwn_data;
	char	port_wwn[WWN_SIZE*2+1];

	lap = (fpcfga_list_t *)arg;

	devfsp = di_devfs_path(node);
	if (devfsp == NULL) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	len = strlen(DEVICES_DIR) + strlen(devfsp) + 1;

	nodepath = calloc(1, len);
	if (nodepath == NULL) {
		lap->l_errno = errno;
		lap->ret = FPCFGA_LIB_ERR;
		rv = DI_WALK_TERMINATE;
		goto out;
	}

	(void) snprintf(nodepath, len, "%s%s", DEVICES_DIR, devfsp);

	/* Skip node if it is HBA */
	match_minor = 0;
	if (!dev_cmp(lap->apidp->xport_phys, nodepath, match_minor)) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	/* If stat'ing a specific device, is this node that device */
	if (lap->cmd == FPCFGA_STAT_FC_DEV) {
		/* checks port wwn property to find a match */
		di_ret = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,
			PORT_WWN_PROP, &port_wwn_data);
		if (di_ret == -1) {
			rv = DI_WALK_CONTINUE;
			goto out;
		} else {
			(void) sprintf(port_wwn, "%016llx",
				(wwnConversion(port_wwn_data)));
			/*
			 * port wwn doesn't match contine to walk
			 * if match call do_stat_FCP_dev.
			 */
			if (strncmp(port_wwn, lap->apidp->dyncomp,
					WWN_SIZE*2)) {
				rv = DI_WALK_CONTINUE;
				goto out;
			}
		}
	}

	/*
	 * If stat'ing a xport only, we look at device nodes only to get
	 * xport configuration status. So a limited stat will suffice.
	 */
	if (lap->cmd == FPCFGA_STAT_FCA_PORT) {
		limited_stat = 1;
	} else {
		limited_stat = 0;
	}

	/*
	 * Ignore errors if stat'ing a bus or listing all
	 */
	ret = do_stat_FCP_dev(node, nodepath, lap, limited_stat);
	if (ret != FPCFGA_OK) {
		rv = DI_WALK_CONTINUE;
		goto out;
	}

	/* Are we done ? */
	rv = DI_WALK_CONTINUE;
	if (lap->cmd == FPCFGA_STAT_FCA_PORT &&
	    lap->chld_config == CFGA_STAT_CONFIGURED) {
		rv = DI_WALK_TERMINATE;
	}

	/*FALLTHRU*/
out:
	S_FREE(nodepath);
	if (devfsp != NULL) di_devfs_path_free(devfsp);
	return (rv);
}

static fpcfga_ret_t
do_stat_fca_xport(fpcfga_list_t *lap, int limited_stat,
	HBA_PORTATTRIBUTES portAttrs)
{
	cfga_list_data_t *clp = NULL;
	ldata_list_t *listp = NULL;
	int l_errno = 0;
	uint_t devinfo_state = 0;
	walkarg_t walkarg;
	fpcfga_ret_t ret;
	cfga_cond_t cond = CFGA_COND_UNKNOWN;

	assert(lap->xport_logp != NULL);

	/* Get xport state */
	if (lap->apidp->flags == FLAG_DEVINFO_FORCE) {
		walkarg.flags = FLAG_DEVINFO_FORCE;
	} else {
		walkarg.flags = 0;
	}
	walkarg.walkmode.node_args.flags = 0;
	walkarg.walkmode.node_args.fcn = get_xport_state;

	ret = walk_tree(lap->apidp->xport_phys, &devinfo_state,
		DINFOCPYALL | DINFOPATH, &walkarg, FPCFGA_WALK_NODE, &l_errno);
	if (ret == FPCFGA_OK) {
		lap->xport_rstate = xport_devinfo_to_recep_state(devinfo_state);
	} else {
		lap->xport_rstate = CFGA_STAT_NONE;
	}

	/*
	 * Get topology works okay even if the fp port is connected
	 * to a switch and no devices connected to the switch.
	 * In this case the list will only shows fp port info without
	 * any device listed.
	 */
	switch (portAttrs.PortType) {
		case HBA_PORTTYPE_NLPORT:
			(void) snprintf(lap->xport_type,
				sizeof (lap->xport_type), "%s",
				FP_FC_PUBLIC_PORT_TYPE);
			break;
		case HBA_PORTTYPE_NPORT:
			(void) snprintf(lap->xport_type,
				sizeof (lap->xport_type), "%s",
				FP_FC_FABRIC_PORT_TYPE);
			break;
		case HBA_PORTTYPE_LPORT:
			(void) snprintf(lap->xport_type,
				sizeof (lap->xport_type), "%s",
				FP_FC_PRIVATE_PORT_TYPE);
			break;
		case HBA_PORTTYPE_PTP:
			(void) snprintf(lap->xport_type,
				sizeof (lap->xport_type), "%s",
				FP_FC_PT_TO_PT_PORT_TYPE);
			break;
		/*
		 * HBA_PORTTYPE_UNKNOWN means nothing is connected
		 */
		case HBA_PORTTYPE_UNKNOWN:
			(void) snprintf(lap->xport_type,
				sizeof (lap->xport_type), "%s",
				FP_FC_PORT_TYPE);
			break;
		/* NOT_PRESENT, OTHER, FPORT, FLPORT */
		default:
			(void) snprintf(lap->xport_type,
				sizeof (lap->xport_type), "%s",
				FP_FC_PORT_TYPE);
			cond = CFGA_COND_FAILED;
			break;
	}

	if (limited_stat) {
		/* We only want to know bus(receptacle) connect status */
		return (FPCFGA_OK);
	}

	listp = calloc(1, sizeof (ldata_list_t));
	if (listp == NULL) {
		lap->l_errno = errno;
		return (FPCFGA_LIB_ERR);
	}

	clp = &listp->ldata;

	(void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id), "%s",
	    lap->xport_logp);
	(void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id), "%s",
	    lap->apidp->xport_phys);

	clp->ap_class[0] = '\0';	/* Filled by libcfgadm */
	clp->ap_r_state = lap->xport_rstate;
	clp->ap_o_state = lap->chld_config;
	clp->ap_cond = cond;
	clp->ap_busy = 0;
	clp->ap_status_time = (time_t)-1;
	clp->ap_info[0] = '\0';
	(void) strncpy(clp->ap_type, lap->xport_type, sizeof (clp->ap_type));

	/* Link it in.  lap->listp is NULL originally. */
	listp->next = lap->listp;
	/* lap->listp now gets cfga_list_data for the fca port. */
	lap->listp = listp;

	return (FPCFGA_OK);
}


static int
get_xport_state(di_node_t node, void *arg)
{
	uint_t *di_statep = (uint_t *)arg;

	*di_statep = di_state(node);

	return (DI_WALK_TERMINATE);
}

/*
 * Routine for updating ldata list based on the state of device node.
 * When no matching accessible ldata is found a new ldata is created
 * with proper state information.
 *
 * Overall algorithm:
 * If the device node is online and the matching ldata is found
 * the target device is updated with configued and unknown condition.
 * If the device node is offline or down and the matching ldata is found
 * the target device is updated with configued and unusable condition.
 * If the device node is online but the matching ldata is not found
 * the target device is created with configued and failing condition.
 * If the device node is offline or down and the matching ldata is not found
 * the target device is created with configued and unusable condition.
 */
static fpcfga_ret_t
do_stat_fc_dev(
	const di_node_t node,
	const char *nodepath,
	fpcfga_list_t *lap,
	int limited_stat)
{
	uint_t dctl_state = 0, devinfo_state = 0;
	char *dyncomp = NULL;
	cfga_list_data_t *clp = NULL;
	cfga_busy_t busy;
	ldata_list_t *listp = NULL;
	ldata_list_t *matchldp = NULL;
	int l_errno = 0;
	cfga_stat_t ostate;
	cfga_cond_t cond;
	fpcfga_ret_t ret;

	assert(lap->apidp->xport_phys != NULL);
	assert(lap->xport_logp != NULL);

	cond = CFGA_COND_UNKNOWN;

	devinfo_state = di_state(node);
	ostate = dev_devinfo_to_occupant_state(devinfo_state);

	/*
	 * NOTE: The framework cannot currently detect layered driver
	 * opens, so the busy indicator is not very reliable. Also,
	 * non-root users will not be able to determine busy
	 * status (libdevice needs root permissions).
	 * This should probably be fixed by adding a DI_BUSY to the di_state()
	 * routine in libdevinfo.
	 */
	if (devctl_cmd(nodepath, FPCFGA_DEV_GETSTATE, &dctl_state,
	    &l_errno) == FPCFGA_OK) {
		busy = ((dctl_state & DEVICE_BUSY) == DEVICE_BUSY) ? 1 : 0;
	} else {
		busy = 0;
	}

	/* We only want to know device config state */
	if (limited_stat) {
		if (((strcmp(lap->xport_type, FP_FC_FABRIC_PORT_TYPE) == 0) ||
			strcmp(lap->xport_type, FP_FC_PUBLIC_PORT_TYPE) == 0)) {
			lap->chld_config = CFGA_STAT_CONFIGURED;
		} else {
			if (ostate != CFGA_STAT_UNCONFIGURED) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
			}
		}
		return (FPCFGA_OK);
	}

	/*
	 * If child device is configured, see if it is accessible also
	 * for FPCFGA_STAT_FC_DEV cmd.
	 */
	if (lap->cmd == FPCFGA_STAT_FC_DEV) {
		switch (ostate) {
		case CFGA_STAT_CONFIGURED:
			/*
			 * if configured and not accessble, the device is
			 * till be displayed with failing condition.
			 * return code should be FPCFGA_OK to display it.
			 */
		case CFGA_STAT_NONE:
			/*
			 * If not unconfigured and not attached
			 * the state is set to CFGA_STAT_NONE currently.
			 * This is okay for the detached node due to
			 * the driver being unloaded.
			 * May need to define another state to
			 * isolate the detached only state.
			 *
			 * handle the same way as configured.
			 */
			if (lap->ret != FPCFGA_ACCESS_OK) {
				cond = CFGA_COND_FAILING;
			}
			lap->chld_config = CFGA_STAT_CONFIGURED;
			break;
		case CFGA_STAT_UNCONFIGURED:
			/*
			 * if unconfigured - offline or down,
			 * set to cond to unusable regardless of accessibility.
			 * This behavior needs to be examined further.
			 * When the device is not accessible the node
			 * may get offline or down. In that case failing
			 * cond may make more sense.
			 * In anycase the ostate will be set to configured
			 * configured.
			 */
			cond = CFGA_COND_UNUSABLE;
			/*
			 * For fabric port the fca port is considered as
			 * configured since user configured previously
			 * for any existing node.  Otherwise when the
			 * device was accessible, the hba is considered as
			 * configured.
			 */
			if (((strcmp(lap->xport_type,
				FP_FC_PUBLIC_PORT_TYPE) == 0) ||
				(strcmp(lap->xport_type,
				FP_FC_FABRIC_PORT_TYPE) == 0)) ||
				(lap->ret == FPCFGA_ACCESS_OK)) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
			} else {
				lap->ret = FPCFGA_APID_NOEXIST;
				return (FPCFGA_OK);
			}
			break;
		default:
			break;
		}

		/* if device found in disco ports, ldata already created. */
		if (lap->ret == FPCFGA_ACCESS_OK) {
			/*
			 * if cond is not changed then don't update
			 * condition to keep the previous condition.
			 */
			if (cond != CFGA_COND_UNKNOWN) {
				lap->listp->ldata.ap_cond = cond;
			}
			lap->listp->ldata.ap_o_state = CFGA_STAT_CONFIGURED;
			lap->listp->ldata.ap_busy = busy;
			lap->ret = FPCFGA_OK;
			return (FPCFGA_OK);
		}
	}

	/*
	 * if cmd is stat all check ldata list
	 * to see if the node exist on the dev list.  Otherwise create
	 * the list element.
	 */
	if (lap->cmd == FPCFGA_STAT_ALL) {
		if (lap->listp != NULL) {
			if ((ret = make_dyncomp_from_dinode(node,
					&dyncomp, &l_errno)) != FPCFGA_OK) {
				return (ret);
			}
			ret = is_dyn_ap_on_ldata_list(dyncomp, lap->listp,
					&matchldp, &l_errno);
			switch (ret) {
			case FPCFGA_ACCESS_OK:
				/* node exists so set ostate to configured. */
				lap->chld_config = CFGA_STAT_CONFIGURED;
				matchldp->ldata.ap_o_state =
					CFGA_STAT_CONFIGURED;
				matchldp->ldata.ap_busy = busy;
				clp = &matchldp->ldata;
				switch (ostate) {
				case CFGA_STAT_CONFIGURED:
				/*
				 * If not unconfigured and not attached
				 * the state is set to CFGA_STAT_NONE currently.
				 * This is okay for the detached node due to
				 * the driver being unloaded.
				 * May need to define another state to
				 * isolate the detached only state.
				 */
				case CFGA_STAT_NONE:
					/* update ap_type and ap_info */
					get_hw_info(node, clp);
					break;
				/*
				 * node is offline or down.
				 * set cond to unusable.
				 */
				case CFGA_STAT_UNCONFIGURED:
					/*
					 * if cond is not unknown
					 * we already set the cond from
					 * a different node with the same
					 * port WWN or initial probing
					 * was failed so don't update again.
					 */
					if (matchldp->ldata.ap_cond ==
						CFGA_COND_UNKNOWN) {
						matchldp->ldata.ap_cond =
						CFGA_COND_UNUSABLE;
					}
					break;
				default:
					break;
				}
				/* node found in ldata list so just return. */
				lap->ret = FPCFGA_OK;
				S_FREE(dyncomp);
				return (FPCFGA_OK);
			case FPCFGA_LIB_ERR:
				lap->l_errno = l_errno;
				S_FREE(dyncomp);
				return (ret);
			case FPCFGA_APID_NOACCESS:
				switch (ostate) {
				/* node is attached but not in dev list */
				case CFGA_STAT_CONFIGURED:
				case CFGA_STAT_NONE:
					lap->chld_config = CFGA_STAT_CONFIGURED;
					cond = CFGA_COND_FAILING;
					break;
				/*
				 * node is offline or down.
				 * set cond to unusable.
				 */
				case CFGA_STAT_UNCONFIGURED:
					/*
					 * For fabric port the fca port is
					 * considered as configured since user
					 * configured previously for any
					 * existing node.
					 */
					cond = CFGA_COND_UNUSABLE;
					if ((strcmp(lap->xport_type,
						FP_FC_PUBLIC_PORT_TYPE) == 0) ||
						(strcmp(lap->xport_type,
						FP_FC_FABRIC_PORT_TYPE) == 0)) {
						lap->chld_config =
						CFGA_STAT_CONFIGURED;
					} else {
						lap->ret = FPCFGA_OK;
						S_FREE(dyncomp);
						return (FPCFGA_OK);
					}
					break;
				default:
				/*
				 * continue to create ldata_list struct for
				 * this node
				 */
					break;
				}
			default:
				break;
			}
		} else {
			/*
			 * dev_list is null so there is no accessible dev.
			 * set the cond and continue to create ldata.
			 */
			switch (ostate) {
			case CFGA_STAT_CONFIGURED:
			case CFGA_STAT_NONE:
				cond = CFGA_COND_FAILING;
				lap->chld_config = CFGA_STAT_CONFIGURED;
				break;
			/*
			 * node is offline or down.
			 * set cond to unusable.
			 */
			case CFGA_STAT_UNCONFIGURED:
				cond = CFGA_COND_UNUSABLE;
				/*
				 * For fabric port the fca port is
				 * considered as configured since user
				 * configured previously for any
				 * existing node.
				 */
				if ((strcmp(lap->xport_type,
					FP_FC_PUBLIC_PORT_TYPE) == 0) ||
					(strcmp(lap->xport_type,
					FP_FC_FABRIC_PORT_TYPE) == 0)) {
					lap->chld_config =
					CFGA_STAT_CONFIGURED;
				} else {
					lap->ret = FPCFGA_OK;
					S_FREE(dyncomp);
					return (FPCFGA_OK);
				}
				break;
			default:
				break;
			}
		}
	}

	listp = calloc(1, sizeof (ldata_list_t));
	if (listp == NULL) {
		lap->l_errno = errno;
		S_FREE(dyncomp);
		return (FPCFGA_LIB_ERR);
	}

	clp = &listp->ldata;

	/* Create the dynamic component. */
	if (dyncomp == NULL) {
		ret = make_dyncomp_from_dinode(node, &dyncomp, &l_errno);
		if (ret != FPCFGA_OK) {
			S_FREE(listp);
			return (ret);
		}
	}

	/* Create logical and physical ap_id */
	(void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id), "%s%s%s",
	    lap->xport_logp, DYN_SEP, dyncomp);

	(void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id), "%s%s%s",
	    lap->apidp->xport_phys, DYN_SEP, dyncomp);

	S_FREE(dyncomp);

	clp->ap_class[0] = '\0'; /* Filled in by libcfgadm */
	clp->ap_r_state = lap->xport_rstate;
	/* set to ostate to configured and set cond with info. */
	clp->ap_o_state = CFGA_STAT_CONFIGURED;
	clp->ap_cond = cond;
	clp->ap_busy = busy;
	clp->ap_status_time = (time_t)-1;

	/* get ap_type and ap_info. */
	get_hw_info(node, clp);

	/* Link it in */
	listp->next = lap->listp;
	lap->listp = listp;

	lap->ret = FPCFGA_OK;
	return (FPCFGA_OK);
}

/*
 * Wrapper routine for handling path info.
 *
 * When show_FCP_dev option is given stat_path_info_FCP_dev() is called.
 * Otherwise stat_path_info_fc_dev() is called.
 */
int
stat_path_info_node(
	di_node_t 	root,
	void 		*arg,
	int 		*l_errnop)
{
	fpcfga_list_t *lap = NULL;

	lap = (fpcfga_list_t *)arg;
	if ((lap->apidp->flags & (FLAG_FCP_DEV)) == FLAG_FCP_DEV) {
		return (stat_path_info_FCP_dev(root, lap, l_errnop));
	} else {
		return (stat_path_info_fc_dev(root, lap, l_errnop));
	}
}

/*
 * Routine for updating ldata list based on the state of path info node.
 * When no matching accessible ldata is found a new ldata is created
 * with proper state information.
 *
 * Overall algorithm:
 * If the path info node is not offline and the matching ldata is found
 * the target device is updated with configued and unknown condition.
 * If the path info node is offline or failed and the matching ldata is found
 * the target device is updated with configued and unusable condition.
 * If the path info node is online but the matching ldata is not found
 * the target device is created with configued and failing condition.
 * If the path info is offline or failed and the matching ldata is not found
 * the target device is created with configued and unusable condition.
 */
static int
stat_path_info_fc_dev(
	di_node_t 	root,
	fpcfga_list_t	*lap,
	int 		*l_errnop)
{
	ldata_list_t *matchldp = NULL;
	di_path_t path = DI_PATH_NIL;
	uchar_t		*port_wwn_data;
	char		port_wwn[WWN_SIZE*2+1];
	int		count;
	fpcfga_ret_t 	ret;
	di_path_state_t	pstate;

	if (root == DI_NODE_NIL) {
		return (FPCFGA_LIB_ERR);
	}

	/*
	 * if stat on a specific dev and walk_node found it okay
	 * then just return ok.
	 */
	if ((lap->cmd == FPCFGA_STAT_FC_DEV) && (lap->ret == FPCFGA_OK)) {
		return (FPCFGA_OK);
	}

	/*
	 * if stat on a fca xport and chld_config is set
	 * then just return ok.
	 */
	if ((lap->cmd == FPCFGA_STAT_FCA_PORT) &&
				(lap->chld_config == CFGA_STAT_CONFIGURED)) {
		return (FPCFGA_OK);
	}

	/*
	 * when there is no path_info node return FPCFGA_OK.
	 * That way the result from walk_node shall be maintained.
	 */
	if ((path = di_path_next_client(root, path)) == DI_PATH_NIL) {
		/*
		 * if the dev was in dev list but not found
		 * return OK to indicate is not configured.
		 */
		if (lap->ret == FPCFGA_ACCESS_OK) {
			lap->ret = FPCFGA_OK;
		}
		return (FPCFGA_OK);
	}

	/* if stat on fca port return. */
	if (lap->cmd == FPCFGA_STAT_FCA_PORT) {
		if (((strcmp(lap->xport_type, FP_FC_FABRIC_PORT_TYPE) == 0) ||
			strcmp(lap->xport_type, FP_FC_PUBLIC_PORT_TYPE) == 0)) {
			lap->chld_config = CFGA_STAT_CONFIGURED;
			return (FPCFGA_OK);
		} else {
			if ((pstate = di_path_state(path)) !=
				DI_PATH_STATE_OFFLINE) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
				return (FPCFGA_OK);
			}
		}
	}
	/*
	 * now parse the path info node.
	 */
	do {
		count = di_path_prop_lookup_bytes(path, PORT_WWN_PROP,
			&port_wwn_data);
		if (count != WWN_SIZE) {
			ret = FPCFGA_LIB_ERR;
			break;
		}

		(void) sprintf(port_wwn, "%016llx",
			(wwnConversion(port_wwn_data)));
		switch (lap->cmd) {
		case FPCFGA_STAT_FC_DEV:
			/* if no match contine to the next path info node. */
			if (strncmp(port_wwn, lap->apidp->dyncomp,
					WWN_SIZE*2)) {
				break;
			}
			/* if device in dev_list, ldata already created. */
			if (lap->ret == FPCFGA_ACCESS_OK) {
				lap->listp->ldata.ap_o_state =
					CFGA_STAT_CONFIGURED;
				if (((pstate = di_path_state(path)) ==
					DI_PATH_STATE_OFFLINE) ||
					(pstate == DI_PATH_STATE_FAULT)) {
					lap->listp->ldata.ap_cond =
							CFGA_COND_UNUSABLE;
				}
				lap->ret = FPCFGA_OK;
				return (FPCFGA_OK);
			} else {
				if ((strcmp(lap->xport_type,
					FP_FC_PUBLIC_PORT_TYPE) == 0) ||
					(strcmp(lap->xport_type,
					FP_FC_FABRIC_PORT_TYPE) == 0)) {
					lap->chld_config = CFGA_STAT_CONFIGURED;
					return (init_ldata_for_mpath_dev(
						path, port_wwn, l_errnop, lap));
				} else {
					if ((di_path_state(path)) !=
						DI_PATH_STATE_OFFLINE) {
					    return (init_ldata_for_mpath_dev(
						path, port_wwn, l_errnop, lap));
					} else {
					    lap->ret = FPCFGA_APID_NOEXIST;
					    return (FPCFGA_OK);
					}
				}
			}
		case FPCFGA_STAT_ALL:
			/* check if there is list data. */
			if (lap->listp != NULL) {
				ret = is_dyn_ap_on_ldata_list(port_wwn,
					lap->listp, &matchldp, l_errnop);
				if (ret == FPCFGA_ACCESS_OK) {
					lap->chld_config = CFGA_STAT_CONFIGURED;
					matchldp->ldata.ap_o_state =
							CFGA_STAT_CONFIGURED;
					/*
					 * Update the condition as unusable
					 * if the pathinfo state is failed
					 * or offline.
					 */
					if (((pstate = di_path_state(path)) ==
						DI_PATH_STATE_OFFLINE) ||
						(pstate ==
							DI_PATH_STATE_FAULT)) {
						matchldp->ldata.ap_cond =
							CFGA_COND_UNUSABLE;
					}
					break;
				} else if (ret == FPCFGA_LIB_ERR) {
					lap->l_errno = *l_errnop;
					return (ret);
				}
			}
			/*
			 * now create ldata for this particular path info node.
			 * if port top is private loop and pathinfo is in
			 * in offline state don't include to ldata list.
			 */
			if (((strcmp(lap->xport_type,
				FP_FC_PUBLIC_PORT_TYPE) == 0) ||
				(strcmp(lap->xport_type,
					FP_FC_FABRIC_PORT_TYPE) == 0)) ||
				(di_path_state(path) !=
					DI_PATH_STATE_OFFLINE)) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
				ret = init_ldata_for_mpath_dev(
					path, port_wwn, l_errnop, lap);
				if (ret != FPCFGA_OK) {
					return (ret);
				}
			}
			break;
		case FPCFGA_STAT_FCA_PORT:
			if (di_path_state(path) != DI_PATH_STATE_OFFLINE) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
				return (FPCFGA_OK);
			}
		}
		path = di_path_next_client(root, path);
	} while (path != DI_PATH_NIL);

	return (FPCFGA_OK);

}

/*
 * Routine for updating ldata list based on the state of path info node.
 * When no matching accessible ldata is found a new ldata is created
 * with proper state information.
 *
 * The difference from stat_path_info_fc_dev() is
 * to handle FCP SCSI LUN information. Otherwise overall algorithm is
 * same.
 *
 * Overall algorithm:
 * If the path info node is not offline and the matching ldata is found
 * the target device is updated with configued and unknown condition.
 * If the path info node is offline or failed and the matching ldata is found
 * the target device is updated with configued and unusable condition.
 * If the path info node is online but the matching ldata is not found
 * the target device is created with configued and failing condition.
 * If the path info is offline or failed and the matching ldata is not found
 * the target device is created with configued and unusable condition.
 */
static int
stat_path_info_FCP_dev(
	di_node_t 	root,
	fpcfga_list_t	*lap,
	int 		*l_errnop)
{
	ldata_list_t	*matchldp = NULL, *listp = NULL;
	cfga_list_data_t	*clp;
	di_path_t	path = DI_PATH_NIL;
	di_node_t	client_node = DI_NODE_NIL;
	char		*port_wwn = NULL, *nodepath = NULL;
	int		*lun_nump;
	fpcfga_ret_t 	ldata_ret;
	di_path_state_t	pstate;
	cfga_busy_t	busy;
	uint_t		dctl_state = 0;

	if (root == DI_NODE_NIL) {
		return (FPCFGA_LIB_ERR);
	}

	/*
	 * if stat on a fca xport and chld_config is set
	 * then just return ok.
	 */
	if ((lap->cmd == FPCFGA_STAT_FCA_PORT) &&
				(lap->chld_config == CFGA_STAT_CONFIGURED)) {
		return (FPCFGA_OK);
	}
	/*
	 * when there is no path_info node return FPCFGA_OK.
	 * That way the result from walk_node shall be maintained.
	 */
	if ((path = di_path_next_client(root, path)) == DI_PATH_NIL) {
		/*
		 * if the dev was in dev list but not found
		 * return ok.
		 */
		if (lap->ret == FPCFGA_ACCESS_OK) {
			lap->ret = FPCFGA_OK;
		}
		return (FPCFGA_OK);
	}
	/*
	 * If stat on fca port and port topology is fabric return here.
	 * If not fabric return only when path state is not offfline.
	 * The other cases are handbled below.
	 */
	if (lap->cmd == FPCFGA_STAT_FCA_PORT) {
		if (((strcmp(lap->xport_type, FP_FC_FABRIC_PORT_TYPE) == 0) ||
			strcmp(lap->xport_type, FP_FC_PUBLIC_PORT_TYPE) == 0)) {
			lap->chld_config = CFGA_STAT_CONFIGURED;
			return (FPCFGA_OK);
		} else {
			if ((pstate = di_path_state(path)) !=
				DI_PATH_STATE_OFFLINE) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
				return (FPCFGA_OK);
			}
		}
	}
	/*
	 * now parse the path info node.
	 */
	do {
		switch (lap->cmd) {
		case FPCFGA_STAT_FC_DEV:
			if ((make_portwwn_luncomp_from_pinode(path, &port_wwn,
				&lun_nump, l_errnop)) != FPCFGA_OK) {
				return (FPCFGA_LIB_ERR);
			}

			if ((ldata_ret = is_FCP_dev_ap_on_ldata_list(port_wwn,
				*lun_nump, lap->listp, &matchldp))
				== FPCFGA_LIB_ERR) {
				S_FREE(port_wwn);
				return (ldata_ret);
			}

			if (ldata_ret == FPCFGA_ACCESS_OK) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
				matchldp->ldata.ap_o_state =
						CFGA_STAT_CONFIGURED;
				/*
				 * Update the condition as unusable
				 * if the pathinfo state is failed
				 * or offline.
				 */
				if (((pstate = di_path_state(path)) ==
					DI_PATH_STATE_OFFLINE) ||
					(pstate == DI_PATH_STATE_FAULT)) {
					matchldp->ldata.ap_cond =
							CFGA_COND_UNUSABLE;
				}
				lap->ret = FPCFGA_OK;
				break;
			}

			if (strncmp(port_wwn, lap->apidp->dyncomp, WWN_SIZE*2)
					!= 0) {
				break;
			}
			/*
			 * now create ldata for this particular path info node.
			 * if port top is private loop and pathinfo is in
			 * in offline state don't include to ldata list.
			 */
			if (((strcmp(lap->xport_type,
				FP_FC_PUBLIC_PORT_TYPE) == 0) ||
				(strcmp(lap->xport_type,
					FP_FC_FABRIC_PORT_TYPE) == 0)) ||
				(di_path_state(path) !=
					DI_PATH_STATE_OFFLINE)) {
			    lap->chld_config = CFGA_STAT_CONFIGURED;
				/* create ldata for this pi node. */
			    client_node = di_path_client_node(path);
			    if (client_node == DI_NODE_NIL) {
				*l_errnop = errno;
				S_FREE(port_wwn);
				return (FPCFGA_LIB_ERR);
			    }
			    if ((construct_nodepath_from_dinode(
				client_node, &nodepath, l_errnop))
					!= FPCFGA_OK) {
				S_FREE(port_wwn);
				return (FPCFGA_LIB_ERR);
			    }

			    listp = calloc(1, sizeof (ldata_list_t));
			    if (listp == NULL) {
				S_FREE(port_wwn);
				S_FREE(nodepath);
				lap->l_errno = errno;
				return (FPCFGA_LIB_ERR);
			    }

			    clp = &listp->ldata;

			    /* Create logical and physical ap_id */
			    (void) snprintf(clp->ap_log_id,
				sizeof (clp->ap_log_id), "%s%s%s%s%d",
				lap->xport_logp, DYN_SEP, port_wwn,
				LUN_COMP_SEP, *lun_nump);
			    (void) snprintf(clp->ap_phys_id,
				sizeof (clp->ap_phys_id), "%s%s%s%s%d",
				lap->apidp->xport_phys, DYN_SEP, port_wwn,
				LUN_COMP_SEP, *lun_nump);
				/*
				 * We reached here since FCP dev is not found
				 * in ldata list but path info node exists.
				 *
				 * Update the condition as failing
				 * if the pathinfo state was normal.
				 * Update the condition as unusable
				 * if the pathinfo state is failed
				 * or offline.
				 */
			    clp->ap_class[0] = '\0'; /* Filled by libcfgadm */
			    clp->ap_o_state = CFGA_STAT_CONFIGURED;
			    if (((pstate = di_path_state(path))
					== DI_PATH_STATE_OFFLINE) ||
				(pstate == DI_PATH_STATE_FAULT)) {
				clp->ap_cond = CFGA_COND_UNUSABLE;
			    } else {
				clp->ap_cond = CFGA_COND_FAILING;
			    }
			    clp->ap_r_state = lap->xport_rstate;
			    clp->ap_info[0] = '\0';
				/* update ap_type and ap_info */
			    get_hw_info(client_node, clp);
			    if (devctl_cmd(nodepath, FPCFGA_DEV_GETSTATE,
				&dctl_state, l_errnop) == FPCFGA_OK) {
				busy = ((dctl_state & DEVICE_BUSY)
					== DEVICE_BUSY) ? 1 : 0;
			    } else {
				busy = 0;
			    }
			    clp->ap_busy = busy;
			    clp->ap_status_time = (time_t)-1;

			    (void) insert_ldata_to_ldatalist(port_wwn,
				lun_nump, listp, &(lap->listp));
			}
			break;
		case FPCFGA_STAT_ALL:
			if ((make_portwwn_luncomp_from_pinode(path, &port_wwn,
				&lun_nump, l_errnop)) != FPCFGA_OK) {
				return (FPCFGA_LIB_ERR);
			}

			if ((ldata_ret = is_FCP_dev_ap_on_ldata_list(port_wwn,
				*lun_nump, lap->listp, &matchldp))
				== FPCFGA_LIB_ERR) {
				S_FREE(port_wwn);
				return (ldata_ret);
			}

			if (ldata_ret == FPCFGA_ACCESS_OK) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
				matchldp->ldata.ap_o_state =
						CFGA_STAT_CONFIGURED;
				/*
				 * Update the condition as unusable
				 * if the pathinfo state is failed
				 * or offline.
				 */
				if (((pstate = di_path_state(path)) ==
					DI_PATH_STATE_OFFLINE) ||
					(pstate == DI_PATH_STATE_FAULT)) {
					matchldp->ldata.ap_cond =
							CFGA_COND_UNUSABLE;
				}
				break;
			}
			/*
			 * now create ldata for this particular path info node.
			 * if port top is private loop and pathinfo is in
			 * in offline state don't include to ldata list.
			 */
			if (((strcmp(lap->xport_type,
				FP_FC_PUBLIC_PORT_TYPE) == 0) ||
				(strcmp(lap->xport_type,
					FP_FC_FABRIC_PORT_TYPE) == 0)) ||
				(di_path_state(path) !=
					DI_PATH_STATE_OFFLINE)) {
			    lap->chld_config = CFGA_STAT_CONFIGURED;
				/* create ldata for this pi node. */
			    client_node = di_path_client_node(path);
			    if (client_node == DI_NODE_NIL) {
				*l_errnop = errno;
				S_FREE(port_wwn);
				return (FPCFGA_LIB_ERR);
			    }
			    if ((construct_nodepath_from_dinode(
				client_node, &nodepath, l_errnop))
					!= FPCFGA_OK) {
				S_FREE(port_wwn);
				return (FPCFGA_LIB_ERR);
			    }

			    listp = calloc(1, sizeof (ldata_list_t));
			    if (listp == NULL) {
				S_FREE(port_wwn);
				S_FREE(nodepath);
				lap->l_errno = errno;
				return (FPCFGA_LIB_ERR);
			    }

			    clp = &listp->ldata;

			    /* Create logical and physical ap_id */
			    (void) snprintf(clp->ap_log_id,
				sizeof (clp->ap_log_id), "%s%s%s%s%d",
				lap->xport_logp, DYN_SEP, port_wwn,
				LUN_COMP_SEP, *lun_nump);
			    (void) snprintf(clp->ap_phys_id,
				sizeof (clp->ap_phys_id), "%s%s%s%s%d",
				lap->apidp->xport_phys, DYN_SEP, port_wwn,
				LUN_COMP_SEP, *lun_nump);
				/*
				 * We reached here since FCP dev is not found
				 * in ldata list but path info node exists.
				 *
				 * Update the condition as failing
				 * if the pathinfo state was normal.
				 * Update the condition as unusable
				 * if the pathinfo state is failed
				 * or offline.
				 */
			    clp->ap_class[0] = '\0'; /* Filled by libcfgadm */
			    clp->ap_o_state = CFGA_STAT_CONFIGURED;
			    if (((pstate = di_path_state(path))
					== DI_PATH_STATE_OFFLINE) ||
				(pstate == DI_PATH_STATE_FAULT)) {
				clp->ap_cond = CFGA_COND_UNUSABLE;
			    } else {
				clp->ap_cond = CFGA_COND_FAILING;
			    }
			    clp->ap_r_state = lap->xport_rstate;
			    clp->ap_info[0] = '\0';
				/* update ap_type and ap_info */
			    get_hw_info(client_node, clp);
			    if (devctl_cmd(nodepath, FPCFGA_DEV_GETSTATE,
				&dctl_state, l_errnop) == FPCFGA_OK) {
				busy = ((dctl_state & DEVICE_BUSY)
					== DEVICE_BUSY) ? 1 : 0;
			    } else {
				busy = 0;
			    }
			    clp->ap_busy = busy;
			    clp->ap_status_time = (time_t)-1;

			    (void) insert_ldata_to_ldatalist(port_wwn,
				lun_nump, listp, &(lap->listp));
			}
			break;
		case FPCFGA_STAT_FCA_PORT:
			if (di_path_state(path) != DI_PATH_STATE_OFFLINE) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
				lap->ret = FPCFGA_OK;
				return (FPCFGA_OK);
			}
		}
		path = di_path_next_client(root, path);
	} while (path != DI_PATH_NIL);

	lap->ret = FPCFGA_OK;
	S_FREE(port_wwn);
	S_FREE(nodepath);
	return (FPCFGA_OK);

}

/*
 * Routine for updating ldata list based on the state of device node.
 * When no matching accessible ldata is found a new ldata is created
 * with proper state information.
 *
 * The difference from do_stat_fc_dev() is
 * to handle FCP SCSI LUN information. Otherwise overall algorithm is
 * same.
 *
 * Overall algorithm:
 * If the device node is online and the matching ldata is found
 * the target device is updated with configued and unknown condition.
 * If the device node is offline or down and the matching ldata is found
 * the target device is updated with configued and unusable condition.
 * If the device node is online but the matching ldata is not found
 * the target device is created with configued and failing condition.
 * If the device node is offline or down and the matching ldata is not found
 * the target device is created with configued and unusable condition.
 */
static fpcfga_ret_t
do_stat_FCP_dev(
	const di_node_t node,
	const char *nodepath,
	fpcfga_list_t *lap,
	int limited_stat)
{
	uint_t dctl_state = 0, devinfo_state = 0;
	char *port_wwn = NULL;
	cfga_list_data_t *clp = NULL;
	cfga_busy_t busy;
	ldata_list_t *listp = NULL;
	ldata_list_t *matchldp = NULL;
	int l_errno = 0, *lun_nump;
	cfga_stat_t ostate;
	cfga_cond_t cond;
	fpcfga_ret_t ldata_ret;

	assert(lap->apidp->xport_phys != NULL);
	assert(lap->xport_logp != NULL);

	cond = CFGA_COND_UNKNOWN;

	devinfo_state = di_state(node);
	ostate = dev_devinfo_to_occupant_state(devinfo_state);

	/*
	 * NOTE: The devctl framework cannot currently detect layered driver
	 * opens, so the busy indicator is not very reliable. Also,
	 * non-root users will not be able to determine busy
	 * status (libdevice needs root permissions).
	 * This should probably be fixed by adding a DI_BUSY to the di_state()
	 * routine in libdevinfo.
	 */
	if (devctl_cmd(nodepath, FPCFGA_DEV_GETSTATE, &dctl_state,
	    &l_errno) == FPCFGA_OK) {
		busy = ((dctl_state & DEVICE_BUSY) == DEVICE_BUSY) ? 1 : 0;
	} else {
		busy = 0;
	}

	/* We only want to know device config state */
	if (limited_stat) {
		if (((strcmp(lap->xport_type, FP_FC_FABRIC_PORT_TYPE) == 0) ||
			strcmp(lap->xport_type, FP_FC_PUBLIC_PORT_TYPE) == 0)) {
			lap->chld_config = CFGA_STAT_CONFIGURED;
		} else {
			if (ostate != CFGA_STAT_UNCONFIGURED) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
			}
		}
		return (FPCFGA_OK);
	}

	/*
	 * If child device is configured, see if it is accessible also
	 * for FPCFGA_STAT_FC_DEV cmd.
	 */
	if ((make_portwwn_luncomp_from_dinode(node, &port_wwn, &lun_nump,
			&l_errno)) != FPCFGA_OK) {
		lap->l_errno = l_errno;
		return (FPCFGA_LIB_ERR);
	}

	if ((ldata_ret = is_FCP_dev_ap_on_ldata_list(port_wwn, *lun_nump,
			lap->listp, &matchldp)) == FPCFGA_LIB_ERR) {
		lap->l_errno = l_errno;
		S_FREE(port_wwn);
		return (ldata_ret);
	}

	if (lap->cmd == FPCFGA_STAT_FC_DEV) {
		switch (ostate) {
		case CFGA_STAT_CONFIGURED:
			/*
			 * if configured and not accessble, the device is
			 * till be displayed with failing condition.
			 * return code should be FPCFGA_OK to display it.
			 */
		case CFGA_STAT_NONE:
			/*
			 * If not unconfigured and not attached
			 * the state is set to CFGA_STAT_NONE currently.
			 * This is okay for the detached node due to
			 * the driver being unloaded.
			 * May need to define another state to
			 * isolate the detached only state.
			 *
			 * handle the same way as configured.
			 */
			if (ldata_ret != FPCFGA_ACCESS_OK) {
				cond = CFGA_COND_FAILING;
			}
			lap->chld_config = CFGA_STAT_CONFIGURED;
			break;
		case CFGA_STAT_UNCONFIGURED:
			/*
			 * if unconfigured - offline or down,
			 * set to cond to unusable regardless of accessibility.
			 * This behavior needs to be examined further.
			 * When the device is not accessible the node
			 * may get offline or down. In that case failing
			 * cond may make more sense.
			 * In anycase the ostate will be set to configured
			 * configured.
			 */
			cond = CFGA_COND_UNUSABLE;
			/*
			 * For fabric port the fca port is considered as
			 * configured since user configured previously
			 * for any existing node.  Otherwise when the
			 * device was accessible, the hba is considered as
			 * configured.
			 */
			if (((strcmp(lap->xport_type,
				FP_FC_PUBLIC_PORT_TYPE) == 0) ||
				(strcmp(lap->xport_type,
				FP_FC_FABRIC_PORT_TYPE) == 0)) ||
				(lap->ret == FPCFGA_ACCESS_OK)) {
				lap->chld_config = CFGA_STAT_CONFIGURED;
			} else {
				/*
				 * if lap->ret is okay there is at least
				 * one matching ldata exist.  Need to keep
				 * okay ret to display the matching ones.
				 */
				if (lap->ret != FPCFGA_OK) {
					lap->ret = FPCFGA_APID_NOEXIST;
				}
				S_FREE(port_wwn);
				return (FPCFGA_OK);
			}
			break;
		default:
			break;
		}

		/* if device found in dev_list, ldata already created. */
		if (ldata_ret == FPCFGA_ACCESS_OK) {
			/*
			 * if cond is not changed then don't update
			 * condition to keep any condtion
			 * from initial discovery. If the initial
			 * cond was failed the same condition will be kept.
			 */
			if (cond != CFGA_COND_UNKNOWN) {
				matchldp->ldata.ap_cond = cond;
			}
			matchldp->ldata.ap_o_state = CFGA_STAT_CONFIGURED;
			matchldp->ldata.ap_busy = busy;
			/* update ap_info via inquiry */
			clp = &matchldp->ldata;
			/* update ap_type and ap_info */
			get_hw_info(node, clp);
			lap->ret = FPCFGA_OK;
			S_FREE(port_wwn);
			return (FPCFGA_OK);
		}
	}

	/*
	 * if cmd is stat all check ldata list
	 * to see if the node exist on the dev list.  Otherwise create
	 * the list element.
	 */
	if (lap->cmd == FPCFGA_STAT_ALL) {
		switch (ldata_ret) {
		case FPCFGA_ACCESS_OK:
			/* node exists so set ostate to configured. */
			lap->chld_config = CFGA_STAT_CONFIGURED;
			matchldp->ldata.ap_o_state =
				CFGA_STAT_CONFIGURED;
			matchldp->ldata.ap_busy = busy;
			clp = &matchldp->ldata;
			switch (ostate) {
			case CFGA_STAT_CONFIGURED:
			/*
			 * If not unconfigured and not attached
			 * the state is set to CFGA_STAT_NONE currently.
			 * This is okay for the detached node due to
			 * the driver being unloaded.
			 * May need to define another state to
			 * isolate the detached only state.
			 */
			case CFGA_STAT_NONE:
				/* update ap_type and ap_info */
				get_hw_info(node, clp);
				break;
			/*
			 * node is offline or down.
			 * set cond to unusable.
			 */
			case CFGA_STAT_UNCONFIGURED:
				/*
				 * if cond is not unknown
				 * initial probing was failed
				 * so don't update again.
				 */
				if (matchldp->ldata.ap_cond ==
					CFGA_COND_UNKNOWN) {
					matchldp->ldata.ap_cond =
					CFGA_COND_UNUSABLE;
				}
				break;
			default:
				break;
			}
			/* node found in ldata list so just return. */
			lap->ret = FPCFGA_OK;
			S_FREE(port_wwn);
			return (FPCFGA_OK);
		case FPCFGA_APID_NOACCESS:
			switch (ostate) {
			/* node is attached but not in dev list */
			case CFGA_STAT_CONFIGURED:
			case CFGA_STAT_NONE:
				lap->chld_config = CFGA_STAT_CONFIGURED;
				cond = CFGA_COND_FAILING;
				break;
			/*
			 * node is offline or down.
			 * set cond to unusable.
			 */
			case CFGA_STAT_UNCONFIGURED:
				/*
				 * For fabric port the fca port is
				 * considered as configured since user
				 * configured previously for any
				 * existing node.
				 */
				cond = CFGA_COND_UNUSABLE;
				if ((strcmp(lap->xport_type,
					FP_FC_PUBLIC_PORT_TYPE) == 0) ||
					(strcmp(lap->xport_type,
					FP_FC_FABRIC_PORT_TYPE) == 0)) {
					lap->chld_config =
					CFGA_STAT_CONFIGURED;
				} else {
					lap->ret = FPCFGA_OK;
					S_FREE(port_wwn);
					return (FPCFGA_OK);
				}
				break;
			default:
			/*
			 * continue to create ldata_list struct for
			 * this node
			 */
				break;
			}
		default:
			break;
		}
	}

	listp = calloc(1, sizeof (ldata_list_t));
	if (listp == NULL) {
		lap->l_errno = errno;
		S_FREE(port_wwn);
		return (FPCFGA_LIB_ERR);
	}

	clp = &listp->ldata;

	/* Create logical and physical ap_id */
	(void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id),
		"%s%s%s%s%d", lap->xport_logp, DYN_SEP, port_wwn,
		LUN_COMP_SEP, *lun_nump);
	(void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id),
		"%s%s%s%s%d", lap->apidp->xport_phys, DYN_SEP, port_wwn,
		LUN_COMP_SEP, *lun_nump);
	clp->ap_class[0] = '\0'; /* Filled in by libcfgadm */
	clp->ap_r_state = lap->xport_rstate;
	clp->ap_o_state = CFGA_STAT_CONFIGURED;
	clp->ap_cond = cond;
	clp->ap_busy = busy;
	clp->ap_status_time = (time_t)-1;
	clp->ap_info[0] = '\0';

	get_hw_info(node, clp);

	(void) insert_ldata_to_ldatalist(port_wwn, lun_nump, listp,
		&(lap->listp));

	lap->ret = FPCFGA_OK;
	S_FREE(port_wwn);
	return (FPCFGA_OK);
}

/*
 * Searches the ldata_list to find if the the input port_wwn exist.
 *
 * Input:  port_wwn, ldata_list.
 * Return value: FPCFGA_APID_NOACCESS if not found on ldata_list.
 *		 FPCFGA_ACCESS_OK if found on ldata_list.
 */
static fpcfga_ret_t
is_dyn_ap_on_ldata_list(const char *port_wwn, const ldata_list_t *listp,
			ldata_list_t **matchldpp, int *l_errnop)
{
	char		*dyn = NULL, *dyncomp = NULL;
	int		len;
	ldata_list_t	*tmplp;
	fpcfga_ret_t 	ret;


	ret = FPCFGA_APID_NOACCESS;

	tmplp = (ldata_list_t *)listp;
	while (tmplp != NULL) {
		if ((dyn = GET_DYN(tmplp->ldata.ap_phys_id)) != NULL) {
			len = strlen(DYN_TO_DYNCOMP(dyn)) + 1;
			dyncomp = calloc(1, len);
			if (dyncomp == NULL) {
				*l_errnop = errno;
				ret = FPCFGA_LIB_ERR;
				break;
			}
			(void) strcpy(dyncomp, DYN_TO_DYNCOMP(dyn));
			if (!(strncmp(port_wwn, dyncomp, WWN_SIZE*2))) {
				*matchldpp = tmplp;
				S_FREE(dyncomp);
				ret = FPCFGA_ACCESS_OK;
				break;
			}
			S_FREE(dyncomp);
		}
		tmplp = tmplp->next;
	}

	return (ret);
}

/*
 * Searches the ldata_list to find if the the input port_wwn and lun exist.
 *
 * Input:  port_wwn, ldata_list.
 * Return value: FPCFGA_APID_NOACCESS if not found on ldata_list.
 *		 FPCFGA_ACCESS_OK if found on ldata_list.
 */
static fpcfga_ret_t
is_FCP_dev_ap_on_ldata_list(const char *port_wwn, const int lun_num,
			ldata_list_t *ldatap,
			ldata_list_t **matchldpp)
{
	ldata_list_t *curlp = NULL;
	char *dyn = NULL, *dyncomp = NULL;
	char *lun_dyn = NULL, *lunp = NULL;
	int ldata_lun;
	fpcfga_ret_t ret;

	/*
	 * if there is no list data just return the FCP dev list.
	 * Normally this should not occur since list data should
	 * be created through discoveredPort list.
	 */
	ret = FPCFGA_APID_NOACCESS;
	if (ldatap == NULL) {
		return (ret);
	}

	dyn = GET_DYN(ldatap->ldata.ap_phys_id);
	if (dyn != NULL) dyncomp = DYN_TO_DYNCOMP(dyn);
	if ((dyncomp != NULL) &&
			(strncmp(dyncomp, port_wwn, WWN_SIZE*2) == 0)) {
		lun_dyn = GET_LUN_DYN(dyncomp);
		if (lun_dyn != NULL) {
			lunp = LUN_DYN_TO_LUNCOMP(lun_dyn);
			if ((ldata_lun = atoi(lunp)) == lun_num) {
				*matchldpp = ldatap;
				return (FPCFGA_ACCESS_OK);
			} else if (ldata_lun > lun_num) {
				return (ret);
			}
			/* else continue */
		} else {
			/* we have match without lun comp. */
			*matchldpp = ldatap;
			return (FPCFGA_ACCESS_OK);
		}
	}

	curlp = ldatap->next;

	dyn = dyncomp = NULL;
	lun_dyn = lunp = NULL;
	while (curlp != NULL) {
		dyn = GET_DYN(curlp->ldata.ap_phys_id);
		if (dyn != NULL) dyncomp = DYN_TO_DYNCOMP(dyn);
		if ((dyncomp != NULL) &&
				(strncmp(dyncomp, port_wwn, WWN_SIZE*2) == 0)) {
			lun_dyn = GET_LUN_DYN(dyncomp);
			if (lun_dyn != NULL) {
				lunp = LUN_DYN_TO_LUNCOMP(lun_dyn);
				if ((ldata_lun = atoi(lunp)) == lun_num) {
					*matchldpp = curlp;
					return (FPCFGA_ACCESS_OK);
				} else if (ldata_lun > lun_num) {
					return (ret);
				}
				/* else continue */
			} else {
				/* we have match without lun comp. */
				*matchldpp = curlp;
				return (FPCFGA_ACCESS_OK);
			}
		}
		dyn = dyncomp = NULL;
		lun_dyn = lunp = NULL;
		curlp = curlp->next;
	}

	return (ret);

}

/*
 * This routine is called when a pathinfo without matching pwwn in dev_list
 * is found.
 */
static fpcfga_ret_t
init_ldata_for_mpath_dev(di_path_t path, char *pwwn, int *l_errnop,
	fpcfga_list_t *lap)
{
	ldata_list_t *listp = NULL;
	cfga_list_data_t *clp = NULL;
	size_t		devlen;
	char		*devpath;
	di_node_t	client_node = DI_NODE_NIL;
	uint_t 		dctl_state = 0;
	cfga_busy_t 	busy;
	char		*client_path;
	di_path_state_t	pstate;

	/* get the client node path */
	if (path == DI_PATH_NIL) {
		return (FPCFGA_LIB_ERR);
	}
	client_node = di_path_client_node(path);
	if (client_node == DI_NODE_NIL) {
		return (FPCFGA_LIB_ERR);
	}
	if ((client_path = di_devfs_path(client_node)) == NULL) {
		return (FPCFGA_LIB_ERR);
	}
	devlen = strlen(DEVICES_DIR) + strlen(client_path) + 1;
	devpath = calloc(1, devlen);
	if (devpath == NULL) {
		di_devfs_path_free(client_path);
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}
	(void) snprintf(devpath, devlen, "%s%s", DEVICES_DIR, client_path);

	/* now need to create ldata for this dev */
	listp = calloc(1, sizeof (ldata_list_t));
	if (listp == NULL) {
		di_devfs_path_free(client_path);
		S_FREE(devpath);
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	clp = &listp->ldata;

	/* Create logical and physical ap_id */
	(void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id), "%s%s%s",
			lap->xport_logp, DYN_SEP, pwwn);
	(void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id), "%s%s%s",
			lap->apidp->xport_phys, DYN_SEP, pwwn);

	/* Filled in by libcfgadm */
	clp->ap_class[0] = '\0'; /* Filled by libcfgadm */
	clp->ap_r_state = lap->xport_rstate;
	/* set to ostate to configured. */
	clp->ap_o_state = CFGA_STAT_CONFIGURED;
	/*
	 * This routine is called when a port WWN is not found in dev list
	 * but path info node exists.
	 *
	 * Update the condition as failing if the pathinfo state was normal.
	 * Update the condition as unusable if the pathinfo state is failed
	 * or offline.
	 */
	if (((pstate = di_path_state(path)) == DI_PATH_STATE_OFFLINE) ||
			(pstate == DI_PATH_STATE_FAULT)) {
		clp->ap_cond = CFGA_COND_UNUSABLE;
	} else {
		clp->ap_cond = CFGA_COND_FAILING;
	}
	clp->ap_status_time = (time_t)-1;
	/* update ap_type and ap_info */
	get_hw_info(client_node, clp);

	if (devctl_cmd(devpath, FPCFGA_DEV_GETSTATE,
		&dctl_state, l_errnop) == FPCFGA_OK) {
		busy = ((dctl_state & DEVICE_BUSY) == DEVICE_BUSY) ? 1 : 0;
	} else {
		busy = 0;
	}
	clp->ap_busy = busy;
	/* Link it in */
	listp->next = lap->listp;
	lap->listp = listp;

	di_devfs_path_free(client_path);
	S_FREE(devpath);

	/* now return with ok status with ldata. */
	lap->ret = FPCFGA_OK;
	return (FPCFGA_OK);
}

/*
 * Initialize the cfga_list_data struct for an accessible device
 * from g_get_dev_list().
 *
 * Input:  fca port ldata.
 * Output: device cfga_list_data.
 *
 */
static fpcfga_ret_t
init_ldata_for_accessible_dev(const char *dyncomp, uchar_t inq_type,
							fpcfga_list_t *lap)
{
	ldata_list_t *listp = NULL;
	cfga_list_data_t *clp = NULL;
	int i;

	listp = calloc(1, sizeof (ldata_list_t));
	if (listp == NULL) {
		lap->l_errno = errno;
		return (FPCFGA_LIB_ERR);
	}

	clp = &listp->ldata;

	assert(dyncomp != NULL);

	/* Create logical and physical ap_id */
	(void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id), "%s%s%s",
		lap->xport_logp, DYN_SEP, dyncomp);

	(void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id), "%s%s%s",
		lap->apidp->xport_phys, DYN_SEP, dyncomp);

	clp->ap_class[0] = '\0'; /* Filled in by libcfgadm */
	clp->ap_r_state = lap->xport_rstate;
	clp->ap_o_state = CFGA_STAT_UNCONFIGURED;
	clp->ap_cond = CFGA_COND_UNKNOWN;
	clp->ap_busy = 0;
	clp->ap_status_time = (time_t)-1;
	clp->ap_info[0] = '\0';
	for (i = 0; i < N_DEVICE_TYPES; i++) {
		if (inq_type == device_list[i].itype) {
			(void) snprintf(clp->ap_type, sizeof (clp->ap_type),
			"%s", (char *)device_list[i].name);
		break;
		}
	}
	if (i == N_DEVICE_TYPES) {
		if (inq_type == ERR_INQ_DTYPE) {
			clp->ap_cond = CFGA_COND_FAILED;
			snprintf(clp->ap_type, sizeof (clp->ap_type), "%s",
			    (char *)GET_MSG_STR(ERR_UNAVAILABLE));
		} else {
			(void) snprintf(clp->ap_type, sizeof (clp->ap_type),
				"%s", "unknown");
		}
	}

	/* Link it in */
	(void) insert_ldata_to_ldatalist(dyncomp, NULL, listp, &(lap->listp));

	return (FPCFGA_OK);
}

/*
 * Initialize the cfga_list_data struct for an accessible FCP SCSI LUN device
 * from the report lun data.
 *
 * Input:  fca port ldata. report lun info
 * Output: device cfga_list_data.
 *
 */
static fpcfga_ret_t
init_ldata_for_accessible_FCP_dev(
	const char *port_wwn,
	int num_luns,
	struct report_lun_resp *resp_buf,
	fpcfga_list_t	*lap,
	int *l_errnop)
{
	ldata_list_t *listp = NULL, *listp_start = NULL, *listp_end = NULL,
		*prevlp = NULL, *curlp = NULL, *matchp_start = NULL,
		*matchp_end = NULL;
	cfga_list_data_t *clp = NULL;
	char *dyn = NULL, *dyncomp = NULL;
	uchar_t *lun_string;
	uint16_t lun_num;
	int i, j, str_ret;
	fpcfga_ret_t ret;
	char dtype[CFGA_TYPE_LEN];
	struct scsi_inquiry *inq_buf;
	uchar_t	peri_qual;
	cfga_cond_t cond = CFGA_COND_UNKNOWN;
	uchar_t lun_num_raw[SAM_LUN_SIZE];

	/* when number of lun is 0 it is not an error. so just return ok. */
	if (num_luns == 0) {
		return (FPCFGA_OK);
	}

	for (i = 0; i < num_luns; i++) {
	    lun_string = (uchar_t *)&(resp_buf->lun_string[i]);
	    memcpy(lun_num_raw, lun_string, sizeof (lun_num_raw));
	    if ((ret = get_standard_inq_data(lap->apidp->xport_phys, port_wwn,
		lun_num_raw, &inq_buf, l_errnop))
		!= FPCFGA_OK) {
		if (ret == FPCFGA_FCP_TGT_SEND_SCSI_FAILED) {
			(void) strlcpy(dtype,
			(char *)GET_MSG_STR(ERR_UNAVAILABLE), CFGA_TYPE_LEN);
			cond = CFGA_COND_FAILED;
		} else {
			S_FREE(inq_buf);
			return (FPCFGA_LIB_ERR);
		}
	    } else {
		peri_qual = inq_buf->inq_dtype & FP_PERI_QUAL_MASK;
		/*
		 * peripheral qualifier is not 0 so the device node should not
		 * included in the ldata list. There should not be a device
		 * node for the lun either.
		 */
		if (peri_qual != DPQ_POSSIBLE) {
			S_FREE(inq_buf);
			continue;
		}
		*dtype = '\0';
		for (j = 0; j < N_DEVICE_TYPES; j++) {
		    if ((inq_buf->inq_dtype & DTYPE_MASK)
				== device_list[j].itype) {
			(void) strlcpy(dtype, (char *)device_list[j].name,
					CFGA_TYPE_LEN);
			break;
		    }
		}
		if (*dtype == '\0') {
			(void) strlcpy(dtype,
				(char *)device_list[DTYPE_UNKNOWN_INDEX].name,
				CFGA_TYPE_LEN);
		}
	    }
		/*
		 * Followed FCP driver for getting lun number from report
		 * lun data.
		 * According to SAM-2 there are multiple address method for
		 * FCP SCIS LUN.  Logincal unit addressing, peripheral device
		 * addressing, flat space addressing, and extended logical
		 * unit addressing.
		 *
		 * as of 11/2001 FCP supports logical unit addressing and
		 * peripheral device addressing even thoough 3 defined.
		 * SSFCP_LUN_ADDRESSING 0x80
		 * SSFCP_PD_ADDRESSING 0x00
		 * SSFCP_VOLUME_ADDRESSING 0x40
		 *
		 * the menthod below is used by FCP when (lun_string[0] & 0xC0)
		 * is either SSFCP_LUN_ADDRESSING or SSFCP_PD_ADDRESSING mode.
		 */
	    lun_num = ((lun_string[0] & 0x3F) << 8) | lun_string[1];
	    listp = calloc(1, sizeof (ldata_list_t));
	    if (listp == NULL) {
		*l_errnop = errno;
		list_free(&listp_start);
		return (FPCFGA_LIB_ERR);
	    }

	    clp = &listp->ldata;
		/* Create logical and physical ap_id */
	    (void) snprintf(clp->ap_log_id, sizeof (clp->ap_log_id),
		"%s%s%s%s%d", lap->xport_logp, DYN_SEP, port_wwn,
		LUN_COMP_SEP, lun_num);
	    (void) snprintf(clp->ap_phys_id, sizeof (clp->ap_phys_id),
		"%s%s%s%s%d", lap->apidp->xport_phys, DYN_SEP, port_wwn,
		LUN_COMP_SEP, lun_num);
	    (void) strncpy(clp->ap_type, dtype, strlen(dtype));
	    clp->ap_class[0] = '\0'; /* Filled in by libcfgadm */
	    clp->ap_r_state = lap->xport_rstate;
	    clp->ap_o_state = CFGA_STAT_UNCONFIGURED;
	    clp->ap_cond = cond;
	    clp->ap_busy = 0;
	    clp->ap_status_time = (time_t)-1;
	    clp->ap_info[0] = '\0';
	    if (listp_start == NULL) {
		listp_start = listp;
	    } else {
		if ((ret = insert_FCP_dev_ldata(
			port_wwn, lun_num, listp,
			&listp_start)) != FPCFGA_OK) {
			list_free(&listp_start);
			return (ret);
		}
	    }
	    listp = NULL;
	    S_FREE(inq_buf);
	}

	/*
	 * list data can be null when device peripheral qualifier is not 0
	 * for any luns.  Return ok to continue.
	 */
	if (listp_start == NULL) {
		return (FPCFGA_OK);
	}
	/*
	 * get the end of list for later uses.
	 */
	curlp = listp_start->next;
	prevlp = listp_start;
	while (curlp) {
		prevlp = curlp;
		curlp = curlp->next;
	}
	listp_end = prevlp;

	/*
	 * if there is no list data just return the FCP dev list.
	 * Normally this should not occur since list data should
	 * be created through g_get_dev_list().
	 */
	if (lap->listp == NULL) {
		lap->listp = listp_start;
		for (listp = listp_start; listp != NULL; listp = listp->next) {
			listp->ldata.ap_cond = CFGA_COND_FAILING;
		}
		return (FPCFGA_OK);
	}

	dyn = GET_DYN(lap->listp->ldata.ap_phys_id);
	if ((dyn != NULL) && ((dyncomp = DYN_TO_DYNCOMP(dyn)) != NULL)) {
		if ((str_ret = strncmp(dyncomp, port_wwn, WWN_SIZE*2)) == 0) {
			matchp_start = matchp_end = lap->listp;
			while (matchp_end->next != NULL) {
				dyn = GET_DYN(
					matchp_end->next->ldata.ap_phys_id);
				if ((dyn != NULL) &&
				((dyncomp = DYN_TO_DYNCOMP(dyn)) != NULL)) {
					if ((str_ret = strncmp(dyncomp,
						port_wwn, WWN_SIZE*2)) == 0) {
						matchp_end = matchp_end->next;
					} else {
						break;
					}
				} else {
					break;
				}
			}
			/* fillup inqdtype */
			for (listp = listp_start; listp != NULL;
					listp = listp->next) {
				listp->ldata.ap_cond =
					lap->listp->ldata.ap_cond;
			}
			/* link the new elem of lap->listp. */
			listp_end->next = matchp_end->next;
			/* free the one matching wwn. */
			matchp_end->next = NULL;
			list_free(&matchp_start);
			/* link lap->listp to listp_start. */
			lap->listp = listp_start;
			return (FPCFGA_OK);
		} else if (str_ret > 0) {
			for (listp = listp_start; listp != NULL;
					listp = listp->next) {
				listp->ldata.ap_cond = CFGA_COND_FAILING;
			}
			listp_end->next = lap->listp->next;
			lap->listp = listp_start;
			return (FPCFGA_OK);
		}
	}

	prevlp = lap->listp;
	curlp = lap->listp->next;

	dyn = dyncomp = NULL;
	while (curlp != NULL) {
		dyn = GET_DYN(curlp->ldata.ap_phys_id);
		if ((dyn != NULL) &&
			((dyncomp = DYN_TO_DYNCOMP(dyn)) != NULL)) {
			if ((str_ret = strncmp(dyncomp, port_wwn,
					WWN_SIZE*2)) == 0) {
				matchp_start = matchp_end = curlp;
				while (matchp_end->next != NULL) {
					dyn = GET_DYN(
					matchp_end->next->ldata.ap_phys_id);
					if ((dyn != NULL) &&
						((dyncomp = DYN_TO_DYNCOMP(dyn))
						!= NULL)) {
						if ((str_ret = strncmp(dyncomp,
							port_wwn, WWN_SIZE*2))
							== 0) {
							matchp_end =
							matchp_end->next;
						} else {
							break;
						}
					} else {
						break;
					}
				}
				for (listp = listp_start; listp != NULL;
						listp = listp->next) {
				    listp->ldata.ap_cond = curlp->ldata.ap_cond;
				}
				/* link the next elem to listp_end. */
				listp_end->next = matchp_end->next;
				/* link prevlp to listp_start to drop curlp. */
				prevlp->next = listp_start;
				/* free matching pwwn elem. */
				matchp_end->next = NULL;
				list_free(&matchp_start);
				return (FPCFGA_OK);
			} else if (str_ret > 0) {
				for (listp = listp_start; listp != NULL;
						listp = listp->next) {
					/*
					 * Dev not found from accessible
					 * fc dev list but the node should
					 * exist. Set to failing cond now
					 * and check the node state later.
					 */
				    listp->ldata.ap_cond = CFGA_COND_FAILING;
				}
				/* keep the cur elem by linking to list_end. */
				listp_end->next = curlp;
				prevlp->next = listp_start;
				return (FPCFGA_OK);
			}
		}
		dyn = dyncomp = NULL;
		prevlp = curlp;
		curlp = curlp->next;
	}

	prevlp->next = listp_start;
	for (listp = listp_start; listp != NULL; listp = listp->next) {
		listp->ldata.ap_cond = CFGA_COND_FAILING;
	}

	return (FPCFGA_OK);

}

/* fill in device type, vid, pid from properties */
static void
get_hw_info(di_node_t node, cfga_list_data_t *clp)
{
	char *cp = NULL;
	char *inq_vid, *inq_pid;
	int i;

	/*
	 * if the type is not previously assigned with valid SCSI device type
	 * check devinfo to find the type.
	 * once device is configured it should have a valid device type.
	 * device node is configured but no valid device type is found
	 * the type will be set to unavailable.
	 */
	if (clp->ap_type != NULL) {
		/*
		 * if the type is not one of defined SCSI device type
		 * check devinfo to find the type.
		 *
		 * Note: unknown type is not a valid device type.
		 *	It is added in to the device list table to provide
		 *	constant string of "unknown".
		 */
	    for (i = 0; i < (N_DEVICE_TYPES -1); i++) {
		if (strncmp((char *)clp->ap_type, (char *)device_list[i].name,
			sizeof (clp->ap_type)) == 0) {
			break;
		}
	    }
	    if (i == (N_DEVICE_TYPES - 1)) {
		cp = (char *)get_device_type(node);
		if (cp == NULL) {
			cp = (char *)GET_MSG_STR(ERR_UNAVAILABLE);
		}
		(void) snprintf(clp->ap_type, sizeof (clp->ap_type), "%s",
			S_STR(cp));
	    }
	} else {
		cp = (char *)get_device_type(node);
		if (cp == NULL) {
			cp = (char *)GET_MSG_STR(ERR_UNAVAILABLE);
		}
		(void) snprintf(clp->ap_type, sizeof (clp->ap_type), "%s",
			S_STR(cp));
	}

	/*
	 * Fill in vendor and product ID.
	 */
	if ((di_prop_lookup_strings(DDI_DEV_T_ANY, node,
	    "inquiry-product-id", &inq_pid) == 1) &&
	    (di_prop_lookup_strings(DDI_DEV_T_ANY, node,
	    "inquiry-vendor-id", &inq_vid) == 1)) {
		(void) snprintf(clp->ap_info, sizeof (clp->ap_info),
		    "%s %s", inq_vid, inq_pid);
	}
}

/*
 * Get dtype from "inquiry-device-type" property. If not present,
 * derive it from minor node type
 */
static const char *
get_device_type(di_node_t node)
{
	char *name = NULL;
	int *inq_dtype;
	int i;

	if (node == DI_NODE_NIL) {
		return (NULL);
	}

	/* first, derive type based on inquiry property */
	if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "inquiry-device-type",
	    &inq_dtype) != -1) {
		int itype = (*inq_dtype) & DTYPE_MASK;

		for (i = 0; i < N_DEVICE_TYPES; i++) {
			if (itype == device_list[i].itype) {
				name = (char *)device_list[i].name;
				break;
			}
		}
		/*
		 * when found to be unknown type, set name to null to check
		 * device minor node type.
		 */
		if (i == (N_DEVICE_TYPES - 1)) {
			name = NULL;
		}
	}

	/* if property fails, use minor nodetype */
	if (name == NULL) {
		char *nodetype;
		di_minor_t minor = di_minor_next(node, DI_MINOR_NIL);

		if ((minor != DI_MINOR_NIL) &&
		    ((nodetype = di_minor_nodetype(minor)) != NULL)) {
			for (i = 0; i < N_DEVICE_TYPES; i++) {
				if (device_list[i].ntype &&
				    (strcmp(nodetype, device_list[i].ntype)
				    == 0)) {
					name = (char *)device_list[i].name;
					break;
				}
			}
		}
	}

	return (name);
}

/* Transform list data to stat data */
fpcfga_ret_t
list_ext_postprocess(
	ldata_list_t		**llpp,
	int			nelem,
	cfga_list_data_t	**ap_id_list,
	int			*nlistp,
	char			**errstring)
{
	cfga_list_data_t *ldatap = NULL;
	ldata_list_t *tmplp = NULL;
	int i = -1;

	*ap_id_list = NULL;
	*nlistp = 0;

	if (*llpp == NULL || nelem < 0) {
		return (FPCFGA_LIB_ERR);
	}

	if (nelem == 0) {
		return (FPCFGA_APID_NOEXIST);
	}

	ldatap = calloc(nelem, sizeof (cfga_list_data_t));
	if (ldatap == NULL) {
		cfga_err(errstring, errno, ERR_LIST, 0);
		return (FPCFGA_LIB_ERR);
	}

	/* Extract the list_data structures from the linked list */
	tmplp = *llpp;
	for (i = 0; i < nelem && tmplp != NULL; i++) {
		ldatap[i] = tmplp->ldata;
		tmplp = tmplp->next;
	}

	if (i < nelem || tmplp != NULL) {
		S_FREE(ldatap);
		return (FPCFGA_LIB_ERR);
	}

	*nlistp = nelem;
	*ap_id_list = ldatap;

	return (FPCFGA_OK);
}

/*
 * Convert bus state to receptacle state
 */
static cfga_stat_t
xport_devinfo_to_recep_state(uint_t xport_di_state)
{
	cfga_stat_t rs;

	switch (xport_di_state) {
	case DI_BUS_QUIESCED:
	case DI_BUS_DOWN:
		rs = CFGA_STAT_DISCONNECTED;
		break;
	/*
	 * NOTE: An explicit flag for active should probably be added to
	 * libdevinfo.
	 */
	default:
		rs = CFGA_STAT_CONNECTED;
		break;
	}

	return (rs);
}

/*
 * Convert device state to occupant state
 * if driver is attached the node is configured.
 * if offline or down the node is unconfigured.
 * if only driver detached it is none state which is treated the same
 * way as configured state.
 */
static cfga_stat_t
dev_devinfo_to_occupant_state(uint_t dev_di_state)
{
	/* Driver attached ? */
	if ((dev_di_state & DI_DRIVER_DETACHED) != DI_DRIVER_DETACHED) {
		return (CFGA_STAT_CONFIGURED);
	}

	if ((dev_di_state & DI_DEVICE_OFFLINE) == DI_DEVICE_OFFLINE ||
	    (dev_di_state & DI_DEVICE_DOWN) == DI_DEVICE_DOWN) {
		return (CFGA_STAT_UNCONFIGURED);
	} else {
		return (CFGA_STAT_NONE);
	}
}

/*
 * Wrapper routine for inserting ldata to make an sorted ldata list.
 *
 * When show_FCP_dev option is given insert_FCP_dev_ldata() is called.
 * Otherwise insert_fc_dev_ldata() is called.
 */
static fpcfga_ret_t
insert_ldata_to_ldatalist(
	const char *port_wwn,
	int *lun_nump,
	ldata_list_t *listp,
	ldata_list_t **ldatapp)
{

	if (lun_nump == NULL) {
		return (insert_fc_dev_ldata(port_wwn, listp, ldatapp));
	} else {
		return
		(insert_FCP_dev_ldata(port_wwn, *lun_nump, listp, ldatapp));
	}
}

/*
 * Insert an input ldata to ldata list to make sorted ldata list.
 */
static fpcfga_ret_t
insert_fc_dev_ldata(
	const char *port_wwn,
	ldata_list_t *listp,
	ldata_list_t **ldatapp)
{
	ldata_list_t *prevlp = NULL, *curlp = NULL;
	char *dyn = NULL, *dyncomp = NULL;

	if (*ldatapp == NULL) {
		*ldatapp = listp;
		return (FPCFGA_OK);
	}

	dyn = GET_DYN((*ldatapp)->ldata.ap_phys_id);
	if (dyn != NULL) dyncomp = DYN_TO_DYNCOMP(dyn);
	if ((dyncomp != NULL) &&
		(strncmp(dyncomp, port_wwn, WWN_SIZE*2) >= 0)) {
			listp->next = *ldatapp;
			*ldatapp = listp;
			return (FPCFGA_OK);
	}
	/* else continue */

	prevlp = *ldatapp;
	curlp = (*ldatapp)->next;

	dyn = dyncomp = NULL;
	while (curlp != NULL) {
		dyn = GET_DYN(curlp->ldata.ap_phys_id);
		if (dyn != NULL) dyncomp = DYN_TO_DYNCOMP(dyn);
		if ((dyncomp != NULL) &&
				(strncmp(dyncomp, port_wwn, WWN_SIZE*2) >= 0)) {
			listp->next = prevlp->next;
			prevlp->next = listp;
			return (FPCFGA_OK);
		}
		dyn = dyncomp = NULL;
		prevlp = curlp;
		curlp = curlp->next;
	}

	/* add the ldata to the end of the list. */
	prevlp->next = listp;
	return (FPCFGA_OK);
}

/*
 * Insert an input ldata to ldata list to make sorted ldata list.
 */
static fpcfga_ret_t
insert_FCP_dev_ldata(
	const char *port_wwn,
	int lun_num,
	ldata_list_t *listp,
	ldata_list_t **ldatapp)
{
	ldata_list_t *prevlp = NULL, *curlp = NULL;
	char *dyn = NULL, *dyncomp = NULL;
	char *lun_dyn = NULL, *lunp = NULL;

	if (*ldatapp == NULL) {
		*ldatapp = listp;
		return (FPCFGA_OK);
	}

	dyn = GET_DYN((*ldatapp)->ldata.ap_phys_id);
	if (dyn != NULL) dyncomp = DYN_TO_DYNCOMP(dyn);
	if ((dyncomp != NULL) &&
		(strncmp(dyncomp, port_wwn, WWN_SIZE*2) == 0)) {
		lun_dyn = GET_LUN_DYN(dyncomp);
		if (lun_dyn != NULL) {
			lunp = LUN_DYN_TO_LUNCOMP(lun_dyn);
			if ((atoi(lunp)) >= lun_num) {
				listp->next = *ldatapp;
				*ldatapp = listp;
				return (FPCFGA_OK);
			}
		}
	} else if ((dyncomp != NULL) &&
			(strncmp(dyncomp, port_wwn, WWN_SIZE*2) > 0)) {
		listp->next = *ldatapp;
		*ldatapp = listp;
		return (FPCFGA_OK);
	}

	prevlp = *ldatapp;
	curlp = (*ldatapp)->next;

	dyn = dyncomp = NULL;
	lun_dyn = lunp = NULL;
	while (curlp != NULL) {
		dyn = GET_DYN(curlp->ldata.ap_phys_id);
		if (dyn != NULL) dyncomp = DYN_TO_DYNCOMP(dyn);

		if ((dyncomp != NULL) &&
				(strncmp(dyncomp, port_wwn, WWN_SIZE*2) == 0)) {
			lun_dyn = GET_LUN_DYN(dyncomp);
			if (lun_dyn != NULL) {
				lunp = LUN_DYN_TO_LUNCOMP(lun_dyn);
				if ((atoi(lunp)) >= lun_num) {
					listp->next = prevlp->next;
					prevlp->next = listp;
					return (FPCFGA_OK);
				}
			}
			/* else continue */
		} else if ((dyncomp != NULL) &&
				(strncmp(dyncomp, port_wwn, WWN_SIZE*2) > 0)) {
			listp->next = prevlp->next;
			prevlp->next = listp;
			return (FPCFGA_OK);
		}
		/* else continue */

		dyn = dyncomp = NULL;
		lun_dyn = lunp = NULL;
		prevlp = curlp;
		curlp = curlp->next;
	}

	/* add the ldata to the end of the list. */
	prevlp->next = listp;
	return (FPCFGA_OK);
}

/*
 * This function will return the dtype for the given device
 * It will first issue a report lun to lun 0 and then it will issue a SCSI
 * Inquiry to the first lun returned by report luns.
 *
 * If everything is successful, the dtype will be returned with the peri
 * qualifier masked out.
 *
 * If either the report lun or the scsi inquiry fails, we will first check
 * the return status.  If the return status is SCSI_DEVICE_NOT_TGT, then
 * we will assume this is a remote HBA and return an UNKNOWN DTYPE
 * for all other failures, we will return a dtype of ERR_INQ_DTYPE
 */
static uchar_t
get_inq_dtype(char *xport_phys, char *dyncomp, HBA_HANDLE handle,
    HBA_PORTATTRIBUTES *portAttrs, HBA_PORTATTRIBUTES *discPortAttrs) {
	HBA_STATUS		    status;
	report_lun_resp_t	    *resp_buf;
	int			    num_luns = 0, ret, l_errno;
	uchar_t			    *lun_string;
	uint64_t		    lun = 0;
	struct scsi_inquiry	    inq;
	struct scsi_extended_sense  sense;
	HBA_UINT8		    scsiStatus;
	uint32_t		    inquirySize = sizeof (inq);
	uint32_t		    senseSize = sizeof (sense);

	memset(&inq, 0, sizeof (inq));
	memset(&sense, 0, sizeof (sense));
	if ((ret = get_report_lun_data(xport_phys, dyncomp,
			    &num_luns, &resp_buf, &sense, &l_errno))
	    != FPCFGA_OK) {
		/*
		 * Checking the sense key data as well as the additional
		 * sense key.  The SES Node is not required to repond
		 * to Report LUN.  In the case of Minnow, the SES node
		 * returns with KEY_ILLEGAL_REQUEST and the additional
		 * sense key of 0x20.  In this case we will blindly
		 * send the SCSI Inquiry call to lun 0
		 *
		 * if we get any other error we will set the inq_type
		 * appropriately
		 */
		if ((sense.es_key == KEY_ILLEGAL_REQUEST) &&
		    (sense.es_add_code == 0x20)) {
			lun = 0;
		} else {
			if (ret == FPCFGA_FCP_SEND_SCSI_DEV_NOT_TGT) {
				inq.inq_dtype = DTYPE_UNKNOWN;
			} else {
				inq.inq_dtype = ERR_INQ_DTYPE;
			}
			return (inq.inq_dtype);
		}
	} else {
		/* send the inquiry to the first lun */
		lun_string = (uchar_t *)&(resp_buf->lun_string[0]);
		memcpy(&lun, lun_string, sizeof (lun));
		S_FREE(resp_buf);
	}

	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 = inq.inq_dtype & DTYPE_MASK;
	} else if (status == HBA_STATUS_ERROR_NOT_A_TARGET) {
		inq.inq_dtype = DTYPE_UNKNOWN;
	} else {
		inq.inq_dtype = ERR_INQ_DTYPE;
	}
	return (inq.inq_dtype);
}