Root/tools/perf/builtin-inject.c

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}
251

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive