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