4 * Builtin inject command: Examine the live mode (stdin) event stream
5 * and repipe it to stdout while optionally injecting additional
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 #include "util/auxtrace.h"
21 #include "util/parse-options.h"
23 #include <linux/list.h>
26 struct perf_tool tool;
27 struct perf_session *session;
31 const char *input_name;
32 struct perf_data_file output;
35 struct list_head samples;
36 struct itrace_synth_opts itrace_synth_opts;
40 struct list_head node;
42 union perf_event event[0];
45 static int output_bytes(struct perf_inject *inject, void *buf, size_t sz)
49 size = perf_data_file__write(&inject->output, buf, sz);
53 inject->bytes_written += size;
57 static int perf_event__repipe_synth(struct perf_tool *tool,
58 union perf_event *event)
60 struct perf_inject *inject = container_of(tool, struct perf_inject,
63 return output_bytes(inject, event, event->header.size);
66 static int perf_event__repipe_oe_synth(struct perf_tool *tool,
67 union perf_event *event,
68 struct ordered_events *oe __maybe_unused)
70 return perf_event__repipe_synth(tool, event);
73 static int perf_event__repipe_op2_synth(struct perf_tool *tool,
74 union perf_event *event,
75 struct perf_session *session
78 return perf_event__repipe_synth(tool, event);
81 static int perf_event__repipe_attr(struct perf_tool *tool,
82 union perf_event *event,
83 struct perf_evlist **pevlist)
85 struct perf_inject *inject = container_of(tool, struct perf_inject,
89 ret = perf_event__process_attr(tool, event, pevlist);
93 if (!inject->output.is_pipe)
96 return perf_event__repipe_synth(tool, event);
99 #ifdef HAVE_AUXTRACE_SUPPORT
101 static int copy_bytes(struct perf_inject *inject, int fd, off_t size)
108 ssz = read(fd, buf, min(size, (off_t)sizeof(buf)));
111 ret = output_bytes(inject, buf, ssz);
120 static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
121 union perf_event *event,
122 struct perf_session *session
125 struct perf_inject *inject = container_of(tool, struct perf_inject,
129 inject->have_auxtrace = true;
131 if (!inject->output.is_pipe) {
134 offset = lseek(inject->output.fd, 0, SEEK_CUR);
137 ret = auxtrace_index__auxtrace_event(&session->auxtrace_index,
143 if (perf_data_file__is_pipe(session->file) || !session->one_mmap) {
144 ret = output_bytes(inject, event, event->header.size);
147 ret = copy_bytes(inject, perf_data_file__fd(session->file),
148 event->auxtrace.size);
150 ret = output_bytes(inject, event,
151 event->header.size + event->auxtrace.size);
156 return event->auxtrace.size;
162 perf_event__repipe_auxtrace(struct perf_tool *tool __maybe_unused,
163 union perf_event *event __maybe_unused,
164 struct perf_session *session __maybe_unused)
166 pr_err("AUX area tracing not supported\n");
172 static int perf_event__repipe(struct perf_tool *tool,
173 union perf_event *event,
174 struct perf_sample *sample __maybe_unused,
175 struct machine *machine __maybe_unused)
177 return perf_event__repipe_synth(tool, event);
180 static int perf_event__drop_aux(struct perf_tool *tool,
181 union perf_event *event __maybe_unused,
182 struct perf_sample *sample,
183 struct machine *machine __maybe_unused)
185 struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
188 inject->aux_id = sample->id;
193 typedef int (*inject_handler)(struct perf_tool *tool,
194 union perf_event *event,
195 struct perf_sample *sample,
196 struct perf_evsel *evsel,
197 struct machine *machine);
199 static int perf_event__repipe_sample(struct perf_tool *tool,
200 union perf_event *event,
201 struct perf_sample *sample,
202 struct perf_evsel *evsel,
203 struct machine *machine)
205 if (evsel->handler) {
206 inject_handler f = evsel->handler;
207 return f(tool, event, sample, evsel, machine);
210 build_id__mark_dso_hit(tool, event, sample, evsel, machine);
212 return perf_event__repipe_synth(tool, event);
215 static int perf_event__repipe_mmap(struct perf_tool *tool,
216 union perf_event *event,
217 struct perf_sample *sample,
218 struct machine *machine)
222 err = perf_event__process_mmap(tool, event, sample, machine);
223 perf_event__repipe(tool, event, sample, machine);
228 static int perf_event__repipe_mmap2(struct perf_tool *tool,
229 union perf_event *event,
230 struct perf_sample *sample,
231 struct machine *machine)
235 err = perf_event__process_mmap2(tool, event, sample, machine);
236 perf_event__repipe(tool, event, sample, machine);
241 static int perf_event__repipe_fork(struct perf_tool *tool,
242 union perf_event *event,
243 struct perf_sample *sample,
244 struct machine *machine)
248 err = perf_event__process_fork(tool, event, sample, machine);
249 perf_event__repipe(tool, event, sample, machine);
254 static int perf_event__repipe_comm(struct perf_tool *tool,
255 union perf_event *event,
256 struct perf_sample *sample,
257 struct machine *machine)
261 err = perf_event__process_comm(tool, event, sample, machine);
262 perf_event__repipe(tool, event, sample, machine);
267 static int perf_event__repipe_exit(struct perf_tool *tool,
268 union perf_event *event,
269 struct perf_sample *sample,
270 struct machine *machine)
274 err = perf_event__process_exit(tool, event, sample, machine);
275 perf_event__repipe(tool, event, sample, machine);
280 static int perf_event__repipe_tracing_data(struct perf_tool *tool,
281 union perf_event *event,
282 struct perf_session *session)
286 perf_event__repipe_synth(tool, event);
287 err = perf_event__process_tracing_data(tool, event, session);
292 static int perf_event__repipe_id_index(struct perf_tool *tool,
293 union perf_event *event,
294 struct perf_session *session)
298 perf_event__repipe_synth(tool, event);
299 err = perf_event__process_id_index(tool, event, session);
304 static int dso__read_build_id(struct dso *dso)
306 if (dso->has_build_id)
309 if (filename__read_build_id(dso->long_name, dso->build_id,
310 sizeof(dso->build_id)) > 0) {
311 dso->has_build_id = true;
318 static int dso__inject_build_id(struct dso *dso, struct perf_tool *tool,
319 struct machine *machine)
321 u16 misc = PERF_RECORD_MISC_USER;
324 if (dso__read_build_id(dso) < 0) {
325 pr_debug("no build_id found for %s\n", dso->long_name);
330 misc = PERF_RECORD_MISC_KERNEL;
332 err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe,
335 pr_err("Can't synthesize build_id event for %s\n", dso->long_name);
342 static int perf_event__inject_buildid(struct perf_tool *tool,
343 union perf_event *event,
344 struct perf_sample *sample,
345 struct perf_evsel *evsel __maybe_unused,
346 struct machine *machine)
348 struct addr_location al;
349 struct thread *thread;
352 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
354 thread = machine__findnew_thread(machine, sample->pid, sample->tid);
355 if (thread == NULL) {
356 pr_err("problem processing %d event, skipping it.\n",
361 thread__find_addr_map(thread, cpumode, MAP__FUNCTION, sample->ip, &al);
363 if (al.map != NULL) {
364 if (!al.map->dso->hit) {
365 al.map->dso->hit = 1;
366 if (map__load(al.map, NULL) >= 0) {
367 dso__inject_build_id(al.map->dso, tool, machine);
369 * If this fails, too bad, let the other side
370 * account this as unresolved.
373 #ifdef HAVE_LIBELF_SUPPORT
374 pr_warning("no symbols found in %s, maybe "
375 "install a debug package?\n",
376 al.map->dso->long_name);
384 perf_event__repipe(tool, event, sample, machine);
388 static int perf_inject__sched_process_exit(struct perf_tool *tool,
389 union perf_event *event __maybe_unused,
390 struct perf_sample *sample,
391 struct perf_evsel *evsel __maybe_unused,
392 struct machine *machine __maybe_unused)
394 struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
395 struct event_entry *ent;
397 list_for_each_entry(ent, &inject->samples, node) {
398 if (sample->tid == ent->tid) {
399 list_del_init(&ent->node);
408 static int perf_inject__sched_switch(struct perf_tool *tool,
409 union perf_event *event,
410 struct perf_sample *sample,
411 struct perf_evsel *evsel,
412 struct machine *machine)
414 struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
415 struct event_entry *ent;
417 perf_inject__sched_process_exit(tool, event, sample, evsel, machine);
419 ent = malloc(event->header.size + sizeof(struct event_entry));
421 color_fprintf(stderr, PERF_COLOR_RED,
422 "Not enough memory to process sched switch event!");
426 ent->tid = sample->tid;
427 memcpy(&ent->event, event, event->header.size);
428 list_add(&ent->node, &inject->samples);
432 static int perf_inject__sched_stat(struct perf_tool *tool,
433 union perf_event *event __maybe_unused,
434 struct perf_sample *sample,
435 struct perf_evsel *evsel,
436 struct machine *machine)
438 struct event_entry *ent;
439 union perf_event *event_sw;
440 struct perf_sample sample_sw;
441 struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
442 u32 pid = perf_evsel__intval(evsel, sample, "pid");
444 list_for_each_entry(ent, &inject->samples, node) {
451 event_sw = &ent->event[0];
452 perf_evsel__parse_sample(evsel, event_sw, &sample_sw);
454 sample_sw.period = sample->period;
455 sample_sw.time = sample->time;
456 perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
457 evsel->attr.read_format, &sample_sw,
459 build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
460 return perf_event__repipe(tool, event_sw, &sample_sw, machine);
463 static void sig_handler(int sig __maybe_unused)
468 static int perf_evsel__check_stype(struct perf_evsel *evsel,
469 u64 sample_type, const char *sample_msg)
471 struct perf_event_attr *attr = &evsel->attr;
472 const char *name = perf_evsel__name(evsel);
474 if (!(attr->sample_type & sample_type)) {
475 pr_err("Samples for %s event do not have %s attribute set.",
483 static int __cmd_inject(struct perf_inject *inject)
486 struct perf_session *session = inject->session;
487 struct perf_data_file *file_out = &inject->output;
488 int fd = perf_data_file__fd(file_out);
489 u64 output_data_offset;
491 signal(SIGINT, sig_handler);
493 if (inject->build_ids || inject->sched_stat ||
494 inject->itrace_synth_opts.set) {
495 inject->tool.mmap = perf_event__repipe_mmap;
496 inject->tool.mmap2 = perf_event__repipe_mmap2;
497 inject->tool.fork = perf_event__repipe_fork;
498 inject->tool.tracing_data = perf_event__repipe_tracing_data;
501 output_data_offset = session->header.data_offset;
503 if (inject->build_ids) {
504 inject->tool.sample = perf_event__inject_buildid;
505 } else if (inject->sched_stat) {
506 struct perf_evsel *evsel;
508 evlist__for_each(session->evlist, evsel) {
509 const char *name = perf_evsel__name(evsel);
511 if (!strcmp(name, "sched:sched_switch")) {
512 if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID"))
515 evsel->handler = perf_inject__sched_switch;
516 } else if (!strcmp(name, "sched:sched_process_exit"))
517 evsel->handler = perf_inject__sched_process_exit;
518 else if (!strncmp(name, "sched:sched_stat_", 17))
519 evsel->handler = perf_inject__sched_stat;
521 } else if (inject->itrace_synth_opts.set) {
522 session->itrace_synth_opts = &inject->itrace_synth_opts;
523 inject->itrace_synth_opts.inject = true;
524 inject->tool.comm = perf_event__repipe_comm;
525 inject->tool.exit = perf_event__repipe_exit;
526 inject->tool.id_index = perf_event__repipe_id_index;
527 inject->tool.auxtrace_info = perf_event__process_auxtrace_info;
528 inject->tool.auxtrace = perf_event__process_auxtrace;
529 inject->tool.aux = perf_event__drop_aux;
530 inject->tool.itrace_start = perf_event__drop_aux,
531 inject->tool.ordered_events = true;
532 inject->tool.ordering_requires_timestamps = true;
533 /* Allow space in the header for new attributes */
534 output_data_offset = 4096;
537 if (!inject->itrace_synth_opts.set)
538 auxtrace_index__free(&session->auxtrace_index);
540 if (!file_out->is_pipe)
541 lseek(fd, output_data_offset, SEEK_SET);
543 ret = perf_session__process_events(session);
545 if (!file_out->is_pipe) {
546 if (inject->build_ids) {
547 perf_header__set_feat(&session->header,
549 if (inject->have_auxtrace)
550 dsos__hit_all(session);
553 * The AUX areas have been removed and replaced with
554 * synthesized hardware events, so clear the feature flag and
557 if (inject->itrace_synth_opts.set) {
558 struct perf_evsel *evsel;
560 perf_header__clear_feat(&session->header,
562 if (inject->itrace_synth_opts.last_branch)
563 perf_header__set_feat(&session->header,
564 HEADER_BRANCH_STACK);
565 evsel = perf_evlist__id2evsel_strict(session->evlist,
568 pr_debug("Deleting %s\n",
569 perf_evsel__name(evsel));
570 perf_evlist__remove(session->evlist, evsel);
571 perf_evsel__delete(evsel);
574 session->header.data_offset = output_data_offset;
575 session->header.data_size = inject->bytes_written;
576 perf_session__write_header(session, session->evlist, fd, true);
582 int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
584 struct perf_inject inject = {
586 .sample = perf_event__repipe_sample,
587 .mmap = perf_event__repipe,
588 .mmap2 = perf_event__repipe,
589 .comm = perf_event__repipe,
590 .fork = perf_event__repipe,
591 .exit = perf_event__repipe,
592 .lost = perf_event__repipe,
593 .aux = perf_event__repipe,
594 .itrace_start = perf_event__repipe,
595 .context_switch = perf_event__repipe,
596 .read = perf_event__repipe_sample,
597 .throttle = perf_event__repipe,
598 .unthrottle = perf_event__repipe,
599 .attr = perf_event__repipe_attr,
600 .tracing_data = perf_event__repipe_op2_synth,
601 .auxtrace_info = perf_event__repipe_op2_synth,
602 .auxtrace = perf_event__repipe_auxtrace,
603 .auxtrace_error = perf_event__repipe_op2_synth,
604 .finished_round = perf_event__repipe_oe_synth,
605 .build_id = perf_event__repipe_op2_synth,
606 .id_index = perf_event__repipe_op2_synth,
609 .samples = LIST_HEAD_INIT(inject.samples),
612 .mode = PERF_DATA_MODE_WRITE,
615 struct perf_data_file file = {
616 .mode = PERF_DATA_MODE_READ,
620 const struct option options[] = {
621 OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
622 "Inject build-ids into the output stream"),
623 OPT_STRING('i', "input", &inject.input_name, "file",
625 OPT_STRING('o', "output", &inject.output.path, "file",
627 OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
628 "Merge sched-stat and sched-switch for getting events "
629 "where and how long tasks slept"),
630 OPT_INCR('v', "verbose", &verbose,
631 "be more verbose (show build ids, etc)"),
632 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file",
633 "kallsyms pathname"),
634 OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
635 OPT_CALLBACK_OPTARG(0, "itrace", &inject.itrace_synth_opts,
636 NULL, "opts", "Instruction Tracing options",
637 itrace_parse_synth_opts),
640 const char * const inject_usage[] = {
641 "perf inject [<options>]",
645 argc = parse_options(argc, argv, options, inject_usage, 0);
648 * Any (unrecognized) arguments left?
651 usage_with_options(inject_usage, options);
653 if (perf_data_file__open(&inject.output)) {
654 perror("failed to create output file");
658 inject.tool.ordered_events = inject.sched_stat;
660 file.path = inject.input_name;
661 inject.session = perf_session__new(&file, true, &inject.tool);
662 if (inject.session == NULL)
665 ret = symbol__init(&inject.session->header.env);
669 ret = __cmd_inject(&inject);
672 perf_session__delete(inject.session);