/*
 * 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 <sys/fm/protocol.h>
#include <fm/fmd_api.h>
#include <strings.h>
#include <libdevinfo.h>
#include <sys/modctl.h>

static int      global_disable;

struct except_list {
        char                    *el_fault;
        struct except_list      *el_next;
};

static struct except_list *except_list;

static void
parse_exception_string(fmd_hdl_t *hdl, char *estr)
{
        char    *p;
        char    *next;
        size_t  len;
        struct except_list *elem;

        len = strlen(estr);

        p = estr;
        for (;;) {
                /* Remove leading ':' */
                while (*p == ':')
                        p++;
                if (*p == '\0')
                        break;

                next = strchr(p, ':');

                if (next)
                        *next = '\0';

                elem = fmd_hdl_alloc(hdl,
                    sizeof (struct except_list), FMD_SLEEP);
                elem->el_fault = fmd_hdl_strdup(hdl, p, FMD_SLEEP);
                elem->el_next = except_list;
                except_list = elem;

                if (next) {
                        *next = ':';
                        p = next + 1;
                } else {
                        break;
                }
        }

        if (len != strlen(estr)) {
                fmd_hdl_abort(hdl, "Error parsing exception list: %s\n", estr);
        }
}

/*
 * Returns
 *      1  if fault on exception list
 *      0  otherwise
 */
static int
fault_exception(fmd_hdl_t *hdl, nvlist_t *fault)
{
        struct except_list *elem;

        for (elem = except_list; elem; elem = elem->el_next) {
                if (fmd_nvl_class_match(hdl, fault, elem->el_fault)) {
                        fmd_hdl_debug(hdl, "rio_recv: Skipping fault "
                            "on exception list (%s)\n", elem->el_fault);
                        return (1);
                }
        }

        return (0);
}

static void
free_exception_list(fmd_hdl_t *hdl)
{
        struct except_list *elem;

        while (except_list) {
                elem = except_list;
                except_list = elem->el_next;
                fmd_hdl_strfree(hdl, elem->el_fault);
                fmd_hdl_free(hdl, elem, sizeof (*elem));
        }
}


/*ARGSUSED*/
static void
rio_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl, const char *class)
{
        nvlist_t        **faults = NULL;
        nvlist_t        *asru;
        uint_t          nfaults = 0;
        int             f;
        char            *path;
        char            *uuid;
        char            *scheme;
        di_retire_t     drt = {0};
        int             retire;
        int             rval = 0;
        int             valid_suspect = 0;
        int             error;
        char            *snglfault = FM_FAULT_CLASS"."FM_ERROR_IO".";
        boolean_t       rtr;


        /*
         * If disabled, we don't do retire. We still do unretires though
         */
        if (global_disable && (strcmp(class, FM_LIST_SUSPECT_CLASS) == 0 ||
            strcmp(class, FM_LIST_UPDATED_CLASS) == 0)) {
                fmd_hdl_debug(hdl, "rio_recv: retire disabled\n");
                return;
        }

        drt.rt_abort = (void (*)(void *, const char *, ...))fmd_hdl_abort;
        drt.rt_debug = (void (*)(void *, const char *, ...))fmd_hdl_debug;
        drt.rt_hdl = hdl;

        if (strcmp(class, FM_LIST_SUSPECT_CLASS) == 0) {
                retire = 1;
        } else if (strcmp(class, FM_LIST_REPAIRED_CLASS) == 0) {
                retire = 0;
        } else if (strcmp(class, FM_LIST_UPDATED_CLASS) == 0) {
                retire = 0;
        } else if (strcmp(class, FM_LIST_RESOLVED_CLASS) == 0) {
                return;
        } else if (strncmp(class, snglfault, strlen(snglfault)) == 0) {
                retire = 1;
                faults = &nvl;
                nfaults = 1;
        } else {
                fmd_hdl_debug(hdl, "rio_recv: not list.* class: %s\n", class);
                return;
        }

        if (nfaults == 0 && nvlist_lookup_nvlist_array(nvl,
            FM_SUSPECT_FAULT_LIST, &faults, &nfaults) != 0) {
                fmd_hdl_debug(hdl, "rio_recv: no fault list");
                return;
        }

        for (f = 0; f < nfaults; f++) {
                if (nvlist_lookup_boolean_value(faults[f], FM_SUSPECT_RETIRE,
                    &rtr) == 0 && !rtr) {
                        fmd_hdl_debug(hdl, "rio_recv: retire suppressed");
                        continue;
                }

                if (nvlist_lookup_nvlist(faults[f], FM_FAULT_ASRU,
                    &asru) != 0) {
                        fmd_hdl_debug(hdl, "rio_recv: no asru in fault");
                        continue;
                }

                scheme = NULL;
                if (nvlist_lookup_string(asru, FM_FMRI_SCHEME, &scheme) != 0 ||
                    strcmp(scheme, FM_FMRI_SCHEME_DEV) != 0) {
                        fmd_hdl_debug(hdl, "rio_recv: not \"dev\" scheme: %s",
                            scheme ? scheme : "<NULL>");
                        continue;
                }

                if (fault_exception(hdl, faults[f]))
                        continue;

                if (nvlist_lookup_string(asru, FM_FMRI_DEV_PATH,
                    &path) != 0 || path[0] == '\0') {
                        fmd_hdl_debug(hdl, "rio_recv: no dev path in asru");
                        continue;
                }

                valid_suspect = 1;
                if (retire) {
                        if (fmd_nvl_fmri_has_fault(hdl, asru,
                            FMD_HAS_FAULT_ASRU, NULL) == 1) {
                                error = di_retire_device(path, &drt, 0);
                                if (error != 0) {
                                        fmd_hdl_debug(hdl, "rio_recv:"
                                            " di_retire_device failed:"
                                            " error: %d %s", error, path);
                                        rval = -1;
                                }
                        }
                } else {
                        if (fmd_nvl_fmri_has_fault(hdl, asru,
                            FMD_HAS_FAULT_ASRU, NULL) == 0) {
                                error = di_unretire_device(path, &drt);
                                if (error != 0) {
                                        fmd_hdl_debug(hdl, "rio_recv:"
                                            " di_unretire_device failed:"
                                            " error: %d %s", error, path);
                                        rval = -1;
                                }
                        }
                }
        }
        /*
         * Run through again to handle new faults in a list.updated.
         */
        for (f = 0; f < nfaults; f++) {
                if (nvlist_lookup_boolean_value(faults[f], FM_SUSPECT_RETIRE,
                    &rtr) == 0 && !rtr) {
                        fmd_hdl_debug(hdl, "rio_recv: retire suppressed");
                        continue;
                }

                if (nvlist_lookup_nvlist(faults[f], FM_FAULT_ASRU,
                    &asru) != 0) {
                        fmd_hdl_debug(hdl, "rio_recv: no asru in fault");
                        continue;
                }

                scheme = NULL;
                if (nvlist_lookup_string(asru, FM_FMRI_SCHEME, &scheme) != 0 ||
                    strcmp(scheme, FM_FMRI_SCHEME_DEV) != 0) {
                        fmd_hdl_debug(hdl, "rio_recv: not \"dev\" scheme: %s",
                            scheme ? scheme : "<NULL>");
                        continue;
                }

                if (fault_exception(hdl, faults[f]))
                        continue;

                if (nvlist_lookup_string(asru, FM_FMRI_DEV_PATH,
                    &path) != 0 || path[0] == '\0') {
                        fmd_hdl_debug(hdl, "rio_recv: no dev path in asru");
                        continue;
                }

                if (strcmp(class, FM_LIST_UPDATED_CLASS) == 0) {
                        if (fmd_nvl_fmri_has_fault(hdl, asru,
                            FMD_HAS_FAULT_ASRU, NULL) == 1) {
                                error = di_retire_device(path, &drt, 0);
                                if (error != 0) {
                                        fmd_hdl_debug(hdl, "rio_recv:"
                                            " di_retire_device failed:"
                                            " error: %d %s", error, path);
                                }
                        }
                }
        }

        /*
         * Don't send uuclose or uuresolved unless at least one suspect
         * was valid for this retire agent and no retires/unretires failed.
         */
        if (valid_suspect == 0)
                return;

        /*
         * The fmd framework takes care of moving a case to the repaired
         * state. To move the case to the closed state however, we (the
         * retire agent) need to call fmd_case_uuclose()
         */
        if (strcmp(class, FM_LIST_SUSPECT_CLASS) == 0 && rval == 0) {
                if (nvlist_lookup_string(nvl, FM_SUSPECT_UUID, &uuid) == 0 &&
                    !fmd_case_uuclosed(hdl, uuid)) {
                        fmd_case_uuclose(hdl, uuid);
                }
        }

        /*
         * Similarly to move the case to the resolved state, we (the
         * retire agent) need to call fmd_case_uuresolved()
         */
        if (strcmp(class, FM_LIST_REPAIRED_CLASS) == 0 && rval == 0 &&
            nvlist_lookup_string(nvl, FM_SUSPECT_UUID, &uuid) == 0)
                fmd_case_uuresolved(hdl, uuid);
}

static const fmd_hdl_ops_t fmd_ops = {
        rio_recv,       /* fmdo_recv */
        NULL,           /* fmdo_timeout */
        NULL,           /* fmdo_close */
        NULL,           /* fmdo_stats */
        NULL,           /* fmdo_gc */
};

static const fmd_prop_t rio_props[] = {
        { "global-disable", FMD_TYPE_BOOL, "false" },
        { "fault-exceptions", FMD_TYPE_STRING, NULL },
        { NULL, 0, NULL }
};

static const fmd_hdl_info_t fmd_info = {
        "I/O Retire Agent", "2.0", &fmd_ops, rio_props
};

void
_fmd_init(fmd_hdl_t *hdl)
{
        char    *estr;
        char    *estrdup;

        if (fmd_hdl_register(hdl, FMD_API_VERSION, &fmd_info) != 0) {
                fmd_hdl_debug(hdl, "failed to register handle\n");
                return;
        }

        global_disable = fmd_prop_get_int32(hdl, "global-disable");

        estrdup = NULL;
        if (estr = fmd_prop_get_string(hdl, "fault-exceptions")) {
                estrdup = fmd_hdl_strdup(hdl, estr, FMD_SLEEP);
                fmd_prop_free_string(hdl, estr);
                parse_exception_string(hdl, estrdup);
                fmd_hdl_strfree(hdl, estrdup);
        }
}

void
_fmd_fini(fmd_hdl_t *hdl)
{
        free_exception_list(hdl);
}