/*
 * 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);
}