projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perf tools: Move extra string util functions to util/string2.h
[linux-2.6-block.git] / tools / perf / util / session.c
CommitLineData
fd20e811 1#include <inttypes.h>
94c744b6 2#include <linux/kernel.h>
4e319027 3#include <traceevent/event-parse.h>
05a1f47e 4#include <api/fs/fs.h>
94c744b6 5
ba21594c 6#include <byteswap.h>
94c744b6
ACM		 7#include <unistd.h>
8#include <sys/types.h>
a41794cd 9#include <sys/mman.h>
94c744b6 10
e248de33
ACM		 11#include "evlist.h"
12#include "evsel.h"
94c744b6 13#include "session.h"
45694aa7 14#include "tool.h"
a328626b 15#include "sort.h"
94c744b6 16#include "util.h"
5d67be97 17#include "cpumap.h"
0f6a3015 18#include "perf_regs.h"
b0a45203 19#include "asm/bug.h"
c446870d 20#include "auxtrace.h"
a5499b37 21#include "thread-stack.h"
2d2aea6a 22#include "stat.h"
94c744b6 23
c446870d
AH		 24static int perf_session__deliver_event(struct perf_session *session,
25 union perf_event *event,
26 struct perf_sample *sample,
27 struct perf_tool *tool,
28 u64 file_offset);
d10eb1eb 29
316c7136 30static int perf_session__open(struct perf_session *session)
94c744b6 31{
316c7136 32 struct perf_data_file *file = session->file;
8dc58101 33
316c7136 34 if (perf_session__read_header(session) < 0) {
e87b4911 35 pr_err("incompatible file format (rerun with -v to learn more)\n");
6a4d98d7 36 return -1;
94c744b6
ACM		 37 }
38
cc9784bd
JO		 39 if (perf_data_file__is_pipe(file))
40 return 0;
41
3ba78bd0
JO		 42 if (perf_header__has_feat(&session->header, HEADER_STAT))
43 return 0;
44
316c7136 45 if (!perf_evlist__valid_sample_type(session->evlist)) {
e87b4911 46 pr_err("non matching sample_type\n");
6a4d98d7 47 return -1;
c2a70653
ACM		 48 }
49
316c7136 50 if (!perf_evlist__valid_sample_id_all(session->evlist)) {
e87b4911 51 pr_err("non matching sample_id_all\n");
6a4d98d7 52 return -1;
c2a70653
ACM		 53 }
54
316c7136 55 if (!perf_evlist__valid_read_format(session->evlist)) {
e87b4911 56 pr_err("non matching read_format\n");
6a4d98d7 57 return -1;
9ede473c
JO		 58 }
59
94c744b6 60 return 0;
94c744b6
ACM		 61}
62
7b56cce2 63void perf_session__set_id_hdr_size(struct perf_session *session)
9c90a61c 64{
7b56cce2
ACM		 65 u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);
66
7b56cce2 67 machines__set_id_hdr_size(&session->machines, id_hdr_size);
9c90a61c
ACM		 68}
69
316c7136 70int perf_session__create_kernel_maps(struct perf_session *session)
a1645ce1 71{
316c7136 72 int ret = machine__create_kernel_maps(&session->machines.host);
a1645ce1 73
a1645ce1 74 if (ret >= 0)
316c7136 75 ret = machines__create_guest_kernel_maps(&session->machines);
a1645ce1
ZY		 76 return ret;
77}
78
316c7136 79static void perf_session__destroy_kernel_maps(struct perf_session *session)
076c6e45 80{
316c7136 81 machines__destroy_kernel_maps(&session->machines);
076c6e45
ACM		 82}
83
cfe1c414
AH		 84static bool perf_session__has_comm_exec(struct perf_session *session)
85{
86 struct perf_evsel *evsel;
87
e5cadb93 88 evlist__for_each_entry(session->evlist, evsel) {
cfe1c414
AH		 89 if (evsel->attr.comm_exec)
90 return true;
91 }
92
93 return false;
94}
95
96static void perf_session__set_comm_exec(struct perf_session *session)
97{
98 bool comm_exec = perf_session__has_comm_exec(session);
99
100 machines__set_comm_exec(&session->machines, comm_exec);
101}
102
d10eb1eb 103static int ordered_events__deliver_event(struct ordered_events *oe,
9870d780 104 struct ordered_event *event)
d10eb1eb 105{
9870d780
ACM		 106 struct perf_sample sample;
107 struct perf_session *session = container_of(oe, struct perf_session,
108 ordered_events);
109 int ret = perf_evlist__parse_sample(session->evlist, event->event, &sample);
110
111 if (ret) {
112 pr_err("Can't parse sample, err = %d\n", ret);
113 return ret;
114 }
115
c446870d
AH		 116 return perf_session__deliver_event(session, event->event, &sample,
117 session->tool, event->file_offset);
d10eb1eb
ACM		 118}
119
f5fc1412
JO		 120struct perf_session *perf_session__new(struct perf_data_file *file,
121 bool repipe, struct perf_tool *tool)
94c744b6 122{
316c7136 123 struct perf_session *session = zalloc(sizeof(*session));
efad1415 124
316c7136 125 if (!session)
94c744b6
ACM		 126 goto out;
127
316c7136 128 session->repipe = repipe;
9870d780 129 session->tool = tool;
99fa2984 130 INIT_LIST_HEAD(&session->auxtrace_index);
316c7136 131 machines__init(&session->machines);
9870d780 132 ordered_events__init(&session->ordered_events, ordered_events__deliver_event);
94c744b6 133
6a4d98d7
JO		 134 if (file) {
135 if (perf_data_file__open(file))
64abebf7 136 goto out_delete;
6a4d98d7 137
316c7136 138 session->file = file;
6a4d98d7
JO		 139
140 if (perf_data_file__is_read(file)) {
316c7136 141 if (perf_session__open(session) < 0)
6a4d98d7
JO		 142 goto out_close;
143
0973ad97
DCC		 144 /*
145 * set session attributes that are present in perf.data
146 * but not in pipe-mode.
147 */
148 if (!file->is_pipe) {
149 perf_session__set_id_hdr_size(session);
150 perf_session__set_comm_exec(session);
151 }
6a4d98d7 152 }
4cde998d
ACM		 153 } else {
154 session->machines.host.env = &perf_env;
6a4d98d7
JO		 155 }
156
157 if (!file || perf_data_file__is_write(file)) {
64abebf7
ACM		 158 /*
159 * In O_RDONLY mode this will be performed when reading the
8115d60c 160 * kernel MMAP event, in perf_event__process_mmap().
64abebf7 161 */
316c7136 162 if (perf_session__create_kernel_maps(session) < 0)
a5c2a4c9 163 pr_warning("Cannot read kernel map\n");
64abebf7 164 }
d549c769 165
0973ad97
DCC		 166 /*
167 * In pipe-mode, evlist is empty until PERF_RECORD_HEADER_ATTR is
168 * processed, so perf_evlist__sample_id_all is not meaningful here.
169 */
170 if ((!file || !file->is_pipe) && tool && tool->ordering_requires_timestamps &&
0a8cb85c 171 tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
21ef97f0 172 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
0a8cb85c 173 tool->ordered_events = false;
d10eb1eb 174 }
21ef97f0 175
316c7136 176 return session;
6a4d98d7
JO		 177
178 out_close:
179 perf_data_file__close(file);
180 out_delete:
316c7136 181 perf_session__delete(session);
6a4d98d7 182 out:
4aa65636 183 return NULL;
94c744b6
ACM		 184}
185
b424eba2
ACM		 186static void perf_session__delete_threads(struct perf_session *session)
187{
876650e6 188 machine__delete_threads(&session->machines.host);
b424eba2
ACM		 189}
190
316c7136 191void perf_session__delete(struct perf_session *session)
94c744b6 192{
e1446551
ACM		 193 if (session == NULL)
194 return;
c446870d 195 auxtrace__free(session);
99fa2984 196 auxtrace_index__free(&session->auxtrace_index);
316c7136 197 perf_session__destroy_kernel_maps(session);
316c7136 198 perf_session__delete_threads(session);
f0ce888c 199 perf_env__exit(&session->header.env);
316c7136
ACM		 200 machines__exit(&session->machines);
201 if (session->file)
202 perf_data_file__close(session->file);
203 free(session);
94c744b6 204}
a328626b 205
47c3d109
AH		 206static int process_event_synth_tracing_data_stub(struct perf_tool *tool
207 __maybe_unused,
208 union perf_event *event
1d037ca1
IT		 209 __maybe_unused,
210 struct perf_session *session
211 __maybe_unused)
d20deb64
ACM		 212{
213 dump_printf(": unhandled!\n");
214 return 0;
215}
216
47c3d109
AH		 217static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
218 union perf_event *event __maybe_unused,
1d037ca1
IT		 219 struct perf_evlist **pevlist
220 __maybe_unused)
10d0f086
ACM		 221{
222 dump_printf(": unhandled!\n");
223 return 0;
224}
225
ffe77725
JO		 226static int process_event_synth_event_update_stub(struct perf_tool *tool __maybe_unused,
227 union perf_event *event __maybe_unused,
228 struct perf_evlist **pevlist
229 __maybe_unused)
230{
2d2aea6a
JO		 231 if (dump_trace)
232 perf_event__fprintf_event_update(event, stdout);
233
ffe77725
JO		 234 dump_printf(": unhandled!\n");
235 return 0;
236}
237
1d037ca1
IT		 238static int process_event_sample_stub(struct perf_tool *tool __maybe_unused,
239 union perf_event *event __maybe_unused,
240 struct perf_sample *sample __maybe_unused,
241 struct perf_evsel *evsel __maybe_unused,
242 struct machine *machine __maybe_unused)
9e69c210
ACM		 243{
244 dump_printf(": unhandled!\n");
245 return 0;
246}
247
1d037ca1
IT		 248static int process_event_stub(struct perf_tool *tool __maybe_unused,
249 union perf_event *event __maybe_unused,
250 struct perf_sample *sample __maybe_unused,
251 struct machine *machine __maybe_unused)
06aae590
ACM		 252{
253 dump_printf(": unhandled!\n");
254 return 0;
255}
256
1d037ca1
IT		 257static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
258 union perf_event *event __maybe_unused,
d704ebda 259 struct ordered_events *oe __maybe_unused)
743eb868
ACM		 260{
261 dump_printf(": unhandled!\n");
262 return 0;
263}
264
45694aa7 265static int process_finished_round(struct perf_tool *tool,
d20deb64 266 union perf_event *event,
d704ebda 267 struct ordered_events *oe);
d6b17beb 268
a16ac023
AH		 269static int skipn(int fd, off_t n)
270{
271 char buf[4096];
272 ssize_t ret;
273
274 while (n > 0) {
275 ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
276 if (ret <= 0)
277 return ret;
278 n -= ret;
279 }
280
281 return 0;
282}
283
284static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused,
285 union perf_event *event,
286 struct perf_session *session
287 __maybe_unused)
288{
289 dump_printf(": unhandled!\n");
290 if (perf_data_file__is_pipe(session->file))
291 skipn(perf_data_file__fd(session->file), event->auxtrace.size);
292 return event->auxtrace.size;
293}
294
5fb0ac16
AH		 295static int process_event_op2_stub(struct perf_tool *tool __maybe_unused,
296 union perf_event *event __maybe_unused,
297 struct perf_session *session __maybe_unused)
e9bf54d2
AH		 298{
299 dump_printf(": unhandled!\n");
300 return 0;
301}
302
5f3339d2
JO		 303
304static
305int process_event_thread_map_stub(struct perf_tool *tool __maybe_unused,
306 union perf_event *event __maybe_unused,
307 struct perf_session *session __maybe_unused)
308{
2d2aea6a
JO		 309 if (dump_trace)
310 perf_event__fprintf_thread_map(event, stdout);
311
5f3339d2
JO		 312 dump_printf(": unhandled!\n");
313 return 0;
314}
315
6640b6c2
JO		 316static
317int process_event_cpu_map_stub(struct perf_tool *tool __maybe_unused,
318 union perf_event *event __maybe_unused,
319 struct perf_session *session __maybe_unused)
320{
2d2aea6a
JO		 321 if (dump_trace)
322 perf_event__fprintf_cpu_map(event, stdout);
323
6640b6c2
JO		 324 dump_printf(": unhandled!\n");
325 return 0;
326}
327
374fb9e3
JO		 328static
329int process_event_stat_config_stub(struct perf_tool *tool __maybe_unused,
330 union perf_event *event __maybe_unused,
331 struct perf_session *session __maybe_unused)
332{
2d2aea6a
JO		 333 if (dump_trace)
334 perf_event__fprintf_stat_config(event, stdout);
335
374fb9e3
JO		 336 dump_printf(": unhandled!\n");
337 return 0;
338}
339
d80518c9
JO		 340static int process_stat_stub(struct perf_tool *tool __maybe_unused,
341 union perf_event *event __maybe_unused,
342 struct perf_session *perf_session
343 __maybe_unused)
344{
2d2aea6a
JO		 345 if (dump_trace)
346 perf_event__fprintf_stat(event, stdout);
347
d80518c9
JO		 348 dump_printf(": unhandled!\n");
349 return 0;
350}
351
2d8f0f18
JO		 352static int process_stat_round_stub(struct perf_tool *tool __maybe_unused,
353 union perf_event *event __maybe_unused,
354 struct perf_session *perf_session
355 __maybe_unused)
356{
2d2aea6a
JO		 357 if (dump_trace)
358 perf_event__fprintf_stat_round(event, stdout);
359
2d8f0f18
JO		 360 dump_printf(": unhandled!\n");
361 return 0;
362}
363
9c501402 364void perf_tool__fill_defaults(struct perf_tool *tool)
06aae590 365{
45694aa7
ACM		 366 if (tool->sample == NULL)
367 tool->sample = process_event_sample_stub;
368 if (tool->mmap == NULL)
369 tool->mmap = process_event_stub;
6adb0b0a
DA		 370 if (tool->mmap2 == NULL)
371 tool->mmap2 = process_event_stub;
45694aa7
ACM		 372 if (tool->comm == NULL)
373 tool->comm = process_event_stub;
374 if (tool->fork == NULL)
375 tool->fork = process_event_stub;
376 if (tool->exit == NULL)
377 tool->exit = process_event_stub;
378 if (tool->lost == NULL)
379 tool->lost = perf_event__process_lost;
c4937a91
KL		 380 if (tool->lost_samples == NULL)
381 tool->lost_samples = perf_event__process_lost_samples;
4a96f7a0
AH		 382 if (tool->aux == NULL)
383 tool->aux = perf_event__process_aux;
0ad21f68
AH		 384 if (tool->itrace_start == NULL)
385 tool->itrace_start = perf_event__process_itrace_start;
0286039f
AH		 386 if (tool->context_switch == NULL)
387 tool->context_switch = perf_event__process_switch;
45694aa7
ACM		 388 if (tool->read == NULL)
389 tool->read = process_event_sample_stub;
390 if (tool->throttle == NULL)
391 tool->throttle = process_event_stub;
392 if (tool->unthrottle == NULL)
393 tool->unthrottle = process_event_stub;
394 if (tool->attr == NULL)
395 tool->attr = process_event_synth_attr_stub;
ffe77725
JO		 396 if (tool->event_update == NULL)
397 tool->event_update = process_event_synth_event_update_stub;
45694aa7
ACM		 398 if (tool->tracing_data == NULL)
399 tool->tracing_data = process_event_synth_tracing_data_stub;
400 if (tool->build_id == NULL)
5fb0ac16 401 tool->build_id = process_event_op2_stub;
45694aa7 402 if (tool->finished_round == NULL) {
0a8cb85c 403 if (tool->ordered_events)
45694aa7 404 tool->finished_round = process_finished_round;
d6b17beb 405 else
45694aa7 406 tool->finished_round = process_finished_round_stub;
d6b17beb 407 }
3c659eed 408 if (tool->id_index == NULL)
5fb0ac16 409 tool->id_index = process_event_op2_stub;
a16ac023 410 if (tool->auxtrace_info == NULL)
5fb0ac16 411 tool->auxtrace_info = process_event_op2_stub;
a16ac023
AH		 412 if (tool->auxtrace == NULL)
413 tool->auxtrace = process_event_auxtrace_stub;
e9bf54d2 414 if (tool->auxtrace_error == NULL)
5fb0ac16 415 tool->auxtrace_error = process_event_op2_stub;
5f3339d2
JO		 416 if (tool->thread_map == NULL)
417 tool->thread_map = process_event_thread_map_stub;
6640b6c2
JO		 418 if (tool->cpu_map == NULL)
419 tool->cpu_map = process_event_cpu_map_stub;
374fb9e3
JO		 420 if (tool->stat_config == NULL)
421 tool->stat_config = process_event_stat_config_stub;
d80518c9
JO		 422 if (tool->stat == NULL)
423 tool->stat = process_stat_stub;
2d8f0f18
JO		 424 if (tool->stat_round == NULL)
425 tool->stat_round = process_stat_round_stub;
46bc29b9
AH		 426 if (tool->time_conv == NULL)
427 tool->time_conv = process_event_op2_stub;
06aae590 428}
48000a1a 429
268fb20f
JO		 430static void swap_sample_id_all(union perf_event *event, void *data)
431{
432 void *end = (void *) event + event->header.size;
433 int size = end - data;
434
435 BUG_ON(size % sizeof(u64));
436 mem_bswap_64(data, size);
437}
438
439static void perf_event__all64_swap(union perf_event *event,
1d037ca1 440 bool sample_id_all __maybe_unused)
ba21594c 441{
8115d60c
ACM		 442 struct perf_event_header *hdr = &event->header;
443 mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
ba21594c
ACM		 444}
445
268fb20f 446static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
ba21594c 447{
8115d60c
ACM		 448 event->comm.pid = bswap_32(event->comm.pid);
449 event->comm.tid = bswap_32(event->comm.tid);
268fb20f
JO		 450
451 if (sample_id_all) {
452 void *data = &event->comm.comm;
453
9ac3e487 454 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
268fb20f
JO		 455 swap_sample_id_all(event, data);
456 }
ba21594c
ACM		 457}
458
268fb20f
JO		 459static void perf_event__mmap_swap(union perf_event *event,
460 bool sample_id_all)
ba21594c 461{
8115d60c
ACM		 462 event->mmap.pid = bswap_32(event->mmap.pid);
463 event->mmap.tid = bswap_32(event->mmap.tid);
464 event->mmap.start = bswap_64(event->mmap.start);
465 event->mmap.len = bswap_64(event->mmap.len);
466 event->mmap.pgoff = bswap_64(event->mmap.pgoff);
268fb20f
JO		 467
468 if (sample_id_all) {
469 void *data = &event->mmap.filename;
470
9ac3e487 471 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
268fb20f
JO		 472 swap_sample_id_all(event, data);
473 }
ba21594c
ACM		 474}
475
5c5e854b
SE		 476static void perf_event__mmap2_swap(union perf_event *event,
477 bool sample_id_all)
478{
479 event->mmap2.pid = bswap_32(event->mmap2.pid);
480 event->mmap2.tid = bswap_32(event->mmap2.tid);
481 event->mmap2.start = bswap_64(event->mmap2.start);
482 event->mmap2.len = bswap_64(event->mmap2.len);
483 event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
484 event->mmap2.maj = bswap_32(event->mmap2.maj);
485 event->mmap2.min = bswap_32(event->mmap2.min);
486 event->mmap2.ino = bswap_64(event->mmap2.ino);
487
488 if (sample_id_all) {
489 void *data = &event->mmap2.filename;
490
491 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
492 swap_sample_id_all(event, data);
493 }
494}
268fb20f 495static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
ba21594c 496{
8115d60c
ACM		 497 event->fork.pid = bswap_32(event->fork.pid);
498 event->fork.tid = bswap_32(event->fork.tid);
499 event->fork.ppid = bswap_32(event->fork.ppid);
500 event->fork.ptid = bswap_32(event->fork.ptid);
501 event->fork.time = bswap_64(event->fork.time);
268fb20f
JO		 502
503 if (sample_id_all)
504 swap_sample_id_all(event, &event->fork + 1);
ba21594c
ACM		 505}
506
268fb20f 507static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
ba21594c 508{
8115d60c
ACM		 509 event->read.pid = bswap_32(event->read.pid);
510 event->read.tid = bswap_32(event->read.tid);
511 event->read.value = bswap_64(event->read.value);
512 event->read.time_enabled = bswap_64(event->read.time_enabled);
513 event->read.time_running = bswap_64(event->read.time_running);
514 event->read.id = bswap_64(event->read.id);
268fb20f
JO		 515
516 if (sample_id_all)
517 swap_sample_id_all(event, &event->read + 1);
ba21594c
ACM		 518}
519
4a96f7a0
AH		 520static void perf_event__aux_swap(union perf_event *event, bool sample_id_all)
521{
522 event->aux.aux_offset = bswap_64(event->aux.aux_offset);
523 event->aux.aux_size = bswap_64(event->aux.aux_size);
524 event->aux.flags = bswap_64(event->aux.flags);
525
526 if (sample_id_all)
527 swap_sample_id_all(event, &event->aux + 1);
528}
529
0ad21f68
AH		 530static void perf_event__itrace_start_swap(union perf_event *event,
531 bool sample_id_all)
532{
533 event->itrace_start.pid = bswap_32(event->itrace_start.pid);
534 event->itrace_start.tid = bswap_32(event->itrace_start.tid);
535
536 if (sample_id_all)
537 swap_sample_id_all(event, &event->itrace_start + 1);
538}
539
0286039f
AH		 540static void perf_event__switch_swap(union perf_event *event, bool sample_id_all)
541{
542 if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) {
543 event->context_switch.next_prev_pid =
544 bswap_32(event->context_switch.next_prev_pid);
545 event->context_switch.next_prev_tid =
546 bswap_32(event->context_switch.next_prev_tid);
547 }
548
549 if (sample_id_all)
550 swap_sample_id_all(event, &event->context_switch + 1);
551}
552
dd96c46b
JO		 553static void perf_event__throttle_swap(union perf_event *event,
554 bool sample_id_all)
555{
556 event->throttle.time = bswap_64(event->throttle.time);
557 event->throttle.id = bswap_64(event->throttle.id);
558 event->throttle.stream_id = bswap_64(event->throttle.stream_id);
559
560 if (sample_id_all)
561 swap_sample_id_all(event, &event->throttle + 1);
562}
563
e108c66e
JO		 564static u8 revbyte(u8 b)
565{
566 int rev = (b >> 4) | ((b & 0xf) << 4);
567 rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2);
568 rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1);
569 return (u8) rev;
570}
571
572/*
573 * XXX this is hack in attempt to carry flags bitfield
bd1a0be5 574 * through endian village. ABI says:
e108c66e
JO		 575 *
576 * Bit-fields are allocated from right to left (least to most significant)
577 * on little-endian implementations and from left to right (most to least
578 * significant) on big-endian implementations.
579 *
580 * The above seems to be byte specific, so we need to reverse each
581 * byte of the bitfield. 'Internet' also says this might be implementation
582 * specific and we probably need proper fix and carry perf_event_attr
583 * bitfield flags in separate data file FEAT_ section. Thought this seems
584 * to work for now.
585 */
586static void swap_bitfield(u8 *p, unsigned len)
587{
588 unsigned i;
589
590 for (i = 0; i < len; i++) {
591 *p = revbyte(*p);
592 p++;
593 }
594}
595
eda3913b
DA		 596/* exported for swapping attributes in file header */
597void perf_event__attr_swap(struct perf_event_attr *attr)
598{
599 attr->type = bswap_32(attr->type);
600 attr->size = bswap_32(attr->size);
b30b6172
WN		 601
602#define bswap_safe(f, n) \
603 (attr->size > (offsetof(struct perf_event_attr, f) + \
604 sizeof(attr->f) * (n)))
605#define bswap_field(f, sz) \
606do { \
607 if (bswap_safe(f, 0)) \
608 attr->f = bswap_##sz(attr->f); \
609} while(0)
792d48b4 610#define bswap_field_16(f) bswap_field(f, 16)
b30b6172
WN		 611#define bswap_field_32(f) bswap_field(f, 32)
612#define bswap_field_64(f) bswap_field(f, 64)
613
614 bswap_field_64(config);
615 bswap_field_64(sample_period);
616 bswap_field_64(sample_type);
617 bswap_field_64(read_format);
618 bswap_field_32(wakeup_events);
619 bswap_field_32(bp_type);
620 bswap_field_64(bp_addr);
621 bswap_field_64(bp_len);
622 bswap_field_64(branch_sample_type);
623 bswap_field_64(sample_regs_user);
624 bswap_field_32(sample_stack_user);
625 bswap_field_32(aux_watermark);
792d48b4 626 bswap_field_16(sample_max_stack);
b30b6172
WN		 627
628 /*
629 * After read_format are bitfields. Check read_format because
630 * we are unable to use offsetof on bitfield.
631 */
632 if (bswap_safe(read_format, 1))
633 swap_bitfield((u8 *) (&attr->read_format + 1),
634 sizeof(u64));
635#undef bswap_field_64
636#undef bswap_field_32
637#undef bswap_field
638#undef bswap_safe
eda3913b
DA		 639}
640
268fb20f 641static void perf_event__hdr_attr_swap(union perf_event *event,
1d037ca1 642 bool sample_id_all __maybe_unused)
2c46dbb5
TZ		 643{
644 size_t size;
645
eda3913b 646 perf_event__attr_swap(&event->attr.attr);
2c46dbb5 647
8115d60c
ACM		 648 size = event->header.size;
649 size -= (void *)&event->attr.id - (void *)event;
650 mem_bswap_64(event->attr.id, size);
2c46dbb5
TZ		 651}
652
ffe77725
JO		 653static void perf_event__event_update_swap(union perf_event *event,
654 bool sample_id_all __maybe_unused)
655{
656 event->event_update.type = bswap_64(event->event_update.type);
657 event->event_update.id = bswap_64(event->event_update.id);
658}
659
268fb20f 660static void perf_event__event_type_swap(union perf_event *event,
1d037ca1 661 bool sample_id_all __maybe_unused)
cd19a035 662{
8115d60c
ACM		 663 event->event_type.event_type.event_id =
664 bswap_64(event->event_type.event_type.event_id);
cd19a035
TZ		 665}
666
268fb20f 667static void perf_event__tracing_data_swap(union perf_event *event,
1d037ca1 668 bool sample_id_all __maybe_unused)
9215545e 669{
8115d60c 670 event->tracing_data.size = bswap_32(event->tracing_data.size);
9215545e
TZ		 671}
672
a16ac023
AH		 673static void perf_event__auxtrace_info_swap(union perf_event *event,
674 bool sample_id_all __maybe_unused)
675{
676 size_t size;
677
678 event->auxtrace_info.type = bswap_32(event->auxtrace_info.type);
679
680 size = event->header.size;
681 size -= (void *)&event->auxtrace_info.priv - (void *)event;
682 mem_bswap_64(event->auxtrace_info.priv, size);
683}
684
685static void perf_event__auxtrace_swap(union perf_event *event,
686 bool sample_id_all __maybe_unused)
687{
688 event->auxtrace.size = bswap_64(event->auxtrace.size);
689 event->auxtrace.offset = bswap_64(event->auxtrace.offset);
690 event->auxtrace.reference = bswap_64(event->auxtrace.reference);
691 event->auxtrace.idx = bswap_32(event->auxtrace.idx);
692 event->auxtrace.tid = bswap_32(event->auxtrace.tid);
693 event->auxtrace.cpu = bswap_32(event->auxtrace.cpu);
694}
695
e9bf54d2
AH		 696static void perf_event__auxtrace_error_swap(union perf_event *event,
697 bool sample_id_all __maybe_unused)
698{
699 event->auxtrace_error.type = bswap_32(event->auxtrace_error.type);
700 event->auxtrace_error.code = bswap_32(event->auxtrace_error.code);
701 event->auxtrace_error.cpu = bswap_32(event->auxtrace_error.cpu);
702 event->auxtrace_error.pid = bswap_32(event->auxtrace_error.pid);
703 event->auxtrace_error.tid = bswap_32(event->auxtrace_error.tid);
704 event->auxtrace_error.ip = bswap_64(event->auxtrace_error.ip);
705}
706
5f3339d2
JO		 707static void perf_event__thread_map_swap(union perf_event *event,
708 bool sample_id_all __maybe_unused)
709{
710 unsigned i;
711
712 event->thread_map.nr = bswap_64(event->thread_map.nr);
713
714 for (i = 0; i < event->thread_map.nr; i++)
715 event->thread_map.entries[i].pid = bswap_64(event->thread_map.entries[i].pid);
716}
717
6640b6c2
JO		 718static void perf_event__cpu_map_swap(union perf_event *event,
719 bool sample_id_all __maybe_unused)
720{
721 struct cpu_map_data *data = &event->cpu_map.data;
722 struct cpu_map_entries *cpus;
723 struct cpu_map_mask *mask;
724 unsigned i;
725
726 data->type = bswap_64(data->type);
727
728 switch (data->type) {
729 case PERF_CPU_MAP__CPUS:
730 cpus = (struct cpu_map_entries *)data->data;
731
732 cpus->nr = bswap_16(cpus->nr);
733
734 for (i = 0; i < cpus->nr; i++)
735 cpus->cpu[i] = bswap_16(cpus->cpu[i]);
736 break;
737 case PERF_CPU_MAP__MASK:
738 mask = (struct cpu_map_mask *) data->data;
739
740 mask->nr = bswap_16(mask->nr);
741 mask->long_size = bswap_16(mask->long_size);
742
743 switch (mask->long_size) {
744 case 4: mem_bswap_32(&mask->mask, mask->nr); break;
745 case 8: mem_bswap_64(&mask->mask, mask->nr); break;
746 default:
747 pr_err("cpu_map swap: unsupported long size\n");
748 }
749 default:
750 break;
751 }
752}
753
374fb9e3
JO		 754static void perf_event__stat_config_swap(union perf_event *event,
755 bool sample_id_all __maybe_unused)
756{
757 u64 size;
758
759 size = event->stat_config.nr * sizeof(event->stat_config.data[0]);
760 size += 1; /* nr item itself */
761 mem_bswap_64(&event->stat_config.nr, size);
762}
763
d80518c9
JO		 764static void perf_event__stat_swap(union perf_event *event,
765 bool sample_id_all __maybe_unused)
766{
767 event->stat.id = bswap_64(event->stat.id);
768 event->stat.thread = bswap_32(event->stat.thread);
769 event->stat.cpu = bswap_32(event->stat.cpu);
770 event->stat.val = bswap_64(event->stat.val);
771 event->stat.ena = bswap_64(event->stat.ena);
772 event->stat.run = bswap_64(event->stat.run);
773}
774
2d8f0f18
JO		 775static void perf_event__stat_round_swap(union perf_event *event,
776 bool sample_id_all __maybe_unused)
777{
778 event->stat_round.type = bswap_64(event->stat_round.type);
779 event->stat_round.time = bswap_64(event->stat_round.time);
780}
781
268fb20f
JO		 782typedef void (*perf_event__swap_op)(union perf_event *event,
783 bool sample_id_all);
ba21594c 784
8115d60c
ACM		 785static perf_event__swap_op perf_event__swap_ops[] = {
786 [PERF_RECORD_MMAP] = perf_event__mmap_swap,
5c5e854b 787 [PERF_RECORD_MMAP2] = perf_event__mmap2_swap,
8115d60c
ACM		 788 [PERF_RECORD_COMM] = perf_event__comm_swap,
789 [PERF_RECORD_FORK] = perf_event__task_swap,
790 [PERF_RECORD_EXIT] = perf_event__task_swap,
791 [PERF_RECORD_LOST] = perf_event__all64_swap,
792 [PERF_RECORD_READ] = perf_event__read_swap,
dd96c46b
JO		 793 [PERF_RECORD_THROTTLE] = perf_event__throttle_swap,
794 [PERF_RECORD_UNTHROTTLE] = perf_event__throttle_swap,
8115d60c 795 [PERF_RECORD_SAMPLE] = perf_event__all64_swap,
4a96f7a0 796 [PERF_RECORD_AUX] = perf_event__aux_swap,
0ad21f68 797 [PERF_RECORD_ITRACE_START] = perf_event__itrace_start_swap,
c4937a91 798 [PERF_RECORD_LOST_SAMPLES] = perf_event__all64_swap,
0286039f
AH		 799 [PERF_RECORD_SWITCH] = perf_event__switch_swap,
800 [PERF_RECORD_SWITCH_CPU_WIDE] = perf_event__switch_swap,
eda3913b 801 [PERF_RECORD_HEADER_ATTR] = perf_event__hdr_attr_swap,
8115d60c
ACM		 802 [PERF_RECORD_HEADER_EVENT_TYPE] = perf_event__event_type_swap,
803 [PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap,
804 [PERF_RECORD_HEADER_BUILD_ID] = NULL,
3c659eed 805 [PERF_RECORD_ID_INDEX] = perf_event__all64_swap,
a16ac023
AH		 806 [PERF_RECORD_AUXTRACE_INFO] = perf_event__auxtrace_info_swap,
807 [PERF_RECORD_AUXTRACE] = perf_event__auxtrace_swap,
e9bf54d2 808 [PERF_RECORD_AUXTRACE_ERROR] = perf_event__auxtrace_error_swap,
5f3339d2 809 [PERF_RECORD_THREAD_MAP] = perf_event__thread_map_swap,
6640b6c2 810 [PERF_RECORD_CPU_MAP] = perf_event__cpu_map_swap,
374fb9e3 811 [PERF_RECORD_STAT_CONFIG] = perf_event__stat_config_swap,
d80518c9 812 [PERF_RECORD_STAT] = perf_event__stat_swap,
2d8f0f18 813 [PERF_RECORD_STAT_ROUND] = perf_event__stat_round_swap,
ffe77725 814 [PERF_RECORD_EVENT_UPDATE] = perf_event__event_update_swap,
46bc29b9 815 [PERF_RECORD_TIME_CONV] = perf_event__all64_swap,
8115d60c 816 [PERF_RECORD_HEADER_MAX] = NULL,
ba21594c
ACM		 817};
818
d6b17beb
FW		 819/*
820 * When perf record finishes a pass on every buffers, it records this pseudo
821 * event.
822 * We record the max timestamp t found in the pass n.
823 * Assuming these timestamps are monotonic across cpus, we know that if
824 * a buffer still has events with timestamps below t, they will be all
825 * available and then read in the pass n + 1.
826 * Hence when we start to read the pass n + 2, we can safely flush every
827 * events with timestamps below t.
828 *
829 * ============ PASS n =================
830 * CPU 0 | CPU 1
831 * |
832 * cnt1 timestamps | cnt2 timestamps
833 * 1 | 2
834 * 2 | 3
835 * - | 4 <--- max recorded
836 *
837 * ============ PASS n + 1 ==============
838 * CPU 0 | CPU 1
839 * |
840 * cnt1 timestamps | cnt2 timestamps
841 * 3 | 5
842 * 4 | 6
843 * 5 | 7 <---- max recorded
844 *
845 * Flush every events below timestamp 4
846 *
847 * ============ PASS n + 2 ==============
848 * CPU 0 | CPU 1
849 * |
850 * cnt1 timestamps | cnt2 timestamps
851 * 6 | 8
852 * 7 | 9
853 * - | 10
854 *
855 * Flush every events below timestamp 7
856 * etc...
857 */
b7b61cbe 858static int process_finished_round(struct perf_tool *tool __maybe_unused,
1d037ca1 859 union perf_event *event __maybe_unused,
d704ebda 860 struct ordered_events *oe)
d6b17beb 861{
5531e162
AH		 862 if (dump_trace)
863 fprintf(stdout, "\n");
b7b61cbe 864 return ordered_events__flush(oe, OE_FLUSH__ROUND);
d6b17beb
FW		 865}
866
b7b61cbe
ACM		 867int perf_session__queue_event(struct perf_session *s, union perf_event *event,
868 struct perf_sample *sample, u64 file_offset)
c61e52ee 869{
4a6b362f 870 return ordered_events__queue(&s->ordered_events, event, sample, file_offset);
640c03ce 871}
c61e52ee 872
384b6055 873static void callchain__lbr_callstack_printf(struct perf_sample *sample)
640c03ce 874{
384b6055
KL		 875 struct ip_callchain *callchain = sample->callchain;
876 struct branch_stack *lbr_stack = sample->branch_stack;
877 u64 kernel_callchain_nr = callchain->nr;
640c03ce 878 unsigned int i;
c61e52ee 879
384b6055
KL		 880 for (i = 0; i < kernel_callchain_nr; i++) {
881 if (callchain->ips[i] == PERF_CONTEXT_USER)
882 break;
883 }
884
885 if ((i != kernel_callchain_nr) && lbr_stack->nr) {
886 u64 total_nr;
887 /*
888 * LBR callstack can only get user call chain,
889 * i is kernel call chain number,
890 * 1 is PERF_CONTEXT_USER.
891 *
892 * The user call chain is stored in LBR registers.
893 * LBR are pair registers. The caller is stored
894 * in "from" register, while the callee is stored
895 * in "to" register.
896 * For example, there is a call stack
897 * "A"->"B"->"C"->"D".
898 * The LBR registers will recorde like
899 * "C"->"D", "B"->"C", "A"->"B".
900 * So only the first "to" register and all "from"
901 * registers are needed to construct the whole stack.
902 */
903 total_nr = i + 1 + lbr_stack->nr + 1;
904 kernel_callchain_nr = i + 1;
905
906 printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr);
907
908 for (i = 0; i < kernel_callchain_nr; i++)
909 printf("..... %2d: %016" PRIx64 "\n",
910 i, callchain->ips[i]);
911
912 printf("..... %2d: %016" PRIx64 "\n",
913 (int)(kernel_callchain_nr), lbr_stack->entries[0].to);
914 for (i = 0; i < lbr_stack->nr; i++)
915 printf("..... %2d: %016" PRIx64 "\n",
916 (int)(i + kernel_callchain_nr + 1), lbr_stack->entries[i].from);
917 }
918}
919
920static void callchain__printf(struct perf_evsel *evsel,
921 struct perf_sample *sample)
922{
923 unsigned int i;
924 struct ip_callchain *callchain = sample->callchain;
925
acf2abbd 926 if (perf_evsel__has_branch_callstack(evsel))
384b6055
KL		 927 callchain__lbr_callstack_printf(sample);
928
929 printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr);
640c03ce 930
384b6055 931 for (i = 0; i < callchain->nr; i++)
9486aa38 932 printf("..... %2d: %016" PRIx64 "\n",
384b6055 933 i, callchain->ips[i]);
c61e52ee
FW		 934}
935
b5387528
RAV		 936static void branch_stack__printf(struct perf_sample *sample)
937{
938 uint64_t i;
939
940 printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);
941
0e332f03
AK		 942 for (i = 0; i < sample->branch_stack->nr; i++) {
943 struct branch_entry *e = &sample->branch_stack->entries[i];
944
945 printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 " %hu cycles %s%s%s%s %x\n",
946 i, e->from, e->to,
8074bf51 947 (unsigned short)e->flags.cycles,
0e332f03
AK		 948 e->flags.mispred ? "M" : " ",
949 e->flags.predicted ? "P" : " ",
950 e->flags.abort ? "A" : " ",
951 e->flags.in_tx ? "T" : " ",
952 (unsigned)e->flags.reserved);
953 }
b5387528
RAV		 954}
955
0f6a3015
JO		 956static void regs_dump__printf(u64 mask, u64 *regs)
957{
958 unsigned rid, i = 0;
959
960 for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) {
961 u64 val = regs[i++];
962
963 printf(".... %-5s 0x%" PRIx64 "\n",
964 perf_reg_name(rid), val);
965 }
966}
967
6a21c0b5
SE		 968static const char *regs_abi[] = {
969 [PERF_SAMPLE_REGS_ABI_NONE] = "none",
970 [PERF_SAMPLE_REGS_ABI_32] = "32-bit",
971 [PERF_SAMPLE_REGS_ABI_64] = "64-bit",
972};
973
974static inline const char *regs_dump_abi(struct regs_dump *d)
975{
976 if (d->abi > PERF_SAMPLE_REGS_ABI_64)
977 return "unknown";
978
979 return regs_abi[d->abi];
980}
981
982static void regs__printf(const char *type, struct regs_dump *regs)
983{
984 u64 mask = regs->mask;
985
986 printf("... %s regs: mask 0x%" PRIx64 " ABI %s\n",
987 type,
988 mask,
989 regs_dump_abi(regs));
990
991 regs_dump__printf(mask, regs->regs);
992}
993
352ea45a 994static void regs_user__printf(struct perf_sample *sample)
0f6a3015
JO		 995{
996 struct regs_dump *user_regs = &sample->user_regs;
997
6a21c0b5
SE		 998 if (user_regs->regs)
999 regs__printf("user", user_regs);
1000}
1001
1002static void regs_intr__printf(struct perf_sample *sample)
1003{
1004 struct regs_dump *intr_regs = &sample->intr_regs;
1005
1006 if (intr_regs->regs)
1007 regs__printf("intr", intr_regs);
0f6a3015
JO		 1008}
1009
1010static void stack_user__printf(struct stack_dump *dump)
1011{
1012 printf("... ustack: size %" PRIu64 ", offset 0x%x\n",
1013 dump->size, dump->offset);
1014}
1015
9fa8727a 1016static void perf_evlist__print_tstamp(struct perf_evlist *evlist,
8115d60c 1017 union perf_event *event,
8d50e5b4 1018 struct perf_sample *sample)
9c90a61c 1019{
9fa8727a 1020 u64 sample_type = __perf_evlist__combined_sample_type(evlist);
7f3be652 1021
9c90a61c 1022 if (event->header.type != PERF_RECORD_SAMPLE &&
9fa8727a 1023 !perf_evlist__sample_id_all(evlist)) {
9c90a61c
ACM		 1024 fputs("-1 -1 ", stdout);
1025 return;
1026 }
1027
7f3be652 1028 if ((sample_type & PERF_SAMPLE_CPU))
9c90a61c
ACM		 1029 printf("%u ", sample->cpu);
1030
7f3be652 1031 if (sample_type & PERF_SAMPLE_TIME)
9486aa38 1032 printf("%" PRIu64 " ", sample->time);
9c90a61c
ACM		 1033}
1034
9ede473c
JO		 1035static void sample_read__printf(struct perf_sample *sample, u64 read_format)
1036{
1037 printf("... sample_read:\n");
1038
1039 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1040 printf("...... time enabled %016" PRIx64 "\n",
1041 sample->read.time_enabled);
1042
1043 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1044 printf("...... time running %016" PRIx64 "\n",
1045 sample->read.time_running);
1046
1047 if (read_format & PERF_FORMAT_GROUP) {
1048 u64 i;
1049
1050 printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);
1051
1052 for (i = 0; i < sample->read.group.nr; i++) {
1053 struct sample_read_value *value;
1054
1055 value = &sample->read.group.values[i];
1056 printf("..... id %016" PRIx64
1057 ", value %016" PRIx64 "\n",
1058 value->id, value->value);
1059 }
1060 } else
1061 printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n",
1062 sample->read.one.id, sample->read.one.value);
1063}
1064
9fa8727a 1065static void dump_event(struct perf_evlist *evlist, union perf_event *event,
8d50e5b4 1066 u64 file_offset, struct perf_sample *sample)
9aefcab0
TG		 1067{
1068 if (!dump_trace)
1069 return;
1070
9486aa38
ACM		 1071 printf("\n%#" PRIx64 " [%#x]: event: %d\n",
1072 file_offset, event->header.size, event->header.type);
9aefcab0
TG		 1073
1074 trace_event(event);
1075
1076 if (sample)
9fa8727a 1077 perf_evlist__print_tstamp(evlist, event, sample);
9aefcab0 1078
9486aa38 1079 printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
8115d60c 1080 event->header.size, perf_event__name(event->header.type));
9aefcab0
TG		 1081}
1082
0f6a3015 1083static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
8d50e5b4 1084 struct perf_sample *sample)
9aefcab0 1085{
7f3be652
ACM		 1086 u64 sample_type;
1087
ddbc24b7
ACM		 1088 if (!dump_trace)
1089 return;
1090
0ea590ae 1091 printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
9486aa38 1092 event->header.misc, sample->pid, sample->tid, sample->ip,
7cec0922 1093 sample->period, sample->addr);
9aefcab0 1094
0f6a3015 1095 sample_type = evsel->attr.sample_type;
7f3be652
ACM		 1096
1097 if (sample_type & PERF_SAMPLE_CALLCHAIN)
384b6055 1098 callchain__printf(evsel, sample);
b5387528 1099
acf2abbd 1100 if ((sample_type & PERF_SAMPLE_BRANCH_STACK) && !perf_evsel__has_branch_callstack(evsel))
b5387528 1101 branch_stack__printf(sample);
0f6a3015
JO		 1102
1103 if (sample_type & PERF_SAMPLE_REGS_USER)
352ea45a 1104 regs_user__printf(sample);
0f6a3015 1105
6a21c0b5
SE		 1106 if (sample_type & PERF_SAMPLE_REGS_INTR)
1107 regs_intr__printf(sample);
1108
0f6a3015
JO		 1109 if (sample_type & PERF_SAMPLE_STACK_USER)
1110 stack_user__printf(&sample->user_stack);
05484298
AK		 1111
1112 if (sample_type & PERF_SAMPLE_WEIGHT)
1113 printf("... weight: %" PRIu64 "\n", sample->weight);
98a3b32c
SE		 1114
1115 if (sample_type & PERF_SAMPLE_DATA_SRC)
1116 printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
9ede473c 1117
475eeab9
AK		 1118 if (sample_type & PERF_SAMPLE_TRANSACTION)
1119 printf("... transaction: %" PRIx64 "\n", sample->transaction);
1120
9ede473c
JO		 1121 if (sample_type & PERF_SAMPLE_READ)
1122 sample_read__printf(sample, evsel->attr.read_format);
9aefcab0
TG		 1123}
1124
54245fdc 1125static struct machine *machines__find_for_cpumode(struct machines *machines,
ef89325f
AH		 1126 union perf_event *event,
1127 struct perf_sample *sample)
743eb868 1128{
ad85ace0 1129 struct machine *machine;
743eb868 1130
7c0f4a41 1131 if (perf_guest &&
473398a2
ACM		 1132 ((sample->cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
1133 (sample->cpumode == PERF_RECORD_MISC_GUEST_USER))) {
7fb0a5ee
ND		 1134 u32 pid;
1135
5c5e854b
SE		 1136 if (event->header.type == PERF_RECORD_MMAP
1137 || event->header.type == PERF_RECORD_MMAP2)
7fb0a5ee
ND		 1138 pid = event->mmap.pid;
1139 else
ef89325f 1140 pid = sample->pid;
7fb0a5ee 1141
54245fdc 1142 machine = machines__find(machines, pid);
ad85ace0 1143 if (!machine)
3caeaa56 1144 machine = machines__findnew(machines, DEFAULT_GUEST_KERNEL_ID);
ad85ace0 1145 return machine;
7fb0a5ee 1146 }
743eb868 1147
54245fdc 1148 return &machines->host;
743eb868
ACM		 1149}
1150
313e53b0 1151static int deliver_sample_value(struct perf_evlist *evlist,
e4caec0d
JO		 1152 struct perf_tool *tool,
1153 union perf_event *event,
1154 struct perf_sample *sample,
1155 struct sample_read_value *v,
1156 struct machine *machine)
1157{
313e53b0 1158 struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
e4caec0d 1159
e4caec0d
JO		 1160 if (sid) {
1161 sample->id = v->id;
1162 sample->period = v->value - sid->period;
1163 sid->period = v->value;
1164 }
1165
1166 if (!sid || sid->evsel == NULL) {
313e53b0 1167 ++evlist->stats.nr_unknown_id;
e4caec0d
JO		 1168 return 0;
1169 }
1170
1171 return tool->sample(tool, event, sample, sid->evsel, machine);
1172}
1173
313e53b0 1174static int deliver_sample_group(struct perf_evlist *evlist,
e4caec0d
JO		 1175 struct perf_tool *tool,
1176 union perf_event *event,
1177 struct perf_sample *sample,
1178 struct machine *machine)
1179{
1180 int ret = -EINVAL;
1181 u64 i;
1182
1183 for (i = 0; i < sample->read.group.nr; i++) {
313e53b0 1184 ret = deliver_sample_value(evlist, tool, event, sample,
e4caec0d
JO		 1185 &sample->read.group.values[i],
1186 machine);
1187 if (ret)
1188 break;
1189 }
1190
1191 return ret;
1192}
1193
1194static int
313e53b0 1195 perf_evlist__deliver_sample(struct perf_evlist *evlist,
e4caec0d
JO		 1196 struct perf_tool *tool,
1197 union perf_event *event,
1198 struct perf_sample *sample,
1199 struct perf_evsel *evsel,
1200 struct machine *machine)
1201{
1202 /* We know evsel != NULL. */
1203 u64 sample_type = evsel->attr.sample_type;
1204 u64 read_format = evsel->attr.read_format;
1205
d94386f2 1206 /* Standard sample delivery. */
e4caec0d
JO		 1207 if (!(sample_type & PERF_SAMPLE_READ))
1208 return tool->sample(tool, event, sample, evsel, machine);
1209
1210 /* For PERF_SAMPLE_READ we have either single or group mode. */
1211 if (read_format & PERF_FORMAT_GROUP)
313e53b0 1212 return deliver_sample_group(evlist, tool, event, sample,
e4caec0d
JO		 1213 machine);
1214 else
313e53b0 1215 return deliver_sample_value(evlist, tool, event, sample,
e4caec0d
JO		 1216 &sample->read.one, machine);
1217}
1218
d10eb1eb
ACM		 1219static int machines__deliver_event(struct machines *machines,
1220 struct perf_evlist *evlist,
1221 union perf_event *event,
1222 struct perf_sample *sample,
1223 struct perf_tool *tool, u64 file_offset)
cbf41645 1224{
9e69c210 1225 struct perf_evsel *evsel;
743eb868 1226 struct machine *machine;
9e69c210 1227
9fa8727a 1228 dump_event(evlist, event, file_offset, sample);
532e7269 1229
313e53b0 1230 evsel = perf_evlist__id2evsel(evlist, sample->id);
7b27509f 1231
fa713a4e 1232 machine = machines__find_for_cpumode(machines, event, sample);
743eb868 1233
cbf41645
TG		 1234 switch (event->header.type) {
1235 case PERF_RECORD_SAMPLE:
9e69c210 1236 if (evsel == NULL) {
313e53b0 1237 ++evlist->stats.nr_unknown_id;
6782206b 1238 return 0;
9e69c210 1239 }
1b29ac59 1240 dump_sample(evsel, event, sample);
0c095715 1241 if (machine == NULL) {
313e53b0 1242 ++evlist->stats.nr_unprocessable_samples;
6782206b 1243 return 0;
0c095715 1244 }
313e53b0 1245 return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
cbf41645 1246 case PERF_RECORD_MMAP:
45694aa7 1247 return tool->mmap(tool, event, sample, machine);
5c5e854b 1248 case PERF_RECORD_MMAP2:
930e6fcd
KL		 1249 if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT)
1250 ++evlist->stats.nr_proc_map_timeout;
5c5e854b 1251 return tool->mmap2(tool, event, sample, machine);
cbf41645 1252 case PERF_RECORD_COMM:
45694aa7 1253 return tool->comm(tool, event, sample, machine);
f3b3614a
HB		 1254 case PERF_RECORD_NAMESPACES:
1255 return tool->namespaces(tool, event, sample, machine);
cbf41645 1256 case PERF_RECORD_FORK:
45694aa7 1257 return tool->fork(tool, event, sample, machine);
cbf41645 1258 case PERF_RECORD_EXIT:
45694aa7 1259 return tool->exit(tool, event, sample, machine);
cbf41645 1260 case PERF_RECORD_LOST:
45694aa7 1261 if (tool->lost == perf_event__process_lost)
313e53b0 1262 evlist->stats.total_lost += event->lost.lost;
45694aa7 1263 return tool->lost(tool, event, sample, machine);
c4937a91
KL		 1264 case PERF_RECORD_LOST_SAMPLES:
1265 if (tool->lost_samples == perf_event__process_lost_samples)
1266 evlist->stats.total_lost_samples += event->lost_samples.lost;
1267 return tool->lost_samples(tool, event, sample, machine);
cbf41645 1268 case PERF_RECORD_READ:
45694aa7 1269 return tool->read(tool, event, sample, evsel, machine);
cbf41645 1270 case PERF_RECORD_THROTTLE:
45694aa7 1271 return tool->throttle(tool, event, sample, machine);
cbf41645 1272 case PERF_RECORD_UNTHROTTLE:
45694aa7 1273 return tool->unthrottle(tool, event, sample, machine);
4a96f7a0 1274 case PERF_RECORD_AUX:
05a1f47e
AS		 1275 if (tool->aux == perf_event__process_aux) {
1276 if (event->aux.flags & PERF_AUX_FLAG_TRUNCATED)
1277 evlist->stats.total_aux_lost += 1;
1278 if (event->aux.flags & PERF_AUX_FLAG_PARTIAL)
1279 evlist->stats.total_aux_partial += 1;
1280 }
4a96f7a0 1281 return tool->aux(tool, event, sample, machine);
0ad21f68
AH		 1282 case PERF_RECORD_ITRACE_START:
1283 return tool->itrace_start(tool, event, sample, machine);
0286039f
AH		 1284 case PERF_RECORD_SWITCH:
1285 case PERF_RECORD_SWITCH_CPU_WIDE:
1286 return tool->context_switch(tool, event, sample, machine);
cbf41645 1287 default:
313e53b0 1288 ++evlist->stats.nr_unknown_events;
cbf41645
TG		 1289 return -1;
1290 }
1291}
1292
c446870d
AH		 1293static int perf_session__deliver_event(struct perf_session *session,
1294 union perf_event *event,
1295 struct perf_sample *sample,
1296 struct perf_tool *tool,
1297 u64 file_offset)
1298{
1299 int ret;
1300
1301 ret = auxtrace__process_event(session, event, sample, tool);
1302 if (ret < 0)
1303 return ret;
1304 if (ret > 0)
1305 return 0;
1306
1307 return machines__deliver_event(&session->machines, session->evlist,
1308 event, sample, tool, file_offset);
1309}
1310
d5652d86
AH		 1311static s64 perf_session__process_user_event(struct perf_session *session,
1312 union perf_event *event,
d5652d86 1313 u64 file_offset)
06aae590 1314{
d704ebda 1315 struct ordered_events *oe = &session->ordered_events;
9870d780 1316 struct perf_tool *tool = session->tool;
cc9784bd 1317 int fd = perf_data_file__fd(session->file);
10d0f086
ACM		 1318 int err;
1319
9fa8727a 1320 dump_event(session->evlist, event, file_offset, NULL);
06aae590 1321
cbf41645 1322 /* These events are processed right away */
06aae590 1323 switch (event->header.type) {
2c46dbb5 1324 case PERF_RECORD_HEADER_ATTR:
47c3d109 1325 err = tool->attr(tool, event, &session->evlist);
cfe1c414 1326 if (err == 0) {
7b56cce2 1327 perf_session__set_id_hdr_size(session);
cfe1c414
AH		 1328 perf_session__set_comm_exec(session);
1329 }
10d0f086 1330 return err;
ffe77725
JO		 1331 case PERF_RECORD_EVENT_UPDATE:
1332 return tool->event_update(tool, event, &session->evlist);
f67697bd
JO		 1333 case PERF_RECORD_HEADER_EVENT_TYPE:
1334 /*
1335 * Depreceated, but we need to handle it for sake
1336 * of old data files create in pipe mode.
1337 */
1338 return 0;
9215545e
TZ		 1339 case PERF_RECORD_HEADER_TRACING_DATA:
1340 /* setup for reading amidst mmap */
cc9784bd 1341 lseek(fd, file_offset, SEEK_SET);
47c3d109 1342 return tool->tracing_data(tool, event, session);
c7929e47 1343 case PERF_RECORD_HEADER_BUILD_ID:
45694aa7 1344 return tool->build_id(tool, event, session);
d6b17beb 1345 case PERF_RECORD_FINISHED_ROUND:
d704ebda 1346 return tool->finished_round(tool, event, oe);
3c659eed
AH		 1347 case PERF_RECORD_ID_INDEX:
1348 return tool->id_index(tool, event, session);
a16ac023
AH		 1349 case PERF_RECORD_AUXTRACE_INFO:
1350 return tool->auxtrace_info(tool, event, session);
1351 case PERF_RECORD_AUXTRACE:
1352 /* setup for reading amidst mmap */
1353 lseek(fd, file_offset + event->header.size, SEEK_SET);
1354 return tool->auxtrace(tool, event, session);
e9bf54d2 1355 case PERF_RECORD_AUXTRACE_ERROR:
85ed4729 1356 perf_session__auxtrace_error_inc(session, event);
e9bf54d2 1357 return tool->auxtrace_error(tool, event, session);
5f3339d2
JO		 1358 case PERF_RECORD_THREAD_MAP:
1359 return tool->thread_map(tool, event, session);
6640b6c2
JO		 1360 case PERF_RECORD_CPU_MAP:
1361 return tool->cpu_map(tool, event, session);
374fb9e3
JO		 1362 case PERF_RECORD_STAT_CONFIG:
1363 return tool->stat_config(tool, event, session);
d80518c9
JO		 1364 case PERF_RECORD_STAT:
1365 return tool->stat(tool, event, session);
2d8f0f18
JO		 1366 case PERF_RECORD_STAT_ROUND:
1367 return tool->stat_round(tool, event, session);
46bc29b9
AH		 1368 case PERF_RECORD_TIME_CONV:
1369 session->time_conv = event->time_conv;
1370 return tool->time_conv(tool, event, session);
06aae590 1371 default:
ba74f064 1372 return -EINVAL;
06aae590 1373 }
ba74f064
TG		 1374}
1375
a293829d
AH		 1376int perf_session__deliver_synth_event(struct perf_session *session,
1377 union perf_event *event,
b7b61cbe 1378 struct perf_sample *sample)
a293829d 1379{
fa713a4e 1380 struct perf_evlist *evlist = session->evlist;
9870d780 1381 struct perf_tool *tool = session->tool;
fa713a4e
ACM		 1382
1383 events_stats__inc(&evlist->stats, event->header.type);
a293829d
AH		 1384
1385 if (event->header.type >= PERF_RECORD_USER_TYPE_START)
b7b61cbe 1386 return perf_session__process_user_event(session, event, 0);
a293829d 1387
fa713a4e 1388 return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0);
a293829d
AH		 1389}
1390
268fb20f
JO		 1391static void event_swap(union perf_event *event, bool sample_id_all)
1392{
1393 perf_event__swap_op swap;
1394
1395 swap = perf_event__swap_ops[event->header.type];
1396 if (swap)
1397 swap(event, sample_id_all);
1398}
1399
5a52f33a
AH		 1400int perf_session__peek_event(struct perf_session *session, off_t file_offset,
1401 void *buf, size_t buf_sz,
1402 union perf_event **event_ptr,
1403 struct perf_sample *sample)
1404{
1405 union perf_event *event;
1406 size_t hdr_sz, rest;
1407 int fd;
1408
1409 if (session->one_mmap && !session->header.needs_swap) {
1410 event = file_offset - session->one_mmap_offset +
1411 session->one_mmap_addr;
1412 goto out_parse_sample;
1413 }
1414
1415 if (perf_data_file__is_pipe(session->file))
1416 return -1;
1417
1418 fd = perf_data_file__fd(session->file);
1419 hdr_sz = sizeof(struct perf_event_header);
1420
1421 if (buf_sz < hdr_sz)
1422 return -1;
1423
1424 if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 ||
554e92ed 1425 readn(fd, buf, hdr_sz) != (ssize_t)hdr_sz)
5a52f33a
AH		 1426 return -1;
1427
1428 event = (union perf_event *)buf;
1429
1430 if (session->header.needs_swap)
1431 perf_event_header__bswap(&event->header);
1432
554e92ed 1433 if (event->header.size < hdr_sz || event->header.size > buf_sz)
5a52f33a
AH		 1434 return -1;
1435
1436 rest = event->header.size - hdr_sz;
1437
554e92ed 1438 if (readn(fd, buf, rest) != (ssize_t)rest)
5a52f33a
AH		 1439 return -1;
1440
1441 if (session->header.needs_swap)
1442 event_swap(event, perf_evlist__sample_id_all(session->evlist));
1443
1444out_parse_sample:
1445
1446 if (sample && event->header.type < PERF_RECORD_USER_TYPE_START &&
1447 perf_evlist__parse_sample(session->evlist, event, sample))
1448 return -1;
1449
1450 *event_ptr = event;
1451
1452 return 0;
1453}
1454
d5652d86 1455static s64 perf_session__process_event(struct perf_session *session,
b7b61cbe 1456 union perf_event *event, u64 file_offset)
ba74f064 1457{
313e53b0 1458 struct perf_evlist *evlist = session->evlist;
9870d780 1459 struct perf_tool *tool = session->tool;
8d50e5b4 1460 struct perf_sample sample;
ba74f064
TG		 1461 int ret;
1462
268fb20f 1463 if (session->header.needs_swap)
313e53b0 1464 event_swap(event, perf_evlist__sample_id_all(evlist));
ba74f064
TG		 1465
1466 if (event->header.type >= PERF_RECORD_HEADER_MAX)
1467 return -EINVAL;
1468
313e53b0 1469 events_stats__inc(&evlist->stats, event->header.type);
ba74f064
TG		 1470
1471 if (event->header.type >= PERF_RECORD_USER_TYPE_START)
b7b61cbe 1472 return perf_session__process_user_event(session, event, file_offset);
cbf41645 1473
3dfc2c0a
TG		 1474 /*
1475 * For all kernel events we get the sample data
1476 */
313e53b0 1477 ret = perf_evlist__parse_sample(evlist, event, &sample);
5538beca
FW		 1478 if (ret)
1479 return ret;
3dfc2c0a 1480
0a8cb85c 1481 if (tool->ordered_events) {
b7b61cbe 1482 ret = perf_session__queue_event(session, event, &sample, file_offset);
cbf41645
TG		 1483 if (ret != -ETIME)
1484 return ret;
1485 }
1486
c446870d
AH		 1487 return perf_session__deliver_event(session, event, &sample, tool,
1488 file_offset);
06aae590
ACM		 1489}
1490
316c7136 1491void perf_event_header__bswap(struct perf_event_header *hdr)
ba21594c 1492{
316c7136
ACM		 1493 hdr->type = bswap_32(hdr->type);
1494 hdr->misc = bswap_16(hdr->misc);
1495 hdr->size = bswap_16(hdr->size);
ba21594c
ACM		 1496}
1497
b424eba2
ACM		 1498struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
1499{
1fcb8768 1500 return machine__findnew_thread(&session->machines.host, -1, pid);
b424eba2
ACM		 1501}
1502
9d8b172f 1503int perf_session__register_idle_thread(struct perf_session *session)
06aae590 1504{
1fcb8768 1505 struct thread *thread;
9d8b172f 1506 int err = 0;
06aae590 1507
1fcb8768 1508 thread = machine__findnew_thread(&session->machines.host, 0, 0);
162f0bef 1509 if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
06aae590 1510 pr_err("problem inserting idle task.\n");
9d8b172f 1511 err = -1;
06aae590
ACM		 1512 }
1513
f3b3614a
HB		 1514 if (thread == NULL || thread__set_namespaces(thread, 0, NULL)) {
1515 pr_err("problem inserting idle task.\n");
1516 err = -1;
1517 }
1518
9d8b172f
MH		 1519 /* machine__findnew_thread() got the thread, so put it */
1520 thread__put(thread);
1521 return err;
06aae590
ACM		 1522}
1523
f06149c0
WN		 1524static void
1525perf_session__warn_order(const struct perf_session *session)
1526{
1527 const struct ordered_events *oe = &session->ordered_events;
1528 struct perf_evsel *evsel;
1529 bool should_warn = true;
1530
1531 evlist__for_each_entry(session->evlist, evsel) {
1532 if (evsel->attr.write_backward)
1533 should_warn = false;
1534 }
1535
1536 if (!should_warn)
1537 return;
1538 if (oe->nr_unordered_events != 0)
1539 ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events);
1540}
1541
9870d780 1542static void perf_session__warn_about_errors(const struct perf_session *session)
11095994 1543{
9870d780 1544 const struct events_stats *stats = &session->evlist->stats;
9870d780
ACM		 1545
1546 if (session->tool->lost == perf_event__process_lost &&
ccda068f 1547 stats->nr_events[PERF_RECORD_LOST] != 0) {
7b27509f
ACM		 1548 ui__warning("Processed %d events and lost %d chunks!\n\n"
1549 "Check IO/CPU overload!\n\n",
ccda068f
ACM		 1550 stats->nr_events[0],
1551 stats->nr_events[PERF_RECORD_LOST]);
11095994
ACM		 1552 }
1553
c4937a91
KL		 1554 if (session->tool->lost_samples == perf_event__process_lost_samples) {
1555 double drop_rate;
1556
1557 drop_rate = (double)stats->total_lost_samples /
1558 (double) (stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples);
1559 if (drop_rate > 0.05) {
6ba29c2f 1560 ui__warning("Processed %" PRIu64 " samples and lost %3.2f%% samples!\n\n",
c4937a91
KL		 1561 stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples,
1562 drop_rate * 100.0);
1563 }
1564 }
1565
a38f48e3
AH		 1566 if (session->tool->aux == perf_event__process_aux &&
1567 stats->total_aux_lost != 0) {
1568 ui__warning("AUX data lost %" PRIu64 " times out of %u!\n\n",
1569 stats->total_aux_lost,
1570 stats->nr_events[PERF_RECORD_AUX]);
1571 }
1572
05a1f47e
AS		 1573 if (session->tool->aux == perf_event__process_aux &&
1574 stats->total_aux_partial != 0) {
1575 bool vmm_exclusive = false;
1576
1577 (void)sysfs__read_bool("module/kvm_intel/parameters/vmm_exclusive",
1578 &vmm_exclusive);
1579
1580 ui__warning("AUX data had gaps in it %" PRIu64 " times out of %u!\n\n"
1581 "Are you running a KVM guest in the background?%s\n\n",
1582 stats->total_aux_partial,
1583 stats->nr_events[PERF_RECORD_AUX],
1584 vmm_exclusive ?
1585 "\nReloading kvm_intel module with vmm_exclusive=0\n"
1586 "will reduce the gaps to only guest's timeslices." :
1587 "");
1588 }
1589
ccda068f 1590 if (stats->nr_unknown_events != 0) {
11095994
ACM		 1591 ui__warning("Found %u unknown events!\n\n"
1592 "Is this an older tool processing a perf.data "
1593 "file generated by a more recent tool?\n\n"
1594 "If that is not the case, consider "
1595 "reporting to linux-kernel@vger.kernel.org.\n\n",
ccda068f 1596 stats->nr_unknown_events);
11095994
ACM		 1597 }
1598
ccda068f 1599 if (stats->nr_unknown_id != 0) {
9e69c210 1600 ui__warning("%u samples with id not present in the header\n",
ccda068f 1601 stats->nr_unknown_id);
9e69c210
ACM		 1602 }
1603
ccda068f 1604 if (stats->nr_invalid_chains != 0) {
75be989a
ACM		 1605 ui__warning("Found invalid callchains!\n\n"
1606 "%u out of %u events were discarded for this reason.\n\n"
1607 "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
ccda068f
ACM		 1608 stats->nr_invalid_chains,
1609 stats->nr_events[PERF_RECORD_SAMPLE]);
75be989a 1610 }
0c095715 1611
ccda068f 1612 if (stats->nr_unprocessable_samples != 0) {
0c095715
JR		 1613 ui__warning("%u unprocessable samples recorded.\n"
1614 "Do you have a KVM guest running and not using 'perf kvm'?\n",
ccda068f 1615 stats->nr_unprocessable_samples);
0c095715 1616 }
f61ff6c0 1617
f06149c0 1618 perf_session__warn_order(session);
85ed4729
AH		 1619
1620 events_stats__auxtrace_error_warn(stats);
930e6fcd
KL		 1621
1622 if (stats->nr_proc_map_timeout != 0) {
1623 ui__warning("%d map information files for pre-existing threads were\n"
1624 "not processed, if there are samples for addresses they\n"
1625 "will not be resolved, you may find out which are these\n"
1626 "threads by running with -v and redirecting the output\n"
9d9cad76
KL		 1627 "to a file.\n"
1628 "The time limit to process proc map is too short?\n"
1629 "Increase it by --proc-map-timeout\n",
930e6fcd
KL		 1630 stats->nr_proc_map_timeout);
1631 }
11095994
ACM		 1632}
1633
a5499b37
AH		 1634static int perf_session__flush_thread_stack(struct thread *thread,
1635 void *p __maybe_unused)
1636{
1637 return thread_stack__flush(thread);
1638}
1639
1640static int perf_session__flush_thread_stacks(struct perf_session *session)
1641{
1642 return machines__for_each_thread(&session->machines,
1643 perf_session__flush_thread_stack,
1644 NULL);
1645}
1646
8dc58101
TZ		 1647volatile int session_done;
1648
b7b61cbe 1649static int __perf_session__process_pipe_events(struct perf_session *session)
8dc58101 1650{
fa713a4e 1651 struct ordered_events *oe = &session->ordered_events;
9870d780 1652 struct perf_tool *tool = session->tool;
316c7136 1653 int fd = perf_data_file__fd(session->file);
444d2866
SE		 1654 union perf_event *event;
1655 uint32_t size, cur_size = 0;
1656 void *buf = NULL;
d5652d86 1657 s64 skip = 0;
8dc58101 1658 u64 head;
727ebd54 1659 ssize_t err;
8dc58101
TZ		 1660 void *p;
1661
45694aa7 1662 perf_tool__fill_defaults(tool);
8dc58101
TZ		 1663
1664 head = 0;
444d2866
SE		 1665 cur_size = sizeof(union perf_event);
1666
1667 buf = malloc(cur_size);
1668 if (!buf)
1669 return -errno;
1e0d4f02 1670 ordered_events__set_copy_on_queue(oe, true);
8dc58101 1671more:
444d2866 1672 event = buf;
cc9784bd 1673 err = readn(fd, event, sizeof(struct perf_event_header));
8dc58101
TZ		 1674 if (err <= 0) {
1675 if (err == 0)
1676 goto done;
1677
1678 pr_err("failed to read event header\n");
1679 goto out_err;
1680 }
1681
316c7136 1682 if (session->header.needs_swap)
444d2866 1683 perf_event_header__bswap(&event->header);
8dc58101 1684
444d2866 1685 size = event->header.size;
27389d78
AH		 1686 if (size < sizeof(struct perf_event_header)) {
1687 pr_err("bad event header size\n");
1688 goto out_err;
1689 }
8dc58101 1690
444d2866
SE		 1691 if (size > cur_size) {
1692 void *new = realloc(buf, size);
1693 if (!new) {
1694 pr_err("failed to allocate memory to read event\n");
1695 goto out_err;
1696 }
1697 buf = new;
1698 cur_size = size;
1699 event = buf;
1700 }
1701 p = event;
8dc58101
TZ		 1702 p += sizeof(struct perf_event_header);
1703
794e43b5 1704 if (size - sizeof(struct perf_event_header)) {
cc9784bd 1705 err = readn(fd, p, size - sizeof(struct perf_event_header));
794e43b5
TZ		 1706 if (err <= 0) {
1707 if (err == 0) {
1708 pr_err("unexpected end of event stream\n");
1709 goto done;
1710 }
8dc58101 1711
794e43b5
TZ		 1712 pr_err("failed to read event data\n");
1713 goto out_err;
1714 }
8dc58101
TZ		 1715 }
1716
b7b61cbe 1717 if ((skip = perf_session__process_event(session, event, head)) < 0) {
9389a460 1718 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
444d2866 1719 head, event->header.size, event->header.type);
9389a460
JO		 1720 err = -EINVAL;
1721 goto out_err;
8dc58101
TZ		 1722 }
1723
1724 head += size;
1725
8dc58101
TZ		 1726 if (skip > 0)
1727 head += skip;
1728
1729 if (!session_done())
1730 goto more;
1731done:
8c16b649 1732 /* do the final flush for ordered samples */
b7b61cbe 1733 err = ordered_events__flush(oe, OE_FLUSH__FINAL);
c446870d
AH		 1734 if (err)
1735 goto out_err;
1736 err = auxtrace__flush_events(session, tool);
a5499b37
AH		 1737 if (err)
1738 goto out_err;
1739 err = perf_session__flush_thread_stacks(session);
8dc58101 1740out_err:
444d2866 1741 free(buf);
9870d780 1742 perf_session__warn_about_errors(session);
adc56ed1 1743 ordered_events__free(&session->ordered_events);
c446870d 1744 auxtrace__free_events(session);
8dc58101
TZ		 1745 return err;
1746}
1747
998bedc8
FW		 1748static union perf_event *
1749fetch_mmaped_event(struct perf_session *session,
1750 u64 head, size_t mmap_size, char *buf)
1751{
1752 union perf_event *event;
1753
1754 /*
1755 * Ensure we have enough space remaining to read
1756 * the size of the event in the headers.
1757 */
1758 if (head + sizeof(event->header) > mmap_size)
1759 return NULL;
1760
1761 event = (union perf_event *)(buf + head);
1762
1763 if (session->header.needs_swap)
1764 perf_event_header__bswap(&event->header);
1765
27389d78
AH		 1766 if (head + event->header.size > mmap_size) {
1767 /* We're not fetching the event so swap back again */
1768 if (session->header.needs_swap)
1769 perf_event_header__bswap(&event->header);
998bedc8 1770 return NULL;
27389d78 1771 }
998bedc8
FW		 1772
1773 return event;
1774}
1775
35d48ddf
DM		 1776/*
1777 * On 64bit we can mmap the data file in one go. No need for tiny mmap
1778 * slices. On 32bit we use 32MB.
1779 */
1780#if BITS_PER_LONG == 64
1781#define MMAP_SIZE ULLONG_MAX
1782#define NUM_MMAPS 1
1783#else
1784#define MMAP_SIZE (32 * 1024 * 1024ULL)
1785#define NUM_MMAPS 128
1786#endif
1787
4ac30cf7
NK		 1788static int __perf_session__process_events(struct perf_session *session,
1789 u64 data_offset, u64 data_size,
b7b61cbe 1790 u64 file_size)
06aae590 1791{
fa713a4e 1792 struct ordered_events *oe = &session->ordered_events;
9870d780 1793 struct perf_tool *tool = session->tool;
cc9784bd 1794 int fd = perf_data_file__fd(session->file);
d5652d86 1795 u64 head, page_offset, file_offset, file_pos, size;
fe174207 1796 int err, mmap_prot, mmap_flags, map_idx = 0;
0c1fe6b2 1797 size_t mmap_size;
35d48ddf 1798 char *buf, *mmaps[NUM_MMAPS];
8115d60c 1799 union perf_event *event;
4d3001fd 1800 struct ui_progress prog;
d5652d86 1801 s64 skip;
0331ee0c 1802
45694aa7 1803 perf_tool__fill_defaults(tool);
06aae590 1804
0331ee0c
TG		 1805 page_offset = page_size * (data_offset / page_size);
1806 file_offset = page_offset;
1807 head = data_offset - page_offset;
06aae590 1808
381c02f6
MR		 1809 if (data_size == 0)
1810 goto out;
1811
1812 if (data_offset + data_size < file_size)
d6513281
TG		 1813 file_size = data_offset + data_size;
1814
4d3001fd 1815 ui_progress__init(&prog, file_size, "Processing events...");
55b44629 1816
35d48ddf 1817 mmap_size = MMAP_SIZE;
919d86d3 1818 if (mmap_size > file_size) {
55b44629 1819 mmap_size = file_size;
919d86d3
AH		 1820 session->one_mmap = true;
1821 }
55b44629 1822
fe174207
TG		 1823 memset(mmaps, 0, sizeof(mmaps));
1824
ba21594c
ACM		 1825 mmap_prot = PROT_READ;
1826 mmap_flags = MAP_SHARED;
1827
0331ee0c 1828 if (session->header.needs_swap) {
ba21594c
ACM		 1829 mmap_prot |= PROT_WRITE;
1830 mmap_flags = MAP_PRIVATE;
1831 }
06aae590 1832remap:
cc9784bd 1833 buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd,
55b44629 1834 file_offset);
06aae590
ACM		 1835 if (buf == MAP_FAILED) {
1836 pr_err("failed to mmap file\n");
1837 err = -errno;
1838 goto out_err;
1839 }
fe174207
TG		 1840 mmaps[map_idx] = buf;
1841 map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
d6513281 1842 file_pos = file_offset + head;
919d86d3
AH		 1843 if (session->one_mmap) {
1844 session->one_mmap_addr = buf;
1845 session->one_mmap_offset = file_offset;
1846 }
06aae590
ACM		 1847
1848more:
998bedc8
FW		 1849 event = fetch_mmaped_event(session, head, mmap_size, buf);
1850 if (!event) {
fe174207
TG		 1851 if (mmaps[map_idx]) {
1852 munmap(mmaps[map_idx], mmap_size);
1853 mmaps[map_idx] = NULL;
1854 }
06aae590 1855
0331ee0c
TG		 1856 page_offset = page_size * (head / page_size);
1857 file_offset += page_offset;
1858 head -= page_offset;
06aae590
ACM		 1859 goto remap;
1860 }
1861
1862 size = event->header.size;
1863
27389d78 1864 if (size < sizeof(struct perf_event_header) ||
b7b61cbe 1865 (skip = perf_session__process_event(session, event, file_pos)) < 0) {
9389a460
JO		 1866 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1867 file_offset + head, event->header.size,
1868 event->header.type);
1869 err = -EINVAL;
1870 goto out_err;
06aae590
ACM		 1871 }
1872
6f917c70
AH		 1873 if (skip)
1874 size += skip;
1875
06aae590 1876 head += size;
d6513281 1877 file_pos += size;
06aae590 1878
4d3001fd 1879 ui_progress__update(&prog, size);
55b44629 1880
33e940a2 1881 if (session_done())
8c16b649 1882 goto out;
33e940a2 1883
d6513281 1884 if (file_pos < file_size)
06aae590 1885 goto more;
d6513281 1886
8c16b649 1887out:
c61e52ee 1888 /* do the final flush for ordered samples */
b7b61cbe 1889 err = ordered_events__flush(oe, OE_FLUSH__FINAL);
c446870d
AH		 1890 if (err)
1891 goto out_err;
1892 err = auxtrace__flush_events(session, tool);
a5499b37
AH		 1893 if (err)
1894 goto out_err;
1895 err = perf_session__flush_thread_stacks(session);
06aae590 1896out_err:
a5580f3e 1897 ui_progress__finish();
9870d780 1898 perf_session__warn_about_errors(session);
b26dc730
WN		 1899 /*
1900 * We may switching perf.data output, make ordered_events
1901 * reusable.
1902 */
1903 ordered_events__reinit(&session->ordered_events);
c446870d 1904 auxtrace__free_events(session);
919d86d3 1905 session->one_mmap = false;
06aae590
ACM		 1906 return err;
1907}
27295592 1908
b7b61cbe 1909int perf_session__process_events(struct perf_session *session)
6122e4e4 1910{
316c7136 1911 u64 size = perf_data_file__size(session->file);
6122e4e4
ACM		 1912 int err;
1913
9d8b172f 1914 if (perf_session__register_idle_thread(session) < 0)
6122e4e4
ACM		 1915 return -ENOMEM;
1916
316c7136
ACM		 1917 if (!perf_data_file__is_pipe(session->file))
1918 err = __perf_session__process_events(session,
1919 session->header.data_offset,
b7b61cbe 1920 session->header.data_size, size);
8dc58101 1921 else
b7b61cbe 1922 err = __perf_session__process_pipe_events(session);
88ca895d 1923
6122e4e4
ACM		 1924 return err;
1925}
1926
7f3be652 1927bool perf_session__has_traces(struct perf_session *session, const char *msg)
27295592 1928{
93ea01c2
DA		 1929 struct perf_evsel *evsel;
1930
e5cadb93 1931 evlist__for_each_entry(session->evlist, evsel) {
93ea01c2
DA		 1932 if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
1933 return true;
27295592
ACM		 1934 }
1935
93ea01c2
DA		 1936 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
1937 return false;
27295592 1938}
56b03f3c 1939
743eb868
ACM		 1940int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
1941 const char *symbol_name, u64 addr)
56b03f3c
ACM		 1942{
1943 char *bracket;
a0b2f5af 1944 int i;
a1645ce1
ZY		 1945 struct ref_reloc_sym *ref;
1946
1947 ref = zalloc(sizeof(struct ref_reloc_sym));
1948 if (ref == NULL)
1949 return -ENOMEM;
56b03f3c 1950
a1645ce1
ZY		 1951 ref->name = strdup(symbol_name);
1952 if (ref->name == NULL) {
1953 free(ref);
56b03f3c 1954 return -ENOMEM;
a1645ce1 1955 }
56b03f3c 1956
a1645ce1 1957 bracket = strchr(ref->name, ']');
56b03f3c
ACM		 1958 if (bracket)
1959 *bracket = '\0';
1960
a1645ce1 1961 ref->addr = addr;
9de89fe7
ACM		 1962
1963 for (i = 0; i < MAP__NR_TYPES; ++i) {
a1645ce1 1964 struct kmap *kmap = map__kmap(maps[i]);
ba92732e
WN		 1965
1966 if (!kmap)
1967 continue;
a1645ce1 1968 kmap->ref_reloc_sym = ref;
9de89fe7
ACM		 1969 }
1970
56b03f3c
ACM		 1971 return 0;
1972}
1f626bc3 1973
316c7136 1974size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp)
1f626bc3 1975{
316c7136 1976 return machines__fprintf_dsos(&session->machines, fp);
1f626bc3 1977}
f869097e 1978
316c7136 1979size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp,
417c2ff6 1980 bool (skip)(struct dso *dso, int parm), int parm)
f869097e 1981{
316c7136 1982 return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm);
f869097e 1983}
e248de33
ACM		 1984
1985size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
1986{
c446870d
AH		 1987 size_t ret;
1988 const char *msg = "";
1989
1990 if (perf_header__has_feat(&session->header, HEADER_AUXTRACE))
1991 msg = " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)";
1992
fe692ac8 1993 ret = fprintf(fp, "\nAggregated stats:%s\n", msg);
e248de33 1994
75be989a 1995 ret += events_stats__fprintf(&session->evlist->stats, fp);
e248de33
ACM		 1996 return ret;
1997}
c0230b2b 1998
b424eba2
ACM		 1999size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
2000{
2001 /*
2002 * FIXME: Here we have to actually print all the machines in this
2003 * session, not just the host...
2004 */
876650e6 2005 return machine__fprintf(&session->machines.host, fp);
b424eba2
ACM		 2006}
2007
9cbdb702
DA		 2008struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
2009 unsigned int type)
2010{
2011 struct perf_evsel *pos;
2012
e5cadb93 2013 evlist__for_each_entry(session->evlist, pos) {
9cbdb702
DA		 2014 if (pos->attr.type == type)
2015 return pos;
2016 }
2017 return NULL;
2018}
2019
5d67be97
AB		 2020int perf_session__cpu_bitmap(struct perf_session *session,
2021 const char *cpu_list, unsigned long *cpu_bitmap)
2022{
8bac41cb 2023 int i, err = -1;
5d67be97
AB		 2024 struct cpu_map *map;
2025
2026 for (i = 0; i < PERF_TYPE_MAX; ++i) {
2027 struct perf_evsel *evsel;
2028
2029 evsel = perf_session__find_first_evtype(session, i);
2030 if (!evsel)
2031 continue;
2032
2033 if (!(evsel->attr.sample_type & PERF_SAMPLE_CPU)) {
2034 pr_err("File does not contain CPU events. "
2035 "Remove -c option to proceed.\n");
2036 return -1;
2037 }
2038 }
2039
2040 map = cpu_map__new(cpu_list);
47fbe53b
DA		 2041 if (map == NULL) {
2042 pr_err("Invalid cpu_list\n");
2043 return -1;
2044 }
5d67be97
AB		 2045
2046 for (i = 0; i < map->nr; i++) {
2047 int cpu = map->map[i];
2048
2049 if (cpu >= MAX_NR_CPUS) {
2050 pr_err("Requested CPU %d too large. "
2051 "Consider raising MAX_NR_CPUS\n", cpu);
8bac41cb 2052 goto out_delete_map;
5d67be97
AB		 2053 }
2054
2055 set_bit(cpu, cpu_bitmap);
2056 }
2057
8bac41cb
SF		 2058 err = 0;
2059
2060out_delete_map:
f30a79b0 2061 cpu_map__put(map);
8bac41cb 2062 return err;
5d67be97 2063}
fbe96f29
SE		 2064
2065void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
2066 bool full)
2067{
fbe96f29
SE		 2068 if (session == NULL || fp == NULL)
2069 return;
2070
fbe96f29 2071 fprintf(fp, "# ========\n");
fbe96f29
SE		 2072 perf_header__fprintf_info(session, fp, full);
2073 fprintf(fp, "# ========\n#\n");
2074}
da378962
ACM		 2075
2076
2077int __perf_session__set_tracepoints_handlers(struct perf_session *session,
2078 const struct perf_evsel_str_handler *assocs,
2079 size_t nr_assocs)
2080{
da378962 2081 struct perf_evsel *evsel;
da378962
ACM		 2082 size_t i;
2083 int err;
2084
2085 for (i = 0; i < nr_assocs; i++) {
ccf53eac
ACM		 2086 /*
2087 * Adding a handler for an event not in the session,
2088 * just ignore it.
2089 */
2090 evsel = perf_evlist__find_tracepoint_by_name(session->evlist, assocs[i].name);
da378962 2091 if (evsel == NULL)
ccf53eac 2092 continue;
da378962
ACM		 2093
2094 err = -EEXIST;
744a9719 2095 if (evsel->handler != NULL)
ccf53eac 2096 goto out;
744a9719 2097 evsel->handler = assocs[i].handler;
da378962
ACM		 2098 }
2099
2100 err = 0;
2101out:
2102 return err;
da378962 2103}
3c659eed
AH		 2104
2105int perf_event__process_id_index(struct perf_tool *tool __maybe_unused,
2106 union perf_event *event,
2107 struct perf_session *session)
2108{
2109 struct perf_evlist *evlist = session->evlist;
2110 struct id_index_event *ie = &event->id_index;
2111 size_t i, nr, max_nr;
2112
2113 max_nr = (ie->header.size - sizeof(struct id_index_event)) /
2114 sizeof(struct id_index_entry);
2115 nr = ie->nr;
2116 if (nr > max_nr)
2117 return -EINVAL;
2118
2119 if (dump_trace)
2120 fprintf(stdout, " nr: %zu\n", nr);
2121
2122 for (i = 0; i < nr; i++) {
2123 struct id_index_entry *e = &ie->entries[i];
2124 struct perf_sample_id *sid;
2125
2126 if (dump_trace) {
2127 fprintf(stdout, " ... id: %"PRIu64, e->id);
2128 fprintf(stdout, " idx: %"PRIu64, e->idx);
2129 fprintf(stdout, " cpu: %"PRId64, e->cpu);
2130 fprintf(stdout, " tid: %"PRId64"\n", e->tid);
2131 }
2132
2133 sid = perf_evlist__id2sid(evlist, e->id);
2134 if (!sid)
2135 return -ENOENT;
2136 sid->idx = e->idx;
2137 sid->cpu = e->cpu;
2138 sid->tid = e->tid;
2139 }
2140 return 0;
2141}
2142
2143int perf_event__synthesize_id_index(struct perf_tool *tool,
2144 perf_event__handler_t process,
2145 struct perf_evlist *evlist,
2146 struct machine *machine)
2147{
2148 union perf_event *ev;
2149 struct perf_evsel *evsel;
2150 size_t nr = 0, i = 0, sz, max_nr, n;
2151 int err;
2152
2153 pr_debug2("Synthesizing id index\n");
2154
2155 max_nr = (UINT16_MAX - sizeof(struct id_index_event)) /
2156 sizeof(struct id_index_entry);
2157
e5cadb93 2158 evlist__for_each_entry(evlist, evsel)
3c659eed
AH		 2159 nr += evsel->ids;
2160
2161 n = nr > max_nr ? max_nr : nr;
2162 sz = sizeof(struct id_index_event) + n * sizeof(struct id_index_entry);
2163 ev = zalloc(sz);
2164 if (!ev)
2165 return -ENOMEM;
2166
2167 ev->id_index.header.type = PERF_RECORD_ID_INDEX;
2168 ev->id_index.header.size = sz;
2169 ev->id_index.nr = n;
2170
e5cadb93 2171 evlist__for_each_entry(evlist, evsel) {
3c659eed
AH		 2172 u32 j;
2173
2174 for (j = 0; j < evsel->ids; j++) {
2175 struct id_index_entry *e;
2176 struct perf_sample_id *sid;
2177
2178 if (i >= n) {
2179 err = process(tool, ev, NULL, machine);
2180 if (err)
2181 goto out_err;
2182 nr -= n;
2183 i = 0;
2184 }
2185
2186 e = &ev->id_index.entries[i++];
2187
2188 e->id = evsel->id[j];
2189
2190 sid = perf_evlist__id2sid(evlist, e->id);
2191 if (!sid) {
2192 free(ev);
2193 return -ENOENT;
2194 }
2195
2196 e->idx = sid->idx;
2197 e->cpu = sid->cpu;
2198 e->tid = sid->tid;
2199 }
2200 }
2201
2202 sz = sizeof(struct id_index_event) + nr * sizeof(struct id_index_entry);
2203 ev->id_index.header.size = sz;
2204 ev->id_index.nr = nr;
2205
2206 err = process(tool, ev, NULL, machine);
2207out_err:
2208 free(ev);
2209
2210 return err;
2211}
Linux 6.x block layer and io_uring tree(s)