/*
 * 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.
 */

/*
 * The "program" executed by the injector consists of a tree of commands.
 * Routines in this file build and execute said command tree.
 */

#include <sys/fm/protocol.h>
#include <unistd.h>

#include <inj.h>
#include <inj_event.h>
#include <inj_lex.h>
#include <inj_err.h>

/*
 * Command tree construction
 */

static inj_list_t inj_cmds;

void
inj_cmds_add(inj_cmd_t *cmd)
{
        inj_list_append(&inj_cmds, cmd);
}

inj_list_t *
inj_cmds_get(void)
{
        return (&inj_cmds);
}

inj_randelem_t *
inj_rand_create(inj_defn_t *ev, uint_t prob)
{
        inj_randelem_t *re = inj_zalloc(sizeof (inj_randelem_t));

        re->re_event = ev;
        re->re_prob = prob;

        return (re);
}

inj_randelem_t *
inj_rand_add(inj_randelem_t *list, inj_randelem_t *new)
{
        new->re_next = list;
        return (new);
}

inj_cmd_t *
inj_cmd_rand(inj_randelem_t *rlist)
{
        inj_randelem_t *r;
        inj_cmd_t *cmd;
        uint_t prob, tmpprob;
        int nelems, i;

        prob = 0;
        for (i = 0, r = rlist; r != NULL; r = r->re_next, i++)
                prob += r->re_prob;

        if (prob != 100) {
                yyerror("probabilities don't sum to 100\n");
                return (NULL);
        }

        nelems = i;

        cmd = inj_zalloc(sizeof (inj_cmd_t));
        cmd->cmd_type = CMD_RANDOM;
        cmd->cmd_num = nelems;
        cmd->cmd_rand = inj_alloc(sizeof (inj_randelem_t *) * nelems);

        prob = 0;
        for (r = rlist, i = 0; i < nelems; i++, r = r->re_next) {
                tmpprob = r->re_prob;
                r->re_prob = prob;
                prob += tmpprob;

                cmd->cmd_rand[i] = r;
        }

        return (cmd);
}

inj_cmd_t *
inj_cmd_repeat(inj_cmd_t *repcmd, uint_t num)
{
        inj_cmd_t *cmd = inj_zalloc(sizeof (inj_cmd_t));

        cmd->cmd_type = CMD_REPEAT;
        cmd->cmd_num = num;
        cmd->cmd_subcmd = repcmd;

        return (cmd);
}

inj_cmd_t *
inj_cmd_send(inj_defn_t *ev)
{
        inj_cmd_t *cmd = inj_zalloc(sizeof (inj_cmd_t));

        cmd->cmd_type = CMD_SEND_EVENT;
        cmd->cmd_event = ev;

        return (cmd);
}

inj_cmd_t *
inj_cmd_sleep(uint_t secs)
{
        inj_cmd_t *cmd = inj_zalloc(sizeof (inj_cmd_t));

        cmd->cmd_type = CMD_SLEEP;
        cmd->cmd_num = secs;

        return (cmd);
}

inj_cmd_t *
inj_cmd_addhrt(hrtime_t delta)
{
        const char *class = "resource.fm.fmd.clock.addhrtime";
        inj_cmd_t *cmd = inj_zalloc(sizeof (inj_cmd_t));
        inj_defn_t *ev = inj_zalloc(sizeof (inj_defn_t));

        ev->defn_name = class;
        ev->defn_lineno = yylineno;

        if ((errno = nvlist_alloc(&ev->defn_nvl, NV_UNIQUE_NAME, 0)) != 0)
                die("failed to allocate nvl for %s event", class);

        if ((errno = nvlist_add_string(ev->defn_nvl, FM_CLASS, class)) != 0 ||
            (errno = nvlist_add_uint8(ev->defn_nvl, FM_VERSION, 1)) != 0 ||
            (errno = nvlist_add_int64(ev->defn_nvl, "delta", delta)) != 0)
                die("failed to build nvl for %s event", class);

        cmd->cmd_type = CMD_SEND_EVENT;
        cmd->cmd_event = ev;

        return (cmd);
}

inj_cmd_t *
inj_cmd_endhrt(void)
{
        return (inj_cmd_addhrt(-1LL)); /* clock underflow causes end of time */
}

static uint64_t
inj_ena(void)
{
        return (((gethrtime() & ENA_FMT1_TIME_MASK) <<
            ENA_FMT1_TIME_SHFT) | (FM_ENA_FMT1 & ENA_FORMAT_MASK));
}

static void
cmd_run_send(const inj_mode_ops_t *mode, void *hdl, inj_defn_t *ev)
{
        if (!quiet) {
                (void) printf("sending event %s ... ", ev->defn_name);
                (void) fflush(stdout);
        }

        if ((errno = nvlist_add_boolean_value(ev->defn_nvl, "__injected",
            1)) != 0)
                warn("failed to add __injected to %s", ev->defn_name);

        if (ev->defn_decl && (ev->defn_decl->decl_flags & DECL_F_AUTOENA) &&
            (errno = nvlist_add_uint64(ev->defn_nvl, "ena", inj_ena())) != 0)
                warn("failed to add ena to %s", ev->defn_name);

        if (verbose) {
                nvlist_print(stdout, ev->defn_nvl);
                (void) printf("\n");
        }

        mode->mo_send(hdl, ev->defn_nvl);

        if (!quiet)
                (void) printf("done\n");
}

static void
cmd_run_random(const inj_mode_ops_t *mode, void *hdl, inj_cmd_t *cmd)
{
        uint_t num = lrand48() % 100;
        int i;

        for (i = 1; i < cmd->cmd_num; i++) {
                if (cmd->cmd_rand[i]->re_prob > num)
                        break;
        }

        cmd_run_send(mode, hdl, cmd->cmd_rand[i - 1]->re_event);
}

static void
cmd_run(const inj_mode_ops_t *mode, void *hdl, inj_cmd_t *cmd)
{
        switch (cmd->cmd_type) {
        case CMD_SEND_EVENT:
                cmd_run_send(mode, hdl, cmd->cmd_event);
                break;

        case CMD_SLEEP:
                (void) printf("sleeping for %d sec%s ... ",
                    cmd->cmd_num, cmd->cmd_num > 1 ? "s" : "");
                (void) fflush(stdout);
                (void) sleep(cmd->cmd_num);
                (void) printf("done\n");
                break;

        case CMD_RANDOM:
                cmd_run_random(mode, hdl, cmd);
                break;

        default:
                warn("ignoring unknown command type: %d\n", cmd->cmd_type);
        }
}

void
inj_program_run(inj_list_t *prog, const inj_mode_ops_t *mode, void *mode_arg)
{
        void *hdl = mode->mo_open(mode_arg);
        inj_cmd_t *cmd;
        int i;

        for (cmd = inj_list_next(prog); cmd != NULL; cmd = inj_list_next(cmd)) {
                if (cmd->cmd_type == CMD_REPEAT) {
                        for (i = 1; i <= cmd->cmd_num; i++) {
                                if (verbose) {
                                        (void) printf("(repeat %d of %d)\n",
                                            i, cmd->cmd_num);
                                }
                                cmd_run(mode, hdl, cmd->cmd_subcmd);
                        }
                } else
                        cmd_run(mode, hdl, cmd);
        }

        mode->mo_close(hdl);
}