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/debug.h"
13
14#include "util/parse-options.h"
15
16static char const *input_name = "-";
17static bool inject_build_ids;
18
19static int perf_event__repipe_synth(union perf_event *event,
20 struct perf_session *session __used)
21{
22 uint32_t size;
23 void *buf = event;
24
25 size = event->header.size;
26
27 while (size) {
28 int ret = write(STDOUT_FILENO, buf, size);
29 if (ret < 0)
30 return -errno;
31
32 size -= ret;
33 buf += ret;
34 }
35
36 return 0;
37}
38
39static int perf_event__repipe(union perf_event *event,
40 struct perf_sample *sample __used,
41 struct perf_session *session)
42{
43 return perf_event__repipe_synth(event, session);
44}
45
46static int perf_event__repipe_sample(union perf_event *event,
47 struct perf_sample *sample __used,
48 struct perf_evsel *evsel __used,
49 struct perf_session *session)
50{
51 return perf_event__repipe_synth(event, session);
52}
53
54static int perf_event__repipe_mmap(union perf_event *event,
55 struct perf_sample *sample,
56 struct perf_session *session)
57{
58 int err;
59
60 err = perf_event__process_mmap(event, sample, session);
61 perf_event__repipe(event, sample, session);
62
63 return err;
64}
65
66static int perf_event__repipe_task(union perf_event *event,
67 struct perf_sample *sample,
68 struct perf_session *session)
69{
70 int err;
71
72 err = perf_event__process_task(event, sample, session);
73 perf_event__repipe(event, sample, session);
74
75 return err;
76}
77
78static int perf_event__repipe_tracing_data(union perf_event *event,
79 struct perf_session *session)
80{
81 int err;
82
83 perf_event__repipe_synth(event, session);
84 err = perf_event__process_tracing_data(event, session);
85
86 return err;
87}
88
89static int dso__read_build_id(struct dso *self)
90{
91 if (self->has_build_id)
92 return 0;
93
94 if (filename__read_build_id(self->long_name, self->build_id,
95 sizeof(self->build_id)) > 0) {
96 self->has_build_id = true;
97 return 0;
98 }
99
100 return -1;
101}
102
103static int dso__inject_build_id(struct dso *self, struct perf_session *session)
104{
105 u16 misc = PERF_RECORD_MISC_USER;
106 struct machine *machine;
107 int err;
108
109 if (dso__read_build_id(self) < 0) {
110 pr_debug("no build_id found for %s\n", self->long_name);
111 return -1;
112 }
113
114 machine = perf_session__find_host_machine(session);
115 if (machine == NULL) {
116 pr_err("Can't find machine for session\n");
117 return -1;
118 }
119
120 if (self->kernel)
121 misc = PERF_RECORD_MISC_KERNEL;
122
123 err = perf_event__synthesize_build_id(self, misc, perf_event__repipe,
124 machine, session);
125 if (err) {
126 pr_err("Can't synthesize build_id event for %s\n", self->long_name);
127 return -1;
128 }
129
130 return 0;
131}
132
133static int perf_event__inject_buildid(union perf_event *event,
134 struct perf_sample *sample,
135 struct perf_evsel *evsel __used,
136 struct perf_session *session)
137{
138 struct addr_location al;
139 struct thread *thread;
140 u8 cpumode;
141
142 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
143
144 thread = perf_session__findnew(session, event->ip.pid);
145 if (thread == NULL) {
146 pr_err("problem processing %d event, skipping it.\n",
147 event->header.type);
148 goto repipe;
149 }
150
151 thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
152 event->ip.pid, event->ip.ip, &al);
153
154 if (al.map != NULL) {
155 if (!al.map->dso->hit) {
156 al.map->dso->hit = 1;
157 if (map__load(al.map, NULL) >= 0) {
158 dso__inject_build_id(al.map->dso, session);
159 /*
160 * If this fails, too bad, let the other side
161 * account this as unresolved.
162 */
163 } else
164 pr_warning("no symbols found in %s, maybe "
165 "install a debug package?\n",
166 al.map->dso->long_name);
167 }
168 }
169
170repipe:
171 perf_event__repipe(event, sample, session);
172 return 0;
173}
174
175struct perf_event_ops inject_ops = {
176 .sample = perf_event__repipe_sample,
177 .mmap = perf_event__repipe,
178 .comm = perf_event__repipe,
179 .fork = perf_event__repipe,
180 .exit = perf_event__repipe,
181 .lost = perf_event__repipe,
182 .read = perf_event__repipe,
183 .throttle = perf_event__repipe,
184 .unthrottle = perf_event__repipe,
185 .attr = perf_event__repipe_synth,
186 .event_type = perf_event__repipe_synth,
187 .tracing_data = perf_event__repipe_synth,
188 .build_id = perf_event__repipe_synth,
189};
190
191extern volatile int session_done;
192
193static void sig_handler(int sig __attribute__((__unused__)))
194{
195 session_done = 1;
196}
197
198static int __cmd_inject(void)
199{
200 struct perf_session *session;
201 int ret = -EINVAL;
202
203 signal(SIGINT, sig_handler);
204
205 if (inject_build_ids) {
206 inject_ops.sample = perf_event__inject_buildid;
207 inject_ops.mmap = perf_event__repipe_mmap;
208 inject_ops.fork = perf_event__repipe_task;
209 inject_ops.tracing_data = perf_event__repipe_tracing_data;
210 }
211
212 session = perf_session__new(input_name, O_RDONLY, false, true, &inject_ops);
213 if (session == NULL)
214 return -ENOMEM;
215
216 ret = perf_session__process_events(session, &inject_ops);
217
218 perf_session__delete(session);
219
220 return ret;
221}
222
223static const char * const report_usage[] = {
224 "perf inject [<options>]",
225 NULL
226};
227
228static const struct option options[] = {
229 OPT_BOOLEAN('b', "build-ids", &inject_build_ids,
230 "Inject build-ids into the output stream"),
231 OPT_INCR('v', "verbose", &verbose,
232 "be more verbose (show build ids, etc)"),
233 OPT_END()
234};
235
236int cmd_inject(int argc, const char **argv, const char *prefix __used)
237{
238 argc = parse_options(argc, argv, options, report_usage, 0);
239
240 /*
241 * Any (unrecognized) arguments left?
242 */
243 if (argc)
244 usage_with_options(report_usage, options);
245
246 if (symbol__init() < 0)
247 return -1;
248
249 return __cmd_inject();
250}