fminject/common/inj_cmds.c

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