/*
* 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"
static fpcfga_ret_t fp_rcm_init(char *, cfga_flags_t, char **, uint_t *,
char **rsrc_fixed);
static int fp_rcm_process_node(di_node_t, void *);
static fpcfga_ret_t fp_rcm_info_table(rcm_info_t *, char **);
static char *chop_minor(char *);
#define MAX_FORMAT 80
#define DEVICES "/devices"
typedef struct {
char *bus_path;
char *filter;
char **errstring;
fpcfga_ret_t ret;
cfga_flags_t flags;
fpcfga_ret_t (*func)(char *, char *, char **, cfga_flags_t);
} walkargs_t;
static fpcfga_ret_t fp_rcm_info_table(rcm_info_t *, char **);
static int fp_rcm_process_node(di_node_t, void *);
static fpcfga_ret_t fp_rcm_init(char *, cfga_flags_t, char **, uint_t *,
char **);
static char *chop_minor(char *);
static rcm_handle_t *rcm_handle = NULL;
static mutex_t rcm_handle_lock;
/*
* fp_rcm_offline()
*
* Offline FP resource consumers.
*/
fpcfga_ret_t
fp_rcm_offline(char *rsrc, char **errstring, cfga_flags_t flags)
{
int rret;
uint_t rflags = 0;
char *rsrc_fixed;
rcm_info_t *rinfo = NULL;
fpcfga_ret_t ret = FPCFGA_OK;
if ((ret = fp_rcm_init(rsrc, flags, errstring, &rflags, &rsrc_fixed))
!= FPCFGA_OK)
return (ret);
if ((rret = rcm_request_offline(rcm_handle, rsrc_fixed, rflags, &rinfo))
!= RCM_SUCCESS) {
cfga_err(errstring, 0, ERRARG_RCM_OFFLINE, rsrc_fixed, 0);
if (rinfo) {
(void) fp_rcm_info_table(rinfo, errstring);
rcm_free_info(rinfo);
}
if (rret == RCM_FAILURE)
(void) fp_rcm_online(rsrc, errstring, flags);
ret = FPCFGA_BUSY;
}
S_FREE(rsrc_fixed);
return (ret);
}
/*
* fp_rcm_online()
*
* Online FP resource consumers that were previously offlined.
*/
fpcfga_ret_t
fp_rcm_online(char *rsrc, char **errstring, cfga_flags_t flags)
{
char *rsrc_fixed;
rcm_info_t *rinfo = NULL;
fpcfga_ret_t ret = FPCFGA_OK;
if ((ret = fp_rcm_init(rsrc, flags, errstring, NULL, &rsrc_fixed))
!= FPCFGA_OK)
return (ret);
if (rcm_notify_online(rcm_handle, rsrc_fixed, 0, &rinfo)
!= RCM_SUCCESS && rinfo != NULL) {
cfga_err(errstring, 0, ERRARG_RCM_ONLINE, rsrc_fixed, 0);
(void) fp_rcm_info_table(rinfo, errstring);
rcm_free_info(rinfo);
ret = FPCFGA_ERR;
}
S_FREE(rsrc_fixed);
return (ret);
}
/*
* fp_rcm_remove()
*
* Remove FP resource consumers after their kernel removal.
*/
fpcfga_ret_t
fp_rcm_remove(char *rsrc, char **errstring, cfga_flags_t flags)
{
char *rsrc_fixed;
rcm_info_t *rinfo = NULL;
fpcfga_ret_t ret = FPCFGA_OK;
if ((ret = fp_rcm_init(rsrc, flags, errstring, NULL, &rsrc_fixed))
!= FPCFGA_OK)
return (ret);
if (rcm_notify_remove(rcm_handle, rsrc_fixed, 0, &rinfo)
!= RCM_SUCCESS) {
cfga_err(errstring, 0, ERRARG_RCM_REMOVE, rsrc_fixed, 0);
if (rinfo) {
(void) fp_rcm_info_table(rinfo, errstring);
rcm_free_info(rinfo);
}
ret = FPCFGA_ERR;
}
S_FREE(rsrc_fixed);
return (ret);
}
/*
* fp_rcm_suspend()
*
* Suspend FP resource consumers before a bus quiesce.
*/
fpcfga_ret_t
fp_rcm_suspend(char *rsrc, char *filter, char **errstring, cfga_flags_t flags)
{
int rret;
uint_t rflags = 0;
char *rsrc_fixed;
char *filter_fixed;
char *rsrc_devpath;
rcm_info_t *rinfo = NULL;
di_node_t node;
fpcfga_ret_t ret = FPCFGA_OK;
walkargs_t walkargs;
timespec_t zerotime = { 0, 0 };
if ((ret = fp_rcm_init(rsrc, flags, errstring, &rflags, &rsrc_fixed))
!= FPCFGA_OK)
return (ret);
/* If a filter is provided, ensure that it makes sense */
if (filter != NULL && strstr(filter, rsrc) != filter) {
S_FREE(rsrc_fixed);
cfga_err(errstring, 0, ERR_APID_INVAL, 0);
return (FPCFGA_ERR);
}
/*
* If no filter is specified: attempt a suspension on the resource,
* directly.
*/
if (filter == NULL) {
if ((rret = rcm_request_suspend(rcm_handle, rsrc_fixed, rflags,
&zerotime, &rinfo)) != RCM_SUCCESS) {
cfga_err(errstring, 0, ERRARG_RCM_SUSPEND, rsrc_fixed,
0);
if (rinfo) {
(void) fp_rcm_info_table(rinfo, errstring);
rcm_free_info(rinfo);
}
if (rret == RCM_FAILURE)
(void) fp_rcm_resume(rsrc, filter, errstring,
(flags & (~CFGA_FLAG_FORCE)));
ret = FPCFGA_BUSY;
}
S_FREE(rsrc_fixed);
return (ret);
}
/*
* If a filter is specified: open the resource with libdevinfo, walk
* through its nodes, and attempt a suspension of each node that
* mismatches the filter.
*/
/* Chop off the filter's minor name */
if ((filter_fixed = chop_minor(filter)) == NULL)
return (FPCFGA_ERR);
/* get a libdevinfo snapshot of the resource's subtree */
rsrc_devpath = rsrc_fixed;
if (strstr(rsrc_fixed, DEVICES) != NULL)
rsrc_devpath += strlen(DEVICES);
node = di_init(rsrc_devpath, DINFOSUBTREE | DINFOMINOR);
if (node == DI_NODE_NIL) {
cfga_err(errstring, 0, ERRARG_DEVINFO, rsrc_fixed, 0);
ret = FPCFGA_ERR;
}
/* apply the filter, and suspend all resources not filtered out */
if (ret == FPCFGA_OK) {
walkargs.bus_path = rsrc_fixed;
walkargs.filter = filter_fixed;
walkargs.errstring = errstring;
walkargs.ret = FPCFGA_OK;
walkargs.flags = rflags;
walkargs.func = fp_rcm_suspend;
if (di_walk_node(node, 0, &walkargs, fp_rcm_process_node) < 0)
cfga_err(errstring, 0, ERRARG_DEVINFO, rsrc_fixed, 0);
ret = walkargs.ret;
}
if (node != DI_NODE_NIL)
di_fini(node);
S_FREE(rsrc_fixed);
S_FREE(filter_fixed);
if (ret != FPCFGA_OK)
(void) fp_rcm_resume(rsrc, filter, errstring,
(flags & (~CFGA_FLAG_FORCE)));
return (ret);
}
/*
* fp_rcm_resume()
*
* Resume FP resource consumers after a bus has been unquiesced.
*/
fpcfga_ret_t
fp_rcm_resume(char *rsrc, char *filter, char **errstring, cfga_flags_t flags)
{
uint_t rflags = 0;
char *rsrc_fixed;
char *filter_fixed;
char *rsrc_devpath;
rcm_info_t *rinfo = NULL;
di_node_t node;
fpcfga_ret_t ret = FPCFGA_OK;
walkargs_t walkargs;
if ((ret = fp_rcm_init(rsrc, flags, errstring, &rflags, &rsrc_fixed))
!= FPCFGA_OK)
return (ret);
/* If a filter is provided, ensure that it makes sense */
if (filter != NULL && strstr(filter, rsrc) != filter) {
S_FREE(rsrc_fixed);
cfga_err(errstring, 0, ERR_APID_INVAL, 0);
return (FPCFGA_ERR);
}
/*
* If no filter is specified: resume the resource directly.
*/
if (filter == NULL) {
if (rcm_notify_resume(rcm_handle, rsrc_fixed, rflags, &rinfo)
!= RCM_SUCCESS && rinfo != NULL) {
cfga_err(errstring, 0, ERRARG_RCM_RESUME, rsrc_fixed,
0);
(void) fp_rcm_info_table(rinfo, errstring);
rcm_free_info(rinfo);
ret = FPCFGA_BUSY;
}
S_FREE(rsrc_fixed);
return (ret);
}
/*
* If a filter is specified: open the resource with libdevinfo, walk
* through its nodes, and resume each of its nodes that mismatches
* the filter.
*/
/* Chop off the filter's minor name */
if ((filter_fixed = chop_minor(filter)) == NULL)
return (FPCFGA_ERR);
/* get a libdevinfo snapshot of the resource's subtree */
rsrc_devpath = rsrc_fixed;
if (strstr(rsrc_fixed, DEVICES) != NULL)
rsrc_devpath += strlen(DEVICES);
node = di_init(rsrc_devpath, DINFOSUBTREE | DINFOMINOR);
if (node == DI_NODE_NIL) {
cfga_err(errstring, 0, ERRARG_DEVINFO, rsrc_fixed, 0);
ret = FPCFGA_ERR;
}
/* apply the filter, and resume all resources not filtered out */
if (ret == FPCFGA_OK) {
walkargs.bus_path = rsrc_fixed;
walkargs.filter = filter_fixed;
walkargs.errstring = errstring;
walkargs.ret = FPCFGA_OK;
walkargs.flags = rflags;
walkargs.func = fp_rcm_resume;
if (di_walk_node(node, 0, &walkargs, fp_rcm_process_node) < 0)
cfga_err(errstring, 0, ERRARG_DEVINFO, rsrc_fixed, 0);
ret = walkargs.ret;
}
if (node != DI_NODE_NIL)
di_fini(node);
S_FREE(rsrc_fixed);
S_FREE(filter_fixed);
return (ret);
}
/*
* fp_rcm_info
*
* Queries RCM information for resources, and formats it into a table.
* The table is appended to the info argument. If the info argument is a
* null pointer, then a new string is malloc'ed. If the info argument is
* not a null pointer, then it is realloc'ed to the required size.
*/
fpcfga_ret_t
fp_rcm_info(char *rsrc, char **errstring, char **info)
{
char *rsrc_fixed;
rcm_info_t *rinfo = NULL;
fpcfga_ret_t ret = FPCFGA_OK;
if ((ret = fp_rcm_init(rsrc, 0, errstring, NULL, &rsrc_fixed))
!= FPCFGA_OK)
return (ret);
if (info == NULL) {
S_FREE(rsrc_fixed);
return (FPCFGA_ERR);
}
if (rcm_get_info(rcm_handle, rsrc_fixed, 0, &rinfo)
!= RCM_SUCCESS) {
cfga_err(errstring, 0, ERRARG_RCM_INFO, rsrc_fixed, 0);
ret = FPCFGA_ERR;
} else if (rinfo == NULL)
ret = FPCFGA_OK;
if (rinfo) {
if ((ret = fp_rcm_info_table(rinfo, info)) != FPCFGA_OK)
cfga_err(errstring, 0, ERRARG_RCM_INFO, rsrc_fixed, 0);
rcm_free_info(rinfo);
}
S_FREE(rsrc_fixed);
return (ret);
}
/*
* fp_rcm_init()
*
* Contains common initialization code for entering a fp_rcm_xx()
* routine.
*/
static fpcfga_ret_t
fp_rcm_init(char *rsrc, cfga_flags_t flags, char **errstring, uint_t *rflags,
char **rsrc_fixed)
{
/* Validate the rsrc argument */
if (rsrc == NULL) {
cfga_err(errstring, 0, ERR_APID_INVAL, 0);
return (FPCFGA_ERR);
}
/* Translate the cfgadm flags to RCM flags */
if (rflags && (flags & CFGA_FLAG_FORCE))
*rflags |= RCM_FORCE;
/* Get a handle for the RCM operations */
(void) mutex_lock(&rcm_handle_lock);
if (rcm_handle == NULL) {
if (rcm_alloc_handle(NULL, RCM_NOPID, NULL, &rcm_handle) !=
RCM_SUCCESS) {
cfga_err(errstring, 0, ERR_RCM_HANDLE, 0);
(void) mutex_unlock(&rcm_handle_lock);
return (FPCFGA_LIB_ERR);
}
}
(void) mutex_unlock(&rcm_handle_lock);
/* Chop off the rsrc's minor, if it has one */
if ((*rsrc_fixed = chop_minor(rsrc)) == NULL)
return (FPCFGA_ERR);
return (FPCFGA_OK);
}
/*
* fp_rcm_process_node
*
* Helper routine for fp_rcm_{suspend,resume}. This is a di_walk_node()
* callback that will apply a filter to every node it sees, and either suspend
* or resume it if it doesn't match the filter.
*/
static int
fp_rcm_process_node(di_node_t node, void *argp)
{
char *devfs_path;
walkargs_t *walkargs;
fpcfga_ret_t ret = FPCFGA_OK;
char disk_path[MAXPATHLEN];
/* Guard against bad arguments */
if ((walkargs = (walkargs_t *)argp) == NULL)
return (DI_WALK_TERMINATE);
if (walkargs->filter == NULL || walkargs->errstring == NULL) {
walkargs->ret = FPCFGA_ERR;
return (DI_WALK_TERMINATE);
}
/* If the node has no minors, then skip it */
if (di_minor_next(node, DI_MINOR_NIL) == DI_MINOR_NIL)
return (DI_WALK_CONTINUE);
/* Construct the devices path */
if ((devfs_path = di_devfs_path(node)) == NULL)
return (DI_WALK_CONTINUE);
(void) snprintf(disk_path, MAXPATHLEN, "%s%s", DEVICES, devfs_path);
di_devfs_path_free(devfs_path);
/*
* If the node does not correspond to the targeted FP bus or the
* disk being filtered out, then use the appropriate suspend/resume
* function.
*/
if (strcmp(disk_path, walkargs->bus_path) != 0 &&
strcmp(disk_path, walkargs->filter) != 0)
ret = (*walkargs->func)(disk_path, NULL, walkargs->errstring,
walkargs->flags);
/* Stop the walk early if the above operation failed */
if (ret != FPCFGA_OK) {
walkargs->ret = ret;
return (DI_WALK_TERMINATE);
}
return (DI_WALK_CONTINUE);
}
/*
* fp_rcm_info_table
*
* Takes an opaque rcm_info_t pointer and a character pointer, and appends
* the rcm_info_t data in the form of a table to the given character pointer.
*/
static fpcfga_ret_t
fp_rcm_info_table(rcm_info_t *rinfo, char **table)
{
int i;
size_t w;
size_t width = 0;
size_t w_rsrc = 0;
size_t w_info = 0;
size_t table_size = 0;
uint_t tuples = 0;
rcm_info_tuple_t *tuple = NULL;
char *rsrc;
char *info;
char *newtable;
static char format[MAX_FORMAT];
const char *info_info_str, *info_rsrc_str;
/* Protect against invalid arguments */
if (rinfo == NULL || table == NULL)
return (FPCFGA_ERR);
/* Set localized table header strings */
rsrc = gettext("Resource");
info = gettext("Information");
/* A first pass, to size up the RCM information */
while (tuple = rcm_info_next(rinfo, tuple)) {
info_info_str = rcm_info_info(tuple);
info_rsrc_str = rcm_info_rsrc(tuple);
if ((info_info_str != NULL) && (info_rsrc_str != NULL)) {
tuples++;
if ((w = strlen(info_rsrc_str)) > w_rsrc)
w_rsrc = w;
if ((w = strlen(info_info_str)) > w_info)
w_info = w;
}
}
/* If nothing was sized up above, stop early */
if (tuples == 0)
return (FPCFGA_OK);
/* Adjust column widths for column headings */
if ((w = strlen(rsrc)) > w_rsrc)
w_rsrc = w;
else if ((w_rsrc - w) % 2)
w_rsrc++;
if ((w = strlen(info)) > w_info)
w_info = w;
else if ((w_info - w) % 2)
w_info++;
/*
* Compute the total line width of each line,
* accounting for intercolumn spacing.
*/
width = w_info + w_rsrc + 4;
/* Allocate space for the table */
table_size = (2 + tuples) * (width + 1) + 2;
if (*table == NULL)
*table = malloc(table_size);
else {
newtable = realloc(*table, strlen(*table) + table_size);
if (newtable != NULL)
*table = newtable;
}
if (*table == NULL)
return (FPCFGA_ERR);
/* Place a table header into the string */
/* The resource header */
(void) strcat(*table, "\n");
w = strlen(rsrc);
for (i = 0; i < ((w_rsrc - w) / 2); i++)
(void) strcat(*table, " ");
(void) strcat(*table, rsrc);
for (i = 0; i < ((w_rsrc - w) / 2); i++)
(void) strcat(*table, " ");
/* The information header */
(void) strcat(*table, " ");
w = strlen(info);
for (i = 0; i < ((w_info - w) / 2); i++)
(void) strcat(*table, " ");
(void) strcat(*table, info);
for (i = 0; i < ((w_info - w) / 2); i++)
(void) strcat(*table, " ");
/* Underline the headers */
(void) strcat(*table, "\n");
for (i = 0; i < w_rsrc; i++)
(void) strcat(*table, "-");
(void) strcat(*table, " ");
for (i = 0; i < w_info; i++)
(void) strcat(*table, "-");
/* Construct the format string */
(void) snprintf(format, MAX_FORMAT, "%%-%ds %%-%ds", w_rsrc, w_info);
/* Add the tuples to the table string */
tuple = NULL;
while ((tuple = rcm_info_next(rinfo, tuple)) != NULL) {
info_info_str = rcm_info_info(tuple);
info_rsrc_str = rcm_info_rsrc(tuple);
if ((info_info_str != NULL) && (info_rsrc_str != NULL)) {
(void) strcat(*table, "\n");
(void) sprintf(&((*table)[strlen(*table)]),
format, info_rsrc_str, info_info_str);
}
}
return (FPCFGA_OK);
}
/*
* chop_minor()
*
* Chops off the minor name portion of a resource. Allocates storage for
* the returned string. Caller must free the storage if return is non-NULL.
*/
static char *
chop_minor(char *rsrc)
{
char *rsrc_fixed;
char *cp;
if ((rsrc_fixed = strdup(rsrc)) == NULL)
return (NULL);
if ((cp = strrchr(rsrc_fixed, ':')) != NULL)
*cp = '\0';
return (rsrc_fixed);
}