OpenSolaris_b135/lib/cfgadm_plugins/scsi/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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include "cfga_scsi.h"
#include <libgen.h>
#include <limits.h>
/*
* This file contains helper routines for the SCSI plugin
*/
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
typedef struct strlist {
const char *str;
struct strlist *next;
} strlist_t;
typedef struct {
scfga_ret_t scsi_err;
cfga_err_t cfga_err;
} errcvt_t;
typedef struct {
scfga_cmd_t cmd;
int type;
int (*fcn)(const devctl_hdl_t);
} set_state_cmd_t;
typedef struct {
scfga_cmd_t cmd;
int type;
int (*state_fcn)(const devctl_hdl_t, uint_t *);
} get_state_cmd_t;
/* Function prototypes */
static char *pathdup(const char *path, int *l_errnop);
static void msg_common(char **err_msgpp, int append_newline, int l_errno,
va_list ap);
/*
* The string table contains most of the strings used by the scsi 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 SCSI bus apid"},
{ERR_APID_INVAL, 0, 1, "invalid SCSI ap_id"},
{ERR_NOT_BUSOP, 0, 1, "operation not supported for SCSI bus"},
{ERR_NOT_DEVOP, 0, 1, "operation not supported for SCSI device"},
{ERR_UNAVAILABLE, 0, 1, "unavailable"},
{ERR_CTRLR_CRIT, 0, 1, "critical partition controlled by SCSI HBA"},
{ERR_BUS_GETSTATE, 0, 1, "failed to get state for SCSI bus"},
{ERR_BUS_NOTCONNECTED, 0, 1, "SCSI bus not connected"},
{ERR_BUS_CONNECTED, 0, 1, "SCSI bus not disconnected"},
{ERR_BUS_QUIESCE, 0, 1, "SCSI bus quiesce failed"},
{ERR_BUS_UNQUIESCE, 0, 1, "SCSI bus unquiesce failed"},
{ERR_BUS_CONFIGURE, 0, 1, "failed to configure devices on SCSI bus"},
{ERR_BUS_UNCONFIGURE, 0, 1, "failed to unconfigure SCSI bus"},
{ERR_DEV_CONFIGURE, 0, 1, "failed to configure SCSI device"},
{ERR_DEV_RECONFIGURE, 1, 1, "failed to reconfigure device: "},
{ERR_DEV_UNCONFIGURE, 0, 1, "failed to unconfigure SCSI device"},
{ERR_DEV_REMOVE, 0, 1, "remove operation failed"},
{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 SCSI device"},
{ERR_RESET, 0, 1, "reset failed"},
{ERR_LIST, 0, 1, "list operation failed"},
{ERR_MAYBE_BUSY, 0, 1, "device may be busy"},
{ERR_BUS_DEV_MISMATCH, 0, 1, "mismatched SCSI bus and device"},
{ERR_VAR_RUN, 0, 1, "/var/run is not mounted"},
{ERR_FORK, 0, 1, "failed to fork cleanup handler"},
/* 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_OPEN, 1, 1, "open failed: "},
{ERRARG_LOCK, 1, 1, "lock failed: "},
{ERRARG_QUIESCE_LOCK, 1, 1, "cannot acquire quiesce lock: "},
/* RCM Errors */
{ERR_RCM_HANDLE, 0, 1, "cannot get RCM handle"},
{ERRARG_RCM_SUSPEND, 0, 1, "failed to suspend: "},
{ERRARG_RCM_RESUME, 0, 1, "failed to resume: "},
{ERRARG_RCM_OFFLINE, 0, 1, "failed to offline: "},
{ERRARG_RCM_CLIENT_OFFLINE, 0, 1, "failed to offline a client device: "},
{ERRARG_RCM_ONLINE, 0, 1, "failed to online: "},
{ERRARG_RCM_REMOVE, 0, 1, "failed to remove: "},
/* Commands */
{CMD_INSERT_DEV, 0, 0, "insert_device"},
{CMD_REMOVE_DEV, 0, 0, "remove_device"},
{CMD_LED_DEV, 0, 0, "led"},
{CMD_LOCATOR_DEV, 0, 0, "locator"},
{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, "\nSCSI specific commands and options:\n"},
{MSG_HELP_USAGE, 0, 0, "\t-x insert_device ap_id [ap_id... ]\n"
"\t-x remove_device ap_id [ap_id... ]\n"
"\t-x replace_device ap_id [ap_id... ]\n"
"\t-x locator[=on|off] ap_id [ap_id... ]\n"
"\t-x led[=LED,mode=on|off|blink] "
"ap_id [ap_id... ]\n"
"\t-x reset_device ap_id [ap_id... ]\n"
"\t-x reset_bus ap_id [ap_id... ]\n"
"\t-x reset_all ap_id [ap_id... ]\n"},
/* hotplug messages */
{MSG_INSDEV, 1, 1, "Adding device to SCSI HBA: "},
{MSG_RMDEV, 1, 1, "Removing SCSI device: "},
{MSG_REPLDEV, 1, 1, "Replacing SCSI device: "},
{MSG_WAIT_LOCK, 0, 1, "Waiting for quiesce lock... "},
/* Hotplugging confirmation prompts */
{CONF_QUIESCE_1, 1, 1,
"This operation will suspend activity on SCSI bus: "},
{CONF_QUIESCE_2, 0, 1, "\nContinue"},
{CONF_UNQUIESCE, 0, 1,
"SCSI bus quiesced successfully.\n"
"It is now safe to proceed with hotplug operation."
"\nEnter y if operation is complete or n to abort"},
{CONF_NO_QUIESCE, 0, 1,
"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"},
/* LED messages */
{MSG_LED_HDR, 0, 1, "Disk Led"},
{MSG_MISSING_LED_NAME, 0, 1, "Missing LED name"},
{MSG_MISSING_LED_MODE, 0, 1, "Missing LED mode"}
};
char *
led_strs[] = {
"fault",
"power",
"attn",
"active",
"locator",
NULL
};
char *
led_mode_strs[] = {
"off",
"on",
"blink",
"faulted",
"unknown",
NULL
};
#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[] = {
{ SCFGA_OK, CFGA_OK },
{ SCFGA_LIB_ERR, CFGA_LIB_ERROR },
{ SCFGA_APID_NOEXIST, CFGA_APID_NOEXIST },
{ SCFGA_NACK, CFGA_NACK },
{ SCFGA_BUSY, CFGA_BUSY },
{ SCFGA_SYSTEM_BUSY, CFGA_SYSTEM_BUSY },
{ SCFGA_OPNOTSUPP, CFGA_OPNOTSUPP },
{ SCFGA_PRIV, CFGA_PRIV },
{ SCFGA_UNKNOWN_ERR, CFGA_ERROR },
{ SCFGA_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[] = {
{ SCFGA_BUS_QUIESCE, BUS_OP, devctl_bus_quiesce },
{ SCFGA_BUS_UNQUIESCE, BUS_OP, devctl_bus_unquiesce },
{ SCFGA_BUS_CONFIGURE, BUS_OP, devctl_bus_configure },
{ SCFGA_BUS_UNCONFIGURE, BUS_OP, devctl_bus_unconfigure },
{ SCFGA_RESET_BUS, BUS_OP, devctl_bus_reset },
{ SCFGA_RESET_ALL, BUS_OP, devctl_bus_resetall },
{ SCFGA_DEV_CONFIGURE, DEV_OP, devctl_device_online },
{ SCFGA_DEV_UNCONFIGURE, DEV_OP, devctl_device_offline },
{ SCFGA_DEV_REMOVE, DEV_OP, devctl_device_remove },
{ SCFGA_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[] = {
{ SCFGA_BUS_GETSTATE, BUS_OP, devctl_bus_getstate },
{ SCFGA_DEV_GETSTATE, DEV_OP, devctl_device_getstate }
};
#define N_GET_STATE_CMDS (sizeof (get_state_cmds)/sizeof (get_state_cmds[0]))
/*
* SCSI hardware specific commands
*/
static hw_cmd_t hw_cmds[] = {
/* Command string Command ID Function */
{ CMD_INSERT_DEV, SCFGA_INSERT_DEV, dev_insert },
{ CMD_REMOVE_DEV, SCFGA_REMOVE_DEV, dev_remove },
{ CMD_REPLACE_DEV, SCFGA_REPLACE_DEV, dev_replace },
{ CMD_LED_DEV, SCFGA_LED_DEV, dev_led },
{ CMD_LOCATOR_DEV, SCFGA_LOCATOR_DEV, dev_led },
{ CMD_RESET_DEV, SCFGA_RESET_DEV, reset_common },
{ CMD_RESET_BUS, SCFGA_RESET_BUS, reset_common },
{ CMD_RESET_ALL, SCFGA_RESET_ALL, reset_common },
};
#define N_HW_CMDS (sizeof (hw_cmds) / sizeof (hw_cmds[0]))
cfga_err_t
err_cvt(scfga_ret_t s_err)
{
int i;
for (i = 0; i < N_ERR_CVT_TBL; i++) {
if (err_cvt_tbl[i].scsi_err == s_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 "/"
*/
static 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);
}
scfga_ret_t
apidt_create(const char *ap_id, apid_t *apidp, char **errstring)
{
char *hba_phys = NULL, *dyn = NULL;
char *dyncomp = NULL, *path = NULL;
int l_errno = 0;
size_t len = 0;
scfga_ret_t ret;
if ((hba_phys = pathdup(ap_id, &l_errno)) == NULL) {
cfga_err(errstring, l_errno, ERR_OP_FAILED, 0);
return (SCFGA_LIB_ERR);
}
/* Extract the base(hba) and dynamic(device) component if any */
dyncomp = NULL;
if ((dyn = GET_DYN(hba_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 = SCFGA_LIB_ERR;
goto err;
}
(void) strcpy(dyncomp, DYN_TO_DYNCOMP(dyn));
/* Remove the dynamic component from the base */
*dyn = '\0';
} else {
apidp->dyntype = NODYNCOMP;
}
/* get dyn comp type */
if (dyncomp != NULL) {
if (strstr(dyncomp, PATH_APID_DYN_SEP) != NULL) {
apidp->dyntype = PATH_APID;
} else {
apidp->dyntype = DEV_APID;
}
}
/* Create the path */
if ((ret = apid_to_path(hba_phys, dyncomp, &path,
&l_errno)) != SCFGA_OK) {
cfga_err(errstring, l_errno, ERR_OP_FAILED, 0);
goto err;
}
assert(path != NULL);
assert(hba_phys != NULL);
apidp->hba_phys = hba_phys;
apidp->dyncomp = dyncomp;
apidp->path = path;
apidp->flags = 0;
return (SCFGA_OK);
err:
S_FREE(hba_phys);
S_FREE(dyncomp);
S_FREE(path);
return (ret);
}
void
apidt_free(apid_t *apidp)
{
if (apidp == NULL)
return;
S_FREE(apidp->hba_phys);
S_FREE(apidp->dyncomp);
S_FREE(apidp->path);
}
scfga_ret_t
walk_tree(
const char *physpath,
void *arg,
uint_t init_flags,
walkarg_t *up,
scfga_cmd_t cmd,
int *l_errnop)
{
int rv;
di_node_t root, walk_root;
char *root_path, *cp = NULL, *init_path;
size_t len;
scfga_ret_t ret;
*l_errnop = 0;
if ((root_path = strdup(physpath)) == NULL) {
*l_errnop = errno;
return (SCFGA_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 = SCFGA_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';
}
/*
* Cached snapshots are always rooted at "/"
*/
init_path = root_path;
if ((init_flags & DINFOCACHE) == DINFOCACHE) {
init_path = "/";
}
/* Get a snapshot */
if ((root = di_init(init_path, init_flags)) == DI_NODE_NIL) {
*l_errnop = errno;
ret = SCFGA_LIB_ERR;
goto out;
}
/*
* Lookup the subtree of interest
*/
walk_root = root;
if ((init_flags & DINFOCACHE) == DINFOCACHE) {
walk_root = di_lookup_node(root, root_path);
}
if (walk_root == DI_NODE_NIL) {
*l_errnop = errno;
di_fini(root);
ret = SCFGA_LIB_ERR;
goto out;
}
/* Walk the tree */
errno = 0;
if (cmd == SCFGA_WALK_NODE) {
rv = di_walk_node(walk_root, up->node_args.flags, arg,
up->node_args.fcn);
} else if (cmd == SCFGA_WALK_PATH) {
rv = stat_path_info(walk_root, arg, l_errnop);
} else {
assert(cmd == SCFGA_WALK_MINOR);
rv = di_walk_minor(walk_root, up->minor_args.nodetype, 0, arg,
up->minor_args.fcn);
}
if (rv != 0) {
*l_errnop = errno;
ret = SCFGA_LIB_ERR;
} else {
*l_errnop = 0;
ret = SCFGA_OK;
}
di_fini(root);
/*FALLTHRU*/
out:
S_FREE(root_path);
return (ret);
}
scfga_ret_t
invoke_cmd(
const char *func,
apid_t *apidtp,
prompt_t *prp,
cfga_flags_t flags,
char **errstring)
{
int i;
int len;
/*
* Determine if the func has an equal sign; only compare up to
* the equals
*/
for (len = 0; func[len] != 0 && func[len] != '='; len++) {
};
for (i = 0; i < N_HW_CMDS; i++) {
const char *s = GET_MSG_STR(hw_cmds[i].str_id);
if (strncmp(func, s, len) == 0 && s[len] == 0) {
return (hw_cmds[i].fcn(func, hw_cmds[i].cmd, apidtp,
prp, flags, errstring));
}
}
cfga_err(errstring, 0, ERRARG_HWCMD_INVAL, func, 0);
return (SCFGA_ERR);
}
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;
if (errstring == NULL || *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(errstring, append_newline, l_errno, ap);
va_end(ap);
}
/*
* 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);
}
/*
* This routine prints the value of an led for a disk.
*/
void
cfga_led_msg(struct cfga_msg *msgp, apid_t *apidp, led_strid_t led,
led_modeid_t mode)
{
char led_msg[MAX_INPUT]; /* 512 bytes */
if ((msgp == NULL) || (msgp->message_routine == NULL)) {
return;
}
if ((apidp == NULL) || (apidp->dyncomp == NULL)) {
return;
}
(void) snprintf(led_msg, sizeof (led_msg), "%-23s\t%s=%s\n",
basename(apidp->dyncomp),
dgettext(TEXT_DOMAIN, led_strs[led]),
dgettext(TEXT_DOMAIN, led_mode_strs[mode]));
(void) (*msgp->message_routine)(msgp->appdata_ptr, led_msg);
}
/*
* 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;
}
}
/*
* Check to see if the given pi_node is the last path to the client device.
*
* Return:
* 0: if there is another path avialable.
* -1: if no other paths available.
*/
static int
check_available_path(
di_node_t client_node,
di_path_t pi_node)
{
di_path_state_t pi_state;
di_path_t next_pi = DI_PATH_NIL;
if (((pi_state = di_path_state(pi_node)) != DI_PATH_STATE_ONLINE) &&
(pi_state != DI_PATH_STATE_STANDBY)) {
/* it is not last available path */
return (0);
}
while (next_pi = di_path_client_next_path(client_node, next_pi)) {
/* if anohter pi node is avaialble, return 0 */
if ((next_pi != pi_node) &&
(((pi_state = di_path_state(next_pi)) ==
DI_PATH_STATE_ONLINE) ||
pi_state == DI_PATH_STATE_STANDBY)) {
return (0);
}
}
return (-1);
}
scfga_ret_t
path_apid_state_change(
apid_t *apidp,
scfga_cmd_t cmd,
cfga_flags_t flags,
char **errstring,
int *l_errnop,
msgid_t errid)
{
di_node_t root, walk_root, client_node;
di_path_t pi_node = DI_PATH_NIL;
char *root_path, *cp, *client_path, devpath[MAXPATHLEN];
int len, found = 0;
scfga_ret_t ret;
char *dev_list[2] = {NULL};
*l_errnop = 0;
/* Make sure apid is pathinfo associated apid. */
if ((apidp->dyntype != PATH_APID) || (apidp->dyncomp == NULL)) {
return (SCFGA_LIB_ERR);
}
if ((cmd != SCFGA_DEV_CONFIGURE) && (cmd != SCFGA_DEV_UNCONFIGURE)) {
return (SCFGA_LIB_ERR);
}
if ((root_path = strdup(apidp->hba_phys)) == NULL) {
*l_errnop = errno;
return (SCFGA_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;
S_FREE(root_path);
return (SCFGA_ERR);
}
/* 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';
}
/*
* Cached snapshots are always rooted at "/"
*/
/* Get a snapshot */
if ((root = di_init("/", DINFOCACHE)) == DI_NODE_NIL) {
*l_errnop = errno;
S_FREE(root_path);
return (SCFGA_ERR);
}
/*
* Lookup the subtree of interest
*/
walk_root = di_lookup_node(root, root_path);
if (walk_root == DI_NODE_NIL) {
*l_errnop = errno;
di_fini(root);
S_FREE(root_path);
return (SCFGA_LIB_ERR);
}
if ((pi_node = di_path_next_client(walk_root, pi_node)) ==
DI_PATH_NIL) {
/* the path apid not found */
di_fini(root);
S_FREE(root_path);
return (SCFGA_APID_NOEXIST);
}
do {
/* check the length first. */
if (strlen(di_path_bus_addr(pi_node)) !=
strlen(apidp->dyncomp)) {
continue;
}
/* compare bus addr. */
if (strcmp(di_path_bus_addr(pi_node), apidp->dyncomp) == 0) {
found = 1;
break;
}
pi_node = di_path_next_client(root, pi_node);
} while (pi_node != DI_PATH_NIL);
if (!found) {
di_fini(root);
S_FREE(root_path);
return (SCFGA_APID_NOEXIST);
}
/* Get client node path. */
client_node = di_path_client_node(pi_node);
if (client_node == DI_NODE_NIL) {
di_fini(root);
S_FREE(root_path);
return (SCFGA_ERR);
} else {
client_path = di_devfs_path(client_node);
if (client_path == NULL) {
di_fini(root);
S_FREE(root_path);
return (SCFGA_ERR);
}
if ((apidp->flags & FLAG_DISABLE_RCM) == 0) {
if (cmd == SCFGA_DEV_UNCONFIGURE) {
if (check_available_path(client_node,
pi_node) != 0) {
/*
* last path. check if unconfiguring
* is okay.
*/
(void) snprintf(devpath,
strlen(DEVICES_DIR) +
strlen(client_path) + 1, "%s%s",
DEVICES_DIR, client_path);
dev_list[0] = devpath;
flags |= FLAG_CLIENT_DEV;
ret = scsi_rcm_offline(dev_list,
errstring, flags);
if (ret != SCFGA_OK) {
di_fini(root);
di_devfs_path_free(client_path);
S_FREE(root_path);
return (ret);
}
}
}
}
}
ret = devctl_cmd(apidp->path, cmd, NULL, l_errnop);
if (ret != SCFGA_OK) {
cfga_err(errstring, *l_errnop, errid, 0);
/*
* If an unconfigure fails, cancel the RCM offline.
* Discard any RCM failures so that the devctl
* failure will still be reported.
*/
if ((apidp->flags & FLAG_DISABLE_RCM) == 0) {
if (cmd == SCFGA_DEV_UNCONFIGURE)
(void) scsi_rcm_online(dev_list,
errstring, flags);
}
}
di_devfs_path_free(client_path);
di_fini(root);
S_FREE(root_path);
return (ret);
}
scfga_ret_t
devctl_cmd(
const char *physpath,
scfga_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 (SCFGA_ERR);
}
/*
* Fix up path for calling devctl.
*/
if ((path = strdup(physpath)) == NULL) {
*l_errnop = errno;
return (SCFGA_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 (SCFGA_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) ? SCFGA_ERR : SCFGA_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
*/
typedef struct walk_link {
char *path;
char len;
char **linkpp;
} walk_link_t;
static int
get_link(di_devlink_t devlink, void *arg)
{
walk_link_t *larg = (walk_link_t *)arg;
/*
* When path is specified, it's the node path without minor
* name. Therefore, the ../.. prefixes needs to be stripped.
*/
if (larg->path) {
char *content = (char *)di_devlink_content(devlink);
char *start = strstr(content, "/devices/");
/* line content must have minor node */
if (start == NULL ||
strncmp(start, larg->path, larg->len) != 0 ||
start[larg->len] != ':')
return (DI_WALK_CONTINUE);
}
*(larg->linkpp) = strdup(di_devlink_path(devlink));
return (DI_WALK_TERMINATE);
}
scfga_ret_t
physpath_to_devlink(
char *node_path,
char **logpp,
int *l_errnop,
int match_minor)
{
walk_link_t larg;
di_devlink_handle_t hdl;
char *minor_path;
if ((hdl = di_devlink_init(NULL, 0)) == NULL) {
*l_errnop = errno;
return (SCFGA_LIB_ERR);
}
*logpp = NULL;
larg.linkpp = logpp;
if (match_minor) {
minor_path = node_path + strlen(DEVICES_DIR);
larg.path = NULL;
} else {
minor_path = NULL;
larg.len = strlen(node_path);
larg.path = node_path;
}
(void) di_devlink_walk(hdl, NULL, minor_path, DI_PRIMARY_LINK,
(void *)&larg, get_link);
(void) di_devlink_fini(&hdl);
if (*logpp == NULL)
return (SCFGA_LIB_ERR);
return (SCFGA_OK);
}
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));
}
}