path: root/usr/src/lib/cfgadm_plugins/fp/common/cfga_utils.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"

/*
 * This file contains helper routines for the FP plugin
 */

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN	"SYS_TEST"
#endif

typedef struct strlist {
	const char *str;
	struct strlist *next;
} strlist_t;

typedef	struct {
	fpcfga_ret_t	fp_err;
	cfga_err_t	cfga_err;
} errcvt_t;

typedef struct {
	fpcfga_cmd_t cmd;
	int type;
	int (*fcn)(const devctl_hdl_t);
} set_state_cmd_t;

typedef struct {
	fpcfga_cmd_t cmd;
	int type;
	int (*state_fcn)(const devctl_hdl_t, uint_t *);
} get_state_cmd_t;

/* defines for nftw() */
#define	NFTW_DEPTH	1
#define	NFTW_CONTINUE	0
#define	NFTW_TERMINATE	1
#define	NFTW_ERROR	-1
#define	MAX_RETRIES	10

/* Function prototypes */
static int do_recurse_dev(const char *path, const struct stat *sbuf,
    int type, struct FTW *ftwp);
static fpcfga_recur_t lookup_dev(const char *lpath, void *arg);
static void msg_common(char **err_msgpp, int append_newline, int l_errno,
    va_list ap);
static void lunlist_free(struct luninfo_list *lunlist);

/* Globals */
struct {
	mutex_t mp;
	void *arg;
	fpcfga_recur_t (*fcn)(const char *lpath, void *arg);
} nftw_arg = {DEFAULTMUTEX};

/*
 * The string table contains most of the strings used by the fp cfgadm plugin.
 * All strings which are to be internationalized must be in this table.
 * Some strings which are not internationalized are also included here.
 * Arguments to messages are NOT internationalized.
 */
msgcvt_t str_tbl[] = {

/*
 * The first element (ERR_UNKNOWN) MUST always be present in the array.
 */
#define	UNKNOWN_ERR_IDX		0	/* Keep the index in sync */


/* msg_code	num_args, I18N	msg_string				*/

/* ERRORS */
{ERR_UNKNOWN,		0, 1,	"unknown error"},
{ERR_OP_FAILED,		0, 1,	"operation failed"},
{ERR_CMD_INVAL,		0, 1,	"invalid command"},
{ERR_NOT_BUSAPID,	0, 1,	"not a FP bus apid"},
{ERR_APID_INVAL,	0, 1,	"invalid FP ap_id"},
{ERR_NOT_BUSOP,		0, 1,	"operation not supported for FC bus"},
{ERR_NOT_DEVOP,		0, 1,	"operation not supported for FC device"},
{ERR_UNAVAILABLE,	0, 1,	"unavailable"},
{ERR_CTRLR_CRIT,	0, 1,	"critical partition controlled by FC HBA"},
{ERR_BUS_GETSTATE,	0, 1,	"failed to get state for FC bus"},
{ERR_BUS_NOTCONNECTED,	0, 1,	"FC bus not connected"},
{ERR_BUS_CONNECTED,	0, 1,	"FC bus not disconnected"},
{ERR_BUS_QUIESCE,	0, 1,	"FC bus quiesce failed"},
{ERR_BUS_UNQUIESCE,	0, 1,	"FC bus unquiesce failed"},
{ERR_BUS_CONFIGURE,	0, 1,	"failed to configure devices on FC bus"},
{ERR_BUS_UNCONFIGURE,	0, 1,	"failed to unconfigure FC bus"},
{ERR_DEV_CONFIGURE,	0, 1,	"failed to configure FC device"},
{ERR_DEV_UNCONFIGURE,	0, 1,	"failed to unconfigure FC device"},
{ERR_FCA_CONFIGURE,	0, 1,	"failed to configure ANY device on FCA port"},
{ERR_FCA_UNCONFIGURE,	0, 1,	"failed to unconfigure ANY device on FCA port"},
{ERR_DEV_REPLACE,	0, 1,	"replace operation failed"},
{ERR_DEV_INSERT,	0, 1,	"insert operation failed"},
{ERR_DEV_GETSTATE,	0, 1,	"failed to get state for FC device"},
{ERR_RESET,		0, 1,	"reset failed"},
{ERR_LIST,		0, 1,	"list operation failed"},
{ERR_SIG_STATE,		0, 1,	"could not restore signal disposition"},
{ERR_MAYBE_BUSY,	0, 1,	"device may be busy"},
{ERR_BUS_DEV_MISMATCH,	0, 1,	"mismatched FC bus and device"},
{ERR_MEM_ALLOC,		0, 1,	"Failed to allocated memory"},
{ERR_DEVCTL_OFFLINE,	0, 1,	"failed to offline device"},
{ERR_UPD_REP,		0, 1,	"Repository update failed"},
{ERR_CONF_OK_UPD_REP,	0, 1,
		"Configuration successful, but Repository update failed"},
{ERR_UNCONF_OK_UPD_REP,	0, 1,
		"Unconfiguration successful, but Repository update failed"},
{ERR_PARTIAL_SUCCESS,	0, 1,
			"Operation partially successful. Some failures seen"},
{ERR_HBA_LOAD_LIBRARY,	0, 1,
			"HBA load library failed"},
{ERR_MATCHING_HBA_PORT,	0, 1,
			"No match HBA port found"},
{ERR_NO_ADAPTER_FOUND,	0, 1,
			"No Fibre Channel adapters found"},

/* Errors with arguments */
{ERRARG_OPT_INVAL,	1, 1,	"invalid option: "},
{ERRARG_HWCMD_INVAL,	1, 1,	"invalid command: "},
{ERRARG_DEVINFO,	1, 1,	"libdevinfo failed on path: "},
{ERRARG_NOT_IN_DEVLIST,	1, 1,	"Device not found in fabric device list: "},
{ERRARG_NOT_IN_DEVINFO,	1, 1,	"Could not find entry in devinfo tree: "},
{ERRARG_DI_GET_PROP,	1, 1,	"Could not get libdevinfo property: "},
{ERRARG_DC_DDEF_ALLOC,	1, 1,	"failed to alloc ddef space: "},
{ERRARG_DC_BYTE_ARRAY,	1, 1,	"failed to add property: "},
{ERRARG_DC_BUS_ACQUIRE,	1, 1,	"failed to acquire bus handle: "},
{ERRARG_BUS_DEV_CREATE,	1, 1,	"failed to create device node: "},
{ERRARG_BUS_DEV_CREATE_UNKNOWN,	1, 1,
	"failed to create device node... Device may be unconfigurable: "},
{ERRARG_DEV_ACQUIRE,	1, 1,	"device acquire operation failed: "},
{ERRARG_DEV_REMOVE,	1, 1,	"remove operation failed: "},

/* Fibre Channel operation Errors */
{ERR_FC,		0, 1,	"FC error"},
{ERR_FC_GET_DEVLIST,	0, 1,	"Failed to get fabric device list"},
{ERR_FC_GET_NEXT_DEV,	0, 1,	"Failed to get next device on device map"},
{ERR_FC_GET_FIRST_DEV,	0, 1,	"Failed to get first device on device map"},
{ERRARG_FC_DEV_MAP_INIT,	1, 1,
	"Failed to initialize device map for: "},
{ERRARG_FC_PROP_LOOKUP_BYTES,	1, 1,	"Failed to get property of "},
{ERRARG_FC_INQUIRY,	1, 1,	"inquiry failed: "},
{ERRARG_FC_REP_LUNS,	1, 1,	"report LUNs failed: "},
{ERRARG_FC_TOPOLOGY,	1, 1,	"failed to get port topology: "},
{ERRARG_PATH_TOO_LONG,	1, 1,	"Path length exceeds max possible: "},
{ERRARG_INVALID_PATH,	1, 1,	"Invalid path: "},
{ERRARG_OPENDIR,	1, 1,	"failure opening directory: "},

/* MPXIO Errors */
{ERRARG_VHCI_GET_PATHLIST,	1, 1,	"failed to get path list from vHCI: "},
{ERRARG_XPORT_NOT_IN_PHCI_LIST,	1, 1,	"Transport not in pHCI list: "},

/* RCM Errors */
{ERR_RCM_HANDLE,	0, 1,	"cannot get RCM handle"},
{ERRARG_RCM_SUSPEND,	1, 1,	"failed to suspend: "},
{ERRARG_RCM_RESUME,	1, 1,	"failed to resume: "},
{ERRARG_RCM_OFFLINE,	1, 1,	"failed to offline: "},
{ERRARG_RCM_ONLINE,	1, 1,	"failed to online: "},
{ERRARG_RCM_REMOVE,	1, 1,	"failed to remove: "},
{ERRARG_RCM_INFO,	1, 1,	"failed to query: "},

/* Commands */
{CMD_INSERT_DEV,	0, 0,	"insert_device"},
{CMD_REMOVE_DEV,	0, 0,	"remove_device"},
{CMD_REPLACE_DEV,	0, 0,	"replace_device"},
{CMD_RESET_DEV,		0, 0,	"reset_device"},
{CMD_RESET_BUS,		0, 0,	"reset_bus"},
{CMD_RESET_ALL,		0, 0,	"reset_all"},

/* help messages */
{MSG_HELP_HDR,		0, 1,	"\nfp attachment point specific options:\n"},
{MSG_HELP_USAGE,	0, 0,
		"\t-c configure -o force_update ap_id [ap_id..]\n"
		"\t-c configure -o no_update ap_id [ap_id...]\n"
		"\t-c unconfigure -o force_update ap_id [ap_id... ]\n"
		"\t-c unconfigure -o no_update ap_id [ap_id... ]\n"},

/* hotplug messages */
{MSG_INSDEV,		1, 1,	"Adding device to FC HBA: "},
{MSG_RMDEV,		1, 1,	"Removing FC device: "},
{MSG_REPLDEV,		1, 1,	"Replacing FC device: "},

/* Hotplugging confirmation prompts */
{CONF_QUIESCE_1,	1, 1,
	"This operation will suspend activity on FC bus: "},

{CONF_QUIESCE_2,	0, 1,	"\nContinue"},

{CONF_UNQUIESCE,	0, 1,
	"FC bus quiesced successfully.\n"
	"It is now safe to proceed with hotplug operation."
	"\nEnter y if operation is complete or n to abort"},

/* Misc. */
{WARN_DISCONNECT,	0, 1,
	"WARNING: Disconnecting critical partitions may cause system hang."
	"\nContinue"}
};


#define	N_STRS	(sizeof (str_tbl) / sizeof (str_tbl[0]))

#define	GET_MSG_NARGS(i)	(str_tbl[msg_idx(i)].nargs)
#define	GET_MSG_INTL(i)		(str_tbl[msg_idx(i)].intl)

static errcvt_t err_cvt_tbl[] = {
	{ FPCFGA_OK,		CFGA_OK			},
	{ FPCFGA_LIB_ERR,	CFGA_LIB_ERROR		},
	{ FPCFGA_APID_NOEXIST,	CFGA_APID_NOEXIST	},
	{ FPCFGA_NACK,		CFGA_NACK		},
	{ FPCFGA_BUSY,		CFGA_BUSY		},
	{ FPCFGA_SYSTEM_BUSY,	CFGA_SYSTEM_BUSY	},
	{ FPCFGA_OPNOTSUPP,	CFGA_OPNOTSUPP		},
	{ FPCFGA_PRIV,		CFGA_PRIV		},
	{ FPCFGA_UNKNOWN_ERR,	CFGA_ERROR		},
	{ FPCFGA_ERR,		CFGA_ERROR		}
};

#define	N_ERR_CVT_TBL	(sizeof (err_cvt_tbl)/sizeof (err_cvt_tbl[0]))

#define	DEV_OP	0
#define	BUS_OP	1
static set_state_cmd_t set_state_cmds[] = {

{ FPCFGA_BUS_QUIESCE,		BUS_OP,		devctl_bus_quiesce	},
{ FPCFGA_BUS_UNQUIESCE,		BUS_OP,		devctl_bus_unquiesce	},
{ FPCFGA_BUS_CONFIGURE,		BUS_OP,		devctl_bus_configure	},
{ FPCFGA_BUS_UNCONFIGURE, 	BUS_OP,		devctl_bus_unconfigure	},
{ FPCFGA_RESET_BUS,		BUS_OP,		devctl_bus_reset	},
{ FPCFGA_RESET_ALL, 		BUS_OP,		devctl_bus_resetall	},
{ FPCFGA_DEV_CONFIGURE,		DEV_OP,		devctl_device_online	},
{ FPCFGA_DEV_UNCONFIGURE,	DEV_OP,		devctl_device_offline	},
{ FPCFGA_DEV_REMOVE,		DEV_OP,		devctl_device_remove	},
{ FPCFGA_RESET_DEV,		DEV_OP,		devctl_device_reset	}

};

#define	N_SET_STATE_CMDS (sizeof (set_state_cmds)/sizeof (set_state_cmds[0]))

static get_state_cmd_t get_state_cmds[] = {
{ FPCFGA_BUS_GETSTATE,		BUS_OP,		devctl_bus_getstate	},
{ FPCFGA_DEV_GETSTATE,		DEV_OP,		devctl_device_getstate	}
};

#define	N_GET_STATE_CMDS (sizeof (get_state_cmds)/sizeof (get_state_cmds[0]))

/* Order is important. Earlier directories are searched first */
static const char *dev_dir_hints[] = {
	CFGA_DEV_DIR,
	DEV_RMT,
	DEV_DSK,
	DEV_RDSK,
	DEV_DIR
};

#define	N_DEV_DIR_HINTS	(sizeof (dev_dir_hints) / sizeof (dev_dir_hints[0]))


/*
 * Routine to search the /dev directory or a subtree of /dev.
 * If the entire /dev hierarchy is to be searched, the most likely directories
 * are searched first.
 */
fpcfga_ret_t
recurse_dev(
	const char	*basedir,
	void		*arg,
	fpcfga_recur_t (*fcn)(const char *lpath, void *arg))
{
	int i, rv = NFTW_ERROR;

	(void) mutex_lock(&nftw_arg.mp);

	nftw_arg.arg = arg;
	nftw_arg.fcn = fcn;

	if (strcmp(basedir, DEV_DIR)) {
		errno = 0;
		rv = nftw(basedir, do_recurse_dev, NFTW_DEPTH, FTW_PHYS);
		goto out;
	}

	/*
	 * Search certain selected subdirectories first if basedir == "/dev".
	 * Ignore errors as some of these directories may not exist.
	 */
	for (i = 0; i < N_DEV_DIR_HINTS; i++) {
		errno = 0;
		if ((rv = nftw(dev_dir_hints[i], do_recurse_dev, NFTW_DEPTH,
		    FTW_PHYS)) == NFTW_TERMINATE) {
			break;
		}
	}

	/*FALLTHRU*/
out:
	(void) mutex_unlock(&nftw_arg.mp);
	return (rv == NFTW_ERROR ? FPCFGA_ERR : FPCFGA_OK);
}

/*ARGSUSED*/
static int
do_recurse_dev(
	const char *path,
	const struct stat *sbuf,
	int type,
	struct FTW *ftwp)
{
	/* We want only VALID symlinks */
	if (type != FTW_SL) {
		return (NFTW_CONTINUE);
	}

	assert(nftw_arg.fcn != NULL);

	if (nftw_arg.fcn(path, nftw_arg.arg) == FPCFGA_TERMINATE) {
		/* terminate prematurely, but may not be error */
		errno = 0;
		return (NFTW_TERMINATE);
	} else {
		return (NFTW_CONTINUE);
	}
}

cfga_err_t
err_cvt(fpcfga_ret_t fp_err)
{
	int i;

	for (i = 0; i < N_ERR_CVT_TBL; i++) {
		if (err_cvt_tbl[i].fp_err == fp_err) {
			return (err_cvt_tbl[i].cfga_err);
		}
	}

	return (CFGA_ERROR);
}

/*
 * Removes duplicate slashes from a pathname and any trailing slashes.
 * Returns "/" if input is "/"
 */
char *
pathdup(const char *path, int *l_errnop)
{
	int prev_was_slash = 0;
	char c, *dp = NULL, *dup = NULL;
	const char *sp = NULL;

	*l_errnop = 0;

	if (path == NULL) {
		return (NULL);
	}

	if ((dup = calloc(1, strlen(path) + 1)) == NULL) {
		*l_errnop = errno;
		return (NULL);
	}

	prev_was_slash = 0;
	for (sp = path, dp = dup; (c = *sp) != '\0'; sp++) {
		if (!prev_was_slash || c != '/') {
			*dp++ = c;
		}
		if (c == '/') {
			prev_was_slash = 1;
		} else {
			prev_was_slash = 0;
		}
	}

	/* Remove trailing slash except if it is the first char */
	if (prev_was_slash && dp != dup && dp - 1 != dup) {
		*(--dp) = '\0';
	} else {
		*dp = '\0';
	}

	return (dup);
}

fpcfga_ret_t
apidt_create(const char *ap_id, apid_t *apidp, char **errstring)
{
	char *xport_phys = NULL, *dyn = NULL;
	char *dyncomp = NULL;
	struct luninfo_list *lunlistp = NULL;
	int l_errno = 0;
	size_t len = 0;
	fpcfga_ret_t ret;

	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 */
	dyncomp = NULL;
	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);
			ret = FPCFGA_LIB_ERR;
			goto err;
		}
		(void) strcpy(dyncomp, DYN_TO_DYNCOMP(dyn));
		if (GET_LUN_DYN(dyncomp)) {
			ret = FPCFGA_APID_NOEXIST;
			goto err;
		}

		/* Remove the dynamic component from the base. */
		*dyn = '\0';
	}

	/* Get the path of dynamic attachment point if already configured. */
	if (dyncomp != NULL) {
		ret = dyn_apid_to_path(xport_phys, dyncomp,
		    &lunlistp, &l_errno);
		if ((ret != FPCFGA_OK) && (ret != FPCFGA_APID_NOCONFIGURE)) {
			cfga_err(errstring, l_errno, ERR_OP_FAILED, 0);
			goto err;
		}
	}

	assert(xport_phys != NULL);

	apidp->xport_phys = xport_phys;
	apidp->dyncomp = dyncomp;
	apidp->lunlist = lunlistp;
	apidp->flags = 0;

	return (FPCFGA_OK);

err:
	S_FREE(xport_phys);
	S_FREE(dyncomp);
	lunlist_free(lunlistp);
	return (ret);
}

static void
lunlist_free(struct luninfo_list *lunlist)
{
struct luninfo_list *lunp;

	while (lunlist != NULL) {
		lunp = lunlist->next;
		S_FREE(lunlist->path);
		S_FREE(lunlist);
		lunlist = lunp;
	}
}

void
apidt_free(apid_t *apidp)
{
	if (apidp == NULL)
		return;

	S_FREE(apidp->xport_phys);
	S_FREE(apidp->dyncomp);
	lunlist_free(apidp->lunlist);
}

fpcfga_ret_t
walk_tree(
	const char	*physpath,
	void		*arg,
	uint_t		init_flags,
	walkarg_t	*up,
	fpcfga_cmd_t	cmd,
	int		*l_errnop)
{
	int rv;
	di_node_t root, tree_root, fpnode;
	char *root_path, *cp = NULL;
	char *devfs_fp_path;
	size_t len;
	fpcfga_ret_t ret;
	int	found = 0;

	*l_errnop = 0;

	if ((root_path = strdup(physpath)) == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	/* Fix up path for di_init() */
	len = strlen(DEVICES_DIR);
	if (strncmp(root_path, DEVICES_DIR SLASH,
	    len + strlen(SLASH)) == 0) {
		cp = root_path + len;
		(void) memmove(root_path, cp, strlen(cp) + 1);
	} else if (*root_path != '/') {
		*l_errnop = 0;
		ret = FPCFGA_ERR;
		goto out;
	}

	/* Remove dynamic component if any */
	if ((cp = GET_DYN(root_path)) != NULL) {
		*cp = '\0';
	}

	/* Remove minor name if any */
	if ((cp = strrchr(root_path, ':')) != NULL) {
		*cp = '\0';
	}

	/*
	 * If force_flag is set
	 * do di_init with DINFOFORCE flag and get to the input fp node
	 * from the device tree.
	 *
	 * In order to get the link between path_info node and scsi_vhci node
	 * it is required to take the snapshot of the whole device tree.
	 * this behavior of libdevinfo is inefficient.  For a specific
	 * fca port DINFOPROP was sufficient on the fca path prior to
	 * scsi_vhci node support.
	 *
	 */
	if ((up->flags & FLAG_DEVINFO_FORCE) == FLAG_DEVINFO_FORCE) {
		tree_root = di_init("/", init_flags | DINFOFORCE);
	} else {
		tree_root = di_init("/", init_flags);
	}

	if (tree_root == DI_NODE_NIL) {
		*l_errnop = errno;
		ret = FPCFGA_LIB_ERR;
		goto out;
	}

	fpnode = di_drv_first_node("fp", tree_root);

	while (fpnode) {
		devfs_fp_path = di_devfs_path(fpnode);
		if ((devfs_fp_path) && !(strncmp(devfs_fp_path,
		    root_path, strlen(root_path)))) {
			found = 1;
			di_devfs_path_free(devfs_fp_path);
			break;
		}
		di_devfs_path_free(devfs_fp_path);
		fpnode = di_drv_next_node(fpnode);
	}
	if (!(found)) {
		ret = FPCFGA_LIB_ERR;
		goto out;
	} else {
		root = fpnode;
	}

	/* Walk the tree */
	errno = 0;
	if (cmd == FPCFGA_WALK_NODE) {
		rv = di_walk_node(root, up->walkmode.node_args.flags, arg,
		    up->walkmode.node_args.fcn);
	} else {
		assert(cmd == FPCFGA_WALK_MINOR);
		rv = di_walk_minor(root, up->walkmode.minor_args.nodetype, 0,
		    arg, up->walkmode.minor_args.fcn);
	}

	if (rv != 0) {
		*l_errnop = errno;
		ret = FPCFGA_LIB_ERR;
	} else {
		if ((up->flags & FLAG_PATH_INFO_WALK) == FLAG_PATH_INFO_WALK) {
			ret = stat_path_info_node(root, arg, l_errnop);
		} else {
			*l_errnop = 0;
			ret = FPCFGA_OK;
		}
	}

	di_fini(tree_root);

	/*FALLTHRU*/
out:
	S_FREE(root_path);
	return (ret);
}


int
msg_idx(msgid_t msgid)
{
	int idx = 0;

	/* The string table index and the error id may or may not be same */
	if (msgid >= 0 && msgid <= N_STRS - 1 &&
	    str_tbl[msgid].msgid == msgid) {
		idx = msgid;
	} else {
		for (idx = 0; idx < N_STRS; idx++) {
			if (str_tbl[idx].msgid == msgid)
				break;
		}
		if (idx >= N_STRS) {
			idx =  UNKNOWN_ERR_IDX;
		}
	}

	return (idx);
}

/*
 * cfga_err() accepts a variable number of message IDs and constructs
 * a corresponding error string which is returned via the errstring argument.
 * cfga_err() calls dgettext() to internationalize proper messages.
 * May be called with a NULL argument.
 */
void
cfga_err(char **errstring, int l_errno, ...)
{
	va_list ap;
	int append_newline = 0;
	char *tmp_str, *tmp_err_str = NULL;

	if (errstring == NULL) {
		return;
	}

	/*
	 * Don't append a newline, the application (for example cfgadm)
	 * should do that.
	 */
	append_newline = 0;

	va_start(ap, l_errno);
	msg_common(&tmp_err_str, append_newline, l_errno, ap);
	va_end(ap);

	if (*errstring == NULL) {
		*errstring = tmp_err_str;
		return;
	}

	/*
	 * *errstring != NULL
	 * There was something in errstring prior to this call.
	 * So, concatenate the old and new strings
	 */
	if ((tmp_str = calloc(1,
	    strlen(*errstring) + strlen(tmp_err_str) + 2)) == NULL) {
		/* In case of error, retain only the earlier message */
		free(tmp_err_str);
		return;
	}

	sprintf(tmp_str, "%s\n%s", *errstring, tmp_err_str);
	free(tmp_err_str);
	free(*errstring);
	*errstring = tmp_str;
}

/*
 * This routine accepts a variable number of message IDs and constructs
 * a corresponding message string which is printed via the message print
 * routine argument.
 */
void
cfga_msg(struct cfga_msg *msgp, ...)
{
	char *p = NULL;
	int append_newline = 0, l_errno = 0;
	va_list ap;

	if (msgp == NULL || msgp->message_routine == NULL) {
		return;
	}

	/* Append a newline after message */
	append_newline = 1;
	l_errno = 0;

	va_start(ap, msgp);
	msg_common(&p, append_newline, l_errno, ap);
	va_end(ap);

	(void) (*msgp->message_routine)(msgp->appdata_ptr, p);

	S_FREE(p);
}

/*
 * Get internationalized string corresponding to message id
 * Caller must free the memory allocated.
 */
char *
cfga_str(int append_newline, ...)
{
	char *p = NULL;
	int l_errno = 0;
	va_list ap;

	va_start(ap, append_newline);
	msg_common(&p, append_newline, l_errno, ap);
	va_end(ap);

	return (p);
}

static void
msg_common(char **msgpp, int append_newline, int l_errno, va_list ap)
{
	int a = 0;
	size_t len = 0;
	int i = 0, n = 0;
	char *s = NULL, *t = NULL;
	strlist_t dummy;
	strlist_t *savep = NULL, *sp = NULL, *tailp = NULL;

	if (*msgpp != NULL) {
		return;
	}

	dummy.next = NULL;
	tailp = &dummy;
	for (len = 0; (a = va_arg(ap, int)) != 0; ) {
		n = GET_MSG_NARGS(a); /* 0 implies no additional args */
		for (i = 0; i <= n; i++) {
			sp = calloc(1, sizeof (*sp));
			if (sp == NULL) {
				goto out;
			}
			if (i == 0 && GET_MSG_INTL(a)) {
				sp->str = dgettext(TEXT_DOMAIN, GET_MSG_STR(a));
			} else if (i == 0) {
				sp->str = GET_MSG_STR(a);
			} else {
				sp->str = va_arg(ap, char *);
			}
			len += (strlen(sp->str));
			sp->next = NULL;
			tailp->next = sp;
			tailp = sp;
		}
	}

	len += 1;	/* terminating NULL */

	s = t = NULL;
	if (l_errno) {
		s = dgettext(TEXT_DOMAIN, ": ");
		t = S_STR(strerror(l_errno));
		if (s != NULL && t != NULL) {
			len += strlen(s) + strlen(t);
		}
	}

	if (append_newline) {
		len++;
	}

	if ((*msgpp = calloc(1, len)) == NULL) {
		goto out;
	}

	**msgpp = '\0';
	for (sp = dummy.next; sp != NULL; sp = sp->next) {
		(void) strcat(*msgpp, sp->str);
	}

	if (s != NULL && t != NULL) {
		(void) strcat(*msgpp, s);
		(void) strcat(*msgpp, t);
	}

	if (append_newline) {
		(void) strcat(*msgpp, dgettext(TEXT_DOMAIN, "\n"));
	}

	/* FALLTHROUGH */
out:
	sp = dummy.next;
	while (sp != NULL) {
		savep = sp->next;
		S_FREE(sp);
		sp = savep;
	}
}

fpcfga_ret_t
devctl_cmd(
	const char	*physpath,
	fpcfga_cmd_t	cmd,
	uint_t		*statep,
	int		*l_errnop)
{
	int rv = -1, i, type;
	devctl_hdl_t hdl = NULL;
	char *cp = NULL, *path = NULL;
	int (*func)(const devctl_hdl_t);
	int (*state_func)(const devctl_hdl_t, uint_t *);

	*l_errnop = 0;

	if (statep != NULL) *statep = 0;

	func = NULL;
	state_func = NULL;
	type = 0;

	for (i = 0; i < N_GET_STATE_CMDS; i++) {
		if (get_state_cmds[i].cmd == cmd) {
			state_func = get_state_cmds[i].state_fcn;
			type = get_state_cmds[i].type;
			assert(statep != NULL);
			break;
		}
	}

	if (state_func == NULL) {
		for (i = 0; i < N_SET_STATE_CMDS; i++) {
			if (set_state_cmds[i].cmd == cmd) {
				func = set_state_cmds[i].fcn;
				type = set_state_cmds[i].type;
				assert(statep == NULL);
				break;
			}
		}
	}

	assert(type == BUS_OP || type == DEV_OP);

	if (func == NULL && state_func == NULL) {
		return (FPCFGA_ERR);
	}

	/*
	 * Fix up path for calling devctl.
	 */
	if ((path = strdup(physpath)) == NULL) {
		*l_errnop = errno;
		return (FPCFGA_LIB_ERR);
	}

	/* Remove dynamic component if any */
	if ((cp = GET_DYN(path)) != NULL) {
		*cp = '\0';
	}

	/* Remove minor name */
	if ((cp = strrchr(path, ':')) != NULL) {
		*cp = '\0';
	}

	errno = 0;

	if (type == BUS_OP) {
		hdl = devctl_bus_acquire(path, 0);
	} else {
		hdl = devctl_device_acquire(path, 0);
	}
	*l_errnop = errno;

	S_FREE(path);

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

	errno = 0;
	/* Only getstate functions require a second argument */
	if (func != NULL && statep == NULL) {
		rv = func(hdl);
		*l_errnop = errno;
	} else if (state_func != NULL && statep != NULL) {
		rv = state_func(hdl, statep);
		*l_errnop = errno;
	} else {
		rv = -1;
		*l_errnop = 0;
	}

	devctl_release(hdl);

	return ((rv == -1) ? FPCFGA_ERR : FPCFGA_OK);
}

/*
 * Is device in a known state ? (One of BUSY, ONLINE, OFFLINE)
 *	BUSY --> One or more device special files are open. Implies online
 *	ONLINE --> driver attached
 *	OFFLINE --> CF1 with offline flag set.
 *	UNKNOWN --> None of the above
 */
int
known_state(di_node_t node)
{
	uint_t state;

	state = di_state(node);

	/*
	 * CF1 without offline flag set is considered unknown state.
	 * We are in a known state if either CF2 (driver attached) or
	 * offline.
	 */
	if ((state & DI_DEVICE_OFFLINE) == DI_DEVICE_OFFLINE ||
	    (state & DI_DRIVER_DETACHED) != DI_DRIVER_DETACHED) {
		return (1);
	}

	return (0);
}

void
list_free(ldata_list_t **llpp)
{
	ldata_list_t *lp, *olp;

	lp = *llpp;
	while (lp != NULL) {
		olp = lp;
		lp = olp->next;
		S_FREE(olp);
	}

	*llpp = NULL;
}

/*
 * Obtain the devlink from a /devices path
 */
fpcfga_ret_t
physpath_to_devlink(
	const char *basedir,
	char *xport_phys,
	char **xport_logpp,
	int *l_errnop,
	int match_minor)
{
	pathm_t pmt = {NULL};
	fpcfga_ret_t ret;

	pmt.phys = xport_phys;
	pmt.ret = FPCFGA_NO_REC;
	pmt.match_minor = match_minor;

	/*
	 * Search the /dev hierarchy starting at basedir.
	 */
	ret = recurse_dev(basedir, &pmt, lookup_dev);
	if (ret == FPCFGA_OK && (ret = pmt.ret) == FPCFGA_OK) {
		assert(pmt.log != NULL);
		*xport_logpp  = pmt.log;
	} else {
		if (pmt.log != NULL) {
			S_FREE(pmt.log);
		}

		*xport_logpp = NULL;
		*l_errnop = pmt.l_errno;
	}

	return (ret);
}

static fpcfga_recur_t
lookup_dev(const char *lpath, void *arg)
{
	char ppath[PATH_MAX];
	pathm_t *pmtp = (pathm_t *)arg;

	if (realpath(lpath, ppath) == NULL) {
		return (FPCFGA_CONTINUE);
	}

	ppath[sizeof (ppath) - 1] = '\0';

	/* Is this the physical path we are looking for */
	if (dev_cmp(ppath, pmtp->phys, pmtp->match_minor))  {
		return (FPCFGA_CONTINUE);
	}

	if ((pmtp->log = strdup(lpath)) == NULL) {
		pmtp->l_errno = errno;
		pmtp->ret = FPCFGA_LIB_ERR;
	} else {
		pmtp->ret = FPCFGA_OK;
	}

	return (FPCFGA_TERMINATE);
}

/* Compare HBA physical ap_id and device path */
int
hba_dev_cmp(const char *hba, const char *devpath)
{
	char *cp = NULL;
	int rv;
	size_t hba_len, dev_len;
	char l_hba[MAXPATHLEN], l_dev[MAXPATHLEN];

	(void) snprintf(l_hba, sizeof (l_hba), "%s", hba);
	(void) snprintf(l_dev, sizeof (l_dev), "%s", devpath);

	/* Remove dynamic component if any */
	if ((cp = GET_DYN(l_hba)) != NULL) {
		*cp = '\0';
	}

	if ((cp = GET_DYN(l_dev)) != NULL) {
		*cp = '\0';
	}


	/* Remove minor names */
	if ((cp = strrchr(l_hba, ':')) != NULL) {
		*cp = '\0';
	}

	if ((cp = strrchr(l_dev, ':')) != NULL) {
		*cp = '\0';
	}

	hba_len = strlen(l_hba);
	dev_len = strlen(l_dev);

	/* Check if HBA path is component of device path */
	if (rv = strncmp(l_hba, l_dev, hba_len)) {
		return (rv);
	}

	/* devpath must have '/' and 1 char in addition to hba path */
	if (dev_len >= hba_len + 2 && l_dev[hba_len] == '/') {
		return (0);
	} else {
		return (-1);
	}
}

int
dev_cmp(const char *dev1, const char *dev2, int match_minor)
{
	char l_dev1[MAXPATHLEN], l_dev2[MAXPATHLEN];
	char *mn1, *mn2;
	int rv;

	(void) snprintf(l_dev1, sizeof (l_dev1), "%s", dev1);
	(void) snprintf(l_dev2, sizeof (l_dev2), "%s", dev2);

	if ((mn1 = GET_DYN(l_dev1)) != NULL) {
		*mn1 = '\0';
	}

	if ((mn2 = GET_DYN(l_dev2)) != NULL) {
		*mn2 = '\0';
	}

	/* Separate out the minor names */
	if ((mn1 = strrchr(l_dev1, ':')) != NULL) {
		*mn1++ = '\0';
	}

	if ((mn2 = strrchr(l_dev2, ':')) != NULL) {
		*mn2++ = '\0';
	}

	if ((rv = strcmp(l_dev1, l_dev2)) != 0 || !match_minor) {
		return (rv);
	}

	/*
	 * Compare minor names
	 */
	if (mn1 == NULL && mn2 == NULL) {
		return (0);
	} else if (mn1 == NULL) {
		return (-1);
	} else if (mn2 == NULL) {
		return (1);
	} else {
		return (strcmp(mn1, mn2));
	}
}

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

	/* Loop as long as we have a retryable error */
	while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
	    status == HBA_STATUS_ERROR_BUSY) &&
	    count++ < HBA_MAX_RETRIES) {
		status = HBA_GetAdapterAttributes(handle, attrs);
		if (status == HBA_STATUS_OK) {
			break;
		}
		sleep(1);
	}
	return (status);
}

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

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

		/* The odds of this occuring are very slim, but possible. */
		if (status == HBA_STATUS_ERROR_STALE_DATA) {
			/*
			 * If we hit a stale data scenario,
			 * we'll just tell the user to try again.
			 */
			status = HBA_STATUS_ERROR_TRY_AGAIN;
			break;
		}
		sleep(1);
	}
	return (status);
}

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

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

		/* The odds of this occuring are very slim, but possible. */
		if (status == HBA_STATUS_ERROR_STALE_DATA) {
			/*
			 * If we hit a stale data scenario,
			 * we'll just tell the user to try again.
			 */
			status = HBA_STATUS_ERROR_TRY_AGAIN;
			break;
		}
		sleep(1);
	}
	return (status);
}

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

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

		/* The odds of this occuring are very slim, but possible. */
		if (status == HBA_STATUS_ERROR_STALE_DATA) {
			/*
			 * If we hit a stale data scenario, we'll just tell the
			 * user to try again.
			 */
			status = HBA_STATUS_ERROR_TRY_AGAIN;
			break;
		}
		sleep(1);
	}
	return (status);
}

/*
 * Find the Adapter port that matches the portPath.
 * When the matching port is found the caller have to close handle
 * and free library.
 */
fpcfga_ret_t
findMatchingAdapterPort(char *portPath, HBA_HANDLE *matchingHandle,
	int *matchingPortIndex, HBA_PORTATTRIBUTES *matchingPortAttrs,
	char **errstring)
{
	HBA_HANDLE	handle;
	HBA_ADAPTERATTRIBUTES	hbaAttrs;
	HBA_PORTATTRIBUTES	portAttrs;
	HBA_STATUS status = HBA_STATUS_OK;
	int count, retry = 0, l_errno = 0;
	int adapterIndex, portIndex;
	char			adapterName[256];
	char			*cfg_ptr, *tmpPtr;
	char			*logical_apid = NULL;

	status = HBA_LoadLibrary();
	if (status != HBA_STATUS_OK) {
		cfga_err(errstring, 0, ERR_HBA_LOAD_LIBRARY, 0);
		return (FPCFGA_LIB_ERR);
	}
	count = HBA_GetNumberOfAdapters();
	if (count == 0) {
		cfga_err(errstring, 0, ERR_NO_ADAPTER_FOUND, 0);
		HBA_FreeLibrary();
		return (FPCFGA_LIB_ERR);
	}

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

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

			/* Loop over all HBA Ports */
			for (portIndex = 0;
			    portIndex < hbaAttrs.NumberOfPorts; portIndex++) {
				if ((status = getAdapterPortAttrs(handle,
				    portIndex,
				    &portAttrs)) != HBA_STATUS_OK) {
					/* Need to refresh adapter */
					if (status ==
					    HBA_STATUS_ERROR_STALE_DATA) {
						HBA_RefreshInformation(handle);
						break;
					} else {
						continue;
					}
				}

				/*
				 * check to see if OSDeviceName is a /dev/cfg
				 * link or the physical path
				 */
				if (strncmp(portAttrs.OSDeviceName,
				    CFGA_DEV_DIR,
				    strlen(CFGA_DEV_DIR)) != 0) {
					tmpPtr = strstr(portAttrs.OSDeviceName,
					    MINOR_SEP);
					if ((tmpPtr != NULL) &&
					    strncmp(portPath,
					    portAttrs.OSDeviceName,
					    strlen(portAttrs.OSDeviceName) -
					    strlen(tmpPtr)) == 0) {
						if (matchingHandle)
							*matchingHandle =
							    handle;
						if (matchingPortIndex)
							*matchingPortIndex =
							    portIndex;
						if (matchingPortAttrs)
							*matchingPortAttrs =
							    portAttrs;
						return (FPCFGA_OK);
					}
				} else {
					/*
					 * strip off the /dev/cfg/ portion of
					 * the OSDeviceName make sure that the
					 * OSDeviceName is at least
					 * strlen("/dev/cfg") + 1 + 1 long.
					 * first 1 is for the / after /dev/cfg
					 * second 1 is to make sure there is
					 * somthing after
					 */
					if (strlen(portAttrs.OSDeviceName) <
					    (strlen(CFGA_DEV_DIR) + 1 + 1))
						continue;
					cfg_ptr = portAttrs.OSDeviceName +
					    strlen(CFGA_DEV_DIR) + 1;
					if (logical_apid == NULL) {
						/*
						 * get the /dev/cfg link from
						 * the portPath
						 */
						if (make_xport_logid(portPath,
						    &logical_apid,
						    &l_errno) != FPCFGA_OK) {
							cfga_err(errstring,
							    l_errno,
							    ERR_LIST, 0);
							HBA_FreeLibrary();
							return
							    (FPCFGA_LIB_ERR);
						}
					}
					/* compare logical ap_id */
					if (strcmp(logical_apid,
					    cfg_ptr) == 0) {
						if (matchingHandle)
							*matchingHandle =
							    handle;
						if (matchingPortIndex)
							*matchingPortIndex =
							    portIndex;
						if (matchingPortAttrs)
							*matchingPortAttrs =
							    portAttrs;
						S_FREE(logical_apid);
						return (FPCFGA_OK);
					}
				}
			}
			if (logical_apid != NULL)
				S_FREE(logical_apid);
		} while ((status == HBA_STATUS_ERROR_STALE_DATA) &&
		    (retry++ < HBA_MAX_RETRIES));

		HBA_CloseAdapter(handle);
	}
	free(logical_apid);

	/* Got here. No matching adapter port found. */
	cfga_err(errstring, 0, ERR_MATCHING_HBA_PORT, 0);
	HBA_FreeLibrary();
	return (FPCFGA_LIB_ERR);
}