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"
20 #include "util/parse-options.h"
22 #include <linux/list.h>
25 struct perf_tool tool
;
26 struct perf_session
*session
;
29 const char *input_name
;
30 struct perf_data_file output
;
32 struct list_head samples
;
36 struct list_head node
;
38 union perf_event event
[0];
41 static int perf_event__repipe_synth(struct perf_tool
*tool
,
42 union perf_event
*event
)
44 struct perf_inject
*inject
= container_of(tool
, struct perf_inject
, tool
);
47 size
= perf_data_file__write(&inject
->output
, event
,
52 inject
->bytes_written
+= size
;
56 static int perf_event__repipe_op2_synth(struct perf_tool
*tool
,
57 union perf_event
*event
,
58 struct perf_session
*session
61 return perf_event__repipe_synth(tool
, event
);
64 static int perf_event__repipe_attr(struct perf_tool
*tool
,
65 union perf_event
*event
,
66 struct perf_evlist
**pevlist
)
68 struct perf_inject
*inject
= container_of(tool
, struct perf_inject
,
72 ret
= perf_event__process_attr(tool
, event
, pevlist
);
76 if (!inject
->output
.is_pipe
)
79 return perf_event__repipe_synth(tool
, event
);
82 static int perf_event__repipe(struct perf_tool
*tool
,
83 union perf_event
*event
,
84 struct perf_sample
*sample __maybe_unused
,
85 struct machine
*machine __maybe_unused
)
87 return perf_event__repipe_synth(tool
, event
);
90 typedef int (*inject_handler
)(struct perf_tool
*tool
,
91 union perf_event
*event
,
92 struct perf_sample
*sample
,
93 struct perf_evsel
*evsel
,
94 struct machine
*machine
);
96 static int perf_event__repipe_sample(struct perf_tool
*tool
,
97 union perf_event
*event
,
98 struct perf_sample
*sample
,
99 struct perf_evsel
*evsel
,
100 struct machine
*machine
)
102 if (evsel
->handler
) {
103 inject_handler f
= evsel
->handler
;
104 return f(tool
, event
, sample
, evsel
, machine
);
107 build_id__mark_dso_hit(tool
, event
, sample
, evsel
, machine
);
109 return perf_event__repipe_synth(tool
, event
);
112 static int perf_event__repipe_mmap(struct perf_tool
*tool
,
113 union perf_event
*event
,
114 struct perf_sample
*sample
,
115 struct machine
*machine
)
119 err
= perf_event__process_mmap(tool
, event
, sample
, machine
);
120 perf_event__repipe(tool
, event
, sample
, machine
);
125 static int perf_event__repipe_mmap2(struct perf_tool
*tool
,
126 union perf_event
*event
,
127 struct perf_sample
*sample
,
128 struct machine
*machine
)
132 err
= perf_event__process_mmap2(tool
, event
, sample
, machine
);
133 perf_event__repipe(tool
, event
, sample
, machine
);
138 static int perf_event__repipe_fork(struct perf_tool
*tool
,
139 union perf_event
*event
,
140 struct perf_sample
*sample
,
141 struct machine
*machine
)
145 err
= perf_event__process_fork(tool
, event
, sample
, machine
);
146 perf_event__repipe(tool
, event
, sample
, machine
);
151 static int perf_event__repipe_tracing_data(struct perf_tool
*tool
,
152 union perf_event
*event
,
153 struct perf_session
*session
)
157 perf_event__repipe_synth(tool
, event
);
158 err
= perf_event__process_tracing_data(tool
, event
, session
);
163 static int dso__read_build_id(struct dso
*dso
)
165 if (dso
->has_build_id
)
168 if (filename__read_build_id(dso
->long_name
, dso
->build_id
,
169 sizeof(dso
->build_id
)) > 0) {
170 dso
->has_build_id
= true;
177 static int dso__inject_build_id(struct dso
*dso
, struct perf_tool
*tool
,
178 struct machine
*machine
)
180 u16 misc
= PERF_RECORD_MISC_USER
;
183 if (dso__read_build_id(dso
) < 0) {
184 pr_debug("no build_id found for %s\n", dso
->long_name
);
189 misc
= PERF_RECORD_MISC_KERNEL
;
191 err
= perf_event__synthesize_build_id(tool
, dso
, misc
, perf_event__repipe
,
194 pr_err("Can't synthesize build_id event for %s\n", dso
->long_name
);
201 static int perf_event__inject_buildid(struct perf_tool
*tool
,
202 union perf_event
*event
,
203 struct perf_sample
*sample
,
204 struct perf_evsel
*evsel __maybe_unused
,
205 struct machine
*machine
)
207 struct addr_location al
;
208 struct thread
*thread
;
211 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
213 thread
= machine__findnew_thread(machine
, sample
->pid
, sample
->tid
);
214 if (thread
== NULL
) {
215 pr_err("problem processing %d event, skipping it.\n",
220 thread__find_addr_map(thread
, machine
, cpumode
, MAP__FUNCTION
,
223 if (al
.map
!= NULL
) {
224 if (!al
.map
->dso
->hit
) {
225 al
.map
->dso
->hit
= 1;
226 if (map__load(al
.map
, NULL
) >= 0) {
227 dso__inject_build_id(al
.map
->dso
, tool
, machine
);
229 * If this fails, too bad, let the other side
230 * account this as unresolved.
233 #ifdef HAVE_LIBELF_SUPPORT
234 pr_warning("no symbols found in %s, maybe "
235 "install a debug package?\n",
236 al
.map
->dso
->long_name
);
243 perf_event__repipe(tool
, event
, sample
, machine
);
247 static int perf_inject__sched_process_exit(struct perf_tool
*tool
,
248 union perf_event
*event __maybe_unused
,
249 struct perf_sample
*sample
,
250 struct perf_evsel
*evsel __maybe_unused
,
251 struct machine
*machine __maybe_unused
)
253 struct perf_inject
*inject
= container_of(tool
, struct perf_inject
, tool
);
254 struct event_entry
*ent
;
256 list_for_each_entry(ent
, &inject
->samples
, node
) {
257 if (sample
->tid
== ent
->tid
) {
258 list_del_init(&ent
->node
);
267 static int perf_inject__sched_switch(struct perf_tool
*tool
,
268 union perf_event
*event
,
269 struct perf_sample
*sample
,
270 struct perf_evsel
*evsel
,
271 struct machine
*machine
)
273 struct perf_inject
*inject
= container_of(tool
, struct perf_inject
, tool
);
274 struct event_entry
*ent
;
276 perf_inject__sched_process_exit(tool
, event
, sample
, evsel
, machine
);
278 ent
= malloc(event
->header
.size
+ sizeof(struct event_entry
));
280 color_fprintf(stderr
, PERF_COLOR_RED
,
281 "Not enough memory to process sched switch event!");
285 ent
->tid
= sample
->tid
;
286 memcpy(&ent
->event
, event
, event
->header
.size
);
287 list_add(&ent
->node
, &inject
->samples
);
291 static int perf_inject__sched_stat(struct perf_tool
*tool
,
292 union perf_event
*event __maybe_unused
,
293 struct perf_sample
*sample
,
294 struct perf_evsel
*evsel
,
295 struct machine
*machine
)
297 struct event_entry
*ent
;
298 union perf_event
*event_sw
;
299 struct perf_sample sample_sw
;
300 struct perf_inject
*inject
= container_of(tool
, struct perf_inject
, tool
);
301 u32 pid
= perf_evsel__intval(evsel
, sample
, "pid");
303 list_for_each_entry(ent
, &inject
->samples
, node
) {
310 event_sw
= &ent
->event
[0];
311 perf_evsel__parse_sample(evsel
, event_sw
, &sample_sw
);
313 sample_sw
.period
= sample
->period
;
314 sample_sw
.time
= sample
->time
;
315 perf_event__synthesize_sample(event_sw
, evsel
->attr
.sample_type
,
316 evsel
->attr
.read_format
, &sample_sw
,
318 build_id__mark_dso_hit(tool
, event_sw
, &sample_sw
, evsel
, machine
);
319 return perf_event__repipe(tool
, event_sw
, &sample_sw
, machine
);
322 static void sig_handler(int sig __maybe_unused
)
327 static int perf_evsel__check_stype(struct perf_evsel
*evsel
,
328 u64 sample_type
, const char *sample_msg
)
330 struct perf_event_attr
*attr
= &evsel
->attr
;
331 const char *name
= perf_evsel__name(evsel
);
333 if (!(attr
->sample_type
& sample_type
)) {
334 pr_err("Samples for %s event do not have %s attribute set.",
342 static int __cmd_inject(struct perf_inject
*inject
)
345 struct perf_session
*session
= inject
->session
;
346 struct perf_data_file
*file_out
= &inject
->output
;
348 signal(SIGINT
, sig_handler
);
350 if (inject
->build_ids
|| inject
->sched_stat
) {
351 inject
->tool
.mmap
= perf_event__repipe_mmap
;
352 inject
->tool
.mmap2
= perf_event__repipe_mmap2
;
353 inject
->tool
.fork
= perf_event__repipe_fork
;
354 inject
->tool
.tracing_data
= perf_event__repipe_tracing_data
;
357 if (inject
->build_ids
) {
358 inject
->tool
.sample
= perf_event__inject_buildid
;
359 } else if (inject
->sched_stat
) {
360 struct perf_evsel
*evsel
;
362 inject
->tool
.ordered_events
= true;
364 evlist__for_each(session
->evlist
, evsel
) {
365 const char *name
= perf_evsel__name(evsel
);
367 if (!strcmp(name
, "sched:sched_switch")) {
368 if (perf_evsel__check_stype(evsel
, PERF_SAMPLE_TID
, "TID"))
371 evsel
->handler
= perf_inject__sched_switch
;
372 } else if (!strcmp(name
, "sched:sched_process_exit"))
373 evsel
->handler
= perf_inject__sched_process_exit
;
374 else if (!strncmp(name
, "sched:sched_stat_", 17))
375 evsel
->handler
= perf_inject__sched_stat
;
379 if (!file_out
->is_pipe
)
380 lseek(file_out
->fd
, session
->header
.data_offset
, SEEK_SET
);
382 ret
= perf_session__process_events(session
, &inject
->tool
);
384 if (!file_out
->is_pipe
) {
385 if (inject
->build_ids
)
386 perf_header__set_feat(&session
->header
,
388 session
->header
.data_size
= inject
->bytes_written
;
389 perf_session__write_header(session
, session
->evlist
, file_out
->fd
, true);
395 int cmd_inject(int argc
, const char **argv
, const char *prefix __maybe_unused
)
397 struct perf_inject inject
= {
399 .sample
= perf_event__repipe_sample
,
400 .mmap
= perf_event__repipe
,
401 .mmap2
= perf_event__repipe
,
402 .comm
= perf_event__repipe
,
403 .fork
= perf_event__repipe
,
404 .exit
= perf_event__repipe
,
405 .lost
= perf_event__repipe
,
406 .read
= perf_event__repipe_sample
,
407 .throttle
= perf_event__repipe
,
408 .unthrottle
= perf_event__repipe
,
409 .attr
= perf_event__repipe_attr
,
410 .tracing_data
= perf_event__repipe_op2_synth
,
411 .finished_round
= perf_event__repipe_op2_synth
,
412 .build_id
= perf_event__repipe_op2_synth
,
415 .samples
= LIST_HEAD_INIT(inject
.samples
),
418 .mode
= PERF_DATA_MODE_WRITE
,
421 struct perf_data_file file
= {
422 .mode
= PERF_DATA_MODE_READ
,
426 const struct option options
[] = {
427 OPT_BOOLEAN('b', "build-ids", &inject
.build_ids
,
428 "Inject build-ids into the output stream"),
429 OPT_STRING('i', "input", &inject
.input_name
, "file",
431 OPT_STRING('o', "output", &inject
.output
.path
, "file",
433 OPT_BOOLEAN('s', "sched-stat", &inject
.sched_stat
,
434 "Merge sched-stat and sched-switch for getting events "
435 "where and how long tasks slept"),
436 OPT_INCR('v', "verbose", &verbose
,
437 "be more verbose (show build ids, etc)"),
438 OPT_STRING(0, "kallsyms", &symbol_conf
.kallsyms_name
, "file",
439 "kallsyms pathname"),
442 const char * const inject_usage
[] = {
443 "perf inject [<options>]",
447 argc
= parse_options(argc
, argv
, options
, inject_usage
, 0);
450 * Any (unrecognized) arguments left?
453 usage_with_options(inject_usage
, options
);
455 if (perf_data_file__open(&inject
.output
)) {
456 perror("failed to create output file");
460 file
.path
= inject
.input_name
;
461 inject
.session
= perf_session__new(&file
, true, &inject
.tool
);
462 if (inject
.session
== NULL
)
465 if (symbol__init(&inject
.session
->header
.env
) < 0)
468 ret
= __cmd_inject(&inject
);
470 perf_session__delete(inject
.session
);