/*
 * 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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <fm/fmd_api.h>
#include <libnvpair.h>
#include <fm/libtopo.h>
#include "out.h"
#include "stats.h"
#include "alloc.h"
#include "stable.h"
#include "literals.h"
#include "lut.h"
#include "esclex.h"
#include "tree.h"
#include "ipath.h"
#include "itree.h"
#include "iexpr.h"
#include "ptree.h"
#include "check.h"
#include "version.h"
#include "fme.h"
#include "eval.h"
#include "config.h"
#include "platform.h"

/*
 * eversholt diagnosis engine (eft.so) main entry points
 */

fmd_hdl_t *Hdl;         /* handle in global for platform.c */

int Debug = 1;  /* turn on here and let fmd_hdl_debug() decide if really on */
hrtime_t Hesitate;      /* hesitation time in ns */
char *Serd_Override;    /* override for Serd engines */
int Verbose;
int Estats;
int Warn;       /* zero -- eft.so should not issue language warnings */
char **Efts;
int Max_fme;            /* Maximum number of open FMEs */

/* stuff exported by yacc-generated parsers */
extern void yyparse(void);
extern int yydebug;

extern struct lut *Dicts;

extern void literals_init(void);
extern void literals_fini(void);

struct eftsubr {
        const char *prefix;
        void (*hdlr)(fmd_hdl_t *, fmd_event_t *, nvlist_t *, const char *);
} eftsubrs[] = {
        { "ereport.",           fme_receive_external_report },
        { "list.repaired",      fme_receive_repair_list },
        { NULL,                 NULL }
};

/*ARGSUSED*/
static void
eft_recv(fmd_hdl_t *hdl, fmd_event_t *ep, nvlist_t *nvl, const char *class)
{
        struct eftsubr *sp = eftsubrs;

        while (sp->prefix != NULL) {
                if (strncmp(class, sp->prefix, strlen(sp->prefix)) == 0)
                        break;
                sp++;
        }

        if (sp->prefix != NULL) {
                (sp->hdlr)(hdl, ep, nvl, class);
        } else {
                out(O_DIE,
                    "eft_recv: event class \"%s\" does not match our "
                    "subscriptions", class);
        }
}

/*ARGSUSED*/
static void
eft_timeout(fmd_hdl_t *hdl, id_t tid, void *arg)
{
        out(O_ALTFP|O_STAMP,
            "\neft.so timer %ld fired with arg %p", tid, arg);

        if (arg == NULL)
                return;

        fme_timer_fired(arg, tid);
}

static void
eft_close(fmd_hdl_t *hdl, fmd_case_t *fmcase)
{
        out(O_ALTFP, "eft_close called for case %s",
            fmd_case_uuid(hdl, fmcase));
        fme_close_case(hdl, fmcase);
}

/*
 * The "serd_override" property allows the N and T parameters of specified serd
 * engines to be overridden. The property is a string consisting of one or more
 * space separated triplets. Each triplet is of the form "name,N,T" where "name"
 * is the name of the serd engine and N and T are the new paremeters to use.
 * For example "serd.io.device.nonfatal,5,3h" would set the parameters for the
 * serd.io.device.nonfatal engine to 5 in 3 hours.
 */
static const fmd_prop_t eft_props[] = {
        { "estats", FMD_TYPE_BOOL, "false" },
        { "hesitate", FMD_TYPE_INT64, "10000000000" },
        { "serd_override", FMD_TYPE_STRING, NULL },
        { "verbose", FMD_TYPE_INT32, "0" },
        { "warn", FMD_TYPE_BOOL, "false" },
        { "status", FMD_TYPE_STRING, NULL },
        { "maxfme", FMD_TYPE_INT32, "0" },
        { NULL, 0, NULL }
};

/*ARGSUSED*/
static void
eft_topo_change(fmd_hdl_t *hdl, topo_hdl_t *thp)
{
        fme_receive_topology_change();
}

static const fmd_hdl_ops_t eft_ops = {
        eft_recv,       /* fmdo_recv */
        eft_timeout,    /* fmdo_timeout */
        eft_close,      /* fmdo_close */
        NULL,           /* fmdo_stats */
        NULL,           /* fmdo_gc */
        NULL,           /* fmdo_send */
        eft_topo_change /* fmdo_topo_change */
};

#define xstr(s) str(s)
#define str(s) #s

static const fmd_hdl_info_t fmd_info = {
        "eft diagnosis engine",
        xstr(VERSION_MAJOR) "." xstr(VERSION_MINOR),
        &eft_ops, eft_props
};

/*
 * ename_strdup -- like strdup but ename comes in and class string goes out
 */
static char *
ename_strdup(struct node *np)
{
        struct node *mynp;
        int len;
        char *buf;

        /* calculate length of buffer required */
        len = 0;
        for (mynp = np; mynp; mynp = mynp->u.name.next)
                len += strlen(mynp->u.name.s) + 1;      /* +1 for dot or NULL */

        buf = MALLOC(len);
        buf[0] = '\0';

        /* now build the string */
        while (np) {
                (void) strcat(buf, np->u.name.s);
                np = np->u.name.next;
                if (np)
                        (void) strcat(buf, ".");
        }

        return (buf);
}

/*ARGSUSED*/
static void
dosubscribe(struct node *lhs, struct node *rhs, void *arg)
{
        char *ename = ename_strdup(lhs);

        fmd_hdl_subscribe(Hdl, ename);
        FREE(ename);
}

/*ARGSUSED*/
static void
dodiscardprint(struct node *lhs, struct node *rhs, void *arg)
{
        char *ename = (char *)lhs;

        out(O_VERB, "allow silent discard_if_config_unknown: \"%s\"", ename);
}

extern struct stats *Filecount;

/*
 * Call all of the _fini() routines to clean up the exiting DE
 */
void
call_finis(void)
{
        platform_free_eft_files(Efts);
        Efts = NULL;
        platform_fini();
        fme_fini();
        itree_fini();
        ipath_fini();
        iexpr_fini();
        istat_fini();
        serd_fini();
        lex_free();
        check_fini();
        tree_fini();
        lut_fini();
        literals_fini();
        stable_fini();
        stats_fini();
        out_fini();
        alloc_fini();
}

/*ARGSUSED*/
static void
doopendict(const char *lhs, void *rhs, void *arg)
{
        out(O_VERB, "opendict: \"%s\"", lhs);
        fmd_hdl_opendict(Hdl, lhs);
}

void
_fmd_init(fmd_hdl_t *hdl)
{
        fmd_case_t *casep = NULL;
        int count;
        char *fname;

        (void) fmd_hdl_register(hdl, FMD_API_VERSION, &fmd_info);

        /* keep handle for routines like out() which need it */
        Hdl = hdl;

        /* set up out(O_ALTFP) first things so it is available for debug */
        alloc_init();
        out_init("eft");
        if ((fname = fmd_prop_get_string(hdl, "status")) != NULL) {
                FILE *fp;

                if ((fp = fopen(fname, "a")) == NULL) {
                        fmd_prop_free_string(hdl, fname);
                        out(O_DIE|O_SYS, "status property file: %s", fname);
                }

                (void) setlinebuf(fp);
                out_altfp(fp);

                out(O_DEBUG, "appending status changes to \"%s\"", fname);
                fmd_prop_free_string(hdl, fname);

                out(O_ALTFP|O_STAMP, "\neft.so startup");
        }


        Estats = fmd_prop_get_int32(hdl, "estats");
        stats_init(Estats);

        stable_init(0);
        literals_init();
        platform_init();
        lut_init();
        tree_init();
        ipath_init();
        iexpr_init();
        Efts = platform_get_eft_files();
        lex_init(Efts, NULL, 0);
        check_init();

        /*
         *  If we read no .eft files, we can't do any
         *  diagnosing, so we just unload ourselves
         */
        if (stats_counter_value(Filecount) == 0) {
                (void) lex_fini();
                call_finis();
                fmd_hdl_debug(hdl, "no fault trees provided.");
                fmd_hdl_unregister(hdl);
                return;
        }

        yyparse();
        (void) lex_fini();
        tree_report();
        if (count = out_errcount())
                out(O_DIE, "%d language error%s encountered, exiting.",
                    OUTS(count));

        /* subscribe to events we expect to consume */
        lut_walk(Ereportenames, (lut_cb)dosubscribe, NULL);
        lut_walk(Ereportenames_discard, (lut_cb)dodiscardprint, NULL);

        /* subscribe to repair events so we can clear state on repair */
        fmd_hdl_subscribe(hdl, "list.repaired");

        /* open dictionaries referenced by all .eft files */
        lut_walk(Dicts, (lut_cb)doopendict, (void *)0);

        Verbose = fmd_prop_get_int32(hdl, "verbose");
        Warn = fmd_prop_get_int32(hdl, "warn");
        Hesitate = fmd_prop_get_int64(hdl, "hesitate");
        Serd_Override = fmd_prop_get_string(hdl, "serd_override");
        Max_fme = fmd_prop_get_int32(hdl, "maxfme");

        out(O_DEBUG, "initialized, verbose %d warn %d maxfme %d",
            Verbose, Warn, Max_fme);

        fme_istat_load(hdl);
        fme_serd_load(hdl);

        out(O_VERB, "reconstituting any existing fmes");
        while ((casep = fmd_case_next(hdl, casep)) != NULL) {
                fme_restart(hdl, casep);
        }
}

/*ARGSUSED*/
void
_fmd_fini(fmd_hdl_t *hdl)
{
        call_finis();
}