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