blob: c8ba120b0dbee3944cd9172acf916965c214bcde [file] [log] [blame]
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02001#include <linux/kernel.h>
2
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02003#include <byteswap.h>
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02004#include <unistd.h>
5#include <sys/types.h>
Arnaldo Carvalho de Meloa41794c2010-05-18 18:29:23 -03006#include <sys/mman.h>
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02007
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -03008#include "evlist.h"
9#include "evsel.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020010#include "session.h"
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020011#include "tool.h"
Arnaldo Carvalho de Meloa3286262009-12-14 14:22:59 -020012#include "sort.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020013#include "util.h"
Anton Blanchard5d67be92011-07-04 21:57:50 +100014#include "cpumap.h"
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -030015#include "event-parse.h"
Jiri Olsa0f6a3012012-08-07 15:20:45 +020016#include "perf_regs.h"
Jiri Olsa7dbf4dc2012-09-10 18:50:19 +020017#include "vdso.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020018
19static int perf_session__open(struct perf_session *self, bool force)
20{
21 struct stat input_stat;
22
Tom Zanussi8dc58102010-04-01 23:59:15 -050023 if (!strcmp(self->filename, "-")) {
24 self->fd_pipe = true;
25 self->fd = STDIN_FILENO;
26
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -030027 if (perf_session__read_header(self, self->fd) < 0)
Stephane Eranian69996df2012-02-09 23:21:06 +010028 pr_err("incompatible file format (rerun with -v to learn more)");
Tom Zanussi8dc58102010-04-01 23:59:15 -050029
30 return 0;
31 }
32
Xiao Guangrongf887f302010-02-04 16:46:42 +080033 self->fd = open(self->filename, O_RDONLY);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020034 if (self->fd < 0) {
Andy Isaacson0f2c3de2010-06-11 20:36:15 -070035 int err = errno;
36
37 pr_err("failed to open %s: %s", self->filename, strerror(err));
38 if (err == ENOENT && !strcmp(self->filename, "perf.data"))
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020039 pr_err(" (try 'perf record' first)");
40 pr_err("\n");
41 return -errno;
42 }
43
44 if (fstat(self->fd, &input_stat) < 0)
45 goto out_close;
46
47 if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
48 pr_err("file %s not owned by current user or root\n",
49 self->filename);
50 goto out_close;
51 }
52
53 if (!input_stat.st_size) {
54 pr_info("zero-sized file (%s), nothing to do!\n",
55 self->filename);
56 goto out_close;
57 }
58
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -030059 if (perf_session__read_header(self, self->fd) < 0) {
Stephane Eranian69996df2012-02-09 23:21:06 +010060 pr_err("incompatible file format (rerun with -v to learn more)");
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020061 goto out_close;
62 }
63
Arnaldo Carvalho de Meloc2a70652011-06-02 11:04:54 -030064 if (!perf_evlist__valid_sample_type(self->evlist)) {
65 pr_err("non matching sample_type");
66 goto out_close;
67 }
68
69 if (!perf_evlist__valid_sample_id_all(self->evlist)) {
70 pr_err("non matching sample_id_all");
71 goto out_close;
72 }
73
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020074 self->size = input_stat.st_size;
75 return 0;
76
77out_close:
78 close(self->fd);
79 self->fd = -1;
80 return -1;
81}
82
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -030083void perf_session__set_id_hdr_size(struct perf_session *session)
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -020084{
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -030085 u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);
86
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -030087 machines__set_id_hdr_size(&session->machines, id_hdr_size);
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -020088}
89
Zhang, Yanmina1645ce2010-04-19 13:32:50 +080090int perf_session__create_kernel_maps(struct perf_session *self)
91{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -030092 int ret = machine__create_kernel_maps(&self->machines.host);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +080093
Zhang, Yanmina1645ce2010-04-19 13:32:50 +080094 if (ret >= 0)
Arnaldo Carvalho de Melod118f8b2010-05-10 12:51:05 -030095 ret = machines__create_guest_kernel_maps(&self->machines);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +080096 return ret;
97}
98
Arnaldo Carvalho de Melo076c6e452010-08-02 18:18:28 -030099static void perf_session__destroy_kernel_maps(struct perf_session *self)
100{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300101 machines__destroy_kernel_maps(&self->machines);
Arnaldo Carvalho de Melo076c6e452010-08-02 18:18:28 -0300102}
103
Ian Munsie21ef97f2010-12-10 14:09:16 +1100104struct perf_session *perf_session__new(const char *filename, int mode,
105 bool force, bool repipe,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200106 struct perf_tool *tool)
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200107{
Robert Richterefad1412011-12-07 10:02:54 +0100108 struct perf_session *self;
109 struct stat st;
110 size_t len;
111
112 if (!filename || !strlen(filename)) {
113 if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
114 filename = "-";
115 else
116 filename = "perf.data";
117 }
118
119 len = strlen(filename);
120 self = zalloc(sizeof(*self) + len);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200121
122 if (self == NULL)
123 goto out;
124
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200125 memcpy(self->filename, filename, len);
Tom Zanussi454c4072010-05-01 01:41:20 -0500126 self->repipe = repipe;
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000127 INIT_LIST_HEAD(&self->ordered_samples.samples);
Thomas Gleixner020bb752010-11-30 17:49:53 +0000128 INIT_LIST_HEAD(&self->ordered_samples.sample_cache);
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000129 INIT_LIST_HEAD(&self->ordered_samples.to_free);
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300130 machines__init(&self->machines);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200131
Arnaldo Carvalho de Melo64abebf72010-01-27 21:05:52 -0200132 if (mode == O_RDONLY) {
133 if (perf_session__open(self, force) < 0)
134 goto out_delete;
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -0300135 perf_session__set_id_hdr_size(self);
Arnaldo Carvalho de Melo64abebf72010-01-27 21:05:52 -0200136 } else if (mode == O_WRONLY) {
137 /*
138 * In O_RDONLY mode this will be performed when reading the
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200139 * kernel MMAP event, in perf_event__process_mmap().
Arnaldo Carvalho de Melo64abebf72010-01-27 21:05:52 -0200140 */
141 if (perf_session__create_kernel_maps(self) < 0)
142 goto out_delete;
143 }
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -0200144
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200145 if (tool && tool->ordering_requires_timestamps &&
Arnaldo Carvalho de Melo5e562472012-08-01 19:25:26 -0300146 tool->ordered_samples && !perf_evlist__sample_id_all(self->evlist)) {
Ian Munsie21ef97f2010-12-10 14:09:16 +1100147 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200148 tool->ordered_samples = false;
Ian Munsie21ef97f2010-12-10 14:09:16 +1100149 }
150
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200151out:
152 return self;
Arnaldo Carvalho de Melo4aa65632009-12-13 19:50:29 -0200153out_delete:
154 perf_session__delete(self);
155 return NULL;
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200156}
157
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200158static void perf_session__delete_dead_threads(struct perf_session *session)
159{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300160 machine__delete_dead_threads(&session->machines.host);
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200161}
162
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200163static void perf_session__delete_threads(struct perf_session *session)
164{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300165 machine__delete_threads(&session->machines.host);
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200166}
167
Namhyung Kim03cd2092012-11-21 13:43:19 +0900168static void perf_session_env__delete(struct perf_session_env *env)
169{
170 free(env->hostname);
171 free(env->os_release);
172 free(env->version);
173 free(env->arch);
174 free(env->cpu_desc);
175 free(env->cpuid);
176
177 free(env->cmdline);
178 free(env->sibling_cores);
179 free(env->sibling_threads);
180 free(env->numa_nodes);
181 free(env->pmu_mappings);
182}
183
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200184void perf_session__delete(struct perf_session *self)
185{
Arnaldo Carvalho de Melo076c6e452010-08-02 18:18:28 -0300186 perf_session__destroy_kernel_maps(self);
Arnaldo Carvalho de Melod65a4582010-07-30 18:31:28 -0300187 perf_session__delete_dead_threads(self);
188 perf_session__delete_threads(self);
Namhyung Kim03cd2092012-11-21 13:43:19 +0900189 perf_session_env__delete(&self->header.env);
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300190 machines__exit(&self->machines);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200191 close(self->fd);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200192 free(self);
Jiri Olsa7dbf4dc2012-09-10 18:50:19 +0200193 vdso__exit();
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200194}
Arnaldo Carvalho de Meloa3286262009-12-14 14:22:59 -0200195
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300196static int process_event_synth_tracing_data_stub(union perf_event *event
197 __maybe_unused,
198 struct perf_session *session
199 __maybe_unused)
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200200{
201 dump_printf(": unhandled!\n");
202 return 0;
203}
204
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300205static int process_event_synth_attr_stub(union perf_event *event __maybe_unused,
206 struct perf_evlist **pevlist
207 __maybe_unused)
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -0200208{
209 dump_printf(": unhandled!\n");
210 return 0;
211}
212
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300213static int process_event_sample_stub(struct perf_tool *tool __maybe_unused,
214 union perf_event *event __maybe_unused,
215 struct perf_sample *sample __maybe_unused,
216 struct perf_evsel *evsel __maybe_unused,
217 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300218{
219 dump_printf(": unhandled!\n");
220 return 0;
221}
222
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300223static int process_event_stub(struct perf_tool *tool __maybe_unused,
224 union perf_event *event __maybe_unused,
225 struct perf_sample *sample __maybe_unused,
226 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200227{
228 dump_printf(": unhandled!\n");
229 return 0;
230}
231
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300232static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
233 union perf_event *event __maybe_unused,
234 struct perf_session *perf_session
235 __maybe_unused)
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200236{
237 dump_printf(": unhandled!\n");
238 return 0;
239}
240
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300241static int process_event_type_stub(struct perf_tool *tool __maybe_unused,
242 union perf_event *event __maybe_unused)
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200243{
244 dump_printf(": unhandled!\n");
245 return 0;
246}
247
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200248static int process_finished_round(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200249 union perf_event *event,
250 struct perf_session *session);
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200251
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200252static void perf_tool__fill_defaults(struct perf_tool *tool)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200253{
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200254 if (tool->sample == NULL)
255 tool->sample = process_event_sample_stub;
256 if (tool->mmap == NULL)
257 tool->mmap = process_event_stub;
258 if (tool->comm == NULL)
259 tool->comm = process_event_stub;
260 if (tool->fork == NULL)
261 tool->fork = process_event_stub;
262 if (tool->exit == NULL)
263 tool->exit = process_event_stub;
264 if (tool->lost == NULL)
265 tool->lost = perf_event__process_lost;
266 if (tool->read == NULL)
267 tool->read = process_event_sample_stub;
268 if (tool->throttle == NULL)
269 tool->throttle = process_event_stub;
270 if (tool->unthrottle == NULL)
271 tool->unthrottle = process_event_stub;
272 if (tool->attr == NULL)
273 tool->attr = process_event_synth_attr_stub;
274 if (tool->event_type == NULL)
275 tool->event_type = process_event_type_stub;
276 if (tool->tracing_data == NULL)
277 tool->tracing_data = process_event_synth_tracing_data_stub;
278 if (tool->build_id == NULL)
279 tool->build_id = process_finished_round_stub;
280 if (tool->finished_round == NULL) {
281 if (tool->ordered_samples)
282 tool->finished_round = process_finished_round;
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200283 else
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200284 tool->finished_round = process_finished_round_stub;
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200285 }
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200286}
David Ahern80c01202012-06-08 11:47:51 -0300287
288void mem_bswap_32(void *src, int byte_size)
289{
290 u32 *m = src;
291 while (byte_size > 0) {
292 *m = bswap_32(*m);
293 byte_size -= sizeof(u32);
294 ++m;
295 }
296}
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200297
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200298void mem_bswap_64(void *src, int byte_size)
299{
300 u64 *m = src;
301
302 while (byte_size > 0) {
303 *m = bswap_64(*m);
304 byte_size -= sizeof(u64);
305 ++m;
306 }
307}
308
Jiri Olsa268fb202012-05-30 14:23:43 +0200309static void swap_sample_id_all(union perf_event *event, void *data)
310{
311 void *end = (void *) event + event->header.size;
312 int size = end - data;
313
314 BUG_ON(size % sizeof(u64));
315 mem_bswap_64(data, size);
316}
317
318static void perf_event__all64_swap(union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300319 bool sample_id_all __maybe_unused)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200320{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200321 struct perf_event_header *hdr = &event->header;
322 mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200323}
324
Jiri Olsa268fb202012-05-30 14:23:43 +0200325static void perf_event__comm_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->comm.pid = bswap_32(event->comm.pid);
328 event->comm.tid = bswap_32(event->comm.tid);
Jiri Olsa268fb202012-05-30 14:23:43 +0200329
330 if (sample_id_all) {
331 void *data = &event->comm.comm;
332
Irina Tirdea9ac3e482012-09-11 01:15:01 +0300333 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
Jiri Olsa268fb202012-05-30 14:23:43 +0200334 swap_sample_id_all(event, data);
335 }
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200336}
337
Jiri Olsa268fb202012-05-30 14:23:43 +0200338static void perf_event__mmap_swap(union perf_event *event,
339 bool sample_id_all)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200340{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200341 event->mmap.pid = bswap_32(event->mmap.pid);
342 event->mmap.tid = bswap_32(event->mmap.tid);
343 event->mmap.start = bswap_64(event->mmap.start);
344 event->mmap.len = bswap_64(event->mmap.len);
345 event->mmap.pgoff = bswap_64(event->mmap.pgoff);
Jiri Olsa268fb202012-05-30 14:23:43 +0200346
347 if (sample_id_all) {
348 void *data = &event->mmap.filename;
349
Irina Tirdea9ac3e482012-09-11 01:15:01 +0300350 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
Jiri Olsa268fb202012-05-30 14:23:43 +0200351 swap_sample_id_all(event, data);
352 }
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200353}
354
Jiri Olsa268fb202012-05-30 14:23:43 +0200355static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200356{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200357 event->fork.pid = bswap_32(event->fork.pid);
358 event->fork.tid = bswap_32(event->fork.tid);
359 event->fork.ppid = bswap_32(event->fork.ppid);
360 event->fork.ptid = bswap_32(event->fork.ptid);
361 event->fork.time = bswap_64(event->fork.time);
Jiri Olsa268fb202012-05-30 14:23:43 +0200362
363 if (sample_id_all)
364 swap_sample_id_all(event, &event->fork + 1);
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200365}
366
Jiri Olsa268fb202012-05-30 14:23:43 +0200367static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200368{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200369 event->read.pid = bswap_32(event->read.pid);
370 event->read.tid = bswap_32(event->read.tid);
371 event->read.value = bswap_64(event->read.value);
372 event->read.time_enabled = bswap_64(event->read.time_enabled);
373 event->read.time_running = bswap_64(event->read.time_running);
374 event->read.id = bswap_64(event->read.id);
Jiri Olsa268fb202012-05-30 14:23:43 +0200375
376 if (sample_id_all)
377 swap_sample_id_all(event, &event->read + 1);
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200378}
379
Jiri Olsae108c662012-05-16 08:59:03 +0200380static u8 revbyte(u8 b)
381{
382 int rev = (b >> 4) | ((b & 0xf) << 4);
383 rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2);
384 rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1);
385 return (u8) rev;
386}
387
388/*
389 * XXX this is hack in attempt to carry flags bitfield
390 * throught endian village. ABI says:
391 *
392 * Bit-fields are allocated from right to left (least to most significant)
393 * on little-endian implementations and from left to right (most to least
394 * significant) on big-endian implementations.
395 *
396 * The above seems to be byte specific, so we need to reverse each
397 * byte of the bitfield. 'Internet' also says this might be implementation
398 * specific and we probably need proper fix and carry perf_event_attr
399 * bitfield flags in separate data file FEAT_ section. Thought this seems
400 * to work for now.
401 */
402static void swap_bitfield(u8 *p, unsigned len)
403{
404 unsigned i;
405
406 for (i = 0; i < len; i++) {
407 *p = revbyte(*p);
408 p++;
409 }
410}
411
David Aherneda39132011-07-15 12:34:09 -0600412/* exported for swapping attributes in file header */
413void perf_event__attr_swap(struct perf_event_attr *attr)
414{
415 attr->type = bswap_32(attr->type);
416 attr->size = bswap_32(attr->size);
417 attr->config = bswap_64(attr->config);
418 attr->sample_period = bswap_64(attr->sample_period);
419 attr->sample_type = bswap_64(attr->sample_type);
420 attr->read_format = bswap_64(attr->read_format);
421 attr->wakeup_events = bswap_32(attr->wakeup_events);
422 attr->bp_type = bswap_32(attr->bp_type);
423 attr->bp_addr = bswap_64(attr->bp_addr);
424 attr->bp_len = bswap_64(attr->bp_len);
Jiri Olsae108c662012-05-16 08:59:03 +0200425
426 swap_bitfield((u8 *) (&attr->read_format + 1), sizeof(u64));
David Aherneda39132011-07-15 12:34:09 -0600427}
428
Jiri Olsa268fb202012-05-30 14:23:43 +0200429static void perf_event__hdr_attr_swap(union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300430 bool sample_id_all __maybe_unused)
Tom Zanussi2c46dbb2010-04-01 23:59:19 -0500431{
432 size_t size;
433
David Aherneda39132011-07-15 12:34:09 -0600434 perf_event__attr_swap(&event->attr.attr);
Tom Zanussi2c46dbb2010-04-01 23:59:19 -0500435
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200436 size = event->header.size;
437 size -= (void *)&event->attr.id - (void *)event;
438 mem_bswap_64(event->attr.id, size);
Tom Zanussi2c46dbb2010-04-01 23:59:19 -0500439}
440
Jiri Olsa268fb202012-05-30 14:23:43 +0200441static void perf_event__event_type_swap(union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300442 bool sample_id_all __maybe_unused)
Tom Zanussicd19a032010-04-01 23:59:20 -0500443{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200444 event->event_type.event_type.event_id =
445 bswap_64(event->event_type.event_type.event_id);
Tom Zanussicd19a032010-04-01 23:59:20 -0500446}
447
Jiri Olsa268fb202012-05-30 14:23:43 +0200448static void perf_event__tracing_data_swap(union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300449 bool sample_id_all __maybe_unused)
Tom Zanussi92155452010-04-01 23:59:21 -0500450{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200451 event->tracing_data.size = bswap_32(event->tracing_data.size);
Tom Zanussi92155452010-04-01 23:59:21 -0500452}
453
Jiri Olsa268fb202012-05-30 14:23:43 +0200454typedef void (*perf_event__swap_op)(union perf_event *event,
455 bool sample_id_all);
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200456
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200457static perf_event__swap_op perf_event__swap_ops[] = {
458 [PERF_RECORD_MMAP] = perf_event__mmap_swap,
459 [PERF_RECORD_COMM] = perf_event__comm_swap,
460 [PERF_RECORD_FORK] = perf_event__task_swap,
461 [PERF_RECORD_EXIT] = perf_event__task_swap,
462 [PERF_RECORD_LOST] = perf_event__all64_swap,
463 [PERF_RECORD_READ] = perf_event__read_swap,
464 [PERF_RECORD_SAMPLE] = perf_event__all64_swap,
David Aherneda39132011-07-15 12:34:09 -0600465 [PERF_RECORD_HEADER_ATTR] = perf_event__hdr_attr_swap,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200466 [PERF_RECORD_HEADER_EVENT_TYPE] = perf_event__event_type_swap,
467 [PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap,
468 [PERF_RECORD_HEADER_BUILD_ID] = NULL,
469 [PERF_RECORD_HEADER_MAX] = NULL,
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200470};
471
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200472struct sample_queue {
473 u64 timestamp;
Thomas Gleixnere4c2df12010-12-07 12:48:50 +0000474 u64 file_offset;
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200475 union perf_event *event;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200476 struct list_head list;
477};
478
Thomas Gleixner020bb752010-11-30 17:49:53 +0000479static void perf_session_free_sample_buffers(struct perf_session *session)
480{
481 struct ordered_samples *os = &session->ordered_samples;
482
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000483 while (!list_empty(&os->to_free)) {
Thomas Gleixner020bb752010-11-30 17:49:53 +0000484 struct sample_queue *sq;
485
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000486 sq = list_entry(os->to_free.next, struct sample_queue, list);
Thomas Gleixner020bb752010-11-30 17:49:53 +0000487 list_del(&sq->list);
488 free(sq);
489 }
490}
491
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100492static int perf_session_deliver_event(struct perf_session *session,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200493 union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200494 struct perf_sample *sample,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200495 struct perf_tool *tool,
Thomas Gleixnerf74725d2010-12-07 12:48:53 +0000496 u64 file_offset);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100497
David Ahernd25380cd2012-08-26 12:24:41 -0600498static int flush_sample_queue(struct perf_session *s,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200499 struct perf_tool *tool)
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200500{
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000501 struct ordered_samples *os = &s->ordered_samples;
502 struct list_head *head = &os->samples;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200503 struct sample_queue *tmp, *iter;
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200504 struct perf_sample sample;
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000505 u64 limit = os->next_flush;
506 u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
Arnaldo Carvalho de Melo88660562011-10-29 12:41:45 -0200507 unsigned idx = 0, progress_next = os->nr_samples / 16;
Frederic Weisbecker5538bec2011-05-22 02:17:22 +0200508 int ret;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200509
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200510 if (!tool->ordered_samples || !limit)
David Ahernd25380cd2012-08-26 12:24:41 -0600511 return 0;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200512
513 list_for_each_entry_safe(iter, tmp, head, list) {
514 if (iter->timestamp > limit)
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000515 break;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200516
Arnaldo Carvalho de Melo0807d2d2012-09-26 12:48:18 -0300517 ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
Frederic Weisbecker5538bec2011-05-22 02:17:22 +0200518 if (ret)
519 pr_err("Can't parse sample, err = %d\n", ret);
David Ahernd25380cd2012-08-26 12:24:41 -0600520 else {
521 ret = perf_session_deliver_event(s, iter->event, &sample, tool,
522 iter->file_offset);
523 if (ret)
524 return ret;
525 }
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200526
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000527 os->last_flush = iter->timestamp;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200528 list_del(&iter->list);
Thomas Gleixner020bb752010-11-30 17:49:53 +0000529 list_add(&iter->list, &os->sample_cache);
Arnaldo Carvalho de Melo88660562011-10-29 12:41:45 -0200530 if (++idx >= progress_next) {
531 progress_next += os->nr_samples / 16;
532 ui_progress__update(idx, os->nr_samples,
533 "Processing time ordered events...");
534 }
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200535 }
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000536
537 if (list_empty(head)) {
538 os->last_sample = NULL;
539 } else if (last_ts <= limit) {
540 os->last_sample =
541 list_entry(head->prev, struct sample_queue, list);
542 }
Arnaldo Carvalho de Melo88660562011-10-29 12:41:45 -0200543
544 os->nr_samples = 0;
David Ahernd25380cd2012-08-26 12:24:41 -0600545
546 return 0;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200547}
548
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200549/*
550 * When perf record finishes a pass on every buffers, it records this pseudo
551 * event.
552 * We record the max timestamp t found in the pass n.
553 * Assuming these timestamps are monotonic across cpus, we know that if
554 * a buffer still has events with timestamps below t, they will be all
555 * available and then read in the pass n + 1.
556 * Hence when we start to read the pass n + 2, we can safely flush every
557 * events with timestamps below t.
558 *
559 * ============ PASS n =================
560 * CPU 0 | CPU 1
561 * |
562 * cnt1 timestamps | cnt2 timestamps
563 * 1 | 2
564 * 2 | 3
565 * - | 4 <--- max recorded
566 *
567 * ============ PASS n + 1 ==============
568 * CPU 0 | CPU 1
569 * |
570 * cnt1 timestamps | cnt2 timestamps
571 * 3 | 5
572 * 4 | 6
573 * 5 | 7 <---- max recorded
574 *
575 * Flush every events below timestamp 4
576 *
577 * ============ PASS n + 2 ==============
578 * CPU 0 | CPU 1
579 * |
580 * cnt1 timestamps | cnt2 timestamps
581 * 6 | 8
582 * 7 | 9
583 * - | 10
584 *
585 * Flush every events below timestamp 7
586 * etc...
587 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200588static int process_finished_round(struct perf_tool *tool,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300589 union perf_event *event __maybe_unused,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200590 struct perf_session *session)
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200591{
David Ahernd25380cd2012-08-26 12:24:41 -0600592 int ret = flush_sample_queue(session, tool);
593 if (!ret)
594 session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200595
David Ahernd25380cd2012-08-26 12:24:41 -0600596 return ret;
Frederic Weisbeckerd6b17be2010-05-03 15:14:33 +0200597}
598
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200599/* The queue is ordered by time */
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100600static void __queue_event(struct sample_queue *new, struct perf_session *s)
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200601{
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000602 struct ordered_samples *os = &s->ordered_samples;
603 struct sample_queue *sample = os->last_sample;
604 u64 timestamp = new->timestamp;
605 struct list_head *p;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200606
Arnaldo Carvalho de Melo88660562011-10-29 12:41:45 -0200607 ++os->nr_samples;
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000608 os->last_sample = new;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200609
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000610 if (!sample) {
611 list_add(&new->list, &os->samples);
612 os->max_timestamp = timestamp;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200613 return;
614 }
615
616 /*
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000617 * last_sample might point to some random place in the list as it's
618 * the last queued event. We expect that the new event is close to
619 * this.
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200620 */
Thomas Gleixnera1225de2010-11-30 17:49:33 +0000621 if (sample->timestamp <= timestamp) {
622 while (sample->timestamp <= timestamp) {
623 p = sample->list.next;
624 if (p == &os->samples) {
625 list_add_tail(&new->list, &os->samples);
626 os->max_timestamp = timestamp;
627 return;
628 }
629 sample = list_entry(p, struct sample_queue, list);
630 }
631 list_add_tail(&new->list, &sample->list);
632 } else {
633 while (sample->timestamp > timestamp) {
634 p = sample->list.prev;
635 if (p == &os->samples) {
636 list_add(&new->list, &os->samples);
637 return;
638 }
639 sample = list_entry(p, struct sample_queue, list);
640 }
641 list_add(&new->list, &sample->list);
642 }
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200643}
644
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000645#define MAX_SAMPLE_BUFFER (64 * 1024 / sizeof(struct sample_queue))
646
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200647static int perf_session_queue_event(struct perf_session *s, union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200648 struct perf_sample *sample, u64 file_offset)
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200649{
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000650 struct ordered_samples *os = &s->ordered_samples;
651 struct list_head *sc = &os->sample_cache;
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200652 u64 timestamp = sample->time;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200653 struct sample_queue *new;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200654
Thomas Gleixner79a14c12010-12-07 12:48:44 +0000655 if (!timestamp || timestamp == ~0ULL)
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100656 return -ETIME;
657
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200658 if (timestamp < s->ordered_samples.last_flush) {
659 printf("Warning: Timestamp below last timeslice flush\n");
660 return -EINVAL;
661 }
662
Thomas Gleixner020bb752010-11-30 17:49:53 +0000663 if (!list_empty(sc)) {
664 new = list_entry(sc->next, struct sample_queue, list);
665 list_del(&new->list);
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000666 } else if (os->sample_buffer) {
667 new = os->sample_buffer + os->sample_buffer_idx;
668 if (++os->sample_buffer_idx == MAX_SAMPLE_BUFFER)
669 os->sample_buffer = NULL;
Thomas Gleixner020bb752010-11-30 17:49:53 +0000670 } else {
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000671 os->sample_buffer = malloc(MAX_SAMPLE_BUFFER * sizeof(*new));
672 if (!os->sample_buffer)
Thomas Gleixner020bb752010-11-30 17:49:53 +0000673 return -ENOMEM;
Thomas Gleixner5c891f32010-11-30 17:49:55 +0000674 list_add(&os->sample_buffer->list, &os->to_free);
675 os->sample_buffer_idx = 2;
676 new = os->sample_buffer + 1;
Thomas Gleixner020bb752010-11-30 17:49:53 +0000677 }
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200678
679 new->timestamp = timestamp;
Thomas Gleixnere4c2df12010-12-07 12:48:50 +0000680 new->file_offset = file_offset;
Thomas Gleixnerfe174202010-11-30 17:49:49 +0000681 new->event = event;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200682
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100683 __queue_event(new, s);
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +0200684
685 return 0;
686}
687
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200688static void callchain__printf(struct perf_sample *sample)
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200689{
690 unsigned int i;
691
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200692 printf("... chain: nr:%" PRIu64 "\n", sample->callchain->nr);
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200693
694 for (i = 0; i < sample->callchain->nr; i++)
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200695 printf("..... %2d: %016" PRIx64 "\n",
696 i, sample->callchain->ips[i]);
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200697}
698
Roberto Agostino Vitillob5387522012-02-09 23:21:01 +0100699static void branch_stack__printf(struct perf_sample *sample)
700{
701 uint64_t i;
702
703 printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);
704
705 for (i = 0; i < sample->branch_stack->nr; i++)
706 printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 "\n",
707 i, sample->branch_stack->entries[i].from,
708 sample->branch_stack->entries[i].to);
709}
710
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200711static void regs_dump__printf(u64 mask, u64 *regs)
712{
713 unsigned rid, i = 0;
714
715 for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) {
716 u64 val = regs[i++];
717
718 printf(".... %-5s 0x%" PRIx64 "\n",
719 perf_reg_name(rid), val);
720 }
721}
722
723static void regs_user__printf(struct perf_sample *sample, u64 mask)
724{
725 struct regs_dump *user_regs = &sample->user_regs;
726
727 if (user_regs->regs) {
728 printf("... user regs: mask 0x%" PRIx64 "\n", mask);
729 regs_dump__printf(mask, user_regs->regs);
730 }
731}
732
733static void stack_user__printf(struct stack_dump *dump)
734{
735 printf("... ustack: size %" PRIu64 ", offset 0x%x\n",
736 dump->size, dump->offset);
737}
738
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200739static void perf_session__print_tstamp(struct perf_session *session,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200740 union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200741 struct perf_sample *sample)
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200742{
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300743 u64 sample_type = perf_evlist__sample_type(session->evlist);
744
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200745 if (event->header.type != PERF_RECORD_SAMPLE &&
Arnaldo Carvalho de Melo5e562472012-08-01 19:25:26 -0300746 !perf_evlist__sample_id_all(session->evlist)) {
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200747 fputs("-1 -1 ", stdout);
748 return;
749 }
750
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300751 if ((sample_type & PERF_SAMPLE_CPU))
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200752 printf("%u ", sample->cpu);
753
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300754 if (sample_type & PERF_SAMPLE_TIME)
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200755 printf("%" PRIu64 " ", sample->time);
Arnaldo Carvalho de Melo9c90a612010-12-02 10:25:28 -0200756}
757
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200758static void dump_event(struct perf_session *session, union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200759 u64 file_offset, struct perf_sample *sample)
Thomas Gleixner9aefcab2010-12-07 12:48:47 +0000760{
761 if (!dump_trace)
762 return;
763
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200764 printf("\n%#" PRIx64 " [%#x]: event: %d\n",
765 file_offset, event->header.size, event->header.type);
Thomas Gleixner9aefcab2010-12-07 12:48:47 +0000766
767 trace_event(event);
768
769 if (sample)
770 perf_session__print_tstamp(session, event, sample);
771
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200772 printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200773 event->header.size, perf_event__name(event->header.type));
Thomas Gleixner9aefcab2010-12-07 12:48:47 +0000774}
775
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200776static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200777 struct perf_sample *sample)
Thomas Gleixner9aefcab2010-12-07 12:48:47 +0000778{
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300779 u64 sample_type;
780
Arnaldo Carvalho de Meloddbc24b2010-12-09 12:20:20 -0200781 if (!dump_trace)
782 return;
783
David Ahern7cec0922011-05-30 13:08:23 -0600784 printf("(IP, %d): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -0200785 event->header.misc, sample->pid, sample->tid, sample->ip,
David Ahern7cec0922011-05-30 13:08:23 -0600786 sample->period, sample->addr);
Thomas Gleixner9aefcab2010-12-07 12:48:47 +0000787
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200788 sample_type = evsel->attr.sample_type;
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300789
790 if (sample_type & PERF_SAMPLE_CALLCHAIN)
Arnaldo Carvalho de Meloddbc24b2010-12-09 12:20:20 -0200791 callchain__printf(sample);
Roberto Agostino Vitillob5387522012-02-09 23:21:01 +0100792
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300793 if (sample_type & PERF_SAMPLE_BRANCH_STACK)
Roberto Agostino Vitillob5387522012-02-09 23:21:01 +0100794 branch_stack__printf(sample);
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200795
796 if (sample_type & PERF_SAMPLE_REGS_USER)
797 regs_user__printf(sample, evsel->attr.sample_regs_user);
798
799 if (sample_type & PERF_SAMPLE_STACK_USER)
800 stack_user__printf(&sample->user_stack);
Thomas Gleixner9aefcab2010-12-07 12:48:47 +0000801}
802
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200803static struct machine *
804 perf_session__find_machine_for_cpumode(struct perf_session *session,
805 union perf_event *event)
806{
807 const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
808
David Ahern7c0f4a42012-07-20 17:25:48 -0600809 if (perf_guest &&
810 ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
811 (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
Nikunj A. Dadhania7fb0a5e2012-04-09 13:52:23 +0530812 u32 pid;
813
814 if (event->header.type == PERF_RECORD_MMAP)
815 pid = event->mmap.pid;
816 else
817 pid = event->ip.pid;
818
David Ahern207b5792012-07-01 16:11:37 -0600819 return perf_session__findnew_machine(session, pid);
Nikunj A. Dadhania7fb0a5e2012-04-09 13:52:23 +0530820 }
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200821
Arnaldo Carvalho de Melo34ba5122012-12-19 09:04:24 -0300822 return &session->machines.host;
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200823}
824
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100825static int perf_session_deliver_event(struct perf_session *session,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200826 union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200827 struct perf_sample *sample,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200828 struct perf_tool *tool,
Thomas Gleixner532e7262010-12-07 12:48:55 +0000829 u64 file_offset)
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100830{
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300831 struct perf_evsel *evsel;
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200832 struct machine *machine;
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300833
Thomas Gleixner532e7262010-12-07 12:48:55 +0000834 dump_event(session, event, file_offset, sample);
835
Arnaldo Carvalho de Melo7b275092011-10-29 12:15:04 -0200836 evsel = perf_evlist__id2evsel(session->evlist, sample->id);
837 if (evsel != NULL && event->header.type != PERF_RECORD_SAMPLE) {
838 /*
839 * XXX We're leaving PERF_RECORD_SAMPLE unnacounted here
840 * because the tools right now may apply filters, discarding
841 * some of the samples. For consistency, in the future we
842 * should have something like nr_filtered_samples and remove
843 * the sample->period from total_sample_period, etc, KISS for
844 * now tho.
845 *
846 * Also testing against NULL allows us to handle files without
847 * attr.sample_id_all and/or without PERF_SAMPLE_ID. In the
848 * future probably it'll be a good idea to restrict event
849 * processing via perf_session to files with both set.
850 */
851 hists__inc_nr_events(&evsel->hists, event->header.type);
852 }
853
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200854 machine = perf_session__find_machine_for_cpumode(session, event);
855
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100856 switch (event->header.type) {
857 case PERF_RECORD_SAMPLE:
Jiri Olsa0f6a3012012-08-07 15:20:45 +0200858 dump_sample(evsel, event, sample);
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300859 if (evsel == NULL) {
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300860 ++session->stats.nr_unknown_id;
Jiri Olsa67822062012-04-12 14:21:01 +0200861 return 0;
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -0300862 }
Joerg Roedel0c095712012-02-10 18:05:04 +0100863 if (machine == NULL) {
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300864 ++session->stats.nr_unprocessable_samples;
Jiri Olsa67822062012-04-12 14:21:01 +0200865 return 0;
Joerg Roedel0c095712012-02-10 18:05:04 +0100866 }
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200867 return tool->sample(tool, event, sample, evsel, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100868 case PERF_RECORD_MMAP:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200869 return tool->mmap(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100870 case PERF_RECORD_COMM:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200871 return tool->comm(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100872 case PERF_RECORD_FORK:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200873 return tool->fork(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100874 case PERF_RECORD_EXIT:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200875 return tool->exit(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100876 case PERF_RECORD_LOST:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200877 if (tool->lost == perf_event__process_lost)
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300878 session->stats.total_lost += event->lost.lost;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200879 return tool->lost(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100880 case PERF_RECORD_READ:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200881 return tool->read(tool, event, sample, evsel, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100882 case PERF_RECORD_THROTTLE:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200883 return tool->throttle(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100884 case PERF_RECORD_UNTHROTTLE:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200885 return tool->unthrottle(tool, event, sample, machine);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100886 default:
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300887 ++session->stats.nr_unknown_events;
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100888 return -1;
889 }
890}
891
Thomas Gleixner3dfc2c02010-12-07 12:48:58 +0000892static int perf_session__preprocess_sample(struct perf_session *session,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200893 union perf_event *event, struct perf_sample *sample)
Thomas Gleixner3dfc2c02010-12-07 12:48:58 +0000894{
895 if (event->header.type != PERF_RECORD_SAMPLE ||
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300896 !(perf_evlist__sample_type(session->evlist) & PERF_SAMPLE_CALLCHAIN))
Thomas Gleixner3dfc2c02010-12-07 12:48:58 +0000897 return 0;
898
899 if (!ip_callchain__valid(sample->callchain, event)) {
900 pr_debug("call-chain problem with event, skipping it.\n");
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300901 ++session->stats.nr_invalid_chains;
902 session->stats.total_invalid_chains += sample->period;
Thomas Gleixner3dfc2c02010-12-07 12:48:58 +0000903 return -EINVAL;
904 }
905 return 0;
906}
907
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200908static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200909 struct perf_tool *tool, u64 file_offset)
Thomas Gleixnerba74f062010-12-07 12:49:01 +0000910{
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -0200911 int err;
912
Thomas Gleixnerba74f062010-12-07 12:49:01 +0000913 dump_event(session, event, file_offset, NULL);
914
915 /* These events are processed right away */
916 switch (event->header.type) {
917 case PERF_RECORD_HEADER_ATTR:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200918 err = tool->attr(event, &session->evlist);
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -0200919 if (err == 0)
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -0300920 perf_session__set_id_hdr_size(session);
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -0200921 return err;
Thomas Gleixnerba74f062010-12-07 12:49:01 +0000922 case PERF_RECORD_HEADER_EVENT_TYPE:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200923 return tool->event_type(tool, event);
Thomas Gleixnerba74f062010-12-07 12:49:01 +0000924 case PERF_RECORD_HEADER_TRACING_DATA:
925 /* setup for reading amidst mmap */
926 lseek(session->fd, file_offset, SEEK_SET);
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200927 return tool->tracing_data(event, session);
Thomas Gleixnerba74f062010-12-07 12:49:01 +0000928 case PERF_RECORD_HEADER_BUILD_ID:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200929 return tool->build_id(tool, event, session);
Thomas Gleixnerba74f062010-12-07 12:49:01 +0000930 case PERF_RECORD_FINISHED_ROUND:
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200931 return tool->finished_round(tool, event, session);
Thomas Gleixnerba74f062010-12-07 12:49:01 +0000932 default:
933 return -EINVAL;
934 }
935}
936
Jiri Olsa268fb202012-05-30 14:23:43 +0200937static void event_swap(union perf_event *event, bool sample_id_all)
938{
939 perf_event__swap_op swap;
940
941 swap = perf_event__swap_ops[event->header.type];
942 if (swap)
943 swap(event, sample_id_all);
944}
945
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100946static int perf_session__process_event(struct perf_session *session,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200947 union perf_event *event,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200948 struct perf_tool *tool,
Thomas Gleixner0331ee02010-11-30 17:49:38 +0000949 u64 file_offset)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200950{
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200951 struct perf_sample sample;
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100952 int ret;
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200953
Jiri Olsa268fb202012-05-30 14:23:43 +0200954 if (session->header.needs_swap)
Arnaldo Carvalho de Melo5e562472012-08-01 19:25:26 -0300955 event_swap(event, perf_evlist__sample_id_all(session->evlist));
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200956
Thomas Gleixner9aefcab2010-12-07 12:48:47 +0000957 if (event->header.type >= PERF_RECORD_HEADER_MAX)
958 return -EINVAL;
Arnaldo Carvalho de Melo640c03c2010-12-02 14:10:21 -0200959
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -0300960 events_stats__inc(&session->stats, event->header.type);
Thomas Gleixner9aefcab2010-12-07 12:48:47 +0000961
962 if (event->header.type >= PERF_RECORD_USER_TYPE_START)
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200963 return perf_session__process_user_event(session, event, tool, file_offset);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100964
Thomas Gleixner3dfc2c02010-12-07 12:48:58 +0000965 /*
966 * For all kernel events we get the sample data
967 */
Arnaldo Carvalho de Melo0807d2d2012-09-26 12:48:18 -0300968 ret = perf_evlist__parse_sample(session->evlist, event, &sample);
Frederic Weisbecker5538bec2011-05-22 02:17:22 +0200969 if (ret)
970 return ret;
Thomas Gleixner3dfc2c02010-12-07 12:48:58 +0000971
972 /* Preprocess sample records - precheck callchains */
973 if (perf_session__preprocess_sample(session, event, &sample))
974 return 0;
975
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200976 if (tool->ordered_samples) {
Thomas Gleixnere4c2df12010-12-07 12:48:50 +0000977 ret = perf_session_queue_event(session, event, &sample,
978 file_offset);
Thomas Gleixnercbf41642010-12-05 14:32:55 +0100979 if (ret != -ETIME)
980 return ret;
981 }
982
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200983 return perf_session_deliver_event(session, event, &sample, tool,
Thomas Gleixnerf74725d2010-12-07 12:48:53 +0000984 file_offset);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200985}
986
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -0200987void perf_event_header__bswap(struct perf_event_header *self)
988{
989 self->type = bswap_32(self->type);
990 self->misc = bswap_16(self->misc);
991 self->size = bswap_16(self->size);
992}
993
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200994struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
995{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300996 return machine__findnew_thread(&session->machines.host, pid);
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -0200997}
998
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -0200999static struct thread *perf_session__register_idle_thread(struct perf_session *self)
1000{
1001 struct thread *thread = perf_session__findnew(self, 0);
1002
1003 if (thread == NULL || thread__set_comm(thread, "swapper")) {
1004 pr_err("problem inserting idle task.\n");
1005 thread = NULL;
1006 }
1007
1008 return thread;
1009}
1010
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001011static void perf_session__warn_about_errors(const struct perf_session *session,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001012 const struct perf_tool *tool)
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001013{
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001014 if (tool->lost == perf_event__process_lost &&
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001015 session->stats.nr_events[PERF_RECORD_LOST] != 0) {
Arnaldo Carvalho de Melo7b275092011-10-29 12:15:04 -02001016 ui__warning("Processed %d events and lost %d chunks!\n\n"
1017 "Check IO/CPU overload!\n\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001018 session->stats.nr_events[0],
1019 session->stats.nr_events[PERF_RECORD_LOST]);
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001020 }
1021
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001022 if (session->stats.nr_unknown_events != 0) {
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001023 ui__warning("Found %u unknown events!\n\n"
1024 "Is this an older tool processing a perf.data "
1025 "file generated by a more recent tool?\n\n"
1026 "If that is not the case, consider "
1027 "reporting to linux-kernel@vger.kernel.org.\n\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001028 session->stats.nr_unknown_events);
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001029 }
1030
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001031 if (session->stats.nr_unknown_id != 0) {
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -03001032 ui__warning("%u samples with id not present in the header\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001033 session->stats.nr_unknown_id);
Arnaldo Carvalho de Melo9e69c212011-03-15 15:44:01 -03001034 }
1035
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001036 if (session->stats.nr_invalid_chains != 0) {
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001037 ui__warning("Found invalid callchains!\n\n"
1038 "%u out of %u events were discarded for this reason.\n\n"
1039 "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001040 session->stats.nr_invalid_chains,
1041 session->stats.nr_events[PERF_RECORD_SAMPLE]);
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001042 }
Joerg Roedel0c095712012-02-10 18:05:04 +01001043
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001044 if (session->stats.nr_unprocessable_samples != 0) {
Joerg Roedel0c095712012-02-10 18:05:04 +01001045 ui__warning("%u unprocessable samples recorded.\n"
1046 "Do you have a KVM guest running and not using 'perf kvm'?\n",
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001047 session->stats.nr_unprocessable_samples);
Joerg Roedel0c095712012-02-10 18:05:04 +01001048 }
Arnaldo Carvalho de Melo11095992011-01-04 16:25:15 -02001049}
1050
Tom Zanussi8dc58102010-04-01 23:59:15 -05001051#define session_done() (*(volatile int *)(&session_done))
1052volatile int session_done;
1053
1054static int __perf_session__process_pipe_events(struct perf_session *self,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001055 struct perf_tool *tool)
Tom Zanussi8dc58102010-04-01 23:59:15 -05001056{
Stephane Eranian444d2862012-05-15 13:28:12 +02001057 union perf_event *event;
1058 uint32_t size, cur_size = 0;
1059 void *buf = NULL;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001060 int skip = 0;
1061 u64 head;
1062 int err;
1063 void *p;
1064
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001065 perf_tool__fill_defaults(tool);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001066
1067 head = 0;
Stephane Eranian444d2862012-05-15 13:28:12 +02001068 cur_size = sizeof(union perf_event);
1069
1070 buf = malloc(cur_size);
1071 if (!buf)
1072 return -errno;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001073more:
Stephane Eranian444d2862012-05-15 13:28:12 +02001074 event = buf;
1075 err = readn(self->fd, event, sizeof(struct perf_event_header));
Tom Zanussi8dc58102010-04-01 23:59:15 -05001076 if (err <= 0) {
1077 if (err == 0)
1078 goto done;
1079
1080 pr_err("failed to read event header\n");
1081 goto out_err;
1082 }
1083
1084 if (self->header.needs_swap)
Stephane Eranian444d2862012-05-15 13:28:12 +02001085 perf_event_header__bswap(&event->header);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001086
Stephane Eranian444d2862012-05-15 13:28:12 +02001087 size = event->header.size;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001088 if (size == 0)
1089 size = 8;
1090
Stephane Eranian444d2862012-05-15 13:28:12 +02001091 if (size > cur_size) {
1092 void *new = realloc(buf, size);
1093 if (!new) {
1094 pr_err("failed to allocate memory to read event\n");
1095 goto out_err;
1096 }
1097 buf = new;
1098 cur_size = size;
1099 event = buf;
1100 }
1101 p = event;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001102 p += sizeof(struct perf_event_header);
1103
Tom Zanussi794e43b2010-05-05 00:27:40 -05001104 if (size - sizeof(struct perf_event_header)) {
Arnaldo Carvalho de Melo1e7972c2011-01-03 16:50:55 -02001105 err = readn(self->fd, p, size - sizeof(struct perf_event_header));
Tom Zanussi794e43b2010-05-05 00:27:40 -05001106 if (err <= 0) {
1107 if (err == 0) {
1108 pr_err("unexpected end of event stream\n");
1109 goto done;
1110 }
Tom Zanussi8dc58102010-04-01 23:59:15 -05001111
Tom Zanussi794e43b2010-05-05 00:27:40 -05001112 pr_err("failed to read event data\n");
1113 goto out_err;
1114 }
Tom Zanussi8dc58102010-04-01 23:59:15 -05001115 }
1116
Stephane Eranian444d2862012-05-15 13:28:12 +02001117 if ((skip = perf_session__process_event(self, event, tool, head)) < 0) {
Jiri Olsa9389a462012-04-16 20:42:51 +02001118 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
Stephane Eranian444d2862012-05-15 13:28:12 +02001119 head, event->header.size, event->header.type);
Jiri Olsa9389a462012-04-16 20:42:51 +02001120 err = -EINVAL;
1121 goto out_err;
Tom Zanussi8dc58102010-04-01 23:59:15 -05001122 }
1123
1124 head += size;
1125
Tom Zanussi8dc58102010-04-01 23:59:15 -05001126 if (skip > 0)
1127 head += skip;
1128
1129 if (!session_done())
1130 goto more;
1131done:
1132 err = 0;
1133out_err:
Stephane Eranian444d2862012-05-15 13:28:12 +02001134 free(buf);
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001135 perf_session__warn_about_errors(self, tool);
Thomas Gleixner020bb752010-11-30 17:49:53 +00001136 perf_session_free_sample_buffers(self);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001137 return err;
1138}
1139
Frederic Weisbecker998bedc2011-05-23 13:06:28 +02001140static union perf_event *
1141fetch_mmaped_event(struct perf_session *session,
1142 u64 head, size_t mmap_size, char *buf)
1143{
1144 union perf_event *event;
1145
1146 /*
1147 * Ensure we have enough space remaining to read
1148 * the size of the event in the headers.
1149 */
1150 if (head + sizeof(event->header) > mmap_size)
1151 return NULL;
1152
1153 event = (union perf_event *)(buf + head);
1154
1155 if (session->header.needs_swap)
1156 perf_event_header__bswap(&event->header);
1157
1158 if (head + event->header.size > mmap_size)
1159 return NULL;
1160
1161 return event;
1162}
1163
David Miller35d48dd2012-11-10 14:12:19 -05001164/*
1165 * On 64bit we can mmap the data file in one go. No need for tiny mmap
1166 * slices. On 32bit we use 32MB.
1167 */
1168#if BITS_PER_LONG == 64
1169#define MMAP_SIZE ULLONG_MAX
1170#define NUM_MMAPS 1
1171#else
1172#define MMAP_SIZE (32 * 1024 * 1024ULL)
1173#define NUM_MMAPS 128
1174#endif
1175
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001176int __perf_session__process_events(struct perf_session *session,
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001177 u64 data_offset, u64 data_size,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001178 u64 file_size, struct perf_tool *tool)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001179{
Thomas Gleixner55b44622010-11-30 17:49:46 +00001180 u64 head, page_offset, file_offset, file_pos, progress_next;
Thomas Gleixnerfe174202010-11-30 17:49:49 +00001181 int err, mmap_prot, mmap_flags, map_idx = 0;
Arnaldo Carvalho de Melo0c1fe6b2012-10-06 14:57:10 -03001182 size_t mmap_size;
David Miller35d48dd2012-11-10 14:12:19 -05001183 char *buf, *mmaps[NUM_MMAPS];
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02001184 union perf_event *event;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001185 uint32_t size;
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001186
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001187 perf_tool__fill_defaults(tool);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001188
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001189 page_offset = page_size * (data_offset / page_size);
1190 file_offset = page_offset;
1191 head = data_offset - page_offset;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001192
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001193 if (data_offset + data_size < file_size)
1194 file_size = data_offset + data_size;
1195
Thomas Gleixner55b44622010-11-30 17:49:46 +00001196 progress_next = file_size / 16;
Thomas Gleixner55b44622010-11-30 17:49:46 +00001197
David Miller35d48dd2012-11-10 14:12:19 -05001198 mmap_size = MMAP_SIZE;
Thomas Gleixner55b44622010-11-30 17:49:46 +00001199 if (mmap_size > file_size)
1200 mmap_size = file_size;
1201
Thomas Gleixnerfe174202010-11-30 17:49:49 +00001202 memset(mmaps, 0, sizeof(mmaps));
1203
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02001204 mmap_prot = PROT_READ;
1205 mmap_flags = MAP_SHARED;
1206
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001207 if (session->header.needs_swap) {
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02001208 mmap_prot |= PROT_WRITE;
1209 mmap_flags = MAP_PRIVATE;
1210 }
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001211remap:
Thomas Gleixner55b44622010-11-30 17:49:46 +00001212 buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, session->fd,
1213 file_offset);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001214 if (buf == MAP_FAILED) {
1215 pr_err("failed to mmap file\n");
1216 err = -errno;
1217 goto out_err;
1218 }
Thomas Gleixnerfe174202010-11-30 17:49:49 +00001219 mmaps[map_idx] = buf;
1220 map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001221 file_pos = file_offset + head;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001222
1223more:
Frederic Weisbecker998bedc2011-05-23 13:06:28 +02001224 event = fetch_mmaped_event(session, head, mmap_size, buf);
1225 if (!event) {
Thomas Gleixnerfe174202010-11-30 17:49:49 +00001226 if (mmaps[map_idx]) {
1227 munmap(mmaps[map_idx], mmap_size);
1228 mmaps[map_idx] = NULL;
1229 }
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001230
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001231 page_offset = page_size * (head / page_size);
1232 file_offset += page_offset;
1233 head -= page_offset;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001234 goto remap;
1235 }
1236
1237 size = event->header.size;
1238
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001239 if (size == 0 ||
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001240 perf_session__process_event(session, event, tool, file_pos) < 0) {
Jiri Olsa9389a462012-04-16 20:42:51 +02001241 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1242 file_offset + head, event->header.size,
1243 event->header.type);
1244 err = -EINVAL;
1245 goto out_err;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001246 }
1247
1248 head += size;
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001249 file_pos += size;
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001250
Thomas Gleixner55b44622010-11-30 17:49:46 +00001251 if (file_pos >= progress_next) {
1252 progress_next += file_size / 16;
Arnaldo Carvalho de Meloca59bcb2011-10-25 13:29:11 -02001253 ui_progress__update(file_pos, file_size,
1254 "Processing events...");
Thomas Gleixner55b44622010-11-30 17:49:46 +00001255 }
1256
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001257 if (file_pos < file_size)
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001258 goto more;
Thomas Gleixnerd6513282010-11-30 17:49:44 +00001259
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001260 err = 0;
Frederic Weisbeckerc61e52e2010-04-24 00:04:12 +02001261 /* do the final flush for ordered samples */
Thomas Gleixner0331ee02010-11-30 17:49:38 +00001262 session->ordered_samples.next_flush = ULLONG_MAX;
David Ahernd25380cd2012-08-26 12:24:41 -06001263 err = flush_sample_queue(session, tool);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001264out_err:
Namhyung Kima5580f32012-11-13 22:30:34 +09001265 ui_progress__finish();
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001266 perf_session__warn_about_errors(session, tool);
Thomas Gleixner020bb752010-11-30 17:49:53 +00001267 perf_session_free_sample_buffers(session);
Arnaldo Carvalho de Melo06aae5902009-12-27 21:36:59 -02001268 return err;
1269}
Arnaldo Carvalho de Melo27295592009-12-27 21:37:01 -02001270
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001271int perf_session__process_events(struct perf_session *self,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001272 struct perf_tool *tool)
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001273{
1274 int err;
1275
1276 if (perf_session__register_idle_thread(self) == NULL)
1277 return -ENOMEM;
1278
Tom Zanussi8dc58102010-04-01 23:59:15 -05001279 if (!self->fd_pipe)
1280 err = __perf_session__process_events(self,
1281 self->header.data_offset,
1282 self->header.data_size,
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001283 self->size, tool);
Tom Zanussi8dc58102010-04-01 23:59:15 -05001284 else
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001285 err = __perf_session__process_pipe_events(self, tool);
Dave Martin88ca8952010-07-27 11:46:12 -03001286
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001287 return err;
1288}
1289
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -03001290bool perf_session__has_traces(struct perf_session *session, const char *msg)
Arnaldo Carvalho de Melo27295592009-12-27 21:37:01 -02001291{
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -03001292 if (!(perf_evlist__sample_type(session->evlist) & PERF_SAMPLE_RAW)) {
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -02001293 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
1294 return false;
Arnaldo Carvalho de Melo27295592009-12-27 21:37:01 -02001295 }
1296
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -02001297 return true;
Arnaldo Carvalho de Melo27295592009-12-27 21:37:01 -02001298}
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001299
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -02001300int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
1301 const char *symbol_name, u64 addr)
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001302{
1303 char *bracket;
Arnaldo Carvalho de Melo9de89fe2010-02-03 16:52:00 -02001304 enum map_type i;
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001305 struct ref_reloc_sym *ref;
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001306
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001307 ref = zalloc(sizeof(struct ref_reloc_sym));
1308 if (ref == NULL)
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001309 return -ENOMEM;
1310
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001311 ref->name = strdup(symbol_name);
1312 if (ref->name == NULL) {
1313 free(ref);
1314 return -ENOMEM;
1315 }
1316
1317 bracket = strchr(ref->name, ']');
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001318 if (bracket)
1319 *bracket = '\0';
1320
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001321 ref->addr = addr;
Arnaldo Carvalho de Melo9de89fe2010-02-03 16:52:00 -02001322
1323 for (i = 0; i < MAP__NR_TYPES; ++i) {
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001324 struct kmap *kmap = map__kmap(maps[i]);
1325 kmap->ref_reloc_sym = ref;
Arnaldo Carvalho de Melo9de89fe2010-02-03 16:52:00 -02001326 }
1327
Arnaldo Carvalho de Melo56b03f32010-01-05 16:50:31 -02001328 return 0;
1329}
Arnaldo Carvalho de Melo1f626bc2010-05-09 19:57:08 -03001330
1331size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp)
1332{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -03001333 return machines__fprintf_dsos(&self->machines, fp);
Arnaldo Carvalho de Melo1f626bc2010-05-09 19:57:08 -03001334}
Arnaldo Carvalho de Melof8690972010-05-19 13:41:23 -03001335
1336size_t perf_session__fprintf_dsos_buildid(struct perf_session *self, FILE *fp,
Arnaldo Carvalho de Melo417c2ff2012-12-07 09:53:58 -03001337 bool (skip)(struct dso *dso, int parm), int parm)
Arnaldo Carvalho de Melof8690972010-05-19 13:41:23 -03001338{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -03001339 return machines__fprintf_dsos_buildid(&self->machines, fp, skip, parm);
Arnaldo Carvalho de Melof8690972010-05-19 13:41:23 -03001340}
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -03001341
1342size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
1343{
1344 struct perf_evsel *pos;
1345 size_t ret = fprintf(fp, "Aggregated stats:\n");
1346
Arnaldo Carvalho de Melo28a6b6a2012-12-18 16:24:46 -03001347 ret += events_stats__fprintf(&session->stats, fp);
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -03001348
1349 list_for_each_entry(pos, &session->evlist->entries, node) {
Arnaldo Carvalho de Melo7289f832012-06-12 12:34:58 -03001350 ret += fprintf(fp, "%s stats:\n", perf_evsel__name(pos));
Arnaldo Carvalho de Melo52168ee2012-12-18 16:02:17 -03001351 ret += events_stats__fprintf(&pos->hists.stats, fp);
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -03001352 }
1353
1354 return ret;
1355}
David Ahernc0230b22011-03-09 22:23:27 -07001356
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -02001357size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
1358{
1359 /*
1360 * FIXME: Here we have to actually print all the machines in this
1361 * session, not just the host...
1362 */
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -03001363 return machine__fprintf(&session->machines.host, fp);
Arnaldo Carvalho de Melob424eba2011-11-09 13:24:25 -02001364}
1365
David Ahern9cbdb702011-04-06 21:54:20 -06001366struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
1367 unsigned int type)
1368{
1369 struct perf_evsel *pos;
1370
1371 list_for_each_entry(pos, &session->evlist->entries, node) {
1372 if (pos->attr.type == type)
1373 return pos;
1374 }
1375 return NULL;
1376}
1377
Jiri Olsa71ad0f52012-08-07 15:20:46 +02001378void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
1379 struct perf_sample *sample, struct machine *machine,
1380 int print_sym, int print_dso, int print_symoffset)
David Ahernc0230b22011-03-09 22:23:27 -07001381{
1382 struct addr_location al;
David Ahernc0230b22011-03-09 22:23:27 -07001383 struct callchain_cursor_node *node;
1384
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -02001385 if (perf_event__preprocess_sample(event, machine, &al, sample,
David Ahernc0230b22011-03-09 22:23:27 -07001386 NULL) < 0) {
1387 error("problem processing %d event, skipping it.\n",
1388 event->header.type);
1389 return;
1390 }
1391
1392 if (symbol_conf.use_callchain && sample->callchain) {
1393
Jiri Olsa71ad0f52012-08-07 15:20:46 +02001394
1395 if (machine__resolve_callchain(machine, evsel, al.thread,
1396 sample, NULL) != 0) {
David Ahernc0230b22011-03-09 22:23:27 -07001397 if (verbose)
1398 error("Failed to resolve callchain. Skipping\n");
1399 return;
1400 }
Namhyung Kim47260642012-05-31 14:43:26 +09001401 callchain_cursor_commit(&callchain_cursor);
David Ahernc0230b22011-03-09 22:23:27 -07001402
1403 while (1) {
Namhyung Kim47260642012-05-31 14:43:26 +09001404 node = callchain_cursor_current(&callchain_cursor);
David Ahernc0230b22011-03-09 22:23:27 -07001405 if (!node)
1406 break;
1407
David Ahern787bef12011-05-27 14:28:43 -06001408 printf("\t%16" PRIx64, node->ip);
1409 if (print_sym) {
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001410 printf(" ");
1411 symbol__fprintf_symname(node->sym, stdout);
David Ahern610723f2011-05-27 14:28:44 -06001412 }
1413 if (print_dso) {
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001414 printf(" (");
David Ahern52deff72012-05-29 22:58:26 -06001415 map__fprintf_dsoname(node->map, stdout);
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001416 printf(")");
David Ahern787bef12011-05-27 14:28:43 -06001417 }
1418 printf("\n");
David Ahernc0230b22011-03-09 22:23:27 -07001419
Namhyung Kim47260642012-05-31 14:43:26 +09001420 callchain_cursor_advance(&callchain_cursor);
David Ahernc0230b22011-03-09 22:23:27 -07001421 }
1422
1423 } else {
David Ahernadc4bf92011-05-30 09:16:27 -06001424 printf("%16" PRIx64, sample->ip);
David Ahern787bef12011-05-27 14:28:43 -06001425 if (print_sym) {
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001426 printf(" ");
Akihiro Nagaia978f2a2012-01-30 13:43:15 +09001427 if (print_symoffset)
1428 symbol__fprintf_symname_offs(al.sym, &al,
1429 stdout);
1430 else
1431 symbol__fprintf_symname(al.sym, stdout);
David Ahern610723f2011-05-27 14:28:44 -06001432 }
1433
1434 if (print_dso) {
Akihiro Nagai547a92e2012-01-30 13:42:57 +09001435 printf(" (");
1436 map__fprintf_dsoname(al.map, stdout);
1437 printf(")");
David Ahern787bef12011-05-27 14:28:43 -06001438 }
David Ahernc0230b22011-03-09 22:23:27 -07001439 }
1440}
Anton Blanchard5d67be92011-07-04 21:57:50 +10001441
1442int perf_session__cpu_bitmap(struct perf_session *session,
1443 const char *cpu_list, unsigned long *cpu_bitmap)
1444{
1445 int i;
1446 struct cpu_map *map;
1447
1448 for (i = 0; i < PERF_TYPE_MAX; ++i) {
1449 struct perf_evsel *evsel;
1450
1451 evsel = perf_session__find_first_evtype(session, i);
1452 if (!evsel)
1453 continue;
1454
1455 if (!(evsel->attr.sample_type & PERF_SAMPLE_CPU)) {
1456 pr_err("File does not contain CPU events. "
1457 "Remove -c option to proceed.\n");
1458 return -1;
1459 }
1460 }
1461
1462 map = cpu_map__new(cpu_list);
David Ahern47fbe532011-11-13 10:45:27 -07001463 if (map == NULL) {
1464 pr_err("Invalid cpu_list\n");
1465 return -1;
1466 }
Anton Blanchard5d67be92011-07-04 21:57:50 +10001467
1468 for (i = 0; i < map->nr; i++) {
1469 int cpu = map->map[i];
1470
1471 if (cpu >= MAX_NR_CPUS) {
1472 pr_err("Requested CPU %d too large. "
1473 "Consider raising MAX_NR_CPUS\n", cpu);
1474 return -1;
1475 }
1476
1477 set_bit(cpu, cpu_bitmap);
1478 }
1479
1480 return 0;
1481}
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001482
1483void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
1484 bool full)
1485{
1486 struct stat st;
1487 int ret;
1488
1489 if (session == NULL || fp == NULL)
1490 return;
1491
1492 ret = fstat(session->fd, &st);
1493 if (ret == -1)
1494 return;
1495
1496 fprintf(fp, "# ========\n");
1497 fprintf(fp, "# captured on: %s", ctime(&st.st_ctime));
1498 perf_header__fprintf_info(session, fp, full);
1499 fprintf(fp, "# ========\n#\n");
1500}
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03001501
1502
1503int __perf_session__set_tracepoints_handlers(struct perf_session *session,
1504 const struct perf_evsel_str_handler *assocs,
1505 size_t nr_assocs)
1506{
1507 struct perf_evlist *evlist = session->evlist;
1508 struct event_format *format;
1509 struct perf_evsel *evsel;
1510 char *tracepoint, *name;
1511 size_t i;
1512 int err;
1513
1514 for (i = 0; i < nr_assocs; i++) {
1515 err = -ENOMEM;
1516 tracepoint = strdup(assocs[i].name);
1517 if (tracepoint == NULL)
1518 goto out;
1519
1520 err = -ENOENT;
1521 name = strchr(tracepoint, ':');
1522 if (name == NULL)
1523 goto out_free;
1524
1525 *name++ = '\0';
1526 format = pevent_find_event_by_name(session->pevent,
1527 tracepoint, name);
1528 if (format == NULL) {
1529 /*
1530 * Adding a handler for an event not in the session,
1531 * just ignore it.
1532 */
1533 goto next;
1534 }
1535
1536 evsel = perf_evlist__find_tracepoint_by_id(evlist, format->id);
1537 if (evsel == NULL)
1538 goto next;
1539
1540 err = -EEXIST;
1541 if (evsel->handler.func != NULL)
1542 goto out_free;
1543 evsel->handler.func = assocs[i].handler;
1544next:
1545 free(tracepoint);
1546 }
1547
1548 err = 0;
1549out:
1550 return err;
1551
1552out_free:
1553 free(tracepoint);
1554 goto out;
1555}