1 /* 2 * builtin-inject.c 3 * 4 * Builtin inject command: Examine the live mode (stdin) event stream 5 * and repipe it to stdout while optionally injecting additional 6 * events into it. 7 */ 8 #include "builtin.h" 9 10 #include "perf.h" 11 #include "util/color.h" 12 #include "util/evlist.h" 13 #include "util/evsel.h" 14 #include "util/session.h" 15 #include "util/tool.h" 16 #include "util/debug.h" 17 #include "util/build-id.h" 18 #include "util/data.h" 19 20 #include "util/parse-options.h" 21 22 #include <linux/list.h> 23 24 struct perf_inject { 25 struct perf_tool tool; 26 struct perf_session *session; 27 bool build_ids; 28 bool sched_stat; 29 const char *input_name; 30 struct perf_data_file output; 31 u64 bytes_written; 32 struct list_head samples; 33 }; 34 35 struct event_entry { 36 struct list_head node; 37 u32 tid; 38 union perf_event event[0]; 39 }; 40 41 static int perf_event__repipe_synth(struct perf_tool *tool, 42 union perf_event *event) 43 { 44 struct perf_inject *inject = container_of(tool, struct perf_inject, tool); 45 ssize_t size; 46 47 size = perf_data_file__write(&inject->output, event, 48 event->header.size); 49 if (size < 0) 50 return -errno; 51 52 inject->bytes_written += size; 53 return 0; 54 } 55 56 static int perf_event__repipe_oe_synth(struct perf_tool *tool, 57 union perf_event *event, 58 struct ordered_events *oe __maybe_unused) 59 { 60 return perf_event__repipe_synth(tool, event); 61 } 62 63 static int perf_event__repipe_op2_synth(struct perf_tool *tool, 64 union perf_event *event, 65 struct perf_session *session 66 __maybe_unused) 67 { 68 return perf_event__repipe_synth(tool, event); 69 } 70 71 static int perf_event__repipe_attr(struct perf_tool *tool, 72 union perf_event *event, 73 struct perf_evlist **pevlist) 74 { 75 struct perf_inject *inject = container_of(tool, struct perf_inject, 76 tool); 77 int ret; 78 79 ret = perf_event__process_attr(tool, event, pevlist); 80 if (ret) 81 return ret; 82 83 if (!inject->output.is_pipe) 84 return 0; 85 86 return perf_event__repipe_synth(tool, event); 87 } 88 89 static int perf_event__repipe(struct perf_tool *tool, 90 union perf_event *event, 91 struct perf_sample *sample __maybe_unused, 92 struct machine *machine __maybe_unused) 93 { 94 return perf_event__repipe_synth(tool, event); 95 } 96 97 typedef int (*inject_handler)(struct perf_tool *tool, 98 union perf_event *event, 99 struct perf_sample *sample, 100 struct perf_evsel *evsel, 101 struct machine *machine); 102 103 static int perf_event__repipe_sample(struct perf_tool *tool, 104 union perf_event *event, 105 struct perf_sample *sample, 106 struct perf_evsel *evsel, 107 struct machine *machine) 108 { 109 if (evsel->handler) { 110 inject_handler f = evsel->handler; 111 return f(tool, event, sample, evsel, machine); 112 } 113 114 build_id__mark_dso_hit(tool, event, sample, evsel, machine); 115 116 return perf_event__repipe_synth(tool, event); 117 } 118 119 static int perf_event__repipe_mmap(struct perf_tool *tool, 120 union perf_event *event, 121 struct perf_sample *sample, 122 struct machine *machine) 123 { 124 int err; 125 126 err = perf_event__process_mmap(tool, event, sample, machine); 127 perf_event__repipe(tool, event, sample, machine); 128 129 return err; 130 } 131 132 static int perf_event__repipe_mmap2(struct perf_tool *tool, 133 union perf_event *event, 134 struct perf_sample *sample, 135 struct machine *machine) 136 { 137 int err; 138 139 err = perf_event__process_mmap2(tool, event, sample, machine); 140 perf_event__repipe(tool, event, sample, machine); 141 142 return err; 143 } 144 145 static int perf_event__repipe_fork(struct perf_tool *tool, 146 union perf_event *event, 147 struct perf_sample *sample, 148 struct machine *machine) 149 { 150 int err; 151 152 err = perf_event__process_fork(tool, event, sample, machine); 153 perf_event__repipe(tool, event, sample, machine); 154 155 return err; 156 } 157 158 static int perf_event__repipe_tracing_data(struct perf_tool *tool, 159 union perf_event *event, 160 struct perf_session *session) 161 { 162 int err; 163 164 perf_event__repipe_synth(tool, event); 165 err = perf_event__process_tracing_data(tool, event, session); 166 167 return err; 168 } 169 170 static int dso__read_build_id(struct dso *dso) 171 { 172 if (dso->has_build_id) 173 return 0; 174 175 if (filename__read_build_id(dso->long_name, dso->build_id, 176 sizeof(dso->build_id)) > 0) { 177 dso->has_build_id = true; 178 return 0; 179 } 180 181 return -1; 182 } 183 184 static int dso__inject_build_id(struct dso *dso, struct perf_tool *tool, 185 struct machine *machine) 186 { 187 u16 misc = PERF_RECORD_MISC_USER; 188 int err; 189 190 if (dso__read_build_id(dso) < 0) { 191 pr_debug("no build_id found for %s\n", dso->long_name); 192 return -1; 193 } 194 195 if (dso->kernel) 196 misc = PERF_RECORD_MISC_KERNEL; 197 198 err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe, 199 machine); 200 if (err) { 201 pr_err("Can't synthesize build_id event for %s\n", dso->long_name); 202 return -1; 203 } 204 205 return 0; 206 } 207 208 static int perf_event__inject_buildid(struct perf_tool *tool, 209 union perf_event *event, 210 struct perf_sample *sample, 211 struct perf_evsel *evsel __maybe_unused, 212 struct machine *machine) 213 { 214 struct addr_location al; 215 struct thread *thread; 216 u8 cpumode; 217 218 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 219 220 thread = machine__findnew_thread(machine, sample->pid, sample->tid); 221 if (thread == NULL) { 222 pr_err("problem processing %d event, skipping it.\n", 223 event->header.type); 224 goto repipe; 225 } 226 227 thread__find_addr_map(thread, cpumode, MAP__FUNCTION, sample->ip, &al); 228 229 if (al.map != NULL) { 230 if (!al.map->dso->hit) { 231 al.map->dso->hit = 1; 232 if (map__load(al.map, NULL) >= 0) { 233 dso__inject_build_id(al.map->dso, tool, machine); 234 /* 235 * If this fails, too bad, let the other side 236 * account this as unresolved. 237 */ 238 } else { 239 #ifdef HAVE_LIBELF_SUPPORT 240 pr_warning("no symbols found in %s, maybe " 241 "install a debug package?\n", 242 al.map->dso->long_name); 243 #endif 244 } 245 } 246 } 247 248 repipe: 249 perf_event__repipe(tool, event, sample, machine); 250 return 0; 251 } 252 253 static int perf_inject__sched_process_exit(struct perf_tool *tool, 254 union perf_event *event __maybe_unused, 255 struct perf_sample *sample, 256 struct perf_evsel *evsel __maybe_unused, 257 struct machine *machine __maybe_unused) 258 { 259 struct perf_inject *inject = container_of(tool, struct perf_inject, tool); 260 struct event_entry *ent; 261 262 list_for_each_entry(ent, &inject->samples, node) { 263 if (sample->tid == ent->tid) { 264 list_del_init(&ent->node); 265 free(ent); 266 break; 267 } 268 } 269 270 return 0; 271 } 272 273 static int perf_inject__sched_switch(struct perf_tool *tool, 274 union perf_event *event, 275 struct perf_sample *sample, 276 struct perf_evsel *evsel, 277 struct machine *machine) 278 { 279 struct perf_inject *inject = container_of(tool, struct perf_inject, tool); 280 struct event_entry *ent; 281 282 perf_inject__sched_process_exit(tool, event, sample, evsel, machine); 283 284 ent = malloc(event->header.size + sizeof(struct event_entry)); 285 if (ent == NULL) { 286 color_fprintf(stderr, PERF_COLOR_RED, 287 "Not enough memory to process sched switch event!"); 288 return -1; 289 } 290 291 ent->tid = sample->tid; 292 memcpy(&ent->event, event, event->header.size); 293 list_add(&ent->node, &inject->samples); 294 return 0; 295 } 296 297 static int perf_inject__sched_stat(struct perf_tool *tool, 298 union perf_event *event __maybe_unused, 299 struct perf_sample *sample, 300 struct perf_evsel *evsel, 301 struct machine *machine) 302 { 303 struct event_entry *ent; 304 union perf_event *event_sw; 305 struct perf_sample sample_sw; 306 struct perf_inject *inject = container_of(tool, struct perf_inject, tool); 307 u32 pid = perf_evsel__intval(evsel, sample, "pid"); 308 309 list_for_each_entry(ent, &inject->samples, node) { 310 if (pid == ent->tid) 311 goto found; 312 } 313 314 return 0; 315 found: 316 event_sw = &ent->event[0]; 317 perf_evsel__parse_sample(evsel, event_sw, &sample_sw); 318 319 sample_sw.period = sample->period; 320 sample_sw.time = sample->time; 321 perf_event__synthesize_sample(event_sw, evsel->attr.sample_type, 322 evsel->attr.read_format, &sample_sw, 323 false); 324 build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine); 325 return perf_event__repipe(tool, event_sw, &sample_sw, machine); 326 } 327 328 static void sig_handler(int sig __maybe_unused) 329 { 330 session_done = 1; 331 } 332 333 static int perf_evsel__check_stype(struct perf_evsel *evsel, 334 u64 sample_type, const char *sample_msg) 335 { 336 struct perf_event_attr *attr = &evsel->attr; 337 const char *name = perf_evsel__name(evsel); 338 339 if (!(attr->sample_type & sample_type)) { 340 pr_err("Samples for %s event do not have %s attribute set.", 341 name, sample_msg); 342 return -EINVAL; 343 } 344 345 return 0; 346 } 347 348 static int __cmd_inject(struct perf_inject *inject) 349 { 350 int ret = -EINVAL; 351 struct perf_session *session = inject->session; 352 struct perf_data_file *file_out = &inject->output; 353 int fd = perf_data_file__fd(file_out); 354 355 signal(SIGINT, sig_handler); 356 357 if (inject->build_ids || inject->sched_stat) { 358 inject->tool.mmap = perf_event__repipe_mmap; 359 inject->tool.mmap2 = perf_event__repipe_mmap2; 360 inject->tool.fork = perf_event__repipe_fork; 361 inject->tool.tracing_data = perf_event__repipe_tracing_data; 362 } 363 364 if (inject->build_ids) { 365 inject->tool.sample = perf_event__inject_buildid; 366 } else if (inject->sched_stat) { 367 struct perf_evsel *evsel; 368 369 evlist__for_each(session->evlist, evsel) { 370 const char *name = perf_evsel__name(evsel); 371 372 if (!strcmp(name, "sched:sched_switch")) { 373 if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID")) 374 return -EINVAL; 375 376 evsel->handler = perf_inject__sched_switch; 377 } else if (!strcmp(name, "sched:sched_process_exit")) 378 evsel->handler = perf_inject__sched_process_exit; 379 else if (!strncmp(name, "sched:sched_stat_", 17)) 380 evsel->handler = perf_inject__sched_stat; 381 } 382 } 383 384 if (!file_out->is_pipe) 385 lseek(fd, session->header.data_offset, SEEK_SET); 386 387 ret = perf_session__process_events(session); 388 389 if (!file_out->is_pipe) { 390 if (inject->build_ids) 391 perf_header__set_feat(&session->header, 392 HEADER_BUILD_ID); 393 session->header.data_size = inject->bytes_written; 394 perf_session__write_header(session, session->evlist, fd, true); 395 } 396 397 return ret; 398 } 399 400 int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused) 401 { 402 struct perf_inject inject = { 403 .tool = { 404 .sample = perf_event__repipe_sample, 405 .mmap = perf_event__repipe, 406 .mmap2 = perf_event__repipe, 407 .comm = perf_event__repipe, 408 .fork = perf_event__repipe, 409 .exit = perf_event__repipe, 410 .lost = perf_event__repipe, 411 .read = perf_event__repipe_sample, 412 .throttle = perf_event__repipe, 413 .unthrottle = perf_event__repipe, 414 .attr = perf_event__repipe_attr, 415 .tracing_data = perf_event__repipe_op2_synth, 416 .finished_round = perf_event__repipe_oe_synth, 417 .build_id = perf_event__repipe_op2_synth, 418 .id_index = perf_event__repipe_op2_synth, 419 }, 420 .input_name = "-", 421 .samples = LIST_HEAD_INIT(inject.samples), 422 .output = { 423 .path = "-", 424 .mode = PERF_DATA_MODE_WRITE, 425 }, 426 }; 427 struct perf_data_file file = { 428 .mode = PERF_DATA_MODE_READ, 429 }; 430 int ret; 431 432 const struct option options[] = { 433 OPT_BOOLEAN('b', "build-ids", &inject.build_ids, 434 "Inject build-ids into the output stream"), 435 OPT_STRING('i', "input", &inject.input_name, "file", 436 "input file name"), 437 OPT_STRING('o', "output", &inject.output.path, "file", 438 "output file name"), 439 OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat, 440 "Merge sched-stat and sched-switch for getting events " 441 "where and how long tasks slept"), 442 OPT_INCR('v', "verbose", &verbose, 443 "be more verbose (show build ids, etc)"), 444 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file", 445 "kallsyms pathname"), 446 OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"), 447 OPT_END() 448 }; 449 const char * const inject_usage[] = { 450 "perf inject [<options>]", 451 NULL 452 }; 453 454 argc = parse_options(argc, argv, options, inject_usage, 0); 455 456 /* 457 * Any (unrecognized) arguments left? 458 */ 459 if (argc) 460 usage_with_options(inject_usage, options); 461 462 if (perf_data_file__open(&inject.output)) { 463 perror("failed to create output file"); 464 return -1; 465 } 466 467 inject.tool.ordered_events = inject.sched_stat; 468 469 file.path = inject.input_name; 470 inject.session = perf_session__new(&file, true, &inject.tool); 471 if (inject.session == NULL) 472 return -1; 473 474 if (symbol__init(&inject.session->header.env) < 0) 475 return -1; 476 477 ret = __cmd_inject(&inject); 478 479 perf_session__delete(inject.session); 480 481 return ret; 482 } 483