blob: a2c97ff1aa6a53271ffb8fda301561f7ab434bae [file] [log] [blame]
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02001#include <linux/kernel.h>
Robert Richter4e319022013-06-11 17:29:18 +02002#include <traceevent/event-parse.h>
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02003
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02004#include <byteswap.h>
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02005#include <unistd.h>
6#include <sys/types.h>
Arnaldo Carvalho de Meloa41794c2010-05-18 18:29:23 -03007#include <sys/mman.h>
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02008
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -03009#include "evlist.h"
10#include "evsel.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020011#include "session.h"
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020012#include "tool.h"
Arnaldo Carvalho de Meloa3286262009-12-14 14:22:59 -020013#include "sort.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020014#include "util.h"
Anton Blanchard5d67be92011-07-04 21:57:50 +100015#include "cpumap.h"
Jiri Olsa0f6a3012012-08-07 15:20:45 +020016#include "perf_regs.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020017
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030018static int perf_session__open(struct perf_session *session)
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020019{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030020 struct perf_data_file *file = session->file;
Tom Zanussi8dc58102010-04-01 23:59:15 -050021
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030022 if (perf_session__read_header(session) < 0) {
Stephane Eranian69996df2012-02-09 23:21:06 +010023 pr_err("incompatible file format (rerun with -v to learn more)");
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020024 return -1;
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020025 }
26
Jiri Olsacc9784bd2013-10-15 16:27:34 +020027 if (perf_data_file__is_pipe(file))
28 return 0;
29
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030030 if (!perf_evlist__valid_sample_type(session->evlist)) {
Arnaldo Carvalho de Meloc2a70652011-06-02 11:04:54 -030031 pr_err("non matching sample_type");
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020032 return -1;
Arnaldo Carvalho de Meloc2a70652011-06-02 11:04:54 -030033 }
34
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030035 if (!perf_evlist__valid_sample_id_all(session->evlist)) {
Arnaldo Carvalho de Meloc2a70652011-06-02 11:04:54 -030036 pr_err("non matching sample_id_all");
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020037 return -1;
Arnaldo Carvalho de Meloc2a70652011-06-02 11:04:54 -030038 }
39
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030040 if (!perf_evlist__valid_read_format(session->evlist)) {
Jiri Olsa9ede4732012-10-10 17:38:13 +020041 pr_err("non matching read_format");
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020042 return -1;
Jiri Olsa9ede4732012-10-10 17:38:13 +020043 }
44
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020045 return 0;
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020046}
47
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -030048void perf_session__set_id_hdr_size(struct perf_session *session)
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -020049{
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -030050 u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);
51
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -030052 machines__set_id_hdr_size(&session->machines, id_hdr_size);
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -020053}
54
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030055int perf_session__create_kernel_maps(struct perf_session *session)
Zhang, Yanmina1645ce2010-04-19 13:32:50 +080056{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030057 int ret = machine__create_kernel_maps(&session->machines.host);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +080058
Zhang, Yanmina1645ce2010-04-19 13:32:50 +080059 if (ret >= 0)
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030060 ret = machines__create_guest_kernel_maps(&session->machines);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +080061 return ret;
62}
63
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030064static void perf_session__destroy_kernel_maps(struct perf_session *session)
Arnaldo Carvalho de Melo076c6e452010-08-02 18:18:28 -030065{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030066 machines__destroy_kernel_maps(&session->machines);
Arnaldo Carvalho de Melo076c6e452010-08-02 18:18:28 -030067}
68
Jiri Olsaf5fc14122013-10-15 16:27:32 +020069struct perf_session *perf_session__new(struct perf_data_file *file,
70 bool repipe, struct perf_tool *tool)
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020071{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030072 struct perf_session *session = zalloc(sizeof(*session));
Robert Richterefad1412011-12-07 10:02:54 +010073
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030074 if (!session)
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020075 goto out;
76
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030077 session->repipe = repipe;
78 INIT_LIST_HEAD(&session->ordered_samples.samples);
79 INIT_LIST_HEAD(&session->ordered_samples.sample_cache);
80 INIT_LIST_HEAD(&session->ordered_samples.to_free);
81 machines__init(&session->machines);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020082
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020083 if (file) {
84 if (perf_data_file__open(file))
Arnaldo Carvalho de Melo64abebf72010-01-27 21:05:52 -020085 goto out_delete;
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020086
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030087 session->file = file;
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020088
89 if (perf_data_file__is_read(file)) {
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030090 if (perf_session__open(session) < 0)
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020091 goto out_close;
92
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -030093 perf_session__set_id_hdr_size(session);
Jiri Olsa6a4d98d2013-10-15 16:27:33 +020094 }
95 }
96
97 if (!file || perf_data_file__is_write(file)) {
Arnaldo Carvalho de Melo64abebf72010-01-27 21:05:52 -020098 /*
99 * In O_RDONLY mode this will be performed when reading the
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200100 * kernel MMAP event, in perf_event__process_mmap().
Arnaldo Carvalho de Melo64abebf72010-01-27 21:05:52 -0200101 */
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -0300102 if (perf_session__create_kernel_maps(session) < 0)
Arnaldo Carvalho de Melo64abebf72010-01-27 21:05:52 -0200103 goto out_delete;
104 }
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -0200105
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200106 if (tool && tool->ordering_requires_timestamps &&
Jiri Olsa0a8cb852014-07-06 14:18:21 +0200107 tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
Ian Munsie21ef97f2010-12-10 14:09:16 +1100108 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
Jiri Olsa0a8cb852014-07-06 14:18:21 +0200109 tool->ordered_events = false;
Ian Munsie21ef97f2010-12-10 14:09:16 +1100110 }
111
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -0300112 return session;
Jiri Olsa6a4d98d2013-10-15 16:27:33 +0200113
114 out_close:
115 perf_data_file__close(file);
116 out_delete:
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -0300117 perf_session__delete(session);
Jiri Olsa6a4d98d2013-10-15 16:27:33 +0200118 out:
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200119 return NULL;
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200120}
121
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200122static void perf_session__delete_dead_threads(struct perf_session *session)
123{
Arnaldo Carvalho de Melo876650e62012-12-18 19:15:48 -0300124 machine__delete_dead_threads(&session->machines.host);
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200125}
126
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200127static void perf_session__delete_threads(struct perf_session *session)
128{
Arnaldo Carvalho de Melo876650e62012-12-18 19:15:48 -0300129 machine__delete_threads(&session->machines.host);
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200130}
131
Namhyung Kim03cd2092012-11-21 13:43:19 +0900132static void perf_session_env__delete(struct perf_session_env *env)
133{
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -0300134 zfree(&env->hostname);
135 zfree(&env->os_release);
136 zfree(&env->version);
137 zfree(&env->arch);
138 zfree(&env->cpu_desc);
139 zfree(&env->cpuid);
Namhyung Kim03cd2092012-11-21 13:43:19 +0900140
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -0300141 zfree(&env->cmdline);
142 zfree(&env->sibling_cores);
143 zfree(&env->sibling_threads);
144 zfree(&env->numa_nodes);
145 zfree(&env->pmu_mappings);
Namhyung Kim03cd2092012-11-21 13:43:19 +0900146}
147
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -0300148void perf_session__delete(struct perf_session *session)
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200149{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -0300150 perf_session__destroy_kernel_maps(session);
151 perf_session__delete_dead_threads(session);
152 perf_session__delete_threads(session);
153 perf_session_env__delete(&session->header.env);
154 machines__exit(&session->machines);
155 if (session->file)
156 perf_data_file__close(session->file);
157 free(session);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200158}
Arnaldo Carvalho de Meloa3286262009-12-14 14:22:59 -0200159
Adrian Hunter47c3d102013-07-04 16:20:21 +0300160static int process_event_synth_tracing_data_stub(struct perf_tool *tool
161 __maybe_unused,
162 union perf_event *event
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300163 __maybe_unused,
164 struct perf_session *session
165 __maybe_unused)
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200166{
167 dump_printf(": unhandled!\n");
168 return 0;
169}
170
Adrian Hunter47c3d102013-07-04 16:20:21 +0300171static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
172 union perf_event *event __maybe_unused,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300173 struct perf_evlist **pevlist
174 __maybe_unused)
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -0200175{
176 dump_printf(": unhandled!\n");
177 return 0;
178}
179
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300180static int process_event_sample_stub(struct perf_tool *tool __maybe_unused,
181 union perf_event *event __maybe_unused,
182 struct perf_sample *sample __maybe_unused,
183 struct perf_evsel *evsel __maybe_unused,
184 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300185{
186 dump_printf(": unhandled!\n");
187 return 0;
188}
189
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300190static int process_event_stub(struct perf_tool *tool __maybe_unused,
191 union perf_event *event __maybe_unused,
192 struct perf_sample *sample __maybe_unused,
193 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200194{
195 dump_printf(": unhandled!\n");
196 return 0;
197}
198
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300199static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
200 union perf_event *event __maybe_unused,
201 struct perf_session *perf_session
202 __maybe_unused)
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200203{
204 dump_printf(": unhandled!\n");
205 return 0;
206}
207
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200208static int process_finished_round(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200209 union perf_event *event,
210 struct perf_session *session);
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200211
David Ahern9c501402013-08-02 14:05:41 -0600212void perf_tool__fill_defaults(struct perf_tool *tool)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200213{
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200214 if (tool->sample == NULL)
215 tool->sample = process_event_sample_stub;
216 if (tool->mmap == NULL)
217 tool->mmap = process_event_stub;
David Ahern6adb0b02013-09-22 19:44:59 -0600218 if (tool->mmap2 == NULL)
219 tool->mmap2 = process_event_stub;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200220 if (tool->comm == NULL)
221 tool->comm = process_event_stub;
222 if (tool->fork == NULL)
223 tool->fork = process_event_stub;
224 if (tool->exit == NULL)
225 tool->exit = process_event_stub;
226 if (tool->lost == NULL)
227 tool->lost = perf_event__process_lost;
228 if (tool->read == NULL)
229 tool->read = process_event_sample_stub;
230 if (tool->throttle == NULL)
231 tool->throttle = process_event_stub;
232 if (tool->unthrottle == NULL)
233 tool->unthrottle = process_event_stub;
234 if (tool->attr == NULL)
235 tool->attr = process_event_synth_attr_stub;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200236 if (tool->tracing_data == NULL)
237 tool->tracing_data = process_event_synth_tracing_data_stub;
238 if (tool->build_id == NULL)
239 tool->build_id = process_finished_round_stub;
240 if (tool->finished_round == NULL) {
Jiri Olsa0a8cb852014-07-06 14:18:21 +0200241 if (tool->ordered_events)
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200242 tool->finished_round = process_finished_round;
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200243 else
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200244 tool->finished_round = process_finished_round_stub;
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200245 }
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200246}
David Ahern80c01202012-06-08 11:47:51 -0300247
Jiri Olsa268fb202012-05-30 14:23:43 +0200248static void swap_sample_id_all(union perf_event *event, void *data)
249{
250 void *end = (void *) event + event->header.size;
251 int size = end - data;
252
253 BUG_ON(size % sizeof(u64));
254 mem_bswap_64(data, size);
255}
256
257static void perf_event__all64_swap(union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300258 bool sample_id_all __maybe_unused)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200259{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200260 struct perf_event_header *hdr = &event->header;
261 mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200262}
263
Jiri Olsa268fb202012-05-30 14:23:43 +0200264static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200265{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200266 event->comm.pid = bswap_32(event->comm.pid);
267 event->comm.tid = bswap_32(event->comm.tid);
Jiri Olsa268fb202012-05-30 14:23:43 +0200268
269 if (sample_id_all) {
270 void *data = &event->comm.comm;
271
Irina Tirdea9ac3e482012-09-11 01:15:01 +0300272 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
Jiri Olsa268fb202012-05-30 14:23:43 +0200273 swap_sample_id_all(event, data);
274 }
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200275}
276
Jiri Olsa268fb202012-05-30 14:23:43 +0200277static void perf_event__mmap_swap(union perf_event *event,
278 bool sample_id_all)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200279{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200280 event->mmap.pid = bswap_32(event->mmap.pid);
281 event->mmap.tid = bswap_32(event->mmap.tid);
282 event->mmap.start = bswap_64(event->mmap.start);
283 event->mmap.len = bswap_64(event->mmap.len);
284 event->mmap.pgoff = bswap_64(event->mmap.pgoff);
Jiri Olsa268fb202012-05-30 14:23:43 +0200285
286 if (sample_id_all) {
287 void *data = &event->mmap.filename;
288
Irina Tirdea9ac3e482012-09-11 01:15:01 +0300289 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
Jiri Olsa268fb202012-05-30 14:23:43 +0200290 swap_sample_id_all(event, data);
291 }
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200292}
293
Stephane Eranian5c5e8542013-08-21 12:10:25 +0200294static void perf_event__mmap2_swap(union perf_event *event,
295 bool sample_id_all)
296{
297 event->mmap2.pid = bswap_32(event->mmap2.pid);
298 event->mmap2.tid = bswap_32(event->mmap2.tid);
299 event->mmap2.start = bswap_64(event->mmap2.start);
300 event->mmap2.len = bswap_64(event->mmap2.len);
301 event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
302 event->mmap2.maj = bswap_32(event->mmap2.maj);
303 event->mmap2.min = bswap_32(event->mmap2.min);
304 event->mmap2.ino = bswap_64(event->mmap2.ino);
305
306 if (sample_id_all) {
307 void *data = &event->mmap2.filename;
308
309 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
310 swap_sample_id_all(event, data);
311 }
312}
Jiri Olsa268fb202012-05-30 14:23:43 +0200313static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200314{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200315 event->fork.pid = bswap_32(event->fork.pid);
316 event->fork.tid = bswap_32(event->fork.tid);
317 event->fork.ppid = bswap_32(event->fork.ppid);
318 event->fork.ptid = bswap_32(event->fork.ptid);
319 event->fork.time = bswap_64(event->fork.time);
Jiri Olsa268fb202012-05-30 14:23:43 +0200320
321 if (sample_id_all)
322 swap_sample_id_all(event, &event->fork + 1);
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200323}
324
Jiri Olsa268fb202012-05-30 14:23:43 +0200325static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200326{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200327 event->read.pid = bswap_32(event->read.pid);
328 event->read.tid = bswap_32(event->read.tid);
329 event->read.value = bswap_64(event->read.value);
330 event->read.time_enabled = bswap_64(event->read.time_enabled);
331 event->read.time_running = bswap_64(event->read.time_running);
332 event->read.id = bswap_64(event->read.id);
Jiri Olsa268fb202012-05-30 14:23:43 +0200333
334 if (sample_id_all)
335 swap_sample_id_all(event, &event->read + 1);
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200336}
337
Jiri Olsadd96c462013-09-01 12:36:15 +0200338static void perf_event__throttle_swap(union perf_event *event,
339 bool sample_id_all)
340{
341 event->throttle.time = bswap_64(event->throttle.time);
342 event->throttle.id = bswap_64(event->throttle.id);
343 event->throttle.stream_id = bswap_64(event->throttle.stream_id);
344
345 if (sample_id_all)
346 swap_sample_id_all(event, &event->throttle + 1);
347}
348
Jiri Olsae108c662012-05-16 08:59:03 +0200349static u8 revbyte(u8 b)
350{
351 int rev = (b >> 4) | ((b & 0xf) << 4);
352 rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2);
353 rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1);
354 return (u8) rev;
355}
356
357/*
358 * XXX this is hack in attempt to carry flags bitfield
359 * throught endian village. ABI says:
360 *
361 * Bit-fields are allocated from right to left (least to most significant)
362 * on little-endian implementations and from left to right (most to least
363 * significant) on big-endian implementations.
364 *
365 * The above seems to be byte specific, so we need to reverse each
366 * byte of the bitfield. 'Internet' also says this might be implementation
367 * specific and we probably need proper fix and carry perf_event_attr
368 * bitfield flags in separate data file FEAT_ section. Thought this seems
369 * to work for now.
370 */
371static void swap_bitfield(u8 *p, unsigned len)
372{
373 unsigned i;
374
375 for (i = 0; i < len; i++) {
376 *p = revbyte(*p);
377 p++;
378 }
379}
380
David Aherneda39132011-07-15 12:34:09 -0600381/* exported for swapping attributes in file header */
382void perf_event__attr_swap(struct perf_event_attr *attr)
383{
384 attr->type = bswap_32(attr->type);
385 attr->size = bswap_32(attr->size);
386 attr->config = bswap_64(attr->config);
387 attr->sample_period = bswap_64(attr->sample_period);
388 attr->sample_type = bswap_64(attr->sample_type);
389 attr->read_format = bswap_64(attr->read_format);
390 attr->wakeup_events = bswap_32(attr->wakeup_events);
391 attr->bp_type = bswap_32(attr->bp_type);
392 attr->bp_addr = bswap_64(attr->bp_addr);
393 attr->bp_len = bswap_64(attr->bp_len);
Adrian Hunter7db59522013-10-18 15:29:03 +0300394 attr->branch_sample_type = bswap_64(attr->branch_sample_type);
395 attr->sample_regs_user = bswap_64(attr->sample_regs_user);
396 attr->sample_stack_user = bswap_32(attr->sample_stack_user);
Jiri Olsae108c662012-05-16 08:59:03 +0200397
398 swap_bitfield((u8 *) (&attr->read_format + 1), sizeof(u64));
David Aherneda39132011-07-15 12:34:09 -0600399}
400
Jiri Olsa268fb202012-05-30 14:23:43 +0200401static void perf_event__hdr_attr_swap(union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300402 bool sample_id_all __maybe_unused)
Tom Zanussi2c46dbb2010-04-01 23:59:19 -0500403{
404 size_t size;
405
David Aherneda39132011-07-15 12:34:09 -0600406 perf_event__attr_swap(&event->attr.attr);
Tom Zanussi2c46dbb2010-04-01 23:59:19 -0500407
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200408 size = event->header.size;
409 size -= (void *)&event->attr.id - (void *)event;
410 mem_bswap_64(event->attr.id, size);
Tom Zanussi2c46dbb2010-04-01 23:59:19 -0500411}
412
Jiri Olsa268fb202012-05-30 14:23:43 +0200413static void perf_event__event_type_swap(union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300414 bool sample_id_all __maybe_unused)
Tom Zanussicd19a032010-04-01 23:59:20 -0500415{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200416 event->event_type.event_type.event_id =
417 bswap_64(event->event_type.event_type.event_id);
Tom Zanussicd19a032010-04-01 23:59:20 -0500418}
419
Jiri Olsa268fb202012-05-30 14:23:43 +0200420static void perf_event__tracing_data_swap(union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300421 bool sample_id_all __maybe_unused)
Tom Zanussi92155452010-04-01 23:59:21 -0500422{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200423 event->tracing_data.size = bswap_32(event->tracing_data.size);
Tom Zanussi92155452010-04-01 23:59:21 -0500424}
425
Jiri Olsa268fb202012-05-30 14:23:43 +0200426typedef void (*perf_event__swap_op)(union perf_event *event,
427 bool sample_id_all);
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200428
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200429static perf_event__swap_op perf_event__swap_ops[] = {
430 [PERF_RECORD_MMAP] = perf_event__mmap_swap,
Stephane Eranian5c5e8542013-08-21 12:10:25 +0200431 [PERF_RECORD_MMAP2] = perf_event__mmap2_swap,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200432 [PERF_RECORD_COMM] = perf_event__comm_swap,
433 [PERF_RECORD_FORK] = perf_event__task_swap,
434 [PERF_RECORD_EXIT] = perf_event__task_swap,
435 [PERF_RECORD_LOST] = perf_event__all64_swap,
436 [PERF_RECORD_READ] = perf_event__read_swap,
Jiri Olsadd96c462013-09-01 12:36:15 +0200437 [PERF_RECORD_THROTTLE] = perf_event__throttle_swap,
438 [PERF_RECORD_UNTHROTTLE] = perf_event__throttle_swap,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200439 [PERF_RECORD_SAMPLE] = perf_event__all64_swap,
David Aherneda39132011-07-15 12:34:09 -0600440 [PERF_RECORD_HEADER_ATTR] = perf_event__hdr_attr_swap,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200441 [PERF_RECORD_HEADER_EVENT_TYPE] = perf_event__event_type_swap,
442 [PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap,
443 [PERF_RECORD_HEADER_BUILD_ID] = NULL,
444 [PERF_RECORD_HEADER_MAX] = NULL,
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200445};
446
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200447struct sample_queue {
448 u64 timestamp;
Thomas Gleixnere4c2df12010-12-07 12:48:50 +0000449 u64 file_offset;
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200450 union perf_event *event;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200451 struct list_head list;
452};
453
Thomas Gleixner020bb752010-11-30 17:49:53 +0000454static void perf_session_free_sample_buffers(struct perf_session *session)
455{
456 struct ordered_samples *os = &session->ordered_samples;
457
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000458 while (!list_empty(&os->to_free)) {
Thomas Gleixner020bb752010-11-30 17:49:53 +0000459 struct sample_queue *sq;
460
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000461 sq = list_entry(os->to_free.next, struct sample_queue, list);
Thomas Gleixner020bb752010-11-30 17:49:53 +0000462 list_del(&sq->list);
463 free(sq);
464 }
465}
466
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100467static int perf_session_deliver_event(struct perf_session *session,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200468 union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200469 struct perf_sample *sample,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200470 struct perf_tool *tool,
Thomas Gleixnerf74725d2010-12-07 12:48:53 +0000471 u64 file_offset);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100472
David Ahernd25380cd2012-08-26 12:24:41 -0600473static int flush_sample_queue(struct perf_session *s,
David Ahern9c501402013-08-02 14:05:41 -0600474 struct perf_tool *tool)
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200475{
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000476 struct ordered_samples *os = &s->ordered_samples;
477 struct list_head *head = &os->samples;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200478 struct sample_queue *tmp, *iter;
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200479 struct perf_sample sample;
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000480 u64 limit = os->next_flush;
481 u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
Jiri Olsa526fd8d2013-09-05 11:14:50 +0200482 bool show_progress = limit == ULLONG_MAX;
Arnaldo Carvalho de Melo4d3001f2013-10-23 15:40:38 -0300483 struct ui_progress prog;
Frederic Weisbecker5538bec2011-05-22 02:17:22 +0200484 int ret;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200485
Jiri Olsa0a8cb852014-07-06 14:18:21 +0200486 if (!tool->ordered_events || !limit)
David Ahernd25380cd2012-08-26 12:24:41 -0600487 return 0;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200488
Arnaldo Carvalho de Melo4d3001f2013-10-23 15:40:38 -0300489 if (show_progress)
490 ui_progress__init(&prog, os->nr_samples, "Processing time ordered events...");
491
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200492 list_for_each_entry_safe(iter, tmp, head, list) {
Arnaldo Carvalho de Melo33e940a2013-09-17 16:34:28 -0300493 if (session_done())
494 return 0;
495
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200496 if (iter->timestamp > limit)
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000497 break;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200498
Arnaldo Carvalho de Melo0807d2d2012-09-26 12:48:18 -0300499 ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
Frederic Weisbecker5538bec2011-05-22 02:17:22 +0200500 if (ret)
501 pr_err("Can't parse sample, err = %d\n", ret);
David Ahernd25380cd2012-08-26 12:24:41 -0600502 else {
503 ret = perf_session_deliver_event(s, iter->event, &sample, tool,
504 iter->file_offset);
505 if (ret)
506 return ret;
507 }
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200508
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000509 os->last_flush = iter->timestamp;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200510 list_del(&iter->list);
Thomas Gleixner020bb752010-11-30 17:49:53 +0000511 list_add(&iter->list, &os->sample_cache);
Jiri Olsaf1dd14602014-07-20 23:55:45 +0200512 os->nr_samples--;
Arnaldo Carvalho de Melo4d3001f2013-10-23 15:40:38 -0300513
514 if (show_progress)
515 ui_progress__update(&prog, 1);
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200516 }
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000517
518 if (list_empty(head)) {
519 os->last_sample = NULL;
520 } else if (last_ts <= limit) {
521 os->last_sample =
522 list_entry(head->prev, struct sample_queue, list);
523 }
Arnaldo Carvalho de Melo88660562011-10-29 12:41:45 -0200524
David Ahernd25380cd2012-08-26 12:24:41 -0600525 return 0;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200526}
527
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200528/*
529 * When perf record finishes a pass on every buffers, it records this pseudo
530 * event.
531 * We record the max timestamp t found in the pass n.
532 * Assuming these timestamps are monotonic across cpus, we know that if
533 * a buffer still has events with timestamps below t, they will be all
534 * available and then read in the pass n + 1.
535 * Hence when we start to read the pass n + 2, we can safely flush every
536 * events with timestamps below t.
537 *
538 * ============ PASS n =================
539 * CPU 0 | CPU 1
540 * |
541 * cnt1 timestamps | cnt2 timestamps
542 * 1 | 2
543 * 2 | 3
544 * - | 4 <--- max recorded
545 *
546 * ============ PASS n + 1 ==============
547 * CPU 0 | CPU 1
548 * |
549 * cnt1 timestamps | cnt2 timestamps
550 * 3 | 5
551 * 4 | 6
552 * 5 | 7 <---- max recorded
553 *
554 * Flush every events below timestamp 4
555 *
556 * ============ PASS n + 2 ==============
557 * CPU 0 | CPU 1
558 * |
559 * cnt1 timestamps | cnt2 timestamps
560 * 6 | 8
561 * 7 | 9
562 * - | 10
563 *
564 * Flush every events below timestamp 7
565 * etc...
566 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200567static int process_finished_round(struct perf_tool *tool,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300568 union perf_event *event __maybe_unused,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200569 struct perf_session *session)
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200570{
David Ahernd25380cd2012-08-26 12:24:41 -0600571 int ret = flush_sample_queue(session, tool);
572 if (!ret)
573 session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200574
David Ahernd25380cd2012-08-26 12:24:41 -0600575 return ret;
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200576}
577
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200578/* The queue is ordered by time */
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100579static void __queue_event(struct sample_queue *new, struct perf_session *s)
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200580{
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000581 struct ordered_samples *os = &s->ordered_samples;
582 struct sample_queue *sample = os->last_sample;
583 u64 timestamp = new->timestamp;
584 struct list_head *p;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200585
Arnaldo Carvalho de Melo88660562011-10-29 12:41:45 -0200586 ++os->nr_samples;
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000587 os->last_sample = new;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200588
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000589 if (!sample) {
590 list_add(&new->list, &os->samples);
591 os->max_timestamp = timestamp;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200592 return;
593 }
594
595 /*
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000596 * last_sample might point to some random place in the list as it's
597 * the last queued event. We expect that the new event is close to
598 * this.
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200599 */
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000600 if (sample->timestamp <= timestamp) {
601 while (sample->timestamp <= timestamp) {
602 p = sample->list.next;
603 if (p == &os->samples) {
604 list_add_tail(&new->list, &os->samples);
605 os->max_timestamp = timestamp;
606 return;
607 }
608 sample = list_entry(p, struct sample_queue, list);
609 }
610 list_add_tail(&new->list, &sample->list);
611 } else {
612 while (sample->timestamp > timestamp) {
613 p = sample->list.prev;
614 if (p == &os->samples) {
615 list_add(&new->list, &os->samples);
616 return;
617 }
618 sample = list_entry(p, struct sample_queue, list);
619 }
620 list_add(&new->list, &sample->list);
621 }
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200622}
623
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000624#define MAX_SAMPLE_BUFFER (64 * 1024 / sizeof(struct sample_queue))
625
David Aherne30b88a2013-08-05 21:41:33 -0400626int perf_session_queue_event(struct perf_session *s, union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200627 struct perf_sample *sample, u64 file_offset)
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200628{
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000629 struct ordered_samples *os = &s->ordered_samples;
630 struct list_head *sc = &os->sample_cache;
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200631 u64 timestamp = sample->time;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200632 struct sample_queue *new;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200633
Thomas Gleixner79a14c12010-12-07 12:48:44 +0000634 if (!timestamp || timestamp == ~0ULL)
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100635 return -ETIME;
636
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200637 if (timestamp < s->ordered_samples.last_flush) {
638 printf("Warning: Timestamp below last timeslice flush\n");
639 return -EINVAL;
640 }
641
Thomas Gleixner020bb752010-11-30 17:49:53 +0000642 if (!list_empty(sc)) {
643 new = list_entry(sc->next, struct sample_queue, list);
644 list_del(&new->list);
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000645 } else if (os->sample_buffer) {
646 new = os->sample_buffer + os->sample_buffer_idx;
647 if (++os->sample_buffer_idx == MAX_SAMPLE_BUFFER)
648 os->sample_buffer = NULL;
Thomas Gleixner020bb752010-11-30 17:49:53 +0000649 } else {
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000650 os->sample_buffer = malloc(MAX_SAMPLE_BUFFER * sizeof(*new));
651 if (!os->sample_buffer)
Thomas Gleixner020bb752010-11-30 17:49:53 +0000652 return -ENOMEM;
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000653 list_add(&os->sample_buffer->list, &os->to_free);
654 os->sample_buffer_idx = 2;
655 new = os->sample_buffer + 1;
Thomas Gleixner020bb752010-11-30 17:49:53 +0000656 }
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200657
658 new->timestamp = timestamp;
Thomas Gleixnere4c2df12010-12-07 12:48:50 +0000659 new->file_offset = file_offset;
Thomas Gleixnerfe174202010-11-30 17:49:49 +0000660 new->event = event;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200661
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100662 __queue_event(new, s);
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200663
664 return 0;
665}
666
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200667static void callchain__printf(struct perf_sample *sample)
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200668{
669 unsigned int i;
670
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200671 printf("... chain: nr:%" PRIu64 "\n", sample->callchain->nr);
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200672
673 for (i = 0; i < sample->callchain->nr; i++)
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200674 printf("..... %2d: %016" PRIx64 "\n",
675 i, sample->callchain->ips[i]);
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200676}
677
Roberto Agostino Vitillob5387522012-02-09 23:21:01 +0100678static void branch_stack__printf(struct perf_sample *sample)
679{
680 uint64_t i;
681
682 printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);
683
684 for (i = 0; i < sample->branch_stack->nr; i++)
685 printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 "\n",
686 i, sample->branch_stack->entries[i].from,
687 sample->branch_stack->entries[i].to);
688}
689
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200690static void regs_dump__printf(u64 mask, u64 *regs)
691{
692 unsigned rid, i = 0;
693
694 for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) {
695 u64 val = regs[i++];
696
697 printf(".... %-5s 0x%" PRIx64 "\n",
698 perf_reg_name(rid), val);
699 }
700}
701
Jiri Olsa352ea452014-01-07 13:47:25 +0100702static void regs_user__printf(struct perf_sample *sample)
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200703{
704 struct regs_dump *user_regs = &sample->user_regs;
705
706 if (user_regs->regs) {
Jiri Olsa352ea452014-01-07 13:47:25 +0100707 u64 mask = user_regs->mask;
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200708 printf("... user regs: mask 0x%" PRIx64 "\n", mask);
709 regs_dump__printf(mask, user_regs->regs);
710 }
711}
712
713static void stack_user__printf(struct stack_dump *dump)
714{
715 printf("... ustack: size %" PRIu64 ", offset 0x%x\n",
716 dump->size, dump->offset);
717}
718
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200719static void perf_session__print_tstamp(struct perf_session *session,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200720 union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200721 struct perf_sample *sample)
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200722{
Adrian Hunter75562572013-08-27 11:23:09 +0300723 u64 sample_type = __perf_evlist__combined_sample_type(session->evlist);
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300724
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200725 if (event->header.type != PERF_RECORD_SAMPLE &&
Arnaldo Carvalho de Melo5e562472012-08-01 19:25:26 -0300726 !perf_evlist__sample_id_all(session->evlist)) {
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200727 fputs("-1 -1 ", stdout);
728 return;
729 }
730
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300731 if ((sample_type & PERF_SAMPLE_CPU))
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200732 printf("%u ", sample->cpu);
733
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300734 if (sample_type & PERF_SAMPLE_TIME)
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200735 printf("%" PRIu64 " ", sample->time);
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200736}
737
Jiri Olsa9ede4732012-10-10 17:38:13 +0200738static void sample_read__printf(struct perf_sample *sample, u64 read_format)
739{
740 printf("... sample_read:\n");
741
742 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
743 printf("...... time enabled %016" PRIx64 "\n",
744 sample->read.time_enabled);
745
746 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
747 printf("...... time running %016" PRIx64 "\n",
748 sample->read.time_running);
749
750 if (read_format & PERF_FORMAT_GROUP) {
751 u64 i;
752
753 printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);
754
755 for (i = 0; i < sample->read.group.nr; i++) {
756 struct sample_read_value *value;
757
758 value = &sample->read.group.values[i];
759 printf("..... id %016" PRIx64
760 ", value %016" PRIx64 "\n",
761 value->id, value->value);
762 }
763 } else
764 printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n",
765 sample->read.one.id, sample->read.one.value);
766}
767
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200768static void dump_event(struct perf_session *session, union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200769 u64 file_offset, struct perf_sample *sample)
Thomas Gleixner9aefcab02010-12-07 12:48:47 +0000770{
771 if (!dump_trace)
772 return;
773
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200774 printf("\n%#" PRIx64 " [%#x]: event: %d\n",
775 file_offset, event->header.size, event->header.type);
Thomas Gleixner9aefcab02010-12-07 12:48:47 +0000776
777 trace_event(event);
778
779 if (sample)
780 perf_session__print_tstamp(session, event, sample);
781
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200782 printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200783 event->header.size, perf_event__name(event->header.type));
Thomas Gleixner9aefcab02010-12-07 12:48:47 +0000784}
785
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200786static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200787 struct perf_sample *sample)
Thomas Gleixner9aefcab02010-12-07 12:48:47 +0000788{
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300789 u64 sample_type;
790
Arnaldo Carvalho de Meloddbc24b2010-12-09 12:20:20 -0200791 if (!dump_trace)
792 return;
793
Don Zickus0ea590a2014-02-25 22:43:46 -0500794 printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200795 event->header.misc, sample->pid, sample->tid, sample->ip,
David Ahern7cec0922011-05-30 13:08:23 -0600796 sample->period, sample->addr);
Thomas Gleixner9aefcab02010-12-07 12:48:47 +0000797
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200798 sample_type = evsel->attr.sample_type;
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300799
800 if (sample_type & PERF_SAMPLE_CALLCHAIN)
Arnaldo Carvalho de Meloddbc24b2010-12-09 12:20:20 -0200801 callchain__printf(sample);
Roberto Agostino Vitillob5387522012-02-09 23:21:01 +0100802
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300803 if (sample_type & PERF_SAMPLE_BRANCH_STACK)
Roberto Agostino Vitillob5387522012-02-09 23:21:01 +0100804 branch_stack__printf(sample);
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200805
806 if (sample_type & PERF_SAMPLE_REGS_USER)
Jiri Olsa352ea452014-01-07 13:47:25 +0100807 regs_user__printf(sample);
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200808
809 if (sample_type & PERF_SAMPLE_STACK_USER)
810 stack_user__printf(&sample->user_stack);
Andi Kleen05484292013-01-24 16:10:29 +0100811
812 if (sample_type & PERF_SAMPLE_WEIGHT)
813 printf("... weight: %" PRIu64 "\n", sample->weight);
Stephane Eranian98a3b322013-01-24 16:10:35 +0100814
815 if (sample_type & PERF_SAMPLE_DATA_SRC)
816 printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
Jiri Olsa9ede4732012-10-10 17:38:13 +0200817
Andi Kleen475eeab2013-09-20 07:40:43 -0700818 if (sample_type & PERF_SAMPLE_TRANSACTION)
819 printf("... transaction: %" PRIx64 "\n", sample->transaction);
820
Jiri Olsa9ede4732012-10-10 17:38:13 +0200821 if (sample_type & PERF_SAMPLE_READ)
822 sample_read__printf(sample, evsel->attr.read_format);
Thomas Gleixner9aefcab02010-12-07 12:48:47 +0000823}
824
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200825static struct machine *
826 perf_session__find_machine_for_cpumode(struct perf_session *session,
Adrian Hunteref893252013-08-27 11:23:06 +0300827 union perf_event *event,
828 struct perf_sample *sample)
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200829{
830 const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
Dongsheng Yangad85ace2013-12-20 13:41:47 -0500831 struct machine *machine;
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200832
David Ahern7c0f4a42012-07-20 17:25:48 -0600833 if (perf_guest &&
834 ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
835 (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
Nikunj A. Dadhania7fb0a5e2012-04-09 13:52:23 +0530836 u32 pid;
837
Stephane Eranian5c5e8542013-08-21 12:10:25 +0200838 if (event->header.type == PERF_RECORD_MMAP
839 || event->header.type == PERF_RECORD_MMAP2)
Nikunj A. Dadhania7fb0a5e2012-04-09 13:52:23 +0530840 pid = event->mmap.pid;
841 else
Adrian Hunteref893252013-08-27 11:23:06 +0300842 pid = sample->pid;
Nikunj A. Dadhania7fb0a5e2012-04-09 13:52:23 +0530843
Dongsheng Yangad85ace2013-12-20 13:41:47 -0500844 machine = perf_session__find_machine(session, pid);
845 if (!machine)
846 machine = perf_session__findnew_machine(session,
847 DEFAULT_GUEST_KERNEL_ID);
848 return machine;
Nikunj A. Dadhania7fb0a5e2012-04-09 13:52:23 +0530849 }
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200850
Arnaldo Carvalho de Melo34ba5122012-12-19 09:04:24 -0300851 return &session->machines.host;
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200852}
853
Jiri Olsae4caec02012-10-10 18:52:24 +0200854static int deliver_sample_value(struct perf_session *session,
855 struct perf_tool *tool,
856 union perf_event *event,
857 struct perf_sample *sample,
858 struct sample_read_value *v,
859 struct machine *machine)
860{
861 struct perf_sample_id *sid;
862
863 sid = perf_evlist__id2sid(session->evlist, v->id);
864 if (sid) {
865 sample->id = v->id;
866 sample->period = v->value - sid->period;
867 sid->period = v->value;
868 }
869
870 if (!sid || sid->evsel == NULL) {
871 ++session->stats.nr_unknown_id;
872 return 0;
873 }
874
875 return tool->sample(tool, event, sample, sid->evsel, machine);
876}
877
878static int deliver_sample_group(struct perf_session *session,
879 struct perf_tool *tool,
880 union perf_event *event,
881 struct perf_sample *sample,
882 struct machine *machine)
883{
884 int ret = -EINVAL;
885 u64 i;
886
887 for (i = 0; i < sample->read.group.nr; i++) {
888 ret = deliver_sample_value(session, tool, event, sample,
889 &sample->read.group.values[i],
890 machine);
891 if (ret)
892 break;
893 }
894
895 return ret;
896}
897
898static int
899perf_session__deliver_sample(struct perf_session *session,
900 struct perf_tool *tool,
901 union perf_event *event,
902 struct perf_sample *sample,
903 struct perf_evsel *evsel,
904 struct machine *machine)
905{
906 /* We know evsel != NULL. */
907 u64 sample_type = evsel->attr.sample_type;
908 u64 read_format = evsel->attr.read_format;
909
910 /* Standard sample delievery. */
911 if (!(sample_type & PERF_SAMPLE_READ))
912 return tool->sample(tool, event, sample, evsel, machine);
913
914 /* For PERF_SAMPLE_READ we have either single or group mode. */
915 if (read_format & PERF_FORMAT_GROUP)
916 return deliver_sample_group(session, tool, event, sample,
917 machine);
918 else
919 return deliver_sample_value(session, tool, event, sample,
920 &sample->read.one, machine);
921}
922
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100923static int perf_session_deliver_event(struct perf_session *session,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200924 union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200925 struct perf_sample *sample,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200926 struct perf_tool *tool,
Thomas Gleixner532e7262010-12-07 12:48:55 +0000927 u64 file_offset)
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100928{
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300929 struct perf_evsel *evsel;
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200930 struct machine *machine;
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300931
Thomas Gleixner532e7262010-12-07 12:48:55 +0000932 dump_event(session, event, file_offset, sample);
933
Arnaldo Carvalho de Melo7b275092011-10-29 12:15:04 -0200934 evsel = perf_evlist__id2evsel(session->evlist, sample->id);
935 if (evsel != NULL && event->header.type != PERF_RECORD_SAMPLE) {
936 /*
937 * XXX We're leaving PERF_RECORD_SAMPLE unnacounted here
938 * because the tools right now may apply filters, discarding
939 * some of the samples. For consistency, in the future we
940 * should have something like nr_filtered_samples and remove
941 * the sample->period from total_sample_period, etc, KISS for
942 * now tho.
943 *
944 * Also testing against NULL allows us to handle files without
945 * attr.sample_id_all and/or without PERF_SAMPLE_ID. In the
946 * future probably it'll be a good idea to restrict event
947 * processing via perf_session to files with both set.
948 */
949 hists__inc_nr_events(&evsel->hists, event->header.type);
950 }
951
Adrian Hunteref893252013-08-27 11:23:06 +0300952 machine = perf_session__find_machine_for_cpumode(session, event,
953 sample);
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200954
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100955 switch (event->header.type) {
956 case PERF_RECORD_SAMPLE:
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200957 dump_sample(evsel, event, sample);
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300958 if (evsel == NULL) {
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300959 ++session->stats.nr_unknown_id;
Jiri Olsa67822062012-04-12 14:21:01 +0200960 return 0;
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300961 }
Joerg Roedel0c095712012-02-10 18:05:04 +0100962 if (machine == NULL) {
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300963 ++session->stats.nr_unprocessable_samples;
Jiri Olsa67822062012-04-12 14:21:01 +0200964 return 0;
Joerg Roedel0c095712012-02-10 18:05:04 +0100965 }
Jiri Olsae4caec02012-10-10 18:52:24 +0200966 return perf_session__deliver_sample(session, tool, event,
967 sample, evsel, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100968 case PERF_RECORD_MMAP:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200969 return tool->mmap(tool, event, sample, machine);
Stephane Eranian5c5e8542013-08-21 12:10:25 +0200970 case PERF_RECORD_MMAP2:
971 return tool->mmap2(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100972 case PERF_RECORD_COMM:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200973 return tool->comm(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100974 case PERF_RECORD_FORK:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200975 return tool->fork(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100976 case PERF_RECORD_EXIT:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200977 return tool->exit(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100978 case PERF_RECORD_LOST:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200979 if (tool->lost == perf_event__process_lost)
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300980 session->stats.total_lost += event->lost.lost;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200981 return tool->lost(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100982 case PERF_RECORD_READ:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200983 return tool->read(tool, event, sample, evsel, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100984 case PERF_RECORD_THROTTLE:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200985 return tool->throttle(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100986 case PERF_RECORD_UNTHROTTLE:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200987 return tool->unthrottle(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100988 default:
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300989 ++session->stats.nr_unknown_events;
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100990 return -1;
991 }
992}
993
Adrian Hunterd5652d82014-07-23 22:19:58 +0300994static s64 perf_session__process_user_event(struct perf_session *session,
995 union perf_event *event,
996 struct perf_tool *tool,
997 u64 file_offset)
Thomas Gleixnerba74f062010-12-07 12:49:01 +0000998{
Jiri Olsacc9784bd2013-10-15 16:27:34 +0200999 int fd = perf_data_file__fd(session->file);
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02001000 int err;
1001
Thomas Gleixnerba74f062010-12-07 12:49:01 +00001002 dump_event(session, event, file_offset, NULL);
1003
1004 /* These events are processed right away */
1005 switch (event->header.type) {
1006 case PERF_RECORD_HEADER_ATTR:
Adrian Hunter47c3d102013-07-04 16:20:21 +03001007 err = tool->attr(tool, event, &session->evlist);
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02001008 if (err == 0)
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -03001009 perf_session__set_id_hdr_size(session);
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02001010 return err;
Jiri Olsaf67697b2014-02-04 15:37:48 +01001011 case PERF_RECORD_HEADER_EVENT_TYPE:
1012 /*
1013 * Depreceated, but we need to handle it for sake
1014 * of old data files create in pipe mode.
1015 */
1016 return 0;
Thomas Gleixnerba74f062010-12-07 12:49:01 +00001017 case PERF_RECORD_HEADER_TRACING_DATA:
1018 /* setup for reading amidst mmap */
Jiri Olsacc9784bd2013-10-15 16:27:34 +02001019 lseek(fd, file_offset, SEEK_SET);
Adrian Hunter47c3d102013-07-04 16:20:21 +03001020 return tool->tracing_data(tool, event, session);
Thomas Gleixnerba74f062010-12-07 12:49:01 +00001021 case PERF_RECORD_HEADER_BUILD_ID:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001022 return tool->build_id(tool, event, session);
Thomas Gleixnerba74f062010-12-07 12:49:01 +00001023 case PERF_RECORD_FINISHED_ROUND:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001024 return tool->finished_round(tool, event, session);
Thomas Gleixnerba74f062010-12-07 12:49:01 +00001025 default:
1026 return -EINVAL;
1027 }
1028}
1029
Jiri Olsa268fb202012-05-30 14:23:43 +02001030static void event_swap(union perf_event *event, bool sample_id_all)
1031{
1032 perf_event__swap_op swap;
1033
1034 swap = perf_event__swap_ops[event->header.type];
1035 if (swap)
1036 swap(event, sample_id_all);
1037}
1038
Adrian Hunterd5652d82014-07-23 22:19:58 +03001039static s64 perf_session__process_event(struct perf_session *session,
David Aherne30b88a2013-08-05 21:41:33 -04001040 union perf_event *event,
1041 struct perf_tool *tool,
1042 u64 file_offset)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001043{
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -02001044 struct perf_sample sample;
Thomas Gleixnercbf41642010-12-05 14:32:55 +01001045 int ret;
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -02001046
Jiri Olsa268fb202012-05-30 14:23:43 +02001047 if (session->header.needs_swap)
Arnaldo Carvalho de Melo5e562472012-08-01 19:25:26 -03001048 event_swap(event, perf_evlist__sample_id_all(session->evlist));
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -02001049
Thomas Gleixner9aefcab02010-12-07 12:48:47 +00001050 if (event->header.type >= PERF_RECORD_HEADER_MAX)
1051 return -EINVAL;
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -02001052
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001053 events_stats__inc(&session->stats, event->header.type);
Thomas Gleixner9aefcab02010-12-07 12:48:47 +00001054
1055 if (event->header.type >= PERF_RECORD_USER_TYPE_START)
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001056 return perf_session__process_user_event(session, event, tool, file_offset);
Thomas Gleixnercbf41642010-12-05 14:32:55 +01001057
Thomas Gleixner3dfc2c02010-12-07 12:48:58 +00001058 /*
1059 * For all kernel events we get the sample data
1060 */
Arnaldo Carvalho de Melo0807d2d2012-09-26 12:48:18 -03001061 ret = perf_evlist__parse_sample(session->evlist, event, &sample);
Frederic Weisbecker5538bec2011-05-22 02:17:22 +02001062 if (ret)
1063 return ret;
Thomas Gleixner3dfc2c02010-12-07 12:48:58 +00001064
Jiri Olsa0a8cb852014-07-06 14:18:21 +02001065 if (tool->ordered_events) {
Thomas Gleixnere4c2df12010-12-07 12:48:50 +00001066 ret = perf_session_queue_event(session, event, &sample,
1067 file_offset);
Thomas Gleixnercbf41642010-12-05 14:32:55 +01001068 if (ret != -ETIME)
1069 return ret;
1070 }
1071
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001072 return perf_session_deliver_event(session, event, &sample, tool,
Thomas Gleixnerf74725d2010-12-07 12:48:53 +00001073 file_offset);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001074}
1075
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001076void perf_event_header__bswap(struct perf_event_header *hdr)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02001077{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001078 hdr->type = bswap_32(hdr->type);
1079 hdr->misc = bswap_16(hdr->misc);
1080 hdr->size = bswap_16(hdr->size);
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02001081}
1082
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -02001083struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
1084{
Adrian Hunter1fcb8762014-07-14 13:02:25 +03001085 return machine__findnew_thread(&session->machines.host, -1, pid);
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -02001086}
1087
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001088static struct thread *perf_session__register_idle_thread(struct perf_session *session)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001089{
Adrian Hunter1fcb8762014-07-14 13:02:25 +03001090 struct thread *thread;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001091
Adrian Hunter1fcb8762014-07-14 13:02:25 +03001092 thread = machine__findnew_thread(&session->machines.host, 0, 0);
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001093 if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001094 pr_err("problem inserting idle task.\n");
1095 thread = NULL;
1096 }
1097
1098 return thread;
1099}
1100
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001101static void perf_session__warn_about_errors(const struct perf_session *session,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001102 const struct perf_tool *tool)
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001103{
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001104 if (tool->lost == perf_event__process_lost &&
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001105 session->stats.nr_events[PERF_RECORD_LOST] != 0) {
Arnaldo Carvalho de Melo7b275092011-10-29 12:15:04 -02001106 ui__warning("Processed %d events and lost %d chunks!\n\n"
1107 "Check IO/CPU overload!\n\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001108 session->stats.nr_events[0],
1109 session->stats.nr_events[PERF_RECORD_LOST]);
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001110 }
1111
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001112 if (session->stats.nr_unknown_events != 0) {
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001113 ui__warning("Found %u unknown events!\n\n"
1114 "Is this an older tool processing a perf.data "
1115 "file generated by a more recent tool?\n\n"
1116 "If that is not the case, consider "
1117 "reporting to linux-kernel@vger.kernel.org.\n\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001118 session->stats.nr_unknown_events);
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001119 }
1120
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001121 if (session->stats.nr_unknown_id != 0) {
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -03001122 ui__warning("%u samples with id not present in the header\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001123 session->stats.nr_unknown_id);
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -03001124 }
1125
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001126 if (session->stats.nr_invalid_chains != 0) {
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001127 ui__warning("Found invalid callchains!\n\n"
1128 "%u out of %u events were discarded for this reason.\n\n"
1129 "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001130 session->stats.nr_invalid_chains,
1131 session->stats.nr_events[PERF_RECORD_SAMPLE]);
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001132 }
Joerg Roedel0c095712012-02-10 18:05:04 +01001133
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001134 if (session->stats.nr_unprocessable_samples != 0) {
Joerg Roedel0c095712012-02-10 18:05:04 +01001135 ui__warning("%u unprocessable samples recorded.\n"
1136 "Do you have a KVM guest running and not using 'perf kvm'?\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001137 session->stats.nr_unprocessable_samples);
Joerg Roedel0c095712012-02-10 18:05:04 +01001138 }
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001139}
1140
Tom Zanussi8dc58102010-04-01 23:59:15 -05001141volatile int session_done;
1142
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001143static int __perf_session__process_pipe_events(struct perf_session *session,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001144 struct perf_tool *tool)
Tom Zanussi8dc58102010-04-01 23:59:15 -05001145{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001146 int fd = perf_data_file__fd(session->file);
Stephane Eranian444d2862012-05-15 13:28:12 +02001147 union perf_event *event;
1148 uint32_t size, cur_size = 0;
1149 void *buf = NULL;
Adrian Hunterd5652d82014-07-23 22:19:58 +03001150 s64 skip = 0;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001151 u64 head;
Jiri Olsa727ebd52013-11-28 11:30:14 +01001152 ssize_t err;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001153 void *p;
1154
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001155 perf_tool__fill_defaults(tool);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001156
1157 head = 0;
Stephane Eranian444d2862012-05-15 13:28:12 +02001158 cur_size = sizeof(union perf_event);
1159
1160 buf = malloc(cur_size);
1161 if (!buf)
1162 return -errno;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001163more:
Stephane Eranian444d2862012-05-15 13:28:12 +02001164 event = buf;
Jiri Olsacc9784bd2013-10-15 16:27:34 +02001165 err = readn(fd, event, sizeof(struct perf_event_header));
Tom Zanussi8dc58102010-04-01 23:59:15 -05001166 if (err <= 0) {
1167 if (err == 0)
1168 goto done;
1169
1170 pr_err("failed to read event header\n");
1171 goto out_err;
1172 }
1173
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001174 if (session->header.needs_swap)
Stephane Eranian444d2862012-05-15 13:28:12 +02001175 perf_event_header__bswap(&event->header);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001176
Stephane Eranian444d2862012-05-15 13:28:12 +02001177 size = event->header.size;
Adrian Hunter27389d72013-07-04 16:20:27 +03001178 if (size < sizeof(struct perf_event_header)) {
1179 pr_err("bad event header size\n");
1180 goto out_err;
1181 }
Tom Zanussi8dc58102010-04-01 23:59:15 -05001182
Stephane Eranian444d2862012-05-15 13:28:12 +02001183 if (size > cur_size) {
1184 void *new = realloc(buf, size);
1185 if (!new) {
1186 pr_err("failed to allocate memory to read event\n");
1187 goto out_err;
1188 }
1189 buf = new;
1190 cur_size = size;
1191 event = buf;
1192 }
1193 p = event;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001194 p += sizeof(struct perf_event_header);
1195
Tom Zanussi794e43b2010-05-05 00:27:40 -05001196 if (size - sizeof(struct perf_event_header)) {
Jiri Olsacc9784bd2013-10-15 16:27:34 +02001197 err = readn(fd, p, size - sizeof(struct perf_event_header));
Tom Zanussi794e43b2010-05-05 00:27:40 -05001198 if (err <= 0) {
1199 if (err == 0) {
1200 pr_err("unexpected end of event stream\n");
1201 goto done;
1202 }
Tom Zanussi8dc58102010-04-01 23:59:15 -05001203
Tom Zanussi794e43b2010-05-05 00:27:40 -05001204 pr_err("failed to read event data\n");
1205 goto out_err;
1206 }
Tom Zanussi8dc58102010-04-01 23:59:15 -05001207 }
1208
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001209 if ((skip = perf_session__process_event(session, event, tool, head)) < 0) {
Jiri Olsa9389a462012-04-16 20:42:51 +02001210 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
Stephane Eranian444d2862012-05-15 13:28:12 +02001211 head, event->header.size, event->header.type);
Jiri Olsa9389a462012-04-16 20:42:51 +02001212 err = -EINVAL;
1213 goto out_err;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001214 }
1215
1216 head += size;
1217
Tom Zanussi8dc58102010-04-01 23:59:15 -05001218 if (skip > 0)
1219 head += skip;
1220
1221 if (!session_done())
1222 goto more;
1223done:
Adrian Hunter8c16b642013-10-18 15:29:02 +03001224 /* do the final flush for ordered samples */
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001225 session->ordered_samples.next_flush = ULLONG_MAX;
1226 err = flush_sample_queue(session, tool);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001227out_err:
Stephane Eranian444d2862012-05-15 13:28:12 +02001228 free(buf);
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001229 perf_session__warn_about_errors(session, tool);
1230 perf_session_free_sample_buffers(session);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001231 return err;
1232}
1233
Frederic Weisbecker998bedc2011-05-23 13:06:28 +02001234static union perf_event *
1235fetch_mmaped_event(struct perf_session *session,
1236 u64 head, size_t mmap_size, char *buf)
1237{
1238 union perf_event *event;
1239
1240 /*
1241 * Ensure we have enough space remaining to read
1242 * the size of the event in the headers.
1243 */
1244 if (head + sizeof(event->header) > mmap_size)
1245 return NULL;
1246
1247 event = (union perf_event *)(buf + head);
1248
1249 if (session->header.needs_swap)
1250 perf_event_header__bswap(&event->header);
1251
Adrian Hunter27389d72013-07-04 16:20:27 +03001252 if (head + event->header.size > mmap_size) {
1253 /* We're not fetching the event so swap back again */
1254 if (session->header.needs_swap)
1255 perf_event_header__bswap(&event->header);
Frederic Weisbecker998bedc2011-05-23 13:06:28 +02001256 return NULL;
Adrian Hunter27389d72013-07-04 16:20:27 +03001257 }
Frederic Weisbecker998bedc2011-05-23 13:06:28 +02001258
1259 return event;
1260}
1261
David Miller35d48dd2012-11-10 14:12:19 -05001262/*
1263 * On 64bit we can mmap the data file in one go. No need for tiny mmap
1264 * slices. On 32bit we use 32MB.
1265 */
1266#if BITS_PER_LONG == 64
1267#define MMAP_SIZE ULLONG_MAX
1268#define NUM_MMAPS 1
1269#else
1270#define MMAP_SIZE (32 * 1024 * 1024ULL)
1271#define NUM_MMAPS 128
1272#endif
1273
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001274int __perf_session__process_events(struct perf_session *session,
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001275 u64 data_offset, u64 data_size,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001276 u64 file_size, struct perf_tool *tool)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001277{
Jiri Olsacc9784bd2013-10-15 16:27:34 +02001278 int fd = perf_data_file__fd(session->file);
Adrian Hunterd5652d82014-07-23 22:19:58 +03001279 u64 head, page_offset, file_offset, file_pos, size;
Thomas Gleixnerfe174202010-11-30 17:49:49 +00001280 int err, mmap_prot, mmap_flags, map_idx = 0;
Arnaldo Carvalho de Melo0c1fe6b2012-10-06 14:57:10 -03001281 size_t mmap_size;
David Miller35d48dd2012-11-10 14:12:19 -05001282 char *buf, *mmaps[NUM_MMAPS];
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02001283 union perf_event *event;
Arnaldo Carvalho de Melo4d3001f2013-10-23 15:40:38 -03001284 struct ui_progress prog;
Adrian Hunterd5652d82014-07-23 22:19:58 +03001285 s64 skip;
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001286
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001287 perf_tool__fill_defaults(tool);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001288
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001289 page_offset = page_size * (data_offset / page_size);
1290 file_offset = page_offset;
1291 head = data_offset - page_offset;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001292
Namhyung Kimb314e5c2013-09-30 17:19:48 +09001293 if (data_size && (data_offset + data_size < file_size))
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001294 file_size = data_offset + data_size;
1295
Arnaldo Carvalho de Melo4d3001f2013-10-23 15:40:38 -03001296 ui_progress__init(&prog, file_size, "Processing events...");
Thomas Gleixner55b446292010-11-30 17:49:46 +00001297
David Miller35d48dd2012-11-10 14:12:19 -05001298 mmap_size = MMAP_SIZE;
Adrian Hunter919d86d2014-07-14 13:02:51 +03001299 if (mmap_size > file_size) {
Thomas Gleixner55b446292010-11-30 17:49:46 +00001300 mmap_size = file_size;
Adrian Hunter919d86d2014-07-14 13:02:51 +03001301 session->one_mmap = true;
1302 }
Thomas Gleixner55b446292010-11-30 17:49:46 +00001303
Thomas Gleixnerfe174202010-11-30 17:49:49 +00001304 memset(mmaps, 0, sizeof(mmaps));
1305
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02001306 mmap_prot = PROT_READ;
1307 mmap_flags = MAP_SHARED;
1308
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001309 if (session->header.needs_swap) {
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02001310 mmap_prot |= PROT_WRITE;
1311 mmap_flags = MAP_PRIVATE;
1312 }
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001313remap:
Jiri Olsacc9784bd2013-10-15 16:27:34 +02001314 buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd,
Thomas Gleixner55b446292010-11-30 17:49:46 +00001315 file_offset);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001316 if (buf == MAP_FAILED) {
1317 pr_err("failed to mmap file\n");
1318 err = -errno;
1319 goto out_err;
1320 }
Thomas Gleixnerfe174202010-11-30 17:49:49 +00001321 mmaps[map_idx] = buf;
1322 map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001323 file_pos = file_offset + head;
Adrian Hunter919d86d2014-07-14 13:02:51 +03001324 if (session->one_mmap) {
1325 session->one_mmap_addr = buf;
1326 session->one_mmap_offset = file_offset;
1327 }
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001328
1329more:
Frederic Weisbecker998bedc2011-05-23 13:06:28 +02001330 event = fetch_mmaped_event(session, head, mmap_size, buf);
1331 if (!event) {
Thomas Gleixnerfe174202010-11-30 17:49:49 +00001332 if (mmaps[map_idx]) {
1333 munmap(mmaps[map_idx], mmap_size);
1334 mmaps[map_idx] = NULL;
1335 }
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001336
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001337 page_offset = page_size * (head / page_size);
1338 file_offset += page_offset;
1339 head -= page_offset;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001340 goto remap;
1341 }
1342
1343 size = event->header.size;
1344
Adrian Hunter27389d72013-07-04 16:20:27 +03001345 if (size < sizeof(struct perf_event_header) ||
Adrian Hunter6f917c72014-07-23 22:19:57 +03001346 (skip = perf_session__process_event(session, event, tool, file_pos))
1347 < 0) {
Jiri Olsa9389a462012-04-16 20:42:51 +02001348 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1349 file_offset + head, event->header.size,
1350 event->header.type);
1351 err = -EINVAL;
1352 goto out_err;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001353 }
1354
Adrian Hunter6f917c72014-07-23 22:19:57 +03001355 if (skip)
1356 size += skip;
1357
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001358 head += size;
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001359 file_pos += size;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001360
Arnaldo Carvalho de Melo4d3001f2013-10-23 15:40:38 -03001361 ui_progress__update(&prog, size);
Thomas Gleixner55b446292010-11-30 17:49:46 +00001362
Arnaldo Carvalho de Melo33e940a2013-09-17 16:34:28 -03001363 if (session_done())
Adrian Hunter8c16b642013-10-18 15:29:02 +03001364 goto out;
Arnaldo Carvalho de Melo33e940a2013-09-17 16:34:28 -03001365
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001366 if (file_pos < file_size)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001367 goto more;
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001368
Adrian Hunter8c16b642013-10-18 15:29:02 +03001369out:
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +02001370 /* do the final flush for ordered samples */
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001371 session->ordered_samples.next_flush = ULLONG_MAX;
David Ahernd25380cd2012-08-26 12:24:41 -06001372 err = flush_sample_queue(session, tool);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001373out_err:
Namhyung Kima5580f32012-11-13 22:30:34 +09001374 ui_progress__finish();
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001375 perf_session__warn_about_errors(session, tool);
Thomas Gleixner020bb752010-11-30 17:49:53 +00001376 perf_session_free_sample_buffers(session);
Adrian Hunter919d86d2014-07-14 13:02:51 +03001377 session->one_mmap = false;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001378 return err;
1379}
Arnaldo Carvalho de Melo27295592009-12-27 21:37:01 -02001380
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001381int perf_session__process_events(struct perf_session *session,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001382 struct perf_tool *tool)
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001383{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001384 u64 size = perf_data_file__size(session->file);
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001385 int err;
1386
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001387 if (perf_session__register_idle_thread(session) == NULL)
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001388 return -ENOMEM;
1389
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001390 if (!perf_data_file__is_pipe(session->file))
1391 err = __perf_session__process_events(session,
1392 session->header.data_offset,
1393 session->header.data_size,
Jiri Olsacc9784bd2013-10-15 16:27:34 +02001394 size, tool);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001395 else
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001396 err = __perf_session__process_pipe_events(session, tool);
Dave Martin88ca8952010-07-27 11:46:12 -03001397
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001398 return err;
1399}
1400
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -03001401bool perf_session__has_traces(struct perf_session *session, const char *msg)
Arnaldo Carvalho de Melo27295592009-12-27 21:37:01 -02001402{
David Ahern93ea01c292013-08-07 22:50:58 -04001403 struct perf_evsel *evsel;
1404
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03001405 evlist__for_each(session->evlist, evsel) {
David Ahern93ea01c292013-08-07 22:50:58 -04001406 if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
1407 return true;
Arnaldo Carvalho de Melo27295592009-12-27 21:37:01 -02001408 }
1409
David Ahern93ea01c292013-08-07 22:50:58 -04001410 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
1411 return false;
Arnaldo Carvalho de Melo27295592009-12-27 21:37:01 -02001412}
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001413
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -02001414int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
1415 const char *symbol_name, u64 addr)
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001416{
1417 char *bracket;
Arnaldo Carvalho de Melo9de89fe2010-02-03 16:52:00 -02001418 enum map_type i;
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001419 struct ref_reloc_sym *ref;
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001420
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001421 ref = zalloc(sizeof(struct ref_reloc_sym));
1422 if (ref == NULL)
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001423 return -ENOMEM;
1424
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001425 ref->name = strdup(symbol_name);
1426 if (ref->name == NULL) {
1427 free(ref);
1428 return -ENOMEM;
1429 }
1430
1431 bracket = strchr(ref->name, ']');
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001432 if (bracket)
1433 *bracket = '\0';
1434
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001435 ref->addr = addr;
Arnaldo Carvalho de Melo9de89fe2010-02-03 16:52:00 -02001436
1437 for (i = 0; i < MAP__NR_TYPES; ++i) {
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001438 struct kmap *kmap = map__kmap(maps[i]);
1439 kmap->ref_reloc_sym = ref;
Arnaldo Carvalho de Melo9de89fe2010-02-03 16:52:00 -02001440 }
1441
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001442 return 0;
1443}
Arnaldo Carvalho de Melo1f626bc2010-05-09 19:57:08 -03001444
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001445size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp)
Arnaldo Carvalho de Melo1f626bc2010-05-09 19:57:08 -03001446{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001447 return machines__fprintf_dsos(&session->machines, fp);
Arnaldo Carvalho de Melo1f626bc2010-05-09 19:57:08 -03001448}
Arnaldo Carvalho de Melof8690972010-05-19 13:41:23 -03001449
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001450size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp,
Arnaldo Carvalho de Melo417c2ff2012-12-07 09:53:58 -03001451 bool (skip)(struct dso *dso, int parm), int parm)
Arnaldo Carvalho de Melof8690972010-05-19 13:41:23 -03001452{
Arnaldo Carvalho de Melo316c7132013-11-05 15:32:36 -03001453 return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm);
Arnaldo Carvalho de Melof8690972010-05-19 13:41:23 -03001454}
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -03001455
1456size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
1457{
1458 struct perf_evsel *pos;
1459 size_t ret = fprintf(fp, "Aggregated stats:\n");
1460
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001461 ret += events_stats__fprintf(&session->stats, fp);
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -03001462
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03001463 evlist__for_each(session->evlist, pos) {
Arnaldo Carvalho de Melo7289f832012-06-12 12:34:58 -03001464 ret += fprintf(fp, "%s stats:\n", perf_evsel__name(pos));
Arnaldo Carvalho de Melo52168ee2012-12-18 16:02:17 -03001465 ret += events_stats__fprintf(&pos->hists.stats, fp);
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -03001466 }
1467
1468 return ret;
1469}
David Ahernc0230b22011-03-09 22:23:27 -07001470
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -02001471size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
1472{
1473 /*
1474 * FIXME: Here we have to actually print all the machines in this
1475 * session, not just the host...
1476 */
Arnaldo Carvalho de Melo876650e62012-12-18 19:15:48 -03001477 return machine__fprintf(&session->machines.host, fp);
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -02001478}
1479
David Ahern9cbdb702011-04-06 21:54:20 -06001480struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
1481 unsigned int type)
1482{
1483 struct perf_evsel *pos;
1484
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03001485 evlist__for_each(session->evlist, pos) {
David Ahern9cbdb702011-04-06 21:54:20 -06001486 if (pos->attr.type == type)
1487 return pos;
1488 }
1489 return NULL;
1490}
1491
Adrian Huntera2cb3cf2013-12-04 16:16:36 +02001492void perf_evsel__print_ip(struct perf_evsel *evsel, struct perf_sample *sample,
Arnaldo Carvalho de Melocc22e572013-12-19 17:20:06 -03001493 struct addr_location *al,
David Ahern307cbb92013-08-07 22:50:53 -04001494 unsigned int print_opts, unsigned int stack_depth)
David Ahernc0230b22011-03-09 22:23:27 -07001495{
David Ahernc0230b22011-03-09 22:23:27 -07001496 struct callchain_cursor_node *node;
David Aherna6ffaf92013-08-07 22:50:51 -04001497 int print_ip = print_opts & PRINT_IP_OPT_IP;
1498 int print_sym = print_opts & PRINT_IP_OPT_SYM;
1499 int print_dso = print_opts & PRINT_IP_OPT_DSO;
1500 int print_symoffset = print_opts & PRINT_IP_OPT_SYMOFFSET;
David Ahernb0b35f02013-08-07 22:50:52 -04001501 int print_oneline = print_opts & PRINT_IP_OPT_ONELINE;
Adrian Huntercc8fae12013-12-06 09:42:57 +02001502 int print_srcline = print_opts & PRINT_IP_OPT_SRCLINE;
David Ahernb0b35f02013-08-07 22:50:52 -04001503 char s = print_oneline ? ' ' : '\t';
David Ahernc0230b22011-03-09 22:23:27 -07001504
David Ahernc0230b22011-03-09 22:23:27 -07001505 if (symbol_conf.use_callchain && sample->callchain) {
Adrian Huntera2cb3cf2013-12-04 16:16:36 +02001506 struct addr_location node_al;
David Ahernc0230b22011-03-09 22:23:27 -07001507
Arnaldo Carvalho de Melocc22e572013-12-19 17:20:06 -03001508 if (machine__resolve_callchain(al->machine, evsel, al->thread,
Waiman Long91e95612013-10-18 10:38:48 -04001509 sample, NULL, NULL,
1510 PERF_MAX_STACK_DEPTH) != 0) {
David Ahernc0230b22011-03-09 22:23:27 -07001511 if (verbose)
1512 error("Failed to resolve callchain. Skipping\n");
1513 return;
1514 }
Namhyung Kim47260642012-05-31 14:43:26 +09001515 callchain_cursor_commit(&callchain_cursor);
David Ahernc0230b22011-03-09 22:23:27 -07001516
Adrian Huntera2cb3cf2013-12-04 16:16:36 +02001517 if (print_symoffset)
1518 node_al = *al;
1519
David Ahern307cbb92013-08-07 22:50:53 -04001520 while (stack_depth) {
Adrian Huntera4eb24a2013-12-06 09:42:56 +02001521 u64 addr = 0;
1522
Namhyung Kim47260642012-05-31 14:43:26 +09001523 node = callchain_cursor_current(&callchain_cursor);
David Ahernc0230b22011-03-09 22:23:27 -07001524 if (!node)
1525 break;
1526
David Ahernd2ff1b12013-11-18 13:32:44 -07001527 if (node->sym && node->sym->ignore)
1528 goto next;
1529
David Aherna6ffaf92013-08-07 22:50:51 -04001530 if (print_ip)
David Ahernb0b35f02013-08-07 22:50:52 -04001531 printf("%c%16" PRIx64, s, node->ip);
David Aherna6ffaf92013-08-07 22:50:51 -04001532
Adrian Huntera4eb24a2013-12-06 09:42:56 +02001533 if (node->map)
1534 addr = node->map->map_ip(node->map, node->ip);
1535
David Ahern787bef12011-05-27 14:28:43 -06001536 if (print_sym) {
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001537 printf(" ");
David Ahern251f4262013-07-28 09:14:34 -06001538 if (print_symoffset) {
Adrian Huntera4eb24a2013-12-06 09:42:56 +02001539 node_al.addr = addr;
Adrian Huntera2cb3cf2013-12-04 16:16:36 +02001540 node_al.map = node->map;
1541 symbol__fprintf_symname_offs(node->sym, &node_al, stdout);
David Ahern251f4262013-07-28 09:14:34 -06001542 } else
1543 symbol__fprintf_symname(node->sym, stdout);
David Ahern610723f2011-05-27 14:28:44 -06001544 }
David Ahern251f4262013-07-28 09:14:34 -06001545
David Ahern610723f2011-05-27 14:28:44 -06001546 if (print_dso) {
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001547 printf(" (");
David Ahern52deff72012-05-29 22:58:26 -06001548 map__fprintf_dsoname(node->map, stdout);
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001549 printf(")");
David Ahern787bef12011-05-27 14:28:43 -06001550 }
David Ahernb0b35f02013-08-07 22:50:52 -04001551
Adrian Huntercc8fae12013-12-06 09:42:57 +02001552 if (print_srcline)
1553 map__fprintf_srcline(node->map, addr, "\n ",
1554 stdout);
1555
David Ahernb0b35f02013-08-07 22:50:52 -04001556 if (!print_oneline)
1557 printf("\n");
David Ahernc0230b22011-03-09 22:23:27 -07001558
David Ahern307cbb92013-08-07 22:50:53 -04001559 stack_depth--;
David Ahernd2ff1b12013-11-18 13:32:44 -07001560next:
1561 callchain_cursor_advance(&callchain_cursor);
David Ahernc0230b22011-03-09 22:23:27 -07001562 }
1563
1564 } else {
Adrian Huntera2cb3cf2013-12-04 16:16:36 +02001565 if (al->sym && al->sym->ignore)
David Ahernd2ff1b12013-11-18 13:32:44 -07001566 return;
1567
David Aherna6ffaf92013-08-07 22:50:51 -04001568 if (print_ip)
1569 printf("%16" PRIx64, sample->ip);
1570
David Ahern787bef12011-05-27 14:28:43 -06001571 if (print_sym) {
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001572 printf(" ");
Akihiro Nagaia978f2a2012-01-30 13:43:15 +09001573 if (print_symoffset)
Adrian Huntera2cb3cf2013-12-04 16:16:36 +02001574 symbol__fprintf_symname_offs(al->sym, al,
Akihiro Nagaia978f2a2012-01-30 13:43:15 +09001575 stdout);
1576 else
Adrian Huntera2cb3cf2013-12-04 16:16:36 +02001577 symbol__fprintf_symname(al->sym, stdout);
David Ahern610723f2011-05-27 14:28:44 -06001578 }
1579
1580 if (print_dso) {
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001581 printf(" (");
Adrian Huntera2cb3cf2013-12-04 16:16:36 +02001582 map__fprintf_dsoname(al->map, stdout);
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001583 printf(")");
David Ahern787bef12011-05-27 14:28:43 -06001584 }
Adrian Huntercc8fae12013-12-06 09:42:57 +02001585
1586 if (print_srcline)
1587 map__fprintf_srcline(al->map, al->addr, "\n ", stdout);
David Ahernc0230b22011-03-09 22:23:27 -07001588 }
1589}
Anton Blanchard5d67be92011-07-04 21:57:50 +10001590
1591int perf_session__cpu_bitmap(struct perf_session *session,
1592 const char *cpu_list, unsigned long *cpu_bitmap)
1593{
Stanislav Fomichev8bac41c2014-01-20 15:39:39 +04001594 int i, err = -1;
Anton Blanchard5d67be92011-07-04 21:57:50 +10001595 struct cpu_map *map;
1596
1597 for (i = 0; i < PERF_TYPE_MAX; ++i) {
1598 struct perf_evsel *evsel;
1599
1600 evsel = perf_session__find_first_evtype(session, i);
1601 if (!evsel)
1602 continue;
1603
1604 if (!(evsel->attr.sample_type & PERF_SAMPLE_CPU)) {
1605 pr_err("File does not contain CPU events. "
1606 "Remove -c option to proceed.\n");
1607 return -1;
1608 }
1609 }
1610
1611 map = cpu_map__new(cpu_list);
David Ahern47fbe532011-11-13 10:45:27 -07001612 if (map == NULL) {
1613 pr_err("Invalid cpu_list\n");
1614 return -1;
1615 }
Anton Blanchard5d67be92011-07-04 21:57:50 +10001616
1617 for (i = 0; i < map->nr; i++) {
1618 int cpu = map->map[i];
1619
1620 if (cpu >= MAX_NR_CPUS) {
1621 pr_err("Requested CPU %d too large. "
1622 "Consider raising MAX_NR_CPUS\n", cpu);
Stanislav Fomichev8bac41c2014-01-20 15:39:39 +04001623 goto out_delete_map;
Anton Blanchard5d67be92011-07-04 21:57:50 +10001624 }
1625
1626 set_bit(cpu, cpu_bitmap);
1627 }
1628
Stanislav Fomichev8bac41c2014-01-20 15:39:39 +04001629 err = 0;
1630
1631out_delete_map:
1632 cpu_map__delete(map);
1633 return err;
Anton Blanchard5d67be92011-07-04 21:57:50 +10001634}
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001635
1636void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
1637 bool full)
1638{
1639 struct stat st;
Masanari Iidac5765ec2014-05-15 02:13:38 +09001640 int fd, ret;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001641
1642 if (session == NULL || fp == NULL)
1643 return;
1644
Masanari Iidac5765ec2014-05-15 02:13:38 +09001645 fd = perf_data_file__fd(session->file);
1646
Jiri Olsacc9784bd2013-10-15 16:27:34 +02001647 ret = fstat(fd, &st);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001648 if (ret == -1)
1649 return;
1650
1651 fprintf(fp, "# ========\n");
1652 fprintf(fp, "# captured on: %s", ctime(&st.st_ctime));
1653 perf_header__fprintf_info(session, fp, full);
1654 fprintf(fp, "# ========\n#\n");
1655}
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03001656
1657
1658int __perf_session__set_tracepoints_handlers(struct perf_session *session,
1659 const struct perf_evsel_str_handler *assocs,
1660 size_t nr_assocs)
1661{
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03001662 struct perf_evsel *evsel;
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03001663 size_t i;
1664 int err;
1665
1666 for (i = 0; i < nr_assocs; i++) {
Arnaldo Carvalho de Meloccf53ea2013-09-06 15:19:01 -03001667 /*
1668 * Adding a handler for an event not in the session,
1669 * just ignore it.
1670 */
1671 evsel = perf_evlist__find_tracepoint_by_name(session->evlist, assocs[i].name);
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03001672 if (evsel == NULL)
Arnaldo Carvalho de Meloccf53ea2013-09-06 15:19:01 -03001673 continue;
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03001674
1675 err = -EEXIST;
Arnaldo Carvalho de Melo744a9712013-11-06 10:17:38 -03001676 if (evsel->handler != NULL)
Arnaldo Carvalho de Meloccf53ea2013-09-06 15:19:01 -03001677 goto out;
Arnaldo Carvalho de Melo744a9712013-11-06 10:17:38 -03001678 evsel->handler = assocs[i].handler;
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03001679 }
1680
1681 err = 0;
1682out:
1683 return err;
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03001684}