1 // SPDX-License-Identifier: GPL-2.0
4 #include <linux/kernel.h>
5 #include <traceevent/event-parse.h>
10 #include <sys/types.h>
23 #include "perf_regs.h"
27 #include "thread-stack.h"
28 #include "sample-raw.h"
30 #include "arch/common.h"
32 #ifdef HAVE_ZSTD_SUPPORT
33 static int perf_session__process_compressed_event(struct perf_session
*session
,
34 union perf_event
*event
, u64 file_offset
)
37 size_t decomp_size
, src_size
;
38 u64 decomp_last_rem
= 0;
39 size_t decomp_len
= session
->header
.env
.comp_mmap_len
;
40 struct decomp
*decomp
, *decomp_last
= session
->decomp_last
;
42 decomp
= mmap(NULL
, sizeof(struct decomp
) + decomp_len
, PROT_READ
|PROT_WRITE
,
43 MAP_ANONYMOUS
|MAP_PRIVATE
, -1, 0);
44 if (decomp
== MAP_FAILED
) {
45 pr_err("Couldn't allocate memory for decompression\n");
49 decomp
->file_pos
= file_offset
;
53 decomp_last_rem
= decomp_last
->size
- decomp_last
->head
;
54 memcpy(decomp
->data
, &(decomp_last
->data
[decomp_last
->head
]), decomp_last_rem
);
55 decomp
->size
= decomp_last_rem
;
58 src
= (void *)event
+ sizeof(struct compressed_event
);
59 src_size
= event
->pack
.header
.size
- sizeof(struct compressed_event
);
61 decomp_size
= zstd_decompress_stream(&(session
->zstd_data
), src
, src_size
,
62 &(decomp
->data
[decomp_last_rem
]), decomp_len
- decomp_last_rem
);
64 munmap(decomp
, sizeof(struct decomp
) + decomp_len
);
65 pr_err("Couldn't decompress data\n");
69 decomp
->size
+= decomp_size
;
71 if (session
->decomp
== NULL
) {
72 session
->decomp
= decomp
;
73 session
->decomp_last
= decomp
;
75 session
->decomp_last
->next
= decomp
;
76 session
->decomp_last
= decomp
;
79 pr_debug("decomp (B): %ld to %ld\n", src_size
, decomp_size
);
83 #else /* !HAVE_ZSTD_SUPPORT */
84 #define perf_session__process_compressed_event perf_session__process_compressed_event_stub
87 static int perf_session__deliver_event(struct perf_session
*session
,
88 union perf_event
*event
,
89 struct perf_tool
*tool
,
92 static int perf_session__open(struct perf_session
*session
)
94 struct perf_data
*data
= session
->data
;
96 if (perf_session__read_header(session
) < 0) {
97 pr_err("incompatible file format (rerun with -v to learn more)\n");
101 if (perf_data__is_pipe(data
))
104 if (perf_header__has_feat(&session
->header
, HEADER_STAT
))
107 if (!perf_evlist__valid_sample_type(session
->evlist
)) {
108 pr_err("non matching sample_type\n");
112 if (!perf_evlist__valid_sample_id_all(session
->evlist
)) {
113 pr_err("non matching sample_id_all\n");
117 if (!perf_evlist__valid_read_format(session
->evlist
)) {
118 pr_err("non matching read_format\n");
125 void perf_session__set_id_hdr_size(struct perf_session
*session
)
127 u16 id_hdr_size
= perf_evlist__id_hdr_size(session
->evlist
);
129 machines__set_id_hdr_size(&session
->machines
, id_hdr_size
);
132 int perf_session__create_kernel_maps(struct perf_session
*session
)
134 int ret
= machine__create_kernel_maps(&session
->machines
.host
);
137 ret
= machines__create_guest_kernel_maps(&session
->machines
);
141 static void perf_session__destroy_kernel_maps(struct perf_session
*session
)
143 machines__destroy_kernel_maps(&session
->machines
);
146 static bool perf_session__has_comm_exec(struct perf_session
*session
)
148 struct perf_evsel
*evsel
;
150 evlist__for_each_entry(session
->evlist
, evsel
) {
151 if (evsel
->attr
.comm_exec
)
158 static void perf_session__set_comm_exec(struct perf_session
*session
)
160 bool comm_exec
= perf_session__has_comm_exec(session
);
162 machines__set_comm_exec(&session
->machines
, comm_exec
);
165 static int ordered_events__deliver_event(struct ordered_events
*oe
,
166 struct ordered_event
*event
)
168 struct perf_session
*session
= container_of(oe
, struct perf_session
,
171 return perf_session__deliver_event(session
, event
->event
,
172 session
->tool
, event
->file_offset
);
175 struct perf_session
*perf_session__new(struct perf_data
*data
,
176 bool repipe
, struct perf_tool
*tool
)
178 struct perf_session
*session
= zalloc(sizeof(*session
));
183 session
->repipe
= repipe
;
184 session
->tool
= tool
;
185 INIT_LIST_HEAD(&session
->auxtrace_index
);
186 machines__init(&session
->machines
);
187 ordered_events__init(&session
->ordered_events
,
188 ordered_events__deliver_event
, NULL
);
190 perf_env__init(&session
->header
.env
);
192 if (perf_data__open(data
))
195 session
->data
= data
;
197 if (perf_data__is_read(data
)) {
198 if (perf_session__open(session
) < 0)
202 * set session attributes that are present in perf.data
203 * but not in pipe-mode.
205 if (!data
->is_pipe
) {
206 perf_session__set_id_hdr_size(session
);
207 perf_session__set_comm_exec(session
);
210 perf_evlist__init_trace_event_sample_raw(session
->evlist
);
212 /* Open the directory data. */
213 if (data
->is_dir
&& perf_data__open_dir(data
))
217 session
->machines
.host
.env
= &perf_env
;
220 session
->machines
.host
.single_address_space
=
221 perf_env__single_address_space(session
->machines
.host
.env
);
223 if (!data
|| perf_data__is_write(data
)) {
225 * In O_RDONLY mode this will be performed when reading the
226 * kernel MMAP event, in perf_event__process_mmap().
228 if (perf_session__create_kernel_maps(session
) < 0)
229 pr_warning("Cannot read kernel map\n");
233 * In pipe-mode, evlist is empty until PERF_RECORD_HEADER_ATTR is
234 * processed, so perf_evlist__sample_id_all is not meaningful here.
236 if ((!data
|| !data
->is_pipe
) && tool
&& tool
->ordering_requires_timestamps
&&
237 tool
->ordered_events
&& !perf_evlist__sample_id_all(session
->evlist
)) {
238 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
239 tool
->ordered_events
= false;
245 perf_session__delete(session
);
250 static void perf_session__delete_threads(struct perf_session
*session
)
252 machine__delete_threads(&session
->machines
.host
);
255 static void perf_session__release_decomp_events(struct perf_session
*session
)
257 struct decomp
*next
, *decomp
;
259 next
= session
->decomp
;
260 decomp_len
= session
->header
.env
.comp_mmap_len
;
266 munmap(decomp
, decomp_len
+ sizeof(struct decomp
));
270 void perf_session__delete(struct perf_session
*session
)
274 auxtrace__free(session
);
275 auxtrace_index__free(&session
->auxtrace_index
);
276 perf_session__destroy_kernel_maps(session
);
277 perf_session__delete_threads(session
);
278 perf_session__release_decomp_events(session
);
279 perf_env__exit(&session
->header
.env
);
280 machines__exit(&session
->machines
);
282 perf_data__close(session
->data
);
286 static int process_event_synth_tracing_data_stub(struct perf_session
*session
288 union perf_event
*event
291 dump_printf(": unhandled!\n");
295 static int process_event_synth_attr_stub(struct perf_tool
*tool __maybe_unused
,
296 union perf_event
*event __maybe_unused
,
297 struct perf_evlist
**pevlist
300 dump_printf(": unhandled!\n");
304 static int process_event_synth_event_update_stub(struct perf_tool
*tool __maybe_unused
,
305 union perf_event
*event __maybe_unused
,
306 struct perf_evlist
**pevlist
310 perf_event__fprintf_event_update(event
, stdout
);
312 dump_printf(": unhandled!\n");
316 static int process_event_sample_stub(struct perf_tool
*tool __maybe_unused
,
317 union perf_event
*event __maybe_unused
,
318 struct perf_sample
*sample __maybe_unused
,
319 struct perf_evsel
*evsel __maybe_unused
,
320 struct machine
*machine __maybe_unused
)
322 dump_printf(": unhandled!\n");
326 static int process_event_stub(struct perf_tool
*tool __maybe_unused
,
327 union perf_event
*event __maybe_unused
,
328 struct perf_sample
*sample __maybe_unused
,
329 struct machine
*machine __maybe_unused
)
331 dump_printf(": unhandled!\n");
335 static int process_finished_round_stub(struct perf_tool
*tool __maybe_unused
,
336 union perf_event
*event __maybe_unused
,
337 struct ordered_events
*oe __maybe_unused
)
339 dump_printf(": unhandled!\n");
343 static int process_finished_round(struct perf_tool
*tool
,
344 union perf_event
*event
,
345 struct ordered_events
*oe
);
347 static int skipn(int fd
, off_t n
)
353 ret
= read(fd
, buf
, min(n
, (off_t
)sizeof(buf
)));
362 static s64
process_event_auxtrace_stub(struct perf_session
*session __maybe_unused
,
363 union perf_event
*event
)
365 dump_printf(": unhandled!\n");
366 if (perf_data__is_pipe(session
->data
))
367 skipn(perf_data__fd(session
->data
), event
->auxtrace
.size
);
368 return event
->auxtrace
.size
;
371 static int process_event_op2_stub(struct perf_session
*session __maybe_unused
,
372 union perf_event
*event __maybe_unused
)
374 dump_printf(": unhandled!\n");
380 int process_event_thread_map_stub(struct perf_session
*session __maybe_unused
,
381 union perf_event
*event __maybe_unused
)
384 perf_event__fprintf_thread_map(event
, stdout
);
386 dump_printf(": unhandled!\n");
391 int process_event_cpu_map_stub(struct perf_session
*session __maybe_unused
,
392 union perf_event
*event __maybe_unused
)
395 perf_event__fprintf_cpu_map(event
, stdout
);
397 dump_printf(": unhandled!\n");
402 int process_event_stat_config_stub(struct perf_session
*session __maybe_unused
,
403 union perf_event
*event __maybe_unused
)
406 perf_event__fprintf_stat_config(event
, stdout
);
408 dump_printf(": unhandled!\n");
412 static int process_stat_stub(struct perf_session
*perf_session __maybe_unused
,
413 union perf_event
*event
)
416 perf_event__fprintf_stat(event
, stdout
);
418 dump_printf(": unhandled!\n");
422 static int process_stat_round_stub(struct perf_session
*perf_session __maybe_unused
,
423 union perf_event
*event
)
426 perf_event__fprintf_stat_round(event
, stdout
);
428 dump_printf(": unhandled!\n");
432 static int perf_session__process_compressed_event_stub(struct perf_session
*session __maybe_unused
,
433 union perf_event
*event __maybe_unused
,
434 u64 file_offset __maybe_unused
)
436 dump_printf(": unhandled!\n");
440 void perf_tool__fill_defaults(struct perf_tool
*tool
)
442 if (tool
->sample
== NULL
)
443 tool
->sample
= process_event_sample_stub
;
444 if (tool
->mmap
== NULL
)
445 tool
->mmap
= process_event_stub
;
446 if (tool
->mmap2
== NULL
)
447 tool
->mmap2
= process_event_stub
;
448 if (tool
->comm
== NULL
)
449 tool
->comm
= process_event_stub
;
450 if (tool
->namespaces
== NULL
)
451 tool
->namespaces
= process_event_stub
;
452 if (tool
->fork
== NULL
)
453 tool
->fork
= process_event_stub
;
454 if (tool
->exit
== NULL
)
455 tool
->exit
= process_event_stub
;
456 if (tool
->lost
== NULL
)
457 tool
->lost
= perf_event__process_lost
;
458 if (tool
->lost_samples
== NULL
)
459 tool
->lost_samples
= perf_event__process_lost_samples
;
460 if (tool
->aux
== NULL
)
461 tool
->aux
= perf_event__process_aux
;
462 if (tool
->itrace_start
== NULL
)
463 tool
->itrace_start
= perf_event__process_itrace_start
;
464 if (tool
->context_switch
== NULL
)
465 tool
->context_switch
= perf_event__process_switch
;
466 if (tool
->ksymbol
== NULL
)
467 tool
->ksymbol
= perf_event__process_ksymbol
;
468 if (tool
->bpf_event
== NULL
)
469 tool
->bpf_event
= perf_event__process_bpf_event
;
470 if (tool
->read
== NULL
)
471 tool
->read
= process_event_sample_stub
;
472 if (tool
->throttle
== NULL
)
473 tool
->throttle
= process_event_stub
;
474 if (tool
->unthrottle
== NULL
)
475 tool
->unthrottle
= process_event_stub
;
476 if (tool
->attr
== NULL
)
477 tool
->attr
= process_event_synth_attr_stub
;
478 if (tool
->event_update
== NULL
)
479 tool
->event_update
= process_event_synth_event_update_stub
;
480 if (tool
->tracing_data
== NULL
)
481 tool
->tracing_data
= process_event_synth_tracing_data_stub
;
482 if (tool
->build_id
== NULL
)
483 tool
->build_id
= process_event_op2_stub
;
484 if (tool
->finished_round
== NULL
) {
485 if (tool
->ordered_events
)
486 tool
->finished_round
= process_finished_round
;
488 tool
->finished_round
= process_finished_round_stub
;
490 if (tool
->id_index
== NULL
)
491 tool
->id_index
= process_event_op2_stub
;
492 if (tool
->auxtrace_info
== NULL
)
493 tool
->auxtrace_info
= process_event_op2_stub
;
494 if (tool
->auxtrace
== NULL
)
495 tool
->auxtrace
= process_event_auxtrace_stub
;
496 if (tool
->auxtrace_error
== NULL
)
497 tool
->auxtrace_error
= process_event_op2_stub
;
498 if (tool
->thread_map
== NULL
)
499 tool
->thread_map
= process_event_thread_map_stub
;
500 if (tool
->cpu_map
== NULL
)
501 tool
->cpu_map
= process_event_cpu_map_stub
;
502 if (tool
->stat_config
== NULL
)
503 tool
->stat_config
= process_event_stat_config_stub
;
504 if (tool
->stat
== NULL
)
505 tool
->stat
= process_stat_stub
;
506 if (tool
->stat_round
== NULL
)
507 tool
->stat_round
= process_stat_round_stub
;
508 if (tool
->time_conv
== NULL
)
509 tool
->time_conv
= process_event_op2_stub
;
510 if (tool
->feature
== NULL
)
511 tool
->feature
= process_event_op2_stub
;
512 if (tool
->compressed
== NULL
)
513 tool
->compressed
= perf_session__process_compressed_event
;
516 static void swap_sample_id_all(union perf_event
*event
, void *data
)
518 void *end
= (void *) event
+ event
->header
.size
;
519 int size
= end
- data
;
521 BUG_ON(size
% sizeof(u64
));
522 mem_bswap_64(data
, size
);
525 static void perf_event__all64_swap(union perf_event
*event
,
526 bool sample_id_all __maybe_unused
)
528 struct perf_event_header
*hdr
= &event
->header
;
529 mem_bswap_64(hdr
+ 1, event
->header
.size
- sizeof(*hdr
));
532 static void perf_event__comm_swap(union perf_event
*event
, bool sample_id_all
)
534 event
->comm
.pid
= bswap_32(event
->comm
.pid
);
535 event
->comm
.tid
= bswap_32(event
->comm
.tid
);
538 void *data
= &event
->comm
.comm
;
540 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
541 swap_sample_id_all(event
, data
);
545 static void perf_event__mmap_swap(union perf_event
*event
,
548 event
->mmap
.pid
= bswap_32(event
->mmap
.pid
);
549 event
->mmap
.tid
= bswap_32(event
->mmap
.tid
);
550 event
->mmap
.start
= bswap_64(event
->mmap
.start
);
551 event
->mmap
.len
= bswap_64(event
->mmap
.len
);
552 event
->mmap
.pgoff
= bswap_64(event
->mmap
.pgoff
);
555 void *data
= &event
->mmap
.filename
;
557 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
558 swap_sample_id_all(event
, data
);
562 static void perf_event__mmap2_swap(union perf_event
*event
,
565 event
->mmap2
.pid
= bswap_32(event
->mmap2
.pid
);
566 event
->mmap2
.tid
= bswap_32(event
->mmap2
.tid
);
567 event
->mmap2
.start
= bswap_64(event
->mmap2
.start
);
568 event
->mmap2
.len
= bswap_64(event
->mmap2
.len
);
569 event
->mmap2
.pgoff
= bswap_64(event
->mmap2
.pgoff
);
570 event
->mmap2
.maj
= bswap_32(event
->mmap2
.maj
);
571 event
->mmap2
.min
= bswap_32(event
->mmap2
.min
);
572 event
->mmap2
.ino
= bswap_64(event
->mmap2
.ino
);
575 void *data
= &event
->mmap2
.filename
;
577 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
578 swap_sample_id_all(event
, data
);
581 static void perf_event__task_swap(union perf_event
*event
, bool sample_id_all
)
583 event
->fork
.pid
= bswap_32(event
->fork
.pid
);
584 event
->fork
.tid
= bswap_32(event
->fork
.tid
);
585 event
->fork
.ppid
= bswap_32(event
->fork
.ppid
);
586 event
->fork
.ptid
= bswap_32(event
->fork
.ptid
);
587 event
->fork
.time
= bswap_64(event
->fork
.time
);
590 swap_sample_id_all(event
, &event
->fork
+ 1);
593 static void perf_event__read_swap(union perf_event
*event
, bool sample_id_all
)
595 event
->read
.pid
= bswap_32(event
->read
.pid
);
596 event
->read
.tid
= bswap_32(event
->read
.tid
);
597 event
->read
.value
= bswap_64(event
->read
.value
);
598 event
->read
.time_enabled
= bswap_64(event
->read
.time_enabled
);
599 event
->read
.time_running
= bswap_64(event
->read
.time_running
);
600 event
->read
.id
= bswap_64(event
->read
.id
);
603 swap_sample_id_all(event
, &event
->read
+ 1);
606 static void perf_event__aux_swap(union perf_event
*event
, bool sample_id_all
)
608 event
->aux
.aux_offset
= bswap_64(event
->aux
.aux_offset
);
609 event
->aux
.aux_size
= bswap_64(event
->aux
.aux_size
);
610 event
->aux
.flags
= bswap_64(event
->aux
.flags
);
613 swap_sample_id_all(event
, &event
->aux
+ 1);
616 static void perf_event__itrace_start_swap(union perf_event
*event
,
619 event
->itrace_start
.pid
= bswap_32(event
->itrace_start
.pid
);
620 event
->itrace_start
.tid
= bswap_32(event
->itrace_start
.tid
);
623 swap_sample_id_all(event
, &event
->itrace_start
+ 1);
626 static void perf_event__switch_swap(union perf_event
*event
, bool sample_id_all
)
628 if (event
->header
.type
== PERF_RECORD_SWITCH_CPU_WIDE
) {
629 event
->context_switch
.next_prev_pid
=
630 bswap_32(event
->context_switch
.next_prev_pid
);
631 event
->context_switch
.next_prev_tid
=
632 bswap_32(event
->context_switch
.next_prev_tid
);
636 swap_sample_id_all(event
, &event
->context_switch
+ 1);
639 static void perf_event__throttle_swap(union perf_event
*event
,
642 event
->throttle
.time
= bswap_64(event
->throttle
.time
);
643 event
->throttle
.id
= bswap_64(event
->throttle
.id
);
644 event
->throttle
.stream_id
= bswap_64(event
->throttle
.stream_id
);
647 swap_sample_id_all(event
, &event
->throttle
+ 1);
650 static u8
revbyte(u8 b
)
652 int rev
= (b
>> 4) | ((b
& 0xf) << 4);
653 rev
= ((rev
& 0xcc) >> 2) | ((rev
& 0x33) << 2);
654 rev
= ((rev
& 0xaa) >> 1) | ((rev
& 0x55) << 1);
659 * XXX this is hack in attempt to carry flags bitfield
660 * through endian village. ABI says:
662 * Bit-fields are allocated from right to left (least to most significant)
663 * on little-endian implementations and from left to right (most to least
664 * significant) on big-endian implementations.
666 * The above seems to be byte specific, so we need to reverse each
667 * byte of the bitfield. 'Internet' also says this might be implementation
668 * specific and we probably need proper fix and carry perf_event_attr
669 * bitfield flags in separate data file FEAT_ section. Thought this seems
672 static void swap_bitfield(u8
*p
, unsigned len
)
676 for (i
= 0; i
< len
; i
++) {
682 /* exported for swapping attributes in file header */
683 void perf_event__attr_swap(struct perf_event_attr
*attr
)
685 attr
->type
= bswap_32(attr
->type
);
686 attr
->size
= bswap_32(attr
->size
);
688 #define bswap_safe(f, n) \
689 (attr->size > (offsetof(struct perf_event_attr, f) + \
690 sizeof(attr->f) * (n)))
691 #define bswap_field(f, sz) \
693 if (bswap_safe(f, 0)) \
694 attr->f = bswap_##sz(attr->f); \
696 #define bswap_field_16(f) bswap_field(f, 16)
697 #define bswap_field_32(f) bswap_field(f, 32)
698 #define bswap_field_64(f) bswap_field(f, 64)
700 bswap_field_64(config
);
701 bswap_field_64(sample_period
);
702 bswap_field_64(sample_type
);
703 bswap_field_64(read_format
);
704 bswap_field_32(wakeup_events
);
705 bswap_field_32(bp_type
);
706 bswap_field_64(bp_addr
);
707 bswap_field_64(bp_len
);
708 bswap_field_64(branch_sample_type
);
709 bswap_field_64(sample_regs_user
);
710 bswap_field_32(sample_stack_user
);
711 bswap_field_32(aux_watermark
);
712 bswap_field_16(sample_max_stack
);
715 * After read_format are bitfields. Check read_format because
716 * we are unable to use offsetof on bitfield.
718 if (bswap_safe(read_format
, 1))
719 swap_bitfield((u8
*) (&attr
->read_format
+ 1),
721 #undef bswap_field_64
722 #undef bswap_field_32
727 static void perf_event__hdr_attr_swap(union perf_event
*event
,
728 bool sample_id_all __maybe_unused
)
732 perf_event__attr_swap(&event
->attr
.attr
);
734 size
= event
->header
.size
;
735 size
-= (void *)&event
->attr
.id
- (void *)event
;
736 mem_bswap_64(event
->attr
.id
, size
);
739 static void perf_event__event_update_swap(union perf_event
*event
,
740 bool sample_id_all __maybe_unused
)
742 event
->event_update
.type
= bswap_64(event
->event_update
.type
);
743 event
->event_update
.id
= bswap_64(event
->event_update
.id
);
746 static void perf_event__event_type_swap(union perf_event
*event
,
747 bool sample_id_all __maybe_unused
)
749 event
->event_type
.event_type
.event_id
=
750 bswap_64(event
->event_type
.event_type
.event_id
);
753 static void perf_event__tracing_data_swap(union perf_event
*event
,
754 bool sample_id_all __maybe_unused
)
756 event
->tracing_data
.size
= bswap_32(event
->tracing_data
.size
);
759 static void perf_event__auxtrace_info_swap(union perf_event
*event
,
760 bool sample_id_all __maybe_unused
)
764 event
->auxtrace_info
.type
= bswap_32(event
->auxtrace_info
.type
);
766 size
= event
->header
.size
;
767 size
-= (void *)&event
->auxtrace_info
.priv
- (void *)event
;
768 mem_bswap_64(event
->auxtrace_info
.priv
, size
);
771 static void perf_event__auxtrace_swap(union perf_event
*event
,
772 bool sample_id_all __maybe_unused
)
774 event
->auxtrace
.size
= bswap_64(event
->auxtrace
.size
);
775 event
->auxtrace
.offset
= bswap_64(event
->auxtrace
.offset
);
776 event
->auxtrace
.reference
= bswap_64(event
->auxtrace
.reference
);
777 event
->auxtrace
.idx
= bswap_32(event
->auxtrace
.idx
);
778 event
->auxtrace
.tid
= bswap_32(event
->auxtrace
.tid
);
779 event
->auxtrace
.cpu
= bswap_32(event
->auxtrace
.cpu
);
782 static void perf_event__auxtrace_error_swap(union perf_event
*event
,
783 bool sample_id_all __maybe_unused
)
785 event
->auxtrace_error
.type
= bswap_32(event
->auxtrace_error
.type
);
786 event
->auxtrace_error
.code
= bswap_32(event
->auxtrace_error
.code
);
787 event
->auxtrace_error
.cpu
= bswap_32(event
->auxtrace_error
.cpu
);
788 event
->auxtrace_error
.pid
= bswap_32(event
->auxtrace_error
.pid
);
789 event
->auxtrace_error
.tid
= bswap_32(event
->auxtrace_error
.tid
);
790 event
->auxtrace_error
.fmt
= bswap_32(event
->auxtrace_error
.fmt
);
791 event
->auxtrace_error
.ip
= bswap_64(event
->auxtrace_error
.ip
);
792 if (event
->auxtrace_error
.fmt
)
793 event
->auxtrace_error
.time
= bswap_64(event
->auxtrace_error
.time
);
796 static void perf_event__thread_map_swap(union perf_event
*event
,
797 bool sample_id_all __maybe_unused
)
801 event
->thread_map
.nr
= bswap_64(event
->thread_map
.nr
);
803 for (i
= 0; i
< event
->thread_map
.nr
; i
++)
804 event
->thread_map
.entries
[i
].pid
= bswap_64(event
->thread_map
.entries
[i
].pid
);
807 static void perf_event__cpu_map_swap(union perf_event
*event
,
808 bool sample_id_all __maybe_unused
)
810 struct cpu_map_data
*data
= &event
->cpu_map
.data
;
811 struct cpu_map_entries
*cpus
;
812 struct cpu_map_mask
*mask
;
815 data
->type
= bswap_64(data
->type
);
817 switch (data
->type
) {
818 case PERF_CPU_MAP__CPUS
:
819 cpus
= (struct cpu_map_entries
*)data
->data
;
821 cpus
->nr
= bswap_16(cpus
->nr
);
823 for (i
= 0; i
< cpus
->nr
; i
++)
824 cpus
->cpu
[i
] = bswap_16(cpus
->cpu
[i
]);
826 case PERF_CPU_MAP__MASK
:
827 mask
= (struct cpu_map_mask
*) data
->data
;
829 mask
->nr
= bswap_16(mask
->nr
);
830 mask
->long_size
= bswap_16(mask
->long_size
);
832 switch (mask
->long_size
) {
833 case 4: mem_bswap_32(&mask
->mask
, mask
->nr
); break;
834 case 8: mem_bswap_64(&mask
->mask
, mask
->nr
); break;
836 pr_err("cpu_map swap: unsupported long size\n");
843 static void perf_event__stat_config_swap(union perf_event
*event
,
844 bool sample_id_all __maybe_unused
)
848 size
= event
->stat_config
.nr
* sizeof(event
->stat_config
.data
[0]);
849 size
+= 1; /* nr item itself */
850 mem_bswap_64(&event
->stat_config
.nr
, size
);
853 static void perf_event__stat_swap(union perf_event
*event
,
854 bool sample_id_all __maybe_unused
)
856 event
->stat
.id
= bswap_64(event
->stat
.id
);
857 event
->stat
.thread
= bswap_32(event
->stat
.thread
);
858 event
->stat
.cpu
= bswap_32(event
->stat
.cpu
);
859 event
->stat
.val
= bswap_64(event
->stat
.val
);
860 event
->stat
.ena
= bswap_64(event
->stat
.ena
);
861 event
->stat
.run
= bswap_64(event
->stat
.run
);
864 static void perf_event__stat_round_swap(union perf_event
*event
,
865 bool sample_id_all __maybe_unused
)
867 event
->stat_round
.type
= bswap_64(event
->stat_round
.type
);
868 event
->stat_round
.time
= bswap_64(event
->stat_round
.time
);
871 typedef void (*perf_event__swap_op
)(union perf_event
*event
,
874 static perf_event__swap_op perf_event__swap_ops
[] = {
875 [PERF_RECORD_MMAP
] = perf_event__mmap_swap
,
876 [PERF_RECORD_MMAP2
] = perf_event__mmap2_swap
,
877 [PERF_RECORD_COMM
] = perf_event__comm_swap
,
878 [PERF_RECORD_FORK
] = perf_event__task_swap
,
879 [PERF_RECORD_EXIT
] = perf_event__task_swap
,
880 [PERF_RECORD_LOST
] = perf_event__all64_swap
,
881 [PERF_RECORD_READ
] = perf_event__read_swap
,
882 [PERF_RECORD_THROTTLE
] = perf_event__throttle_swap
,
883 [PERF_RECORD_UNTHROTTLE
] = perf_event__throttle_swap
,
884 [PERF_RECORD_SAMPLE
] = perf_event__all64_swap
,
885 [PERF_RECORD_AUX
] = perf_event__aux_swap
,
886 [PERF_RECORD_ITRACE_START
] = perf_event__itrace_start_swap
,
887 [PERF_RECORD_LOST_SAMPLES
] = perf_event__all64_swap
,
888 [PERF_RECORD_SWITCH
] = perf_event__switch_swap
,
889 [PERF_RECORD_SWITCH_CPU_WIDE
] = perf_event__switch_swap
,
890 [PERF_RECORD_HEADER_ATTR
] = perf_event__hdr_attr_swap
,
891 [PERF_RECORD_HEADER_EVENT_TYPE
] = perf_event__event_type_swap
,
892 [PERF_RECORD_HEADER_TRACING_DATA
] = perf_event__tracing_data_swap
,
893 [PERF_RECORD_HEADER_BUILD_ID
] = NULL
,
894 [PERF_RECORD_ID_INDEX
] = perf_event__all64_swap
,
895 [PERF_RECORD_AUXTRACE_INFO
] = perf_event__auxtrace_info_swap
,
896 [PERF_RECORD_AUXTRACE
] = perf_event__auxtrace_swap
,
897 [PERF_RECORD_AUXTRACE_ERROR
] = perf_event__auxtrace_error_swap
,
898 [PERF_RECORD_THREAD_MAP
] = perf_event__thread_map_swap
,
899 [PERF_RECORD_CPU_MAP
] = perf_event__cpu_map_swap
,
900 [PERF_RECORD_STAT_CONFIG
] = perf_event__stat_config_swap
,
901 [PERF_RECORD_STAT
] = perf_event__stat_swap
,
902 [PERF_RECORD_STAT_ROUND
] = perf_event__stat_round_swap
,
903 [PERF_RECORD_EVENT_UPDATE
] = perf_event__event_update_swap
,
904 [PERF_RECORD_TIME_CONV
] = perf_event__all64_swap
,
905 [PERF_RECORD_HEADER_MAX
] = NULL
,
909 * When perf record finishes a pass on every buffers, it records this pseudo
911 * We record the max timestamp t found in the pass n.
912 * Assuming these timestamps are monotonic across cpus, we know that if
913 * a buffer still has events with timestamps below t, they will be all
914 * available and then read in the pass n + 1.
915 * Hence when we start to read the pass n + 2, we can safely flush every
916 * events with timestamps below t.
918 * ============ PASS n =================
921 * cnt1 timestamps | cnt2 timestamps
924 * - | 4 <--- max recorded
926 * ============ PASS n + 1 ==============
929 * cnt1 timestamps | cnt2 timestamps
932 * 5 | 7 <---- max recorded
934 * Flush every events below timestamp 4
936 * ============ PASS n + 2 ==============
939 * cnt1 timestamps | cnt2 timestamps
944 * Flush every events below timestamp 7
947 static int process_finished_round(struct perf_tool
*tool __maybe_unused
,
948 union perf_event
*event __maybe_unused
,
949 struct ordered_events
*oe
)
952 fprintf(stdout
, "\n");
953 return ordered_events__flush(oe
, OE_FLUSH__ROUND
);
956 int perf_session__queue_event(struct perf_session
*s
, union perf_event
*event
,
957 u64 timestamp
, u64 file_offset
)
959 return ordered_events__queue(&s
->ordered_events
, event
, timestamp
, file_offset
);
962 static void callchain__lbr_callstack_printf(struct perf_sample
*sample
)
964 struct ip_callchain
*callchain
= sample
->callchain
;
965 struct branch_stack
*lbr_stack
= sample
->branch_stack
;
966 u64 kernel_callchain_nr
= callchain
->nr
;
969 for (i
= 0; i
< kernel_callchain_nr
; i
++) {
970 if (callchain
->ips
[i
] == PERF_CONTEXT_USER
)
974 if ((i
!= kernel_callchain_nr
) && lbr_stack
->nr
) {
977 * LBR callstack can only get user call chain,
978 * i is kernel call chain number,
979 * 1 is PERF_CONTEXT_USER.
981 * The user call chain is stored in LBR registers.
982 * LBR are pair registers. The caller is stored
983 * in "from" register, while the callee is stored
985 * For example, there is a call stack
986 * "A"->"B"->"C"->"D".
987 * The LBR registers will recorde like
988 * "C"->"D", "B"->"C", "A"->"B".
989 * So only the first "to" register and all "from"
990 * registers are needed to construct the whole stack.
992 total_nr
= i
+ 1 + lbr_stack
->nr
+ 1;
993 kernel_callchain_nr
= i
+ 1;
995 printf("... LBR call chain: nr:%" PRIu64
"\n", total_nr
);
997 for (i
= 0; i
< kernel_callchain_nr
; i
++)
998 printf("..... %2d: %016" PRIx64
"\n",
999 i
, callchain
->ips
[i
]);
1001 printf("..... %2d: %016" PRIx64
"\n",
1002 (int)(kernel_callchain_nr
), lbr_stack
->entries
[0].to
);
1003 for (i
= 0; i
< lbr_stack
->nr
; i
++)
1004 printf("..... %2d: %016" PRIx64
"\n",
1005 (int)(i
+ kernel_callchain_nr
+ 1), lbr_stack
->entries
[i
].from
);
1009 static void callchain__printf(struct perf_evsel
*evsel
,
1010 struct perf_sample
*sample
)
1013 struct ip_callchain
*callchain
= sample
->callchain
;
1015 if (perf_evsel__has_branch_callstack(evsel
))
1016 callchain__lbr_callstack_printf(sample
);
1018 printf("... FP chain: nr:%" PRIu64
"\n", callchain
->nr
);
1020 for (i
= 0; i
< callchain
->nr
; i
++)
1021 printf("..... %2d: %016" PRIx64
"\n",
1022 i
, callchain
->ips
[i
]);
1025 static void branch_stack__printf(struct perf_sample
*sample
)
1029 printf("... branch stack: nr:%" PRIu64
"\n", sample
->branch_stack
->nr
);
1031 for (i
= 0; i
< sample
->branch_stack
->nr
; i
++) {
1032 struct branch_entry
*e
= &sample
->branch_stack
->entries
[i
];
1034 printf("..... %2"PRIu64
": %016" PRIx64
" -> %016" PRIx64
" %hu cycles %s%s%s%s %x\n",
1036 (unsigned short)e
->flags
.cycles
,
1037 e
->flags
.mispred
? "M" : " ",
1038 e
->flags
.predicted
? "P" : " ",
1039 e
->flags
.abort
? "A" : " ",
1040 e
->flags
.in_tx
? "T" : " ",
1041 (unsigned)e
->flags
.reserved
);
1045 static void regs_dump__printf(u64 mask
, u64
*regs
)
1047 unsigned rid
, i
= 0;
1049 for_each_set_bit(rid
, (unsigned long *) &mask
, sizeof(mask
) * 8) {
1050 u64 val
= regs
[i
++];
1052 printf(".... %-5s 0x%" PRIx64
"\n",
1053 perf_reg_name(rid
), val
);
1057 static const char *regs_abi
[] = {
1058 [PERF_SAMPLE_REGS_ABI_NONE
] = "none",
1059 [PERF_SAMPLE_REGS_ABI_32
] = "32-bit",
1060 [PERF_SAMPLE_REGS_ABI_64
] = "64-bit",
1063 static inline const char *regs_dump_abi(struct regs_dump
*d
)
1065 if (d
->abi
> PERF_SAMPLE_REGS_ABI_64
)
1068 return regs_abi
[d
->abi
];
1071 static void regs__printf(const char *type
, struct regs_dump
*regs
)
1073 u64 mask
= regs
->mask
;
1075 printf("... %s regs: mask 0x%" PRIx64
" ABI %s\n",
1078 regs_dump_abi(regs
));
1080 regs_dump__printf(mask
, regs
->regs
);
1083 static void regs_user__printf(struct perf_sample
*sample
)
1085 struct regs_dump
*user_regs
= &sample
->user_regs
;
1087 if (user_regs
->regs
)
1088 regs__printf("user", user_regs
);
1091 static void regs_intr__printf(struct perf_sample
*sample
)
1093 struct regs_dump
*intr_regs
= &sample
->intr_regs
;
1095 if (intr_regs
->regs
)
1096 regs__printf("intr", intr_regs
);
1099 static void stack_user__printf(struct stack_dump
*dump
)
1101 printf("... ustack: size %" PRIu64
", offset 0x%x\n",
1102 dump
->size
, dump
->offset
);
1105 static void perf_evlist__print_tstamp(struct perf_evlist
*evlist
,
1106 union perf_event
*event
,
1107 struct perf_sample
*sample
)
1109 u64 sample_type
= __perf_evlist__combined_sample_type(evlist
);
1111 if (event
->header
.type
!= PERF_RECORD_SAMPLE
&&
1112 !perf_evlist__sample_id_all(evlist
)) {
1113 fputs("-1 -1 ", stdout
);
1117 if ((sample_type
& PERF_SAMPLE_CPU
))
1118 printf("%u ", sample
->cpu
);
1120 if (sample_type
& PERF_SAMPLE_TIME
)
1121 printf("%" PRIu64
" ", sample
->time
);
1124 static void sample_read__printf(struct perf_sample
*sample
, u64 read_format
)
1126 printf("... sample_read:\n");
1128 if (read_format
& PERF_FORMAT_TOTAL_TIME_ENABLED
)
1129 printf("...... time enabled %016" PRIx64
"\n",
1130 sample
->read
.time_enabled
);
1132 if (read_format
& PERF_FORMAT_TOTAL_TIME_RUNNING
)
1133 printf("...... time running %016" PRIx64
"\n",
1134 sample
->read
.time_running
);
1136 if (read_format
& PERF_FORMAT_GROUP
) {
1139 printf(".... group nr %" PRIu64
"\n", sample
->read
.group
.nr
);
1141 for (i
= 0; i
< sample
->read
.group
.nr
; i
++) {
1142 struct sample_read_value
*value
;
1144 value
= &sample
->read
.group
.values
[i
];
1145 printf("..... id %016" PRIx64
1146 ", value %016" PRIx64
"\n",
1147 value
->id
, value
->value
);
1150 printf("..... id %016" PRIx64
", value %016" PRIx64
"\n",
1151 sample
->read
.one
.id
, sample
->read
.one
.value
);
1154 static void dump_event(struct perf_evlist
*evlist
, union perf_event
*event
,
1155 u64 file_offset
, struct perf_sample
*sample
)
1160 printf("\n%#" PRIx64
" [%#x]: event: %d\n",
1161 file_offset
, event
->header
.size
, event
->header
.type
);
1164 if (event
->header
.type
== PERF_RECORD_SAMPLE
&& evlist
->trace_event_sample_raw
)
1165 evlist
->trace_event_sample_raw(evlist
, event
, sample
);
1168 perf_evlist__print_tstamp(evlist
, event
, sample
);
1170 printf("%#" PRIx64
" [%#x]: PERF_RECORD_%s", file_offset
,
1171 event
->header
.size
, perf_event__name(event
->header
.type
));
1174 static void dump_sample(struct perf_evsel
*evsel
, union perf_event
*event
,
1175 struct perf_sample
*sample
)
1182 printf("(IP, 0x%x): %d/%d: %#" PRIx64
" period: %" PRIu64
" addr: %#" PRIx64
"\n",
1183 event
->header
.misc
, sample
->pid
, sample
->tid
, sample
->ip
,
1184 sample
->period
, sample
->addr
);
1186 sample_type
= evsel
->attr
.sample_type
;
1188 if (evsel__has_callchain(evsel
))
1189 callchain__printf(evsel
, sample
);
1191 if ((sample_type
& PERF_SAMPLE_BRANCH_STACK
) && !perf_evsel__has_branch_callstack(evsel
))
1192 branch_stack__printf(sample
);
1194 if (sample_type
& PERF_SAMPLE_REGS_USER
)
1195 regs_user__printf(sample
);
1197 if (sample_type
& PERF_SAMPLE_REGS_INTR
)
1198 regs_intr__printf(sample
);
1200 if (sample_type
& PERF_SAMPLE_STACK_USER
)
1201 stack_user__printf(&sample
->user_stack
);
1203 if (sample_type
& PERF_SAMPLE_WEIGHT
)
1204 printf("... weight: %" PRIu64
"\n", sample
->weight
);
1206 if (sample_type
& PERF_SAMPLE_DATA_SRC
)
1207 printf(" . data_src: 0x%"PRIx64
"\n", sample
->data_src
);
1209 if (sample_type
& PERF_SAMPLE_PHYS_ADDR
)
1210 printf(" .. phys_addr: 0x%"PRIx64
"\n", sample
->phys_addr
);
1212 if (sample_type
& PERF_SAMPLE_TRANSACTION
)
1213 printf("... transaction: %" PRIx64
"\n", sample
->transaction
);
1215 if (sample_type
& PERF_SAMPLE_READ
)
1216 sample_read__printf(sample
, evsel
->attr
.read_format
);
1219 static void dump_read(struct perf_evsel
*evsel
, union perf_event
*event
)
1221 struct read_event
*read_event
= &event
->read
;
1227 printf(": %d %d %s %" PRIu64
"\n", event
->read
.pid
, event
->read
.tid
,
1228 evsel
? perf_evsel__name(evsel
) : "FAIL",
1231 read_format
= evsel
->attr
.read_format
;
1233 if (read_format
& PERF_FORMAT_TOTAL_TIME_ENABLED
)
1234 printf("... time enabled : %" PRIu64
"\n", read_event
->time_enabled
);
1236 if (read_format
& PERF_FORMAT_TOTAL_TIME_RUNNING
)
1237 printf("... time running : %" PRIu64
"\n", read_event
->time_running
);
1239 if (read_format
& PERF_FORMAT_ID
)
1240 printf("... id : %" PRIu64
"\n", read_event
->id
);
1243 static struct machine
*machines__find_for_cpumode(struct machines
*machines
,
1244 union perf_event
*event
,
1245 struct perf_sample
*sample
)
1247 struct machine
*machine
;
1250 ((sample
->cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
) ||
1251 (sample
->cpumode
== PERF_RECORD_MISC_GUEST_USER
))) {
1254 if (event
->header
.type
== PERF_RECORD_MMAP
1255 || event
->header
.type
== PERF_RECORD_MMAP2
)
1256 pid
= event
->mmap
.pid
;
1260 machine
= machines__find(machines
, pid
);
1262 machine
= machines__findnew(machines
, DEFAULT_GUEST_KERNEL_ID
);
1266 return &machines
->host
;
1269 static int deliver_sample_value(struct perf_evlist
*evlist
,
1270 struct perf_tool
*tool
,
1271 union perf_event
*event
,
1272 struct perf_sample
*sample
,
1273 struct sample_read_value
*v
,
1274 struct machine
*machine
)
1276 struct perf_sample_id
*sid
= perf_evlist__id2sid(evlist
, v
->id
);
1280 sample
->period
= v
->value
- sid
->period
;
1281 sid
->period
= v
->value
;
1284 if (!sid
|| sid
->evsel
== NULL
) {
1285 ++evlist
->stats
.nr_unknown_id
;
1290 * There's no reason to deliver sample
1291 * for zero period, bail out.
1293 if (!sample
->period
)
1296 return tool
->sample(tool
, event
, sample
, sid
->evsel
, machine
);
1299 static int deliver_sample_group(struct perf_evlist
*evlist
,
1300 struct perf_tool
*tool
,
1301 union perf_event
*event
,
1302 struct perf_sample
*sample
,
1303 struct machine
*machine
)
1308 for (i
= 0; i
< sample
->read
.group
.nr
; i
++) {
1309 ret
= deliver_sample_value(evlist
, tool
, event
, sample
,
1310 &sample
->read
.group
.values
[i
],
1320 perf_evlist__deliver_sample(struct perf_evlist
*evlist
,
1321 struct perf_tool
*tool
,
1322 union perf_event
*event
,
1323 struct perf_sample
*sample
,
1324 struct perf_evsel
*evsel
,
1325 struct machine
*machine
)
1327 /* We know evsel != NULL. */
1328 u64 sample_type
= evsel
->attr
.sample_type
;
1329 u64 read_format
= evsel
->attr
.read_format
;
1331 /* Standard sample delivery. */
1332 if (!(sample_type
& PERF_SAMPLE_READ
))
1333 return tool
->sample(tool
, event
, sample
, evsel
, machine
);
1335 /* For PERF_SAMPLE_READ we have either single or group mode. */
1336 if (read_format
& PERF_FORMAT_GROUP
)
1337 return deliver_sample_group(evlist
, tool
, event
, sample
,
1340 return deliver_sample_value(evlist
, tool
, event
, sample
,
1341 &sample
->read
.one
, machine
);
1344 static int machines__deliver_event(struct machines
*machines
,
1345 struct perf_evlist
*evlist
,
1346 union perf_event
*event
,
1347 struct perf_sample
*sample
,
1348 struct perf_tool
*tool
, u64 file_offset
)
1350 struct perf_evsel
*evsel
;
1351 struct machine
*machine
;
1353 dump_event(evlist
, event
, file_offset
, sample
);
1355 evsel
= perf_evlist__id2evsel(evlist
, sample
->id
);
1357 machine
= machines__find_for_cpumode(machines
, event
, sample
);
1359 switch (event
->header
.type
) {
1360 case PERF_RECORD_SAMPLE
:
1361 if (evsel
== NULL
) {
1362 ++evlist
->stats
.nr_unknown_id
;
1365 dump_sample(evsel
, event
, sample
);
1366 if (machine
== NULL
) {
1367 ++evlist
->stats
.nr_unprocessable_samples
;
1370 return perf_evlist__deliver_sample(evlist
, tool
, event
, sample
, evsel
, machine
);
1371 case PERF_RECORD_MMAP
:
1372 return tool
->mmap(tool
, event
, sample
, machine
);
1373 case PERF_RECORD_MMAP2
:
1374 if (event
->header
.misc
& PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT
)
1375 ++evlist
->stats
.nr_proc_map_timeout
;
1376 return tool
->mmap2(tool
, event
, sample
, machine
);
1377 case PERF_RECORD_COMM
:
1378 return tool
->comm(tool
, event
, sample
, machine
);
1379 case PERF_RECORD_NAMESPACES
:
1380 return tool
->namespaces(tool
, event
, sample
, machine
);
1381 case PERF_RECORD_FORK
:
1382 return tool
->fork(tool
, event
, sample
, machine
);
1383 case PERF_RECORD_EXIT
:
1384 return tool
->exit(tool
, event
, sample
, machine
);
1385 case PERF_RECORD_LOST
:
1386 if (tool
->lost
== perf_event__process_lost
)
1387 evlist
->stats
.total_lost
+= event
->lost
.lost
;
1388 return tool
->lost(tool
, event
, sample
, machine
);
1389 case PERF_RECORD_LOST_SAMPLES
:
1390 if (tool
->lost_samples
== perf_event__process_lost_samples
)
1391 evlist
->stats
.total_lost_samples
+= event
->lost_samples
.lost
;
1392 return tool
->lost_samples(tool
, event
, sample
, machine
);
1393 case PERF_RECORD_READ
:
1394 dump_read(evsel
, event
);
1395 return tool
->read(tool
, event
, sample
, evsel
, machine
);
1396 case PERF_RECORD_THROTTLE
:
1397 return tool
->throttle(tool
, event
, sample
, machine
);
1398 case PERF_RECORD_UNTHROTTLE
:
1399 return tool
->unthrottle(tool
, event
, sample
, machine
);
1400 case PERF_RECORD_AUX
:
1401 if (tool
->aux
== perf_event__process_aux
) {
1402 if (event
->aux
.flags
& PERF_AUX_FLAG_TRUNCATED
)
1403 evlist
->stats
.total_aux_lost
+= 1;
1404 if (event
->aux
.flags
& PERF_AUX_FLAG_PARTIAL
)
1405 evlist
->stats
.total_aux_partial
+= 1;
1407 return tool
->aux(tool
, event
, sample
, machine
);
1408 case PERF_RECORD_ITRACE_START
:
1409 return tool
->itrace_start(tool
, event
, sample
, machine
);
1410 case PERF_RECORD_SWITCH
:
1411 case PERF_RECORD_SWITCH_CPU_WIDE
:
1412 return tool
->context_switch(tool
, event
, sample
, machine
);
1413 case PERF_RECORD_KSYMBOL
:
1414 return tool
->ksymbol(tool
, event
, sample
, machine
);
1415 case PERF_RECORD_BPF_EVENT
:
1416 return tool
->bpf_event(tool
, event
, sample
, machine
);
1418 ++evlist
->stats
.nr_unknown_events
;
1423 static int perf_session__deliver_event(struct perf_session
*session
,
1424 union perf_event
*event
,
1425 struct perf_tool
*tool
,
1428 struct perf_sample sample
;
1431 ret
= perf_evlist__parse_sample(session
->evlist
, event
, &sample
);
1433 pr_err("Can't parse sample, err = %d\n", ret
);
1437 ret
= auxtrace__process_event(session
, event
, &sample
, tool
);
1443 return machines__deliver_event(&session
->machines
, session
->evlist
,
1444 event
, &sample
, tool
, file_offset
);
1447 static s64
perf_session__process_user_event(struct perf_session
*session
,
1448 union perf_event
*event
,
1451 struct ordered_events
*oe
= &session
->ordered_events
;
1452 struct perf_tool
*tool
= session
->tool
;
1453 struct perf_sample sample
= { .time
= 0, };
1454 int fd
= perf_data__fd(session
->data
);
1457 if (event
->header
.type
!= PERF_RECORD_COMPRESSED
||
1458 tool
->compressed
== perf_session__process_compressed_event_stub
)
1459 dump_event(session
->evlist
, event
, file_offset
, &sample
);
1461 /* These events are processed right away */
1462 switch (event
->header
.type
) {
1463 case PERF_RECORD_HEADER_ATTR
:
1464 err
= tool
->attr(tool
, event
, &session
->evlist
);
1466 perf_session__set_id_hdr_size(session
);
1467 perf_session__set_comm_exec(session
);
1470 case PERF_RECORD_EVENT_UPDATE
:
1471 return tool
->event_update(tool
, event
, &session
->evlist
);
1472 case PERF_RECORD_HEADER_EVENT_TYPE
:
1474 * Depreceated, but we need to handle it for sake
1475 * of old data files create in pipe mode.
1478 case PERF_RECORD_HEADER_TRACING_DATA
:
1479 /* setup for reading amidst mmap */
1480 lseek(fd
, file_offset
, SEEK_SET
);
1481 return tool
->tracing_data(session
, event
);
1482 case PERF_RECORD_HEADER_BUILD_ID
:
1483 return tool
->build_id(session
, event
);
1484 case PERF_RECORD_FINISHED_ROUND
:
1485 return tool
->finished_round(tool
, event
, oe
);
1486 case PERF_RECORD_ID_INDEX
:
1487 return tool
->id_index(session
, event
);
1488 case PERF_RECORD_AUXTRACE_INFO
:
1489 return tool
->auxtrace_info(session
, event
);
1490 case PERF_RECORD_AUXTRACE
:
1491 /* setup for reading amidst mmap */
1492 lseek(fd
, file_offset
+ event
->header
.size
, SEEK_SET
);
1493 return tool
->auxtrace(session
, event
);
1494 case PERF_RECORD_AUXTRACE_ERROR
:
1495 perf_session__auxtrace_error_inc(session
, event
);
1496 return tool
->auxtrace_error(session
, event
);
1497 case PERF_RECORD_THREAD_MAP
:
1498 return tool
->thread_map(session
, event
);
1499 case PERF_RECORD_CPU_MAP
:
1500 return tool
->cpu_map(session
, event
);
1501 case PERF_RECORD_STAT_CONFIG
:
1502 return tool
->stat_config(session
, event
);
1503 case PERF_RECORD_STAT
:
1504 return tool
->stat(session
, event
);
1505 case PERF_RECORD_STAT_ROUND
:
1506 return tool
->stat_round(session
, event
);
1507 case PERF_RECORD_TIME_CONV
:
1508 session
->time_conv
= event
->time_conv
;
1509 return tool
->time_conv(session
, event
);
1510 case PERF_RECORD_HEADER_FEATURE
:
1511 return tool
->feature(session
, event
);
1512 case PERF_RECORD_COMPRESSED
:
1513 err
= tool
->compressed(session
, event
, file_offset
);
1515 dump_event(session
->evlist
, event
, file_offset
, &sample
);
1522 int perf_session__deliver_synth_event(struct perf_session
*session
,
1523 union perf_event
*event
,
1524 struct perf_sample
*sample
)
1526 struct perf_evlist
*evlist
= session
->evlist
;
1527 struct perf_tool
*tool
= session
->tool
;
1529 events_stats__inc(&evlist
->stats
, event
->header
.type
);
1531 if (event
->header
.type
>= PERF_RECORD_USER_TYPE_START
)
1532 return perf_session__process_user_event(session
, event
, 0);
1534 return machines__deliver_event(&session
->machines
, evlist
, event
, sample
, tool
, 0);
1537 static void event_swap(union perf_event
*event
, bool sample_id_all
)
1539 perf_event__swap_op swap
;
1541 swap
= perf_event__swap_ops
[event
->header
.type
];
1543 swap(event
, sample_id_all
);
1546 int perf_session__peek_event(struct perf_session
*session
, off_t file_offset
,
1547 void *buf
, size_t buf_sz
,
1548 union perf_event
**event_ptr
,
1549 struct perf_sample
*sample
)
1551 union perf_event
*event
;
1552 size_t hdr_sz
, rest
;
1555 if (session
->one_mmap
&& !session
->header
.needs_swap
) {
1556 event
= file_offset
- session
->one_mmap_offset
+
1557 session
->one_mmap_addr
;
1558 goto out_parse_sample
;
1561 if (perf_data__is_pipe(session
->data
))
1564 fd
= perf_data__fd(session
->data
);
1565 hdr_sz
= sizeof(struct perf_event_header
);
1567 if (buf_sz
< hdr_sz
)
1570 if (lseek(fd
, file_offset
, SEEK_SET
) == (off_t
)-1 ||
1571 readn(fd
, buf
, hdr_sz
) != (ssize_t
)hdr_sz
)
1574 event
= (union perf_event
*)buf
;
1576 if (session
->header
.needs_swap
)
1577 perf_event_header__bswap(&event
->header
);
1579 if (event
->header
.size
< hdr_sz
|| event
->header
.size
> buf_sz
)
1582 rest
= event
->header
.size
- hdr_sz
;
1584 if (readn(fd
, buf
, rest
) != (ssize_t
)rest
)
1587 if (session
->header
.needs_swap
)
1588 event_swap(event
, perf_evlist__sample_id_all(session
->evlist
));
1592 if (sample
&& event
->header
.type
< PERF_RECORD_USER_TYPE_START
&&
1593 perf_evlist__parse_sample(session
->evlist
, event
, sample
))
1601 static s64
perf_session__process_event(struct perf_session
*session
,
1602 union perf_event
*event
, u64 file_offset
)
1604 struct perf_evlist
*evlist
= session
->evlist
;
1605 struct perf_tool
*tool
= session
->tool
;
1608 if (session
->header
.needs_swap
)
1609 event_swap(event
, perf_evlist__sample_id_all(evlist
));
1611 if (event
->header
.type
>= PERF_RECORD_HEADER_MAX
)
1614 events_stats__inc(&evlist
->stats
, event
->header
.type
);
1616 if (event
->header
.type
>= PERF_RECORD_USER_TYPE_START
)
1617 return perf_session__process_user_event(session
, event
, file_offset
);
1619 if (tool
->ordered_events
) {
1620 u64 timestamp
= -1ULL;
1622 ret
= perf_evlist__parse_sample_timestamp(evlist
, event
, ×tamp
);
1623 if (ret
&& ret
!= -1)
1626 ret
= perf_session__queue_event(session
, event
, timestamp
, file_offset
);
1631 return perf_session__deliver_event(session
, event
, tool
, file_offset
);
1634 void perf_event_header__bswap(struct perf_event_header
*hdr
)
1636 hdr
->type
= bswap_32(hdr
->type
);
1637 hdr
->misc
= bswap_16(hdr
->misc
);
1638 hdr
->size
= bswap_16(hdr
->size
);
1641 struct thread
*perf_session__findnew(struct perf_session
*session
, pid_t pid
)
1643 return machine__findnew_thread(&session
->machines
.host
, -1, pid
);
1647 * Threads are identified by pid and tid, and the idle task has pid == tid == 0.
1648 * So here a single thread is created for that, but actually there is a separate
1649 * idle task per cpu, so there should be one 'struct thread' per cpu, but there
1650 * is only 1. That causes problems for some tools, requiring workarounds. For
1651 * example get_idle_thread() in builtin-sched.c, or thread_stack__per_cpu().
1653 int perf_session__register_idle_thread(struct perf_session
*session
)
1655 struct thread
*thread
;
1658 thread
= machine__findnew_thread(&session
->machines
.host
, 0, 0);
1659 if (thread
== NULL
|| thread__set_comm(thread
, "swapper", 0)) {
1660 pr_err("problem inserting idle task.\n");
1664 if (thread
== NULL
|| thread__set_namespaces(thread
, 0, NULL
)) {
1665 pr_err("problem inserting idle task.\n");
1669 /* machine__findnew_thread() got the thread, so put it */
1670 thread__put(thread
);
1675 perf_session__warn_order(const struct perf_session
*session
)
1677 const struct ordered_events
*oe
= &session
->ordered_events
;
1678 struct perf_evsel
*evsel
;
1679 bool should_warn
= true;
1681 evlist__for_each_entry(session
->evlist
, evsel
) {
1682 if (evsel
->attr
.write_backward
)
1683 should_warn
= false;
1688 if (oe
->nr_unordered_events
!= 0)
1689 ui__warning("%u out of order events recorded.\n", oe
->nr_unordered_events
);
1692 static void perf_session__warn_about_errors(const struct perf_session
*session
)
1694 const struct events_stats
*stats
= &session
->evlist
->stats
;
1696 if (session
->tool
->lost
== perf_event__process_lost
&&
1697 stats
->nr_events
[PERF_RECORD_LOST
] != 0) {
1698 ui__warning("Processed %d events and lost %d chunks!\n\n"
1699 "Check IO/CPU overload!\n\n",
1700 stats
->nr_events
[0],
1701 stats
->nr_events
[PERF_RECORD_LOST
]);
1704 if (session
->tool
->lost_samples
== perf_event__process_lost_samples
) {
1707 drop_rate
= (double)stats
->total_lost_samples
/
1708 (double) (stats
->nr_events
[PERF_RECORD_SAMPLE
] + stats
->total_lost_samples
);
1709 if (drop_rate
> 0.05) {
1710 ui__warning("Processed %" PRIu64
" samples and lost %3.2f%%!\n\n",
1711 stats
->nr_events
[PERF_RECORD_SAMPLE
] + stats
->total_lost_samples
,
1716 if (session
->tool
->aux
== perf_event__process_aux
&&
1717 stats
->total_aux_lost
!= 0) {
1718 ui__warning("AUX data lost %" PRIu64
" times out of %u!\n\n",
1719 stats
->total_aux_lost
,
1720 stats
->nr_events
[PERF_RECORD_AUX
]);
1723 if (session
->tool
->aux
== perf_event__process_aux
&&
1724 stats
->total_aux_partial
!= 0) {
1725 bool vmm_exclusive
= false;
1727 (void)sysfs__read_bool("module/kvm_intel/parameters/vmm_exclusive",
1730 ui__warning("AUX data had gaps in it %" PRIu64
" times out of %u!\n\n"
1731 "Are you running a KVM guest in the background?%s\n\n",
1732 stats
->total_aux_partial
,
1733 stats
->nr_events
[PERF_RECORD_AUX
],
1735 "\nReloading kvm_intel module with vmm_exclusive=0\n"
1736 "will reduce the gaps to only guest's timeslices." :
1740 if (stats
->nr_unknown_events
!= 0) {
1741 ui__warning("Found %u unknown events!\n\n"
1742 "Is this an older tool processing a perf.data "
1743 "file generated by a more recent tool?\n\n"
1744 "If that is not the case, consider "
1745 "reporting to linux-kernel@vger.kernel.org.\n\n",
1746 stats
->nr_unknown_events
);
1749 if (stats
->nr_unknown_id
!= 0) {
1750 ui__warning("%u samples with id not present in the header\n",
1751 stats
->nr_unknown_id
);
1754 if (stats
->nr_invalid_chains
!= 0) {
1755 ui__warning("Found invalid callchains!\n\n"
1756 "%u out of %u events were discarded for this reason.\n\n"
1757 "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
1758 stats
->nr_invalid_chains
,
1759 stats
->nr_events
[PERF_RECORD_SAMPLE
]);
1762 if (stats
->nr_unprocessable_samples
!= 0) {
1763 ui__warning("%u unprocessable samples recorded.\n"
1764 "Do you have a KVM guest running and not using 'perf kvm'?\n",
1765 stats
->nr_unprocessable_samples
);
1768 perf_session__warn_order(session
);
1770 events_stats__auxtrace_error_warn(stats
);
1772 if (stats
->nr_proc_map_timeout
!= 0) {
1773 ui__warning("%d map information files for pre-existing threads were\n"
1774 "not processed, if there are samples for addresses they\n"
1775 "will not be resolved, you may find out which are these\n"
1776 "threads by running with -v and redirecting the output\n"
1778 "The time limit to process proc map is too short?\n"
1779 "Increase it by --proc-map-timeout\n",
1780 stats
->nr_proc_map_timeout
);
1784 static int perf_session__flush_thread_stack(struct thread
*thread
,
1785 void *p __maybe_unused
)
1787 return thread_stack__flush(thread
);
1790 static int perf_session__flush_thread_stacks(struct perf_session
*session
)
1792 return machines__for_each_thread(&session
->machines
,
1793 perf_session__flush_thread_stack
,
1797 volatile int session_done
;
1799 static int __perf_session__process_decomp_events(struct perf_session
*session
);
1801 static int __perf_session__process_pipe_events(struct perf_session
*session
)
1803 struct ordered_events
*oe
= &session
->ordered_events
;
1804 struct perf_tool
*tool
= session
->tool
;
1805 int fd
= perf_data__fd(session
->data
);
1806 union perf_event
*event
;
1807 uint32_t size
, cur_size
= 0;
1814 perf_tool__fill_defaults(tool
);
1817 cur_size
= sizeof(union perf_event
);
1819 buf
= malloc(cur_size
);
1822 ordered_events__set_copy_on_queue(oe
, true);
1825 err
= readn(fd
, event
, sizeof(struct perf_event_header
));
1830 pr_err("failed to read event header\n");
1834 if (session
->header
.needs_swap
)
1835 perf_event_header__bswap(&event
->header
);
1837 size
= event
->header
.size
;
1838 if (size
< sizeof(struct perf_event_header
)) {
1839 pr_err("bad event header size\n");
1843 if (size
> cur_size
) {
1844 void *new = realloc(buf
, size
);
1846 pr_err("failed to allocate memory to read event\n");
1854 p
+= sizeof(struct perf_event_header
);
1856 if (size
- sizeof(struct perf_event_header
)) {
1857 err
= readn(fd
, p
, size
- sizeof(struct perf_event_header
));
1860 pr_err("unexpected end of event stream\n");
1864 pr_err("failed to read event data\n");
1869 if ((skip
= perf_session__process_event(session
, event
, head
)) < 0) {
1870 pr_err("%#" PRIx64
" [%#x]: failed to process type: %d\n",
1871 head
, event
->header
.size
, event
->header
.type
);
1881 err
= __perf_session__process_decomp_events(session
);
1885 if (!session_done())
1888 /* do the final flush for ordered samples */
1889 err
= ordered_events__flush(oe
, OE_FLUSH__FINAL
);
1892 err
= auxtrace__flush_events(session
, tool
);
1895 err
= perf_session__flush_thread_stacks(session
);
1899 perf_session__warn_about_errors(session
);
1900 ordered_events__free(&session
->ordered_events
);
1901 auxtrace__free_events(session
);
1905 static union perf_event
*
1906 fetch_mmaped_event(struct perf_session
*session
,
1907 u64 head
, size_t mmap_size
, char *buf
)
1909 union perf_event
*event
;
1912 * Ensure we have enough space remaining to read
1913 * the size of the event in the headers.
1915 if (head
+ sizeof(event
->header
) > mmap_size
)
1918 event
= (union perf_event
*)(buf
+ head
);
1920 if (session
->header
.needs_swap
)
1921 perf_event_header__bswap(&event
->header
);
1923 if (head
+ event
->header
.size
> mmap_size
) {
1924 /* We're not fetching the event so swap back again */
1925 if (session
->header
.needs_swap
)
1926 perf_event_header__bswap(&event
->header
);
1933 static int __perf_session__process_decomp_events(struct perf_session
*session
)
1936 u64 size
, file_pos
= 0;
1937 struct decomp
*decomp
= session
->decomp_last
;
1942 while (decomp
->head
< decomp
->size
&& !session_done()) {
1943 union perf_event
*event
= fetch_mmaped_event(session
, decomp
->head
, decomp
->size
, decomp
->data
);
1948 size
= event
->header
.size
;
1950 if (size
< sizeof(struct perf_event_header
) ||
1951 (skip
= perf_session__process_event(session
, event
, file_pos
)) < 0) {
1952 pr_err("%#" PRIx64
" [%#x]: failed to process type: %d\n",
1953 decomp
->file_pos
+ decomp
->head
, event
->header
.size
, event
->header
.type
);
1960 decomp
->head
+= size
;
1967 * On 64bit we can mmap the data file in one go. No need for tiny mmap
1968 * slices. On 32bit we use 32MB.
1970 #if BITS_PER_LONG == 64
1971 #define MMAP_SIZE ULLONG_MAX
1974 #define MMAP_SIZE (32 * 1024 * 1024ULL)
1975 #define NUM_MMAPS 128
1980 typedef s64 (*reader_cb_t
)(struct perf_session
*session
,
1981 union perf_event
*event
,
1988 reader_cb_t process
;
1992 reader__process_events(struct reader
*rd
, struct perf_session
*session
,
1993 struct ui_progress
*prog
)
1995 u64 data_size
= rd
->data_size
;
1996 u64 head
, page_offset
, file_offset
, file_pos
, size
;
1997 int err
= 0, mmap_prot
, mmap_flags
, map_idx
= 0;
1999 char *buf
, *mmaps
[NUM_MMAPS
];
2000 union perf_event
*event
;
2003 page_offset
= page_size
* (rd
->data_offset
/ page_size
);
2004 file_offset
= page_offset
;
2005 head
= rd
->data_offset
- page_offset
;
2007 ui_progress__init_size(prog
, data_size
, "Processing events...");
2009 data_size
+= rd
->data_offset
;
2011 mmap_size
= MMAP_SIZE
;
2012 if (mmap_size
> data_size
) {
2013 mmap_size
= data_size
;
2014 session
->one_mmap
= true;
2017 memset(mmaps
, 0, sizeof(mmaps
));
2019 mmap_prot
= PROT_READ
;
2020 mmap_flags
= MAP_SHARED
;
2022 if (session
->header
.needs_swap
) {
2023 mmap_prot
|= PROT_WRITE
;
2024 mmap_flags
= MAP_PRIVATE
;
2027 buf
= mmap(NULL
, mmap_size
, mmap_prot
, mmap_flags
, rd
->fd
,
2029 if (buf
== MAP_FAILED
) {
2030 pr_err("failed to mmap file\n");
2034 mmaps
[map_idx
] = buf
;
2035 map_idx
= (map_idx
+ 1) & (ARRAY_SIZE(mmaps
) - 1);
2036 file_pos
= file_offset
+ head
;
2037 if (session
->one_mmap
) {
2038 session
->one_mmap_addr
= buf
;
2039 session
->one_mmap_offset
= file_offset
;
2043 event
= fetch_mmaped_event(session
, head
, mmap_size
, buf
);
2045 if (mmaps
[map_idx
]) {
2046 munmap(mmaps
[map_idx
], mmap_size
);
2047 mmaps
[map_idx
] = NULL
;
2050 page_offset
= page_size
* (head
/ page_size
);
2051 file_offset
+= page_offset
;
2052 head
-= page_offset
;
2056 size
= event
->header
.size
;
2060 if (size
< sizeof(struct perf_event_header
) ||
2061 (skip
= rd
->process(session
, event
, file_pos
)) < 0) {
2062 pr_err("%#" PRIx64
" [%#x]: failed to process type: %d [%s]\n",
2063 file_offset
+ head
, event
->header
.size
,
2064 event
->header
.type
, strerror(-skip
));
2075 err
= __perf_session__process_decomp_events(session
);
2079 ui_progress__update(prog
, size
);
2084 if (file_pos
< data_size
)
2091 static s64
process_simple(struct perf_session
*session
,
2092 union perf_event
*event
,
2095 return perf_session__process_event(session
, event
, file_offset
);
2098 static int __perf_session__process_events(struct perf_session
*session
)
2100 struct reader rd
= {
2101 .fd
= perf_data__fd(session
->data
),
2102 .data_size
= session
->header
.data_size
,
2103 .data_offset
= session
->header
.data_offset
,
2104 .process
= process_simple
,
2106 struct ordered_events
*oe
= &session
->ordered_events
;
2107 struct perf_tool
*tool
= session
->tool
;
2108 struct ui_progress prog
;
2111 perf_tool__fill_defaults(tool
);
2113 if (rd
.data_size
== 0)
2116 ui_progress__init_size(&prog
, rd
.data_size
, "Processing events...");
2118 err
= reader__process_events(&rd
, session
, &prog
);
2121 /* do the final flush for ordered samples */
2122 err
= ordered_events__flush(oe
, OE_FLUSH__FINAL
);
2125 err
= auxtrace__flush_events(session
, tool
);
2128 err
= perf_session__flush_thread_stacks(session
);
2130 ui_progress__finish();
2132 perf_session__warn_about_errors(session
);
2134 * We may switching perf.data output, make ordered_events
2137 ordered_events__reinit(&session
->ordered_events
);
2138 auxtrace__free_events(session
);
2139 session
->one_mmap
= false;
2143 int perf_session__process_events(struct perf_session
*session
)
2145 if (perf_session__register_idle_thread(session
) < 0)
2148 if (perf_data__is_pipe(session
->data
))
2149 return __perf_session__process_pipe_events(session
);
2151 return __perf_session__process_events(session
);
2154 bool perf_session__has_traces(struct perf_session
*session
, const char *msg
)
2156 struct perf_evsel
*evsel
;
2158 evlist__for_each_entry(session
->evlist
, evsel
) {
2159 if (evsel
->attr
.type
== PERF_TYPE_TRACEPOINT
)
2163 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg
);
2167 int map__set_kallsyms_ref_reloc_sym(struct map
*map
, const char *symbol_name
, u64 addr
)
2170 struct ref_reloc_sym
*ref
;
2173 ref
= zalloc(sizeof(struct ref_reloc_sym
));
2177 ref
->name
= strdup(symbol_name
);
2178 if (ref
->name
== NULL
) {
2183 bracket
= strchr(ref
->name
, ']');
2189 kmap
= map__kmap(map
);
2191 kmap
->ref_reloc_sym
= ref
;
2196 size_t perf_session__fprintf_dsos(struct perf_session
*session
, FILE *fp
)
2198 return machines__fprintf_dsos(&session
->machines
, fp
);
2201 size_t perf_session__fprintf_dsos_buildid(struct perf_session
*session
, FILE *fp
,
2202 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
2204 return machines__fprintf_dsos_buildid(&session
->machines
, fp
, skip
, parm
);
2207 size_t perf_session__fprintf_nr_events(struct perf_session
*session
, FILE *fp
)
2210 const char *msg
= "";
2212 if (perf_header__has_feat(&session
->header
, HEADER_AUXTRACE
))
2213 msg
= " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)";
2215 ret
= fprintf(fp
, "\nAggregated stats:%s\n", msg
);
2217 ret
+= events_stats__fprintf(&session
->evlist
->stats
, fp
);
2221 size_t perf_session__fprintf(struct perf_session
*session
, FILE *fp
)
2224 * FIXME: Here we have to actually print all the machines in this
2225 * session, not just the host...
2227 return machine__fprintf(&session
->machines
.host
, fp
);
2230 struct perf_evsel
*perf_session__find_first_evtype(struct perf_session
*session
,
2233 struct perf_evsel
*pos
;
2235 evlist__for_each_entry(session
->evlist
, pos
) {
2236 if (pos
->attr
.type
== type
)
2242 int perf_session__cpu_bitmap(struct perf_session
*session
,
2243 const char *cpu_list
, unsigned long *cpu_bitmap
)
2246 struct cpu_map
*map
;
2248 for (i
= 0; i
< PERF_TYPE_MAX
; ++i
) {
2249 struct perf_evsel
*evsel
;
2251 evsel
= perf_session__find_first_evtype(session
, i
);
2255 if (!(evsel
->attr
.sample_type
& PERF_SAMPLE_CPU
)) {
2256 pr_err("File does not contain CPU events. "
2257 "Remove -C option to proceed.\n");
2262 map
= cpu_map__new(cpu_list
);
2264 pr_err("Invalid cpu_list\n");
2268 for (i
= 0; i
< map
->nr
; i
++) {
2269 int cpu
= map
->map
[i
];
2271 if (cpu
>= MAX_NR_CPUS
) {
2272 pr_err("Requested CPU %d too large. "
2273 "Consider raising MAX_NR_CPUS\n", cpu
);
2274 goto out_delete_map
;
2277 set_bit(cpu
, cpu_bitmap
);
2287 void perf_session__fprintf_info(struct perf_session
*session
, FILE *fp
,
2290 if (session
== NULL
|| fp
== NULL
)
2293 fprintf(fp
, "# ========\n");
2294 perf_header__fprintf_info(session
, fp
, full
);
2295 fprintf(fp
, "# ========\n#\n");
2299 int __perf_session__set_tracepoints_handlers(struct perf_session
*session
,
2300 const struct perf_evsel_str_handler
*assocs
,
2303 struct perf_evsel
*evsel
;
2307 for (i
= 0; i
< nr_assocs
; i
++) {
2309 * Adding a handler for an event not in the session,
2312 evsel
= perf_evlist__find_tracepoint_by_name(session
->evlist
, assocs
[i
].name
);
2317 if (evsel
->handler
!= NULL
)
2319 evsel
->handler
= assocs
[i
].handler
;
2327 int perf_event__process_id_index(struct perf_session
*session
,
2328 union perf_event
*event
)
2330 struct perf_evlist
*evlist
= session
->evlist
;
2331 struct id_index_event
*ie
= &event
->id_index
;
2332 size_t i
, nr
, max_nr
;
2334 max_nr
= (ie
->header
.size
- sizeof(struct id_index_event
)) /
2335 sizeof(struct id_index_entry
);
2341 fprintf(stdout
, " nr: %zu\n", nr
);
2343 for (i
= 0; i
< nr
; i
++) {
2344 struct id_index_entry
*e
= &ie
->entries
[i
];
2345 struct perf_sample_id
*sid
;
2348 fprintf(stdout
, " ... id: %"PRIu64
, e
->id
);
2349 fprintf(stdout
, " idx: %"PRIu64
, e
->idx
);
2350 fprintf(stdout
, " cpu: %"PRId64
, e
->cpu
);
2351 fprintf(stdout
, " tid: %"PRId64
"\n", e
->tid
);
2354 sid
= perf_evlist__id2sid(evlist
, e
->id
);
2364 int perf_event__synthesize_id_index(struct perf_tool
*tool
,
2365 perf_event__handler_t process
,
2366 struct perf_evlist
*evlist
,
2367 struct machine
*machine
)
2369 union perf_event
*ev
;
2370 struct perf_evsel
*evsel
;
2371 size_t nr
= 0, i
= 0, sz
, max_nr
, n
;
2374 pr_debug2("Synthesizing id index\n");
2376 max_nr
= (UINT16_MAX
- sizeof(struct id_index_event
)) /
2377 sizeof(struct id_index_entry
);
2379 evlist__for_each_entry(evlist
, evsel
)
2382 n
= nr
> max_nr
? max_nr
: nr
;
2383 sz
= sizeof(struct id_index_event
) + n
* sizeof(struct id_index_entry
);
2388 ev
->id_index
.header
.type
= PERF_RECORD_ID_INDEX
;
2389 ev
->id_index
.header
.size
= sz
;
2390 ev
->id_index
.nr
= n
;
2392 evlist__for_each_entry(evlist
, evsel
) {
2395 for (j
= 0; j
< evsel
->ids
; j
++) {
2396 struct id_index_entry
*e
;
2397 struct perf_sample_id
*sid
;
2400 err
= process(tool
, ev
, NULL
, machine
);
2407 e
= &ev
->id_index
.entries
[i
++];
2409 e
->id
= evsel
->id
[j
];
2411 sid
= perf_evlist__id2sid(evlist
, e
->id
);
2423 sz
= sizeof(struct id_index_event
) + nr
* sizeof(struct id_index_entry
);
2424 ev
->id_index
.header
.size
= sz
;
2425 ev
->id_index
.nr
= nr
;
2427 err
= process(tool
, ev
, NULL
, machine
);