1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22/* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27/* 28 * The "program" executed by the injector consists of a tree of commands. 29 * Routines in this file build and execute said command tree. 30 */ 31 32#include <sys/fm/protocol.h> 33#include <unistd.h> 34 35#include <inj.h> 36#include <inj_event.h> 37#include <inj_lex.h> 38#include <inj_err.h> 39 40/* 41 * Command tree construction 42 */ 43 44static inj_list_t inj_cmds; 45 46void 47inj_cmds_add(inj_cmd_t *cmd) 48{ 49 inj_list_append(&inj_cmds, cmd); 50} 51 52inj_list_t * 53inj_cmds_get(void) 54{ 55 return (&inj_cmds); 56} 57 58inj_randelem_t * 59inj_rand_create(inj_defn_t *ev, uint_t prob) 60{ 61 inj_randelem_t *re = inj_zalloc(sizeof (inj_randelem_t)); 62 63 re->re_event = ev; 64 re->re_prob = prob; 65 66 return (re); 67} 68 69inj_randelem_t * 70inj_rand_add(inj_randelem_t *list, inj_randelem_t *new) 71{ 72 new->re_next = list; 73 return (new); 74} 75 76inj_cmd_t * 77inj_cmd_rand(inj_randelem_t *rlist) 78{ 79 inj_randelem_t *r; 80 inj_cmd_t *cmd; 81 uint_t prob, tmpprob; 82 int nelems, i; 83 84 prob = 0; 85 for (i = 0, r = rlist; r != NULL; r = r->re_next, i++) 86 prob += r->re_prob; 87 88 if (prob != 100) { 89 yyerror("probabilities don't sum to 100\n"); 90 return (NULL); 91 } 92 93 nelems = i; 94 95 cmd = inj_zalloc(sizeof (inj_cmd_t)); 96 cmd->cmd_type = CMD_RANDOM; 97 cmd->cmd_num = nelems; 98 cmd->cmd_rand = inj_alloc(sizeof (inj_randelem_t *) * nelems); 99 100 prob = 0; 101 for (r = rlist, i = 0; i < nelems; i++, r = r->re_next) { 102 tmpprob = r->re_prob; 103 r->re_prob = prob; 104 prob += tmpprob; 105 106 cmd->cmd_rand[i] = r; 107 } 108 109 return (cmd); 110} 111 112inj_cmd_t * 113inj_cmd_repeat(inj_cmd_t *repcmd, uint_t num) 114{ 115 inj_cmd_t *cmd = inj_zalloc(sizeof (inj_cmd_t)); 116 117 cmd->cmd_type = CMD_REPEAT; 118 cmd->cmd_num = num; 119 cmd->cmd_subcmd = repcmd; 120 121 return (cmd); 122} 123 124inj_cmd_t * 125inj_cmd_send(inj_defn_t *ev) 126{ 127 inj_cmd_t *cmd = inj_zalloc(sizeof (inj_cmd_t)); 128 129 cmd->cmd_type = CMD_SEND_EVENT; 130 cmd->cmd_event = ev; 131 132 return (cmd); 133} 134 135inj_cmd_t * 136inj_cmd_sleep(uint_t secs) 137{ 138 inj_cmd_t *cmd = inj_zalloc(sizeof (inj_cmd_t)); 139 140 cmd->cmd_type = CMD_SLEEP; 141 cmd->cmd_num = secs; 142 143 return (cmd); 144} 145 146inj_cmd_t * 147inj_cmd_addhrt(hrtime_t delta) 148{ 149 const char *class = "resource.fm.fmd.clock.addhrtime"; 150 inj_cmd_t *cmd = inj_zalloc(sizeof (inj_cmd_t)); 151 inj_defn_t *ev = inj_zalloc(sizeof (inj_defn_t)); 152 153 ev->defn_name = class; 154 ev->defn_lineno = yylineno; 155 156 if ((errno = nvlist_alloc(&ev->defn_nvl, NV_UNIQUE_NAME, 0)) != 0) 157 die("failed to allocate nvl for %s event", class); 158 159 if ((errno = nvlist_add_string(ev->defn_nvl, FM_CLASS, class)) != 0 || 160 (errno = nvlist_add_uint8(ev->defn_nvl, FM_VERSION, 1)) != 0 || 161 (errno = nvlist_add_int64(ev->defn_nvl, "delta", delta)) != 0) 162 die("failed to build nvl for %s event", class); 163 164 cmd->cmd_type = CMD_SEND_EVENT; 165 cmd->cmd_event = ev; 166 167 return (cmd); 168} 169 170inj_cmd_t * 171inj_cmd_endhrt(void) 172{ 173 return (inj_cmd_addhrt(-1LL)); /* clock underflow causes end of time */ 174} 175 176static uint64_t 177inj_ena(void) 178{ 179 return (((gethrtime() & ENA_FMT1_TIME_MASK) << 180 ENA_FMT1_TIME_SHFT) | (FM_ENA_FMT1 & ENA_FORMAT_MASK)); 181} 182 183static void 184cmd_run_send(const inj_mode_ops_t *mode, void *hdl, inj_defn_t *ev) 185{ 186 if (!quiet) { 187 (void) printf("sending event %s ... ", ev->defn_name); 188 (void) fflush(stdout); 189 } 190 191 if ((errno = nvlist_add_boolean_value(ev->defn_nvl, "__injected", 192 1)) != 0) 193 warn("failed to add __injected to %s", ev->defn_name); 194 195 if (ev->defn_decl && (ev->defn_decl->decl_flags & DECL_F_AUTOENA) && 196 (errno = nvlist_add_uint64(ev->defn_nvl, "ena", inj_ena())) != 0) 197 warn("failed to add ena to %s", ev->defn_name); 198 199 if (verbose) { 200 nvlist_print(stdout, ev->defn_nvl); 201 (void) printf("\n"); 202 } 203 204 mode->mo_send(hdl, ev->defn_nvl); 205 206 if (!quiet) 207 (void) printf("done\n"); 208} 209 210static void 211cmd_run_random(const inj_mode_ops_t *mode, void *hdl, inj_cmd_t *cmd) 212{ 213 uint_t num = lrand48() % 100; 214 int i; 215 216 for (i = 1; i < cmd->cmd_num; i++) { 217 if (cmd->cmd_rand[i]->re_prob > num) 218 break; 219 } 220 221 cmd_run_send(mode, hdl, cmd->cmd_rand[i - 1]->re_event); 222} 223 224static void 225cmd_run(const inj_mode_ops_t *mode, void *hdl, inj_cmd_t *cmd) 226{ 227 switch (cmd->cmd_type) { 228 case CMD_SEND_EVENT: 229 cmd_run_send(mode, hdl, cmd->cmd_event); 230 break; 231 232 case CMD_SLEEP: 233 (void) printf("sleeping for %d sec%s ... ", 234 cmd->cmd_num, cmd->cmd_num > 1 ? "s" : ""); 235 (void) fflush(stdout); 236 (void) sleep(cmd->cmd_num); 237 (void) printf("done\n"); 238 break; 239 240 case CMD_RANDOM: 241 cmd_run_random(mode, hdl, cmd); 242 break; 243 244 default: 245 warn("ignoring unknown command type: %d\n", cmd->cmd_type); 246 } 247} 248 249void 250inj_program_run(inj_list_t *prog, const inj_mode_ops_t *mode, void *mode_arg) 251{ 252 void *hdl = mode->mo_open(mode_arg); 253 inj_cmd_t *cmd; 254 int i; 255 256 for (cmd = inj_list_next(prog); cmd != NULL; cmd = inj_list_next(cmd)) { 257 if (cmd->cmd_type == CMD_REPEAT) { 258 for (i = 1; i <= cmd->cmd_num; i++) { 259 if (verbose) { 260 (void) printf("(repeat %d of %d)\n", 261 i, cmd->cmd_num); 262 } 263 cmd_run(mode, hdl, cmd->cmd_subcmd); 264 } 265 } else 266 cmd_run(mode, hdl, cmd); 267 } 268 269 mode->mo_close(hdl); 270} 271