1 #include <linux/kernel.h>
2 #include <traceevent/event-parse.h>
16 #include "perf_regs.h"
20 static int perf_session__deliver_event(struct perf_session
*session
,
21 union perf_event
*event
,
22 struct perf_sample
*sample
,
23 struct perf_tool
*tool
,
26 static int perf_session__open(struct perf_session
*session
)
28 struct perf_data_file
*file
= session
->file
;
30 if (perf_session__read_header(session
) < 0) {
31 pr_err("incompatible file format (rerun with -v to learn more)");
35 if (perf_data_file__is_pipe(file
))
38 if (!perf_evlist__valid_sample_type(session
->evlist
)) {
39 pr_err("non matching sample_type");
43 if (!perf_evlist__valid_sample_id_all(session
->evlist
)) {
44 pr_err("non matching sample_id_all");
48 if (!perf_evlist__valid_read_format(session
->evlist
)) {
49 pr_err("non matching read_format");
56 void perf_session__set_id_hdr_size(struct perf_session
*session
)
58 u16 id_hdr_size
= perf_evlist__id_hdr_size(session
->evlist
);
60 machines__set_id_hdr_size(&session
->machines
, id_hdr_size
);
63 int perf_session__create_kernel_maps(struct perf_session
*session
)
65 int ret
= machine__create_kernel_maps(&session
->machines
.host
);
68 ret
= machines__create_guest_kernel_maps(&session
->machines
);
72 static void perf_session__destroy_kernel_maps(struct perf_session
*session
)
74 machines__destroy_kernel_maps(&session
->machines
);
77 static bool perf_session__has_comm_exec(struct perf_session
*session
)
79 struct perf_evsel
*evsel
;
81 evlist__for_each(session
->evlist
, evsel
) {
82 if (evsel
->attr
.comm_exec
)
89 static void perf_session__set_comm_exec(struct perf_session
*session
)
91 bool comm_exec
= perf_session__has_comm_exec(session
);
93 machines__set_comm_exec(&session
->machines
, comm_exec
);
96 static int ordered_events__deliver_event(struct ordered_events
*oe
,
97 struct ordered_event
*event
)
99 struct perf_sample sample
;
100 struct perf_session
*session
= container_of(oe
, struct perf_session
,
102 int ret
= perf_evlist__parse_sample(session
->evlist
, event
->event
, &sample
);
105 pr_err("Can't parse sample, err = %d\n", ret
);
109 return perf_session__deliver_event(session
, event
->event
, &sample
,
110 session
->tool
, event
->file_offset
);
113 struct perf_session
*perf_session__new(struct perf_data_file
*file
,
114 bool repipe
, struct perf_tool
*tool
)
116 struct perf_session
*session
= zalloc(sizeof(*session
));
121 session
->repipe
= repipe
;
122 session
->tool
= tool
;
123 INIT_LIST_HEAD(&session
->auxtrace_index
);
124 machines__init(&session
->machines
);
125 ordered_events__init(&session
->ordered_events
, ordered_events__deliver_event
);
128 if (perf_data_file__open(file
))
131 session
->file
= file
;
133 if (perf_data_file__is_read(file
)) {
134 if (perf_session__open(session
) < 0)
137 perf_session__set_id_hdr_size(session
);
138 perf_session__set_comm_exec(session
);
142 if (!file
|| perf_data_file__is_write(file
)) {
144 * In O_RDONLY mode this will be performed when reading the
145 * kernel MMAP event, in perf_event__process_mmap().
147 if (perf_session__create_kernel_maps(session
) < 0)
148 pr_warning("Cannot read kernel map\n");
151 if (tool
&& tool
->ordering_requires_timestamps
&&
152 tool
->ordered_events
&& !perf_evlist__sample_id_all(session
->evlist
)) {
153 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
154 tool
->ordered_events
= false;
160 perf_data_file__close(file
);
162 perf_session__delete(session
);
167 static void perf_session__delete_threads(struct perf_session
*session
)
169 machine__delete_threads(&session
->machines
.host
);
172 static void perf_session_env__delete(struct perf_session_env
*env
)
174 zfree(&env
->hostname
);
175 zfree(&env
->os_release
);
176 zfree(&env
->version
);
178 zfree(&env
->cpu_desc
);
181 zfree(&env
->cmdline
);
182 zfree(&env
->sibling_cores
);
183 zfree(&env
->sibling_threads
);
184 zfree(&env
->numa_nodes
);
185 zfree(&env
->pmu_mappings
);
188 void perf_session__delete(struct perf_session
*session
)
190 auxtrace__free(session
);
191 auxtrace_index__free(&session
->auxtrace_index
);
192 perf_session__destroy_kernel_maps(session
);
193 perf_session__delete_threads(session
);
194 perf_session_env__delete(&session
->header
.env
);
195 machines__exit(&session
->machines
);
197 perf_data_file__close(session
->file
);
201 static int process_event_synth_tracing_data_stub(struct perf_tool
*tool
203 union perf_event
*event
205 struct perf_session
*session
208 dump_printf(": unhandled!\n");
212 static int process_event_synth_attr_stub(struct perf_tool
*tool __maybe_unused
,
213 union perf_event
*event __maybe_unused
,
214 struct perf_evlist
**pevlist
217 dump_printf(": unhandled!\n");
221 static int process_event_sample_stub(struct perf_tool
*tool __maybe_unused
,
222 union perf_event
*event __maybe_unused
,
223 struct perf_sample
*sample __maybe_unused
,
224 struct perf_evsel
*evsel __maybe_unused
,
225 struct machine
*machine __maybe_unused
)
227 dump_printf(": unhandled!\n");
231 static int process_event_stub(struct perf_tool
*tool __maybe_unused
,
232 union perf_event
*event __maybe_unused
,
233 struct perf_sample
*sample __maybe_unused
,
234 struct machine
*machine __maybe_unused
)
236 dump_printf(": unhandled!\n");
240 static int process_build_id_stub(struct perf_tool
*tool __maybe_unused
,
241 union perf_event
*event __maybe_unused
,
242 struct perf_session
*session __maybe_unused
)
244 dump_printf(": unhandled!\n");
248 static int process_finished_round_stub(struct perf_tool
*tool __maybe_unused
,
249 union perf_event
*event __maybe_unused
,
250 struct ordered_events
*oe __maybe_unused
)
252 dump_printf(": unhandled!\n");
256 static int process_finished_round(struct perf_tool
*tool
,
257 union perf_event
*event
,
258 struct ordered_events
*oe
);
260 static int process_id_index_stub(struct perf_tool
*tool __maybe_unused
,
261 union perf_event
*event __maybe_unused
,
262 struct perf_session
*perf_session
265 dump_printf(": unhandled!\n");
269 static int process_event_auxtrace_info_stub(struct perf_tool
*tool __maybe_unused
,
270 union perf_event
*event __maybe_unused
,
271 struct perf_session
*session __maybe_unused
)
273 dump_printf(": unhandled!\n");
277 static int skipn(int fd
, off_t n
)
283 ret
= read(fd
, buf
, min(n
, (off_t
)sizeof(buf
)));
292 static s64
process_event_auxtrace_stub(struct perf_tool
*tool __maybe_unused
,
293 union perf_event
*event
,
294 struct perf_session
*session
297 dump_printf(": unhandled!\n");
298 if (perf_data_file__is_pipe(session
->file
))
299 skipn(perf_data_file__fd(session
->file
), event
->auxtrace
.size
);
300 return event
->auxtrace
.size
;
304 int process_event_auxtrace_error_stub(struct perf_tool
*tool __maybe_unused
,
305 union perf_event
*event __maybe_unused
,
306 struct perf_session
*session __maybe_unused
)
308 dump_printf(": unhandled!\n");
312 void perf_tool__fill_defaults(struct perf_tool
*tool
)
314 if (tool
->sample
== NULL
)
315 tool
->sample
= process_event_sample_stub
;
316 if (tool
->mmap
== NULL
)
317 tool
->mmap
= process_event_stub
;
318 if (tool
->mmap2
== NULL
)
319 tool
->mmap2
= process_event_stub
;
320 if (tool
->comm
== NULL
)
321 tool
->comm
= process_event_stub
;
322 if (tool
->fork
== NULL
)
323 tool
->fork
= process_event_stub
;
324 if (tool
->exit
== NULL
)
325 tool
->exit
= process_event_stub
;
326 if (tool
->lost
== NULL
)
327 tool
->lost
= perf_event__process_lost
;
328 if (tool
->read
== NULL
)
329 tool
->read
= process_event_sample_stub
;
330 if (tool
->throttle
== NULL
)
331 tool
->throttle
= process_event_stub
;
332 if (tool
->unthrottle
== NULL
)
333 tool
->unthrottle
= process_event_stub
;
334 if (tool
->attr
== NULL
)
335 tool
->attr
= process_event_synth_attr_stub
;
336 if (tool
->tracing_data
== NULL
)
337 tool
->tracing_data
= process_event_synth_tracing_data_stub
;
338 if (tool
->build_id
== NULL
)
339 tool
->build_id
= process_build_id_stub
;
340 if (tool
->finished_round
== NULL
) {
341 if (tool
->ordered_events
)
342 tool
->finished_round
= process_finished_round
;
344 tool
->finished_round
= process_finished_round_stub
;
346 if (tool
->id_index
== NULL
)
347 tool
->id_index
= process_id_index_stub
;
348 if (tool
->auxtrace_info
== NULL
)
349 tool
->auxtrace_info
= process_event_auxtrace_info_stub
;
350 if (tool
->auxtrace
== NULL
)
351 tool
->auxtrace
= process_event_auxtrace_stub
;
352 if (tool
->auxtrace_error
== NULL
)
353 tool
->auxtrace_error
= process_event_auxtrace_error_stub
;
356 static void swap_sample_id_all(union perf_event
*event
, void *data
)
358 void *end
= (void *) event
+ event
->header
.size
;
359 int size
= end
- data
;
361 BUG_ON(size
% sizeof(u64
));
362 mem_bswap_64(data
, size
);
365 static void perf_event__all64_swap(union perf_event
*event
,
366 bool sample_id_all __maybe_unused
)
368 struct perf_event_header
*hdr
= &event
->header
;
369 mem_bswap_64(hdr
+ 1, event
->header
.size
- sizeof(*hdr
));
372 static void perf_event__comm_swap(union perf_event
*event
, bool sample_id_all
)
374 event
->comm
.pid
= bswap_32(event
->comm
.pid
);
375 event
->comm
.tid
= bswap_32(event
->comm
.tid
);
378 void *data
= &event
->comm
.comm
;
380 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
381 swap_sample_id_all(event
, data
);
385 static void perf_event__mmap_swap(union perf_event
*event
,
388 event
->mmap
.pid
= bswap_32(event
->mmap
.pid
);
389 event
->mmap
.tid
= bswap_32(event
->mmap
.tid
);
390 event
->mmap
.start
= bswap_64(event
->mmap
.start
);
391 event
->mmap
.len
= bswap_64(event
->mmap
.len
);
392 event
->mmap
.pgoff
= bswap_64(event
->mmap
.pgoff
);
395 void *data
= &event
->mmap
.filename
;
397 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
398 swap_sample_id_all(event
, data
);
402 static void perf_event__mmap2_swap(union perf_event
*event
,
405 event
->mmap2
.pid
= bswap_32(event
->mmap2
.pid
);
406 event
->mmap2
.tid
= bswap_32(event
->mmap2
.tid
);
407 event
->mmap2
.start
= bswap_64(event
->mmap2
.start
);
408 event
->mmap2
.len
= bswap_64(event
->mmap2
.len
);
409 event
->mmap2
.pgoff
= bswap_64(event
->mmap2
.pgoff
);
410 event
->mmap2
.maj
= bswap_32(event
->mmap2
.maj
);
411 event
->mmap2
.min
= bswap_32(event
->mmap2
.min
);
412 event
->mmap2
.ino
= bswap_64(event
->mmap2
.ino
);
415 void *data
= &event
->mmap2
.filename
;
417 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
418 swap_sample_id_all(event
, data
);
421 static void perf_event__task_swap(union perf_event
*event
, bool sample_id_all
)
423 event
->fork
.pid
= bswap_32(event
->fork
.pid
);
424 event
->fork
.tid
= bswap_32(event
->fork
.tid
);
425 event
->fork
.ppid
= bswap_32(event
->fork
.ppid
);
426 event
->fork
.ptid
= bswap_32(event
->fork
.ptid
);
427 event
->fork
.time
= bswap_64(event
->fork
.time
);
430 swap_sample_id_all(event
, &event
->fork
+ 1);
433 static void perf_event__read_swap(union perf_event
*event
, bool sample_id_all
)
435 event
->read
.pid
= bswap_32(event
->read
.pid
);
436 event
->read
.tid
= bswap_32(event
->read
.tid
);
437 event
->read
.value
= bswap_64(event
->read
.value
);
438 event
->read
.time_enabled
= bswap_64(event
->read
.time_enabled
);
439 event
->read
.time_running
= bswap_64(event
->read
.time_running
);
440 event
->read
.id
= bswap_64(event
->read
.id
);
443 swap_sample_id_all(event
, &event
->read
+ 1);
446 static void perf_event__throttle_swap(union perf_event
*event
,
449 event
->throttle
.time
= bswap_64(event
->throttle
.time
);
450 event
->throttle
.id
= bswap_64(event
->throttle
.id
);
451 event
->throttle
.stream_id
= bswap_64(event
->throttle
.stream_id
);
454 swap_sample_id_all(event
, &event
->throttle
+ 1);
457 static u8
revbyte(u8 b
)
459 int rev
= (b
>> 4) | ((b
& 0xf) << 4);
460 rev
= ((rev
& 0xcc) >> 2) | ((rev
& 0x33) << 2);
461 rev
= ((rev
& 0xaa) >> 1) | ((rev
& 0x55) << 1);
466 * XXX this is hack in attempt to carry flags bitfield
467 * throught endian village. ABI says:
469 * Bit-fields are allocated from right to left (least to most significant)
470 * on little-endian implementations and from left to right (most to least
471 * significant) on big-endian implementations.
473 * The above seems to be byte specific, so we need to reverse each
474 * byte of the bitfield. 'Internet' also says this might be implementation
475 * specific and we probably need proper fix and carry perf_event_attr
476 * bitfield flags in separate data file FEAT_ section. Thought this seems
479 static void swap_bitfield(u8
*p
, unsigned len
)
483 for (i
= 0; i
< len
; i
++) {
489 /* exported for swapping attributes in file header */
490 void perf_event__attr_swap(struct perf_event_attr
*attr
)
492 attr
->type
= bswap_32(attr
->type
);
493 attr
->size
= bswap_32(attr
->size
);
494 attr
->config
= bswap_64(attr
->config
);
495 attr
->sample_period
= bswap_64(attr
->sample_period
);
496 attr
->sample_type
= bswap_64(attr
->sample_type
);
497 attr
->read_format
= bswap_64(attr
->read_format
);
498 attr
->wakeup_events
= bswap_32(attr
->wakeup_events
);
499 attr
->bp_type
= bswap_32(attr
->bp_type
);
500 attr
->bp_addr
= bswap_64(attr
->bp_addr
);
501 attr
->bp_len
= bswap_64(attr
->bp_len
);
502 attr
->branch_sample_type
= bswap_64(attr
->branch_sample_type
);
503 attr
->sample_regs_user
= bswap_64(attr
->sample_regs_user
);
504 attr
->sample_stack_user
= bswap_32(attr
->sample_stack_user
);
505 attr
->aux_watermark
= bswap_32(attr
->aux_watermark
);
507 swap_bitfield((u8
*) (&attr
->read_format
+ 1), sizeof(u64
));
510 static void perf_event__hdr_attr_swap(union perf_event
*event
,
511 bool sample_id_all __maybe_unused
)
515 perf_event__attr_swap(&event
->attr
.attr
);
517 size
= event
->header
.size
;
518 size
-= (void *)&event
->attr
.id
- (void *)event
;
519 mem_bswap_64(event
->attr
.id
, size
);
522 static void perf_event__event_type_swap(union perf_event
*event
,
523 bool sample_id_all __maybe_unused
)
525 event
->event_type
.event_type
.event_id
=
526 bswap_64(event
->event_type
.event_type
.event_id
);
529 static void perf_event__tracing_data_swap(union perf_event
*event
,
530 bool sample_id_all __maybe_unused
)
532 event
->tracing_data
.size
= bswap_32(event
->tracing_data
.size
);
535 static void perf_event__auxtrace_info_swap(union perf_event
*event
,
536 bool sample_id_all __maybe_unused
)
540 event
->auxtrace_info
.type
= bswap_32(event
->auxtrace_info
.type
);
542 size
= event
->header
.size
;
543 size
-= (void *)&event
->auxtrace_info
.priv
- (void *)event
;
544 mem_bswap_64(event
->auxtrace_info
.priv
, size
);
547 static void perf_event__auxtrace_swap(union perf_event
*event
,
548 bool sample_id_all __maybe_unused
)
550 event
->auxtrace
.size
= bswap_64(event
->auxtrace
.size
);
551 event
->auxtrace
.offset
= bswap_64(event
->auxtrace
.offset
);
552 event
->auxtrace
.reference
= bswap_64(event
->auxtrace
.reference
);
553 event
->auxtrace
.idx
= bswap_32(event
->auxtrace
.idx
);
554 event
->auxtrace
.tid
= bswap_32(event
->auxtrace
.tid
);
555 event
->auxtrace
.cpu
= bswap_32(event
->auxtrace
.cpu
);
558 static void perf_event__auxtrace_error_swap(union perf_event
*event
,
559 bool sample_id_all __maybe_unused
)
561 event
->auxtrace_error
.type
= bswap_32(event
->auxtrace_error
.type
);
562 event
->auxtrace_error
.code
= bswap_32(event
->auxtrace_error
.code
);
563 event
->auxtrace_error
.cpu
= bswap_32(event
->auxtrace_error
.cpu
);
564 event
->auxtrace_error
.pid
= bswap_32(event
->auxtrace_error
.pid
);
565 event
->auxtrace_error
.tid
= bswap_32(event
->auxtrace_error
.tid
);
566 event
->auxtrace_error
.ip
= bswap_64(event
->auxtrace_error
.ip
);
569 typedef void (*perf_event__swap_op
)(union perf_event
*event
,
572 static perf_event__swap_op perf_event__swap_ops
[] = {
573 [PERF_RECORD_MMAP
] = perf_event__mmap_swap
,
574 [PERF_RECORD_MMAP2
] = perf_event__mmap2_swap
,
575 [PERF_RECORD_COMM
] = perf_event__comm_swap
,
576 [PERF_RECORD_FORK
] = perf_event__task_swap
,
577 [PERF_RECORD_EXIT
] = perf_event__task_swap
,
578 [PERF_RECORD_LOST
] = perf_event__all64_swap
,
579 [PERF_RECORD_READ
] = perf_event__read_swap
,
580 [PERF_RECORD_THROTTLE
] = perf_event__throttle_swap
,
581 [PERF_RECORD_UNTHROTTLE
] = perf_event__throttle_swap
,
582 [PERF_RECORD_SAMPLE
] = perf_event__all64_swap
,
583 [PERF_RECORD_HEADER_ATTR
] = perf_event__hdr_attr_swap
,
584 [PERF_RECORD_HEADER_EVENT_TYPE
] = perf_event__event_type_swap
,
585 [PERF_RECORD_HEADER_TRACING_DATA
] = perf_event__tracing_data_swap
,
586 [PERF_RECORD_HEADER_BUILD_ID
] = NULL
,
587 [PERF_RECORD_ID_INDEX
] = perf_event__all64_swap
,
588 [PERF_RECORD_AUXTRACE_INFO
] = perf_event__auxtrace_info_swap
,
589 [PERF_RECORD_AUXTRACE
] = perf_event__auxtrace_swap
,
590 [PERF_RECORD_AUXTRACE_ERROR
] = perf_event__auxtrace_error_swap
,
591 [PERF_RECORD_HEADER_MAX
] = NULL
,
595 * When perf record finishes a pass on every buffers, it records this pseudo
597 * We record the max timestamp t found in the pass n.
598 * Assuming these timestamps are monotonic across cpus, we know that if
599 * a buffer still has events with timestamps below t, they will be all
600 * available and then read in the pass n + 1.
601 * Hence when we start to read the pass n + 2, we can safely flush every
602 * events with timestamps below t.
604 * ============ PASS n =================
607 * cnt1 timestamps | cnt2 timestamps
610 * - | 4 <--- max recorded
612 * ============ PASS n + 1 ==============
615 * cnt1 timestamps | cnt2 timestamps
618 * 5 | 7 <---- max recorded
620 * Flush every events below timestamp 4
622 * ============ PASS n + 2 ==============
625 * cnt1 timestamps | cnt2 timestamps
630 * Flush every events below timestamp 7
633 static int process_finished_round(struct perf_tool
*tool __maybe_unused
,
634 union perf_event
*event __maybe_unused
,
635 struct ordered_events
*oe
)
637 return ordered_events__flush(oe
, OE_FLUSH__ROUND
);
640 int perf_session__queue_event(struct perf_session
*s
, union perf_event
*event
,
641 struct perf_sample
*sample
, u64 file_offset
)
643 return ordered_events__queue(&s
->ordered_events
, event
, sample
, file_offset
);
646 static void callchain__lbr_callstack_printf(struct perf_sample
*sample
)
648 struct ip_callchain
*callchain
= sample
->callchain
;
649 struct branch_stack
*lbr_stack
= sample
->branch_stack
;
650 u64 kernel_callchain_nr
= callchain
->nr
;
653 for (i
= 0; i
< kernel_callchain_nr
; i
++) {
654 if (callchain
->ips
[i
] == PERF_CONTEXT_USER
)
658 if ((i
!= kernel_callchain_nr
) && lbr_stack
->nr
) {
661 * LBR callstack can only get user call chain,
662 * i is kernel call chain number,
663 * 1 is PERF_CONTEXT_USER.
665 * The user call chain is stored in LBR registers.
666 * LBR are pair registers. The caller is stored
667 * in "from" register, while the callee is stored
669 * For example, there is a call stack
670 * "A"->"B"->"C"->"D".
671 * The LBR registers will recorde like
672 * "C"->"D", "B"->"C", "A"->"B".
673 * So only the first "to" register and all "from"
674 * registers are needed to construct the whole stack.
676 total_nr
= i
+ 1 + lbr_stack
->nr
+ 1;
677 kernel_callchain_nr
= i
+ 1;
679 printf("... LBR call chain: nr:%" PRIu64
"\n", total_nr
);
681 for (i
= 0; i
< kernel_callchain_nr
; i
++)
682 printf("..... %2d: %016" PRIx64
"\n",
683 i
, callchain
->ips
[i
]);
685 printf("..... %2d: %016" PRIx64
"\n",
686 (int)(kernel_callchain_nr
), lbr_stack
->entries
[0].to
);
687 for (i
= 0; i
< lbr_stack
->nr
; i
++)
688 printf("..... %2d: %016" PRIx64
"\n",
689 (int)(i
+ kernel_callchain_nr
+ 1), lbr_stack
->entries
[i
].from
);
693 static void callchain__printf(struct perf_evsel
*evsel
,
694 struct perf_sample
*sample
)
697 struct ip_callchain
*callchain
= sample
->callchain
;
699 if (has_branch_callstack(evsel
))
700 callchain__lbr_callstack_printf(sample
);
702 printf("... FP chain: nr:%" PRIu64
"\n", callchain
->nr
);
704 for (i
= 0; i
< callchain
->nr
; i
++)
705 printf("..... %2d: %016" PRIx64
"\n",
706 i
, callchain
->ips
[i
]);
709 static void branch_stack__printf(struct perf_sample
*sample
)
713 printf("... branch stack: nr:%" PRIu64
"\n", sample
->branch_stack
->nr
);
715 for (i
= 0; i
< sample
->branch_stack
->nr
; i
++)
716 printf("..... %2"PRIu64
": %016" PRIx64
" -> %016" PRIx64
"\n",
717 i
, sample
->branch_stack
->entries
[i
].from
,
718 sample
->branch_stack
->entries
[i
].to
);
721 static void regs_dump__printf(u64 mask
, u64
*regs
)
725 for_each_set_bit(rid
, (unsigned long *) &mask
, sizeof(mask
) * 8) {
728 printf(".... %-5s 0x%" PRIx64
"\n",
729 perf_reg_name(rid
), val
);
733 static const char *regs_abi
[] = {
734 [PERF_SAMPLE_REGS_ABI_NONE
] = "none",
735 [PERF_SAMPLE_REGS_ABI_32
] = "32-bit",
736 [PERF_SAMPLE_REGS_ABI_64
] = "64-bit",
739 static inline const char *regs_dump_abi(struct regs_dump
*d
)
741 if (d
->abi
> PERF_SAMPLE_REGS_ABI_64
)
744 return regs_abi
[d
->abi
];
747 static void regs__printf(const char *type
, struct regs_dump
*regs
)
749 u64 mask
= regs
->mask
;
751 printf("... %s regs: mask 0x%" PRIx64
" ABI %s\n",
754 regs_dump_abi(regs
));
756 regs_dump__printf(mask
, regs
->regs
);
759 static void regs_user__printf(struct perf_sample
*sample
)
761 struct regs_dump
*user_regs
= &sample
->user_regs
;
764 regs__printf("user", user_regs
);
767 static void regs_intr__printf(struct perf_sample
*sample
)
769 struct regs_dump
*intr_regs
= &sample
->intr_regs
;
772 regs__printf("intr", intr_regs
);
775 static void stack_user__printf(struct stack_dump
*dump
)
777 printf("... ustack: size %" PRIu64
", offset 0x%x\n",
778 dump
->size
, dump
->offset
);
781 static void perf_evlist__print_tstamp(struct perf_evlist
*evlist
,
782 union perf_event
*event
,
783 struct perf_sample
*sample
)
785 u64 sample_type
= __perf_evlist__combined_sample_type(evlist
);
787 if (event
->header
.type
!= PERF_RECORD_SAMPLE
&&
788 !perf_evlist__sample_id_all(evlist
)) {
789 fputs("-1 -1 ", stdout
);
793 if ((sample_type
& PERF_SAMPLE_CPU
))
794 printf("%u ", sample
->cpu
);
796 if (sample_type
& PERF_SAMPLE_TIME
)
797 printf("%" PRIu64
" ", sample
->time
);
800 static void sample_read__printf(struct perf_sample
*sample
, u64 read_format
)
802 printf("... sample_read:\n");
804 if (read_format
& PERF_FORMAT_TOTAL_TIME_ENABLED
)
805 printf("...... time enabled %016" PRIx64
"\n",
806 sample
->read
.time_enabled
);
808 if (read_format
& PERF_FORMAT_TOTAL_TIME_RUNNING
)
809 printf("...... time running %016" PRIx64
"\n",
810 sample
->read
.time_running
);
812 if (read_format
& PERF_FORMAT_GROUP
) {
815 printf(".... group nr %" PRIu64
"\n", sample
->read
.group
.nr
);
817 for (i
= 0; i
< sample
->read
.group
.nr
; i
++) {
818 struct sample_read_value
*value
;
820 value
= &sample
->read
.group
.values
[i
];
821 printf("..... id %016" PRIx64
822 ", value %016" PRIx64
"\n",
823 value
->id
, value
->value
);
826 printf("..... id %016" PRIx64
", value %016" PRIx64
"\n",
827 sample
->read
.one
.id
, sample
->read
.one
.value
);
830 static void dump_event(struct perf_evlist
*evlist
, union perf_event
*event
,
831 u64 file_offset
, struct perf_sample
*sample
)
836 printf("\n%#" PRIx64
" [%#x]: event: %d\n",
837 file_offset
, event
->header
.size
, event
->header
.type
);
842 perf_evlist__print_tstamp(evlist
, event
, sample
);
844 printf("%#" PRIx64
" [%#x]: PERF_RECORD_%s", file_offset
,
845 event
->header
.size
, perf_event__name(event
->header
.type
));
848 static void dump_sample(struct perf_evsel
*evsel
, union perf_event
*event
,
849 struct perf_sample
*sample
)
856 printf("(IP, 0x%x): %d/%d: %#" PRIx64
" period: %" PRIu64
" addr: %#" PRIx64
"\n",
857 event
->header
.misc
, sample
->pid
, sample
->tid
, sample
->ip
,
858 sample
->period
, sample
->addr
);
860 sample_type
= evsel
->attr
.sample_type
;
862 if (sample_type
& PERF_SAMPLE_CALLCHAIN
)
863 callchain__printf(evsel
, sample
);
865 if ((sample_type
& PERF_SAMPLE_BRANCH_STACK
) && !has_branch_callstack(evsel
))
866 branch_stack__printf(sample
);
868 if (sample_type
& PERF_SAMPLE_REGS_USER
)
869 regs_user__printf(sample
);
871 if (sample_type
& PERF_SAMPLE_REGS_INTR
)
872 regs_intr__printf(sample
);
874 if (sample_type
& PERF_SAMPLE_STACK_USER
)
875 stack_user__printf(&sample
->user_stack
);
877 if (sample_type
& PERF_SAMPLE_WEIGHT
)
878 printf("... weight: %" PRIu64
"\n", sample
->weight
);
880 if (sample_type
& PERF_SAMPLE_DATA_SRC
)
881 printf(" . data_src: 0x%"PRIx64
"\n", sample
->data_src
);
883 if (sample_type
& PERF_SAMPLE_TRANSACTION
)
884 printf("... transaction: %" PRIx64
"\n", sample
->transaction
);
886 if (sample_type
& PERF_SAMPLE_READ
)
887 sample_read__printf(sample
, evsel
->attr
.read_format
);
890 static struct machine
*machines__find_for_cpumode(struct machines
*machines
,
891 union perf_event
*event
,
892 struct perf_sample
*sample
)
894 const u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
895 struct machine
*machine
;
898 ((cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
) ||
899 (cpumode
== PERF_RECORD_MISC_GUEST_USER
))) {
902 if (event
->header
.type
== PERF_RECORD_MMAP
903 || event
->header
.type
== PERF_RECORD_MMAP2
)
904 pid
= event
->mmap
.pid
;
908 machine
= machines__find(machines
, pid
);
910 machine
= machines__find(machines
, DEFAULT_GUEST_KERNEL_ID
);
914 return &machines
->host
;
917 static int deliver_sample_value(struct perf_evlist
*evlist
,
918 struct perf_tool
*tool
,
919 union perf_event
*event
,
920 struct perf_sample
*sample
,
921 struct sample_read_value
*v
,
922 struct machine
*machine
)
924 struct perf_sample_id
*sid
= perf_evlist__id2sid(evlist
, v
->id
);
928 sample
->period
= v
->value
- sid
->period
;
929 sid
->period
= v
->value
;
932 if (!sid
|| sid
->evsel
== NULL
) {
933 ++evlist
->stats
.nr_unknown_id
;
937 return tool
->sample(tool
, event
, sample
, sid
->evsel
, machine
);
940 static int deliver_sample_group(struct perf_evlist
*evlist
,
941 struct perf_tool
*tool
,
942 union perf_event
*event
,
943 struct perf_sample
*sample
,
944 struct machine
*machine
)
949 for (i
= 0; i
< sample
->read
.group
.nr
; i
++) {
950 ret
= deliver_sample_value(evlist
, tool
, event
, sample
,
951 &sample
->read
.group
.values
[i
],
961 perf_evlist__deliver_sample(struct perf_evlist
*evlist
,
962 struct perf_tool
*tool
,
963 union perf_event
*event
,
964 struct perf_sample
*sample
,
965 struct perf_evsel
*evsel
,
966 struct machine
*machine
)
968 /* We know evsel != NULL. */
969 u64 sample_type
= evsel
->attr
.sample_type
;
970 u64 read_format
= evsel
->attr
.read_format
;
972 /* Standard sample delievery. */
973 if (!(sample_type
& PERF_SAMPLE_READ
))
974 return tool
->sample(tool
, event
, sample
, evsel
, machine
);
976 /* For PERF_SAMPLE_READ we have either single or group mode. */
977 if (read_format
& PERF_FORMAT_GROUP
)
978 return deliver_sample_group(evlist
, tool
, event
, sample
,
981 return deliver_sample_value(evlist
, tool
, event
, sample
,
982 &sample
->read
.one
, machine
);
985 static int machines__deliver_event(struct machines
*machines
,
986 struct perf_evlist
*evlist
,
987 union perf_event
*event
,
988 struct perf_sample
*sample
,
989 struct perf_tool
*tool
, u64 file_offset
)
991 struct perf_evsel
*evsel
;
992 struct machine
*machine
;
994 dump_event(evlist
, event
, file_offset
, sample
);
996 evsel
= perf_evlist__id2evsel(evlist
, sample
->id
);
998 machine
= machines__find_for_cpumode(machines
, event
, sample
);
1000 switch (event
->header
.type
) {
1001 case PERF_RECORD_SAMPLE
:
1002 dump_sample(evsel
, event
, sample
);
1003 if (evsel
== NULL
) {
1004 ++evlist
->stats
.nr_unknown_id
;
1007 if (machine
== NULL
) {
1008 ++evlist
->stats
.nr_unprocessable_samples
;
1011 return perf_evlist__deliver_sample(evlist
, tool
, event
, sample
, evsel
, machine
);
1012 case PERF_RECORD_MMAP
:
1013 return tool
->mmap(tool
, event
, sample
, machine
);
1014 case PERF_RECORD_MMAP2
:
1015 return tool
->mmap2(tool
, event
, sample
, machine
);
1016 case PERF_RECORD_COMM
:
1017 return tool
->comm(tool
, event
, sample
, machine
);
1018 case PERF_RECORD_FORK
:
1019 return tool
->fork(tool
, event
, sample
, machine
);
1020 case PERF_RECORD_EXIT
:
1021 return tool
->exit(tool
, event
, sample
, machine
);
1022 case PERF_RECORD_LOST
:
1023 if (tool
->lost
== perf_event__process_lost
)
1024 evlist
->stats
.total_lost
+= event
->lost
.lost
;
1025 return tool
->lost(tool
, event
, sample
, machine
);
1026 case PERF_RECORD_READ
:
1027 return tool
->read(tool
, event
, sample
, evsel
, machine
);
1028 case PERF_RECORD_THROTTLE
:
1029 return tool
->throttle(tool
, event
, sample
, machine
);
1030 case PERF_RECORD_UNTHROTTLE
:
1031 return tool
->unthrottle(tool
, event
, sample
, machine
);
1033 ++evlist
->stats
.nr_unknown_events
;
1038 static int perf_session__deliver_event(struct perf_session
*session
,
1039 union perf_event
*event
,
1040 struct perf_sample
*sample
,
1041 struct perf_tool
*tool
,
1046 ret
= auxtrace__process_event(session
, event
, sample
, tool
);
1052 return machines__deliver_event(&session
->machines
, session
->evlist
,
1053 event
, sample
, tool
, file_offset
);
1056 static s64
perf_session__process_user_event(struct perf_session
*session
,
1057 union perf_event
*event
,
1060 struct ordered_events
*oe
= &session
->ordered_events
;
1061 struct perf_tool
*tool
= session
->tool
;
1062 int fd
= perf_data_file__fd(session
->file
);
1065 dump_event(session
->evlist
, event
, file_offset
, NULL
);
1067 /* These events are processed right away */
1068 switch (event
->header
.type
) {
1069 case PERF_RECORD_HEADER_ATTR
:
1070 err
= tool
->attr(tool
, event
, &session
->evlist
);
1072 perf_session__set_id_hdr_size(session
);
1073 perf_session__set_comm_exec(session
);
1076 case PERF_RECORD_HEADER_EVENT_TYPE
:
1078 * Depreceated, but we need to handle it for sake
1079 * of old data files create in pipe mode.
1082 case PERF_RECORD_HEADER_TRACING_DATA
:
1083 /* setup for reading amidst mmap */
1084 lseek(fd
, file_offset
, SEEK_SET
);
1085 return tool
->tracing_data(tool
, event
, session
);
1086 case PERF_RECORD_HEADER_BUILD_ID
:
1087 return tool
->build_id(tool
, event
, session
);
1088 case PERF_RECORD_FINISHED_ROUND
:
1089 return tool
->finished_round(tool
, event
, oe
);
1090 case PERF_RECORD_ID_INDEX
:
1091 return tool
->id_index(tool
, event
, session
);
1092 case PERF_RECORD_AUXTRACE_INFO
:
1093 return tool
->auxtrace_info(tool
, event
, session
);
1094 case PERF_RECORD_AUXTRACE
:
1095 /* setup for reading amidst mmap */
1096 lseek(fd
, file_offset
+ event
->header
.size
, SEEK_SET
);
1097 return tool
->auxtrace(tool
, event
, session
);
1098 case PERF_RECORD_AUXTRACE_ERROR
:
1099 perf_session__auxtrace_error_inc(session
, event
);
1100 return tool
->auxtrace_error(tool
, event
, session
);
1106 int perf_session__deliver_synth_event(struct perf_session
*session
,
1107 union perf_event
*event
,
1108 struct perf_sample
*sample
)
1110 struct perf_evlist
*evlist
= session
->evlist
;
1111 struct perf_tool
*tool
= session
->tool
;
1113 events_stats__inc(&evlist
->stats
, event
->header
.type
);
1115 if (event
->header
.type
>= PERF_RECORD_USER_TYPE_START
)
1116 return perf_session__process_user_event(session
, event
, 0);
1118 return machines__deliver_event(&session
->machines
, evlist
, event
, sample
, tool
, 0);
1121 static void event_swap(union perf_event
*event
, bool sample_id_all
)
1123 perf_event__swap_op swap
;
1125 swap
= perf_event__swap_ops
[event
->header
.type
];
1127 swap(event
, sample_id_all
);
1130 int perf_session__peek_event(struct perf_session
*session
, off_t file_offset
,
1131 void *buf
, size_t buf_sz
,
1132 union perf_event
**event_ptr
,
1133 struct perf_sample
*sample
)
1135 union perf_event
*event
;
1136 size_t hdr_sz
, rest
;
1139 if (session
->one_mmap
&& !session
->header
.needs_swap
) {
1140 event
= file_offset
- session
->one_mmap_offset
+
1141 session
->one_mmap_addr
;
1142 goto out_parse_sample
;
1145 if (perf_data_file__is_pipe(session
->file
))
1148 fd
= perf_data_file__fd(session
->file
);
1149 hdr_sz
= sizeof(struct perf_event_header
);
1151 if (buf_sz
< hdr_sz
)
1154 if (lseek(fd
, file_offset
, SEEK_SET
) == (off_t
)-1 ||
1155 readn(fd
, &buf
, hdr_sz
) != (ssize_t
)hdr_sz
)
1158 event
= (union perf_event
*)buf
;
1160 if (session
->header
.needs_swap
)
1161 perf_event_header__bswap(&event
->header
);
1163 if (event
->header
.size
< hdr_sz
)
1166 rest
= event
->header
.size
- hdr_sz
;
1168 if (readn(fd
, &buf
, rest
) != (ssize_t
)rest
)
1171 if (session
->header
.needs_swap
)
1172 event_swap(event
, perf_evlist__sample_id_all(session
->evlist
));
1176 if (sample
&& event
->header
.type
< PERF_RECORD_USER_TYPE_START
&&
1177 perf_evlist__parse_sample(session
->evlist
, event
, sample
))
1185 static s64
perf_session__process_event(struct perf_session
*session
,
1186 union perf_event
*event
, u64 file_offset
)
1188 struct perf_evlist
*evlist
= session
->evlist
;
1189 struct perf_tool
*tool
= session
->tool
;
1190 struct perf_sample sample
;
1193 if (session
->header
.needs_swap
)
1194 event_swap(event
, perf_evlist__sample_id_all(evlist
));
1196 if (event
->header
.type
>= PERF_RECORD_HEADER_MAX
)
1199 events_stats__inc(&evlist
->stats
, event
->header
.type
);
1201 if (event
->header
.type
>= PERF_RECORD_USER_TYPE_START
)
1202 return perf_session__process_user_event(session
, event
, file_offset
);
1205 * For all kernel events we get the sample data
1207 ret
= perf_evlist__parse_sample(evlist
, event
, &sample
);
1211 if (tool
->ordered_events
) {
1212 ret
= perf_session__queue_event(session
, event
, &sample
, file_offset
);
1217 return perf_session__deliver_event(session
, event
, &sample
, tool
,
1221 void perf_event_header__bswap(struct perf_event_header
*hdr
)
1223 hdr
->type
= bswap_32(hdr
->type
);
1224 hdr
->misc
= bswap_16(hdr
->misc
);
1225 hdr
->size
= bswap_16(hdr
->size
);
1228 struct thread
*perf_session__findnew(struct perf_session
*session
, pid_t pid
)
1230 return machine__findnew_thread(&session
->machines
.host
, -1, pid
);
1233 static struct thread
*perf_session__register_idle_thread(struct perf_session
*session
)
1235 struct thread
*thread
;
1237 thread
= machine__findnew_thread(&session
->machines
.host
, 0, 0);
1238 if (thread
== NULL
|| thread__set_comm(thread
, "swapper", 0)) {
1239 pr_err("problem inserting idle task.\n");
1246 static void perf_session__warn_about_errors(const struct perf_session
*session
)
1248 const struct events_stats
*stats
= &session
->evlist
->stats
;
1249 const struct ordered_events
*oe
= &session
->ordered_events
;
1251 if (session
->tool
->lost
== perf_event__process_lost
&&
1252 stats
->nr_events
[PERF_RECORD_LOST
] != 0) {
1253 ui__warning("Processed %d events and lost %d chunks!\n\n"
1254 "Check IO/CPU overload!\n\n",
1255 stats
->nr_events
[0],
1256 stats
->nr_events
[PERF_RECORD_LOST
]);
1259 if (stats
->nr_unknown_events
!= 0) {
1260 ui__warning("Found %u unknown events!\n\n"
1261 "Is this an older tool processing a perf.data "
1262 "file generated by a more recent tool?\n\n"
1263 "If that is not the case, consider "
1264 "reporting to linux-kernel@vger.kernel.org.\n\n",
1265 stats
->nr_unknown_events
);
1268 if (stats
->nr_unknown_id
!= 0) {
1269 ui__warning("%u samples with id not present in the header\n",
1270 stats
->nr_unknown_id
);
1273 if (stats
->nr_invalid_chains
!= 0) {
1274 ui__warning("Found invalid callchains!\n\n"
1275 "%u out of %u events were discarded for this reason.\n\n"
1276 "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
1277 stats
->nr_invalid_chains
,
1278 stats
->nr_events
[PERF_RECORD_SAMPLE
]);
1281 if (stats
->nr_unprocessable_samples
!= 0) {
1282 ui__warning("%u unprocessable samples recorded.\n"
1283 "Do you have a KVM guest running and not using 'perf kvm'?\n",
1284 stats
->nr_unprocessable_samples
);
1287 if (oe
->nr_unordered_events
!= 0)
1288 ui__warning("%u out of order events recorded.\n", oe
->nr_unordered_events
);
1290 events_stats__auxtrace_error_warn(stats
);
1293 volatile int session_done
;
1295 static int __perf_session__process_pipe_events(struct perf_session
*session
)
1297 struct ordered_events
*oe
= &session
->ordered_events
;
1298 struct perf_tool
*tool
= session
->tool
;
1299 int fd
= perf_data_file__fd(session
->file
);
1300 union perf_event
*event
;
1301 uint32_t size
, cur_size
= 0;
1308 perf_tool__fill_defaults(tool
);
1311 cur_size
= sizeof(union perf_event
);
1313 buf
= malloc(cur_size
);
1318 err
= readn(fd
, event
, sizeof(struct perf_event_header
));
1323 pr_err("failed to read event header\n");
1327 if (session
->header
.needs_swap
)
1328 perf_event_header__bswap(&event
->header
);
1330 size
= event
->header
.size
;
1331 if (size
< sizeof(struct perf_event_header
)) {
1332 pr_err("bad event header size\n");
1336 if (size
> cur_size
) {
1337 void *new = realloc(buf
, size
);
1339 pr_err("failed to allocate memory to read event\n");
1347 p
+= sizeof(struct perf_event_header
);
1349 if (size
- sizeof(struct perf_event_header
)) {
1350 err
= readn(fd
, p
, size
- sizeof(struct perf_event_header
));
1353 pr_err("unexpected end of event stream\n");
1357 pr_err("failed to read event data\n");
1362 if ((skip
= perf_session__process_event(session
, event
, head
)) < 0) {
1363 pr_err("%#" PRIx64
" [%#x]: failed to process type: %d\n",
1364 head
, event
->header
.size
, event
->header
.type
);
1374 if (!session_done())
1377 /* do the final flush for ordered samples */
1378 err
= ordered_events__flush(oe
, OE_FLUSH__FINAL
);
1381 err
= auxtrace__flush_events(session
, tool
);
1384 perf_session__warn_about_errors(session
);
1385 ordered_events__free(&session
->ordered_events
);
1386 auxtrace__free_events(session
);
1390 static union perf_event
*
1391 fetch_mmaped_event(struct perf_session
*session
,
1392 u64 head
, size_t mmap_size
, char *buf
)
1394 union perf_event
*event
;
1397 * Ensure we have enough space remaining to read
1398 * the size of the event in the headers.
1400 if (head
+ sizeof(event
->header
) > mmap_size
)
1403 event
= (union perf_event
*)(buf
+ head
);
1405 if (session
->header
.needs_swap
)
1406 perf_event_header__bswap(&event
->header
);
1408 if (head
+ event
->header
.size
> mmap_size
) {
1409 /* We're not fetching the event so swap back again */
1410 if (session
->header
.needs_swap
)
1411 perf_event_header__bswap(&event
->header
);
1419 * On 64bit we can mmap the data file in one go. No need for tiny mmap
1420 * slices. On 32bit we use 32MB.
1422 #if BITS_PER_LONG == 64
1423 #define MMAP_SIZE ULLONG_MAX
1426 #define MMAP_SIZE (32 * 1024 * 1024ULL)
1427 #define NUM_MMAPS 128
1430 static int __perf_session__process_events(struct perf_session
*session
,
1431 u64 data_offset
, u64 data_size
,
1434 struct ordered_events
*oe
= &session
->ordered_events
;
1435 struct perf_tool
*tool
= session
->tool
;
1436 int fd
= perf_data_file__fd(session
->file
);
1437 u64 head
, page_offset
, file_offset
, file_pos
, size
;
1438 int err
, mmap_prot
, mmap_flags
, map_idx
= 0;
1440 char *buf
, *mmaps
[NUM_MMAPS
];
1441 union perf_event
*event
;
1442 struct ui_progress prog
;
1445 perf_tool__fill_defaults(tool
);
1447 page_offset
= page_size
* (data_offset
/ page_size
);
1448 file_offset
= page_offset
;
1449 head
= data_offset
- page_offset
;
1451 if (data_size
&& (data_offset
+ data_size
< file_size
))
1452 file_size
= data_offset
+ data_size
;
1454 ui_progress__init(&prog
, file_size
, "Processing events...");
1456 mmap_size
= MMAP_SIZE
;
1457 if (mmap_size
> file_size
) {
1458 mmap_size
= file_size
;
1459 session
->one_mmap
= true;
1462 memset(mmaps
, 0, sizeof(mmaps
));
1464 mmap_prot
= PROT_READ
;
1465 mmap_flags
= MAP_SHARED
;
1467 if (session
->header
.needs_swap
) {
1468 mmap_prot
|= PROT_WRITE
;
1469 mmap_flags
= MAP_PRIVATE
;
1472 buf
= mmap(NULL
, mmap_size
, mmap_prot
, mmap_flags
, fd
,
1474 if (buf
== MAP_FAILED
) {
1475 pr_err("failed to mmap file\n");
1479 mmaps
[map_idx
] = buf
;
1480 map_idx
= (map_idx
+ 1) & (ARRAY_SIZE(mmaps
) - 1);
1481 file_pos
= file_offset
+ head
;
1482 if (session
->one_mmap
) {
1483 session
->one_mmap_addr
= buf
;
1484 session
->one_mmap_offset
= file_offset
;
1488 event
= fetch_mmaped_event(session
, head
, mmap_size
, buf
);
1490 if (mmaps
[map_idx
]) {
1491 munmap(mmaps
[map_idx
], mmap_size
);
1492 mmaps
[map_idx
] = NULL
;
1495 page_offset
= page_size
* (head
/ page_size
);
1496 file_offset
+= page_offset
;
1497 head
-= page_offset
;
1501 size
= event
->header
.size
;
1503 if (size
< sizeof(struct perf_event_header
) ||
1504 (skip
= perf_session__process_event(session
, event
, file_pos
)) < 0) {
1505 pr_err("%#" PRIx64
" [%#x]: failed to process type: %d\n",
1506 file_offset
+ head
, event
->header
.size
,
1507 event
->header
.type
);
1518 ui_progress__update(&prog
, size
);
1523 if (file_pos
< file_size
)
1527 /* do the final flush for ordered samples */
1528 err
= ordered_events__flush(oe
, OE_FLUSH__FINAL
);
1531 err
= auxtrace__flush_events(session
, tool
);
1533 ui_progress__finish();
1534 perf_session__warn_about_errors(session
);
1535 ordered_events__free(&session
->ordered_events
);
1536 auxtrace__free_events(session
);
1537 session
->one_mmap
= false;
1541 int perf_session__process_events(struct perf_session
*session
)
1543 u64 size
= perf_data_file__size(session
->file
);
1546 if (perf_session__register_idle_thread(session
) == NULL
)
1549 if (!perf_data_file__is_pipe(session
->file
))
1550 err
= __perf_session__process_events(session
,
1551 session
->header
.data_offset
,
1552 session
->header
.data_size
, size
);
1554 err
= __perf_session__process_pipe_events(session
);
1559 bool perf_session__has_traces(struct perf_session
*session
, const char *msg
)
1561 struct perf_evsel
*evsel
;
1563 evlist__for_each(session
->evlist
, evsel
) {
1564 if (evsel
->attr
.type
== PERF_TYPE_TRACEPOINT
)
1568 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg
);
1572 int maps__set_kallsyms_ref_reloc_sym(struct map
**maps
,
1573 const char *symbol_name
, u64 addr
)
1577 struct ref_reloc_sym
*ref
;
1579 ref
= zalloc(sizeof(struct ref_reloc_sym
));
1583 ref
->name
= strdup(symbol_name
);
1584 if (ref
->name
== NULL
) {
1589 bracket
= strchr(ref
->name
, ']');
1595 for (i
= 0; i
< MAP__NR_TYPES
; ++i
) {
1596 struct kmap
*kmap
= map__kmap(maps
[i
]);
1600 kmap
->ref_reloc_sym
= ref
;
1606 size_t perf_session__fprintf_dsos(struct perf_session
*session
, FILE *fp
)
1608 return machines__fprintf_dsos(&session
->machines
, fp
);
1611 size_t perf_session__fprintf_dsos_buildid(struct perf_session
*session
, FILE *fp
,
1612 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
1614 return machines__fprintf_dsos_buildid(&session
->machines
, fp
, skip
, parm
);
1617 size_t perf_session__fprintf_nr_events(struct perf_session
*session
, FILE *fp
)
1620 const char *msg
= "";
1622 if (perf_header__has_feat(&session
->header
, HEADER_AUXTRACE
))
1623 msg
= " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)";
1625 ret
= fprintf(fp
, "Aggregated stats:%s\n", msg
);
1627 ret
+= events_stats__fprintf(&session
->evlist
->stats
, fp
);
1631 size_t perf_session__fprintf(struct perf_session
*session
, FILE *fp
)
1634 * FIXME: Here we have to actually print all the machines in this
1635 * session, not just the host...
1637 return machine__fprintf(&session
->machines
.host
, fp
);
1640 struct perf_evsel
*perf_session__find_first_evtype(struct perf_session
*session
,
1643 struct perf_evsel
*pos
;
1645 evlist__for_each(session
->evlist
, pos
) {
1646 if (pos
->attr
.type
== type
)
1652 void perf_evsel__print_ip(struct perf_evsel
*evsel
, struct perf_sample
*sample
,
1653 struct addr_location
*al
,
1654 unsigned int print_opts
, unsigned int stack_depth
)
1656 struct callchain_cursor_node
*node
;
1657 int print_ip
= print_opts
& PRINT_IP_OPT_IP
;
1658 int print_sym
= print_opts
& PRINT_IP_OPT_SYM
;
1659 int print_dso
= print_opts
& PRINT_IP_OPT_DSO
;
1660 int print_symoffset
= print_opts
& PRINT_IP_OPT_SYMOFFSET
;
1661 int print_oneline
= print_opts
& PRINT_IP_OPT_ONELINE
;
1662 int print_srcline
= print_opts
& PRINT_IP_OPT_SRCLINE
;
1663 char s
= print_oneline
? ' ' : '\t';
1665 if (symbol_conf
.use_callchain
&& sample
->callchain
) {
1666 struct addr_location node_al
;
1668 if (thread__resolve_callchain(al
->thread
, evsel
,
1670 PERF_MAX_STACK_DEPTH
) != 0) {
1672 error("Failed to resolve callchain. Skipping\n");
1675 callchain_cursor_commit(&callchain_cursor
);
1677 if (print_symoffset
)
1680 while (stack_depth
) {
1683 node
= callchain_cursor_current(&callchain_cursor
);
1687 if (node
->sym
&& node
->sym
->ignore
)
1691 printf("%c%16" PRIx64
, s
, node
->ip
);
1694 addr
= node
->map
->map_ip(node
->map
, node
->ip
);
1698 if (print_symoffset
) {
1699 node_al
.addr
= addr
;
1700 node_al
.map
= node
->map
;
1701 symbol__fprintf_symname_offs(node
->sym
, &node_al
, stdout
);
1703 symbol__fprintf_symname(node
->sym
, stdout
);
1708 map__fprintf_dsoname(node
->map
, stdout
);
1713 map__fprintf_srcline(node
->map
, addr
, "\n ",
1721 callchain_cursor_advance(&callchain_cursor
);
1725 if (al
->sym
&& al
->sym
->ignore
)
1729 printf("%16" PRIx64
, sample
->ip
);
1733 if (print_symoffset
)
1734 symbol__fprintf_symname_offs(al
->sym
, al
,
1737 symbol__fprintf_symname(al
->sym
, stdout
);
1742 map__fprintf_dsoname(al
->map
, stdout
);
1747 map__fprintf_srcline(al
->map
, al
->addr
, "\n ", stdout
);
1751 int perf_session__cpu_bitmap(struct perf_session
*session
,
1752 const char *cpu_list
, unsigned long *cpu_bitmap
)
1755 struct cpu_map
*map
;
1757 for (i
= 0; i
< PERF_TYPE_MAX
; ++i
) {
1758 struct perf_evsel
*evsel
;
1760 evsel
= perf_session__find_first_evtype(session
, i
);
1764 if (!(evsel
->attr
.sample_type
& PERF_SAMPLE_CPU
)) {
1765 pr_err("File does not contain CPU events. "
1766 "Remove -c option to proceed.\n");
1771 map
= cpu_map__new(cpu_list
);
1773 pr_err("Invalid cpu_list\n");
1777 for (i
= 0; i
< map
->nr
; i
++) {
1778 int cpu
= map
->map
[i
];
1780 if (cpu
>= MAX_NR_CPUS
) {
1781 pr_err("Requested CPU %d too large. "
1782 "Consider raising MAX_NR_CPUS\n", cpu
);
1783 goto out_delete_map
;
1786 set_bit(cpu
, cpu_bitmap
);
1792 cpu_map__delete(map
);
1796 void perf_session__fprintf_info(struct perf_session
*session
, FILE *fp
,
1802 if (session
== NULL
|| fp
== NULL
)
1805 fd
= perf_data_file__fd(session
->file
);
1807 ret
= fstat(fd
, &st
);
1811 fprintf(fp
, "# ========\n");
1812 fprintf(fp
, "# captured on: %s", ctime(&st
.st_ctime
));
1813 perf_header__fprintf_info(session
, fp
, full
);
1814 fprintf(fp
, "# ========\n#\n");
1818 int __perf_session__set_tracepoints_handlers(struct perf_session
*session
,
1819 const struct perf_evsel_str_handler
*assocs
,
1822 struct perf_evsel
*evsel
;
1826 for (i
= 0; i
< nr_assocs
; i
++) {
1828 * Adding a handler for an event not in the session,
1831 evsel
= perf_evlist__find_tracepoint_by_name(session
->evlist
, assocs
[i
].name
);
1836 if (evsel
->handler
!= NULL
)
1838 evsel
->handler
= assocs
[i
].handler
;
1846 int perf_event__process_id_index(struct perf_tool
*tool __maybe_unused
,
1847 union perf_event
*event
,
1848 struct perf_session
*session
)
1850 struct perf_evlist
*evlist
= session
->evlist
;
1851 struct id_index_event
*ie
= &event
->id_index
;
1852 size_t i
, nr
, max_nr
;
1854 max_nr
= (ie
->header
.size
- sizeof(struct id_index_event
)) /
1855 sizeof(struct id_index_entry
);
1861 fprintf(stdout
, " nr: %zu\n", nr
);
1863 for (i
= 0; i
< nr
; i
++) {
1864 struct id_index_entry
*e
= &ie
->entries
[i
];
1865 struct perf_sample_id
*sid
;
1868 fprintf(stdout
, " ... id: %"PRIu64
, e
->id
);
1869 fprintf(stdout
, " idx: %"PRIu64
, e
->idx
);
1870 fprintf(stdout
, " cpu: %"PRId64
, e
->cpu
);
1871 fprintf(stdout
, " tid: %"PRId64
"\n", e
->tid
);
1874 sid
= perf_evlist__id2sid(evlist
, e
->id
);
1884 int perf_event__synthesize_id_index(struct perf_tool
*tool
,
1885 perf_event__handler_t process
,
1886 struct perf_evlist
*evlist
,
1887 struct machine
*machine
)
1889 union perf_event
*ev
;
1890 struct perf_evsel
*evsel
;
1891 size_t nr
= 0, i
= 0, sz
, max_nr
, n
;
1894 pr_debug2("Synthesizing id index\n");
1896 max_nr
= (UINT16_MAX
- sizeof(struct id_index_event
)) /
1897 sizeof(struct id_index_entry
);
1899 evlist__for_each(evlist
, evsel
)
1902 n
= nr
> max_nr
? max_nr
: nr
;
1903 sz
= sizeof(struct id_index_event
) + n
* sizeof(struct id_index_entry
);
1908 ev
->id_index
.header
.type
= PERF_RECORD_ID_INDEX
;
1909 ev
->id_index
.header
.size
= sz
;
1910 ev
->id_index
.nr
= n
;
1912 evlist__for_each(evlist
, evsel
) {
1915 for (j
= 0; j
< evsel
->ids
; j
++) {
1916 struct id_index_entry
*e
;
1917 struct perf_sample_id
*sid
;
1920 err
= process(tool
, ev
, NULL
, machine
);
1927 e
= &ev
->id_index
.entries
[i
++];
1929 e
->id
= evsel
->id
[j
];
1931 sid
= perf_evlist__id2sid(evlist
, e
->id
);
1943 sz
= sizeof(struct id_index_event
) + nr
* sizeof(struct id_index_entry
);
1944 ev
->id_index
.header
.size
= sz
;
1945 ev
->id_index
.nr
= nr
;
1947 err
= process(tool
, ev
, NULL
, machine
);