OpenSolaris_b135/lib/cfgadm_plugins/fp/common/cfga_list.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 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 = NULL;
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 == NULL) {
(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);
}