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 machines__init(&session
->machines
);
124 ordered_events__init(&session
->ordered_events
, ordered_events__deliver_event
);
127 if (perf_data_file__open(file
))
130 session
->file
= file
;
132 if (perf_data_file__is_read(file
)) {
133 if (perf_session__open(session
) < 0)
136 perf_session__set_id_hdr_size(session
);
137 perf_session__set_comm_exec(session
);
141 if (!file
|| perf_data_file__is_write(file
)) {
143 * In O_RDONLY mode this will be performed when reading the
144 * kernel MMAP event, in perf_event__process_mmap().
146 if (perf_session__create_kernel_maps(session
) < 0)
147 pr_warning("Cannot read kernel map\n");
150 if (tool
&& tool
->ordering_requires_timestamps
&&
151 tool
->ordered_events
&& !perf_evlist__sample_id_all(session
->evlist
)) {
152 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
153 tool
->ordered_events
= false;
159 perf_data_file__close(file
);
161 perf_session__delete(session
);
166 static void perf_session__delete_threads(struct perf_session
*session
)
168 machine__delete_threads(&session
->machines
.host
);
171 static void perf_session_env__delete(struct perf_session_env
*env
)
173 zfree(&env
->hostname
);
174 zfree(&env
->os_release
);
175 zfree(&env
->version
);
177 zfree(&env
->cpu_desc
);
180 zfree(&env
->cmdline
);
181 zfree(&env
->sibling_cores
);
182 zfree(&env
->sibling_threads
);
183 zfree(&env
->numa_nodes
);
184 zfree(&env
->pmu_mappings
);
187 void perf_session__delete(struct perf_session
*session
)
189 auxtrace__free(session
);
190 perf_session__destroy_kernel_maps(session
);
191 perf_session__delete_threads(session
);
192 perf_session_env__delete(&session
->header
.env
);
193 machines__exit(&session
->machines
);
195 perf_data_file__close(session
->file
);
199 static int process_event_synth_tracing_data_stub(struct perf_tool
*tool
201 union perf_event
*event
203 struct perf_session
*session
206 dump_printf(": unhandled!\n");
210 static int process_event_synth_attr_stub(struct perf_tool
*tool __maybe_unused
,
211 union perf_event
*event __maybe_unused
,
212 struct perf_evlist
**pevlist
215 dump_printf(": unhandled!\n");
219 static int process_event_sample_stub(struct perf_tool
*tool __maybe_unused
,
220 union perf_event
*event __maybe_unused
,
221 struct perf_sample
*sample __maybe_unused
,
222 struct perf_evsel
*evsel __maybe_unused
,
223 struct machine
*machine __maybe_unused
)
225 dump_printf(": unhandled!\n");
229 static int process_event_stub(struct perf_tool
*tool __maybe_unused
,
230 union perf_event
*event __maybe_unused
,
231 struct perf_sample
*sample __maybe_unused
,
232 struct machine
*machine __maybe_unused
)
234 dump_printf(": unhandled!\n");
238 static int process_build_id_stub(struct perf_tool
*tool __maybe_unused
,
239 union perf_event
*event __maybe_unused
,
240 struct perf_session
*session __maybe_unused
)
242 dump_printf(": unhandled!\n");
246 static int process_finished_round_stub(struct perf_tool
*tool __maybe_unused
,
247 union perf_event
*event __maybe_unused
,
248 struct ordered_events
*oe __maybe_unused
)
250 dump_printf(": unhandled!\n");
254 static int process_finished_round(struct perf_tool
*tool
,
255 union perf_event
*event
,
256 struct ordered_events
*oe
);
258 static int process_id_index_stub(struct perf_tool
*tool __maybe_unused
,
259 union perf_event
*event __maybe_unused
,
260 struct perf_session
*perf_session
263 dump_printf(": unhandled!\n");
267 static int process_event_auxtrace_info_stub(struct perf_tool
*tool __maybe_unused
,
268 union perf_event
*event __maybe_unused
,
269 struct perf_session
*session __maybe_unused
)
271 dump_printf(": unhandled!\n");
275 static int skipn(int fd
, off_t n
)
281 ret
= read(fd
, buf
, min(n
, (off_t
)sizeof(buf
)));
290 static s64
process_event_auxtrace_stub(struct perf_tool
*tool __maybe_unused
,
291 union perf_event
*event
,
292 struct perf_session
*session
295 dump_printf(": unhandled!\n");
296 if (perf_data_file__is_pipe(session
->file
))
297 skipn(perf_data_file__fd(session
->file
), event
->auxtrace
.size
);
298 return event
->auxtrace
.size
;
302 int process_event_auxtrace_error_stub(struct perf_tool
*tool __maybe_unused
,
303 union perf_event
*event __maybe_unused
,
304 struct perf_session
*session __maybe_unused
)
306 dump_printf(": unhandled!\n");
310 void perf_tool__fill_defaults(struct perf_tool
*tool
)
312 if (tool
->sample
== NULL
)
313 tool
->sample
= process_event_sample_stub
;
314 if (tool
->mmap
== NULL
)
315 tool
->mmap
= process_event_stub
;
316 if (tool
->mmap2
== NULL
)
317 tool
->mmap2
= process_event_stub
;
318 if (tool
->comm
== NULL
)
319 tool
->comm
= process_event_stub
;
320 if (tool
->fork
== NULL
)
321 tool
->fork
= process_event_stub
;
322 if (tool
->exit
== NULL
)
323 tool
->exit
= process_event_stub
;
324 if (tool
->lost
== NULL
)
325 tool
->lost
= perf_event__process_lost
;
326 if (tool
->read
== NULL
)
327 tool
->read
= process_event_sample_stub
;
328 if (tool
->throttle
== NULL
)
329 tool
->throttle
= process_event_stub
;
330 if (tool
->unthrottle
== NULL
)
331 tool
->unthrottle
= process_event_stub
;
332 if (tool
->attr
== NULL
)
333 tool
->attr
= process_event_synth_attr_stub
;
334 if (tool
->tracing_data
== NULL
)
335 tool
->tracing_data
= process_event_synth_tracing_data_stub
;
336 if (tool
->build_id
== NULL
)
337 tool
->build_id
= process_build_id_stub
;
338 if (tool
->finished_round
== NULL
) {
339 if (tool
->ordered_events
)
340 tool
->finished_round
= process_finished_round
;
342 tool
->finished_round
= process_finished_round_stub
;
344 if (tool
->id_index
== NULL
)
345 tool
->id_index
= process_id_index_stub
;
346 if (tool
->auxtrace_info
== NULL
)
347 tool
->auxtrace_info
= process_event_auxtrace_info_stub
;
348 if (tool
->auxtrace
== NULL
)
349 tool
->auxtrace
= process_event_auxtrace_stub
;
350 if (tool
->auxtrace_error
== NULL
)
351 tool
->auxtrace_error
= process_event_auxtrace_error_stub
;
354 static void swap_sample_id_all(union perf_event
*event
, void *data
)
356 void *end
= (void *) event
+ event
->header
.size
;
357 int size
= end
- data
;
359 BUG_ON(size
% sizeof(u64
));
360 mem_bswap_64(data
, size
);
363 static void perf_event__all64_swap(union perf_event
*event
,
364 bool sample_id_all __maybe_unused
)
366 struct perf_event_header
*hdr
= &event
->header
;
367 mem_bswap_64(hdr
+ 1, event
->header
.size
- sizeof(*hdr
));
370 static void perf_event__comm_swap(union perf_event
*event
, bool sample_id_all
)
372 event
->comm
.pid
= bswap_32(event
->comm
.pid
);
373 event
->comm
.tid
= bswap_32(event
->comm
.tid
);
376 void *data
= &event
->comm
.comm
;
378 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
379 swap_sample_id_all(event
, data
);
383 static void perf_event__mmap_swap(union perf_event
*event
,
386 event
->mmap
.pid
= bswap_32(event
->mmap
.pid
);
387 event
->mmap
.tid
= bswap_32(event
->mmap
.tid
);
388 event
->mmap
.start
= bswap_64(event
->mmap
.start
);
389 event
->mmap
.len
= bswap_64(event
->mmap
.len
);
390 event
->mmap
.pgoff
= bswap_64(event
->mmap
.pgoff
);
393 void *data
= &event
->mmap
.filename
;
395 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
396 swap_sample_id_all(event
, data
);
400 static void perf_event__mmap2_swap(union perf_event
*event
,
403 event
->mmap2
.pid
= bswap_32(event
->mmap2
.pid
);
404 event
->mmap2
.tid
= bswap_32(event
->mmap2
.tid
);
405 event
->mmap2
.start
= bswap_64(event
->mmap2
.start
);
406 event
->mmap2
.len
= bswap_64(event
->mmap2
.len
);
407 event
->mmap2
.pgoff
= bswap_64(event
->mmap2
.pgoff
);
408 event
->mmap2
.maj
= bswap_32(event
->mmap2
.maj
);
409 event
->mmap2
.min
= bswap_32(event
->mmap2
.min
);
410 event
->mmap2
.ino
= bswap_64(event
->mmap2
.ino
);
413 void *data
= &event
->mmap2
.filename
;
415 data
+= PERF_ALIGN(strlen(data
) + 1, sizeof(u64
));
416 swap_sample_id_all(event
, data
);
419 static void perf_event__task_swap(union perf_event
*event
, bool sample_id_all
)
421 event
->fork
.pid
= bswap_32(event
->fork
.pid
);
422 event
->fork
.tid
= bswap_32(event
->fork
.tid
);
423 event
->fork
.ppid
= bswap_32(event
->fork
.ppid
);
424 event
->fork
.ptid
= bswap_32(event
->fork
.ptid
);
425 event
->fork
.time
= bswap_64(event
->fork
.time
);
428 swap_sample_id_all(event
, &event
->fork
+ 1);
431 static void perf_event__read_swap(union perf_event
*event
, bool sample_id_all
)
433 event
->read
.pid
= bswap_32(event
->read
.pid
);
434 event
->read
.tid
= bswap_32(event
->read
.tid
);
435 event
->read
.value
= bswap_64(event
->read
.value
);
436 event
->read
.time_enabled
= bswap_64(event
->read
.time_enabled
);
437 event
->read
.time_running
= bswap_64(event
->read
.time_running
);
438 event
->read
.id
= bswap_64(event
->read
.id
);
441 swap_sample_id_all(event
, &event
->read
+ 1);
444 static void perf_event__throttle_swap(union perf_event
*event
,
447 event
->throttle
.time
= bswap_64(event
->throttle
.time
);
448 event
->throttle
.id
= bswap_64(event
->throttle
.id
);
449 event
->throttle
.stream_id
= bswap_64(event
->throttle
.stream_id
);
452 swap_sample_id_all(event
, &event
->throttle
+ 1);
455 static u8
revbyte(u8 b
)
457 int rev
= (b
>> 4) | ((b
& 0xf) << 4);
458 rev
= ((rev
& 0xcc) >> 2) | ((rev
& 0x33) << 2);
459 rev
= ((rev
& 0xaa) >> 1) | ((rev
& 0x55) << 1);
464 * XXX this is hack in attempt to carry flags bitfield
465 * throught endian village. ABI says:
467 * Bit-fields are allocated from right to left (least to most significant)
468 * on little-endian implementations and from left to right (most to least
469 * significant) on big-endian implementations.
471 * The above seems to be byte specific, so we need to reverse each
472 * byte of the bitfield. 'Internet' also says this might be implementation
473 * specific and we probably need proper fix and carry perf_event_attr
474 * bitfield flags in separate data file FEAT_ section. Thought this seems
477 static void swap_bitfield(u8
*p
, unsigned len
)
481 for (i
= 0; i
< len
; i
++) {
487 /* exported for swapping attributes in file header */
488 void perf_event__attr_swap(struct perf_event_attr
*attr
)
490 attr
->type
= bswap_32(attr
->type
);
491 attr
->size
= bswap_32(attr
->size
);
492 attr
->config
= bswap_64(attr
->config
);
493 attr
->sample_period
= bswap_64(attr
->sample_period
);
494 attr
->sample_type
= bswap_64(attr
->sample_type
);
495 attr
->read_format
= bswap_64(attr
->read_format
);
496 attr
->wakeup_events
= bswap_32(attr
->wakeup_events
);
497 attr
->bp_type
= bswap_32(attr
->bp_type
);
498 attr
->bp_addr
= bswap_64(attr
->bp_addr
);
499 attr
->bp_len
= bswap_64(attr
->bp_len
);
500 attr
->branch_sample_type
= bswap_64(attr
->branch_sample_type
);
501 attr
->sample_regs_user
= bswap_64(attr
->sample_regs_user
);
502 attr
->sample_stack_user
= bswap_32(attr
->sample_stack_user
);
503 attr
->aux_watermark
= bswap_32(attr
->aux_watermark
);
505 swap_bitfield((u8
*) (&attr
->read_format
+ 1), sizeof(u64
));
508 static void perf_event__hdr_attr_swap(union perf_event
*event
,
509 bool sample_id_all __maybe_unused
)
513 perf_event__attr_swap(&event
->attr
.attr
);
515 size
= event
->header
.size
;
516 size
-= (void *)&event
->attr
.id
- (void *)event
;
517 mem_bswap_64(event
->attr
.id
, size
);
520 static void perf_event__event_type_swap(union perf_event
*event
,
521 bool sample_id_all __maybe_unused
)
523 event
->event_type
.event_type
.event_id
=
524 bswap_64(event
->event_type
.event_type
.event_id
);
527 static void perf_event__tracing_data_swap(union perf_event
*event
,
528 bool sample_id_all __maybe_unused
)
530 event
->tracing_data
.size
= bswap_32(event
->tracing_data
.size
);
533 static void perf_event__auxtrace_info_swap(union perf_event
*event
,
534 bool sample_id_all __maybe_unused
)
538 event
->auxtrace_info
.type
= bswap_32(event
->auxtrace_info
.type
);
540 size
= event
->header
.size
;
541 size
-= (void *)&event
->auxtrace_info
.priv
- (void *)event
;
542 mem_bswap_64(event
->auxtrace_info
.priv
, size
);
545 static void perf_event__auxtrace_swap(union perf_event
*event
,
546 bool sample_id_all __maybe_unused
)
548 event
->auxtrace
.size
= bswap_64(event
->auxtrace
.size
);
549 event
->auxtrace
.offset
= bswap_64(event
->auxtrace
.offset
);
550 event
->auxtrace
.reference
= bswap_64(event
->auxtrace
.reference
);
551 event
->auxtrace
.idx
= bswap_32(event
->auxtrace
.idx
);
552 event
->auxtrace
.tid
= bswap_32(event
->auxtrace
.tid
);
553 event
->auxtrace
.cpu
= bswap_32(event
->auxtrace
.cpu
);
556 static void perf_event__auxtrace_error_swap(union perf_event
*event
,
557 bool sample_id_all __maybe_unused
)
559 event
->auxtrace_error
.type
= bswap_32(event
->auxtrace_error
.type
);
560 event
->auxtrace_error
.code
= bswap_32(event
->auxtrace_error
.code
);
561 event
->auxtrace_error
.cpu
= bswap_32(event
->auxtrace_error
.cpu
);
562 event
->auxtrace_error
.pid
= bswap_32(event
->auxtrace_error
.pid
);
563 event
->auxtrace_error
.tid
= bswap_32(event
->auxtrace_error
.tid
);
564 event
->auxtrace_error
.ip
= bswap_64(event
->auxtrace_error
.ip
);
567 typedef void (*perf_event__swap_op
)(union perf_event
*event
,
570 static perf_event__swap_op perf_event__swap_ops
[] = {
571 [PERF_RECORD_MMAP
] = perf_event__mmap_swap
,
572 [PERF_RECORD_MMAP2
] = perf_event__mmap2_swap
,
573 [PERF_RECORD_COMM
] = perf_event__comm_swap
,
574 [PERF_RECORD_FORK
] = perf_event__task_swap
,
575 [PERF_RECORD_EXIT
] = perf_event__task_swap
,
576 [PERF_RECORD_LOST
] = perf_event__all64_swap
,
577 [PERF_RECORD_READ
] = perf_event__read_swap
,
578 [PERF_RECORD_THROTTLE
] = perf_event__throttle_swap
,
579 [PERF_RECORD_UNTHROTTLE
] = perf_event__throttle_swap
,
580 [PERF_RECORD_SAMPLE
] = perf_event__all64_swap
,
581 [PERF_RECORD_HEADER_ATTR
] = perf_event__hdr_attr_swap
,
582 [PERF_RECORD_HEADER_EVENT_TYPE
] = perf_event__event_type_swap
,
583 [PERF_RECORD_HEADER_TRACING_DATA
] = perf_event__tracing_data_swap
,
584 [PERF_RECORD_HEADER_BUILD_ID
] = NULL
,
585 [PERF_RECORD_ID_INDEX
] = perf_event__all64_swap
,
586 [PERF_RECORD_AUXTRACE_INFO
] = perf_event__auxtrace_info_swap
,
587 [PERF_RECORD_AUXTRACE
] = perf_event__auxtrace_swap
,
588 [PERF_RECORD_AUXTRACE_ERROR
] = perf_event__auxtrace_error_swap
,
589 [PERF_RECORD_HEADER_MAX
] = NULL
,
593 * When perf record finishes a pass on every buffers, it records this pseudo
595 * We record the max timestamp t found in the pass n.
596 * Assuming these timestamps are monotonic across cpus, we know that if
597 * a buffer still has events with timestamps below t, they will be all
598 * available and then read in the pass n + 1.
599 * Hence when we start to read the pass n + 2, we can safely flush every
600 * events with timestamps below t.
602 * ============ PASS n =================
605 * cnt1 timestamps | cnt2 timestamps
608 * - | 4 <--- max recorded
610 * ============ PASS n + 1 ==============
613 * cnt1 timestamps | cnt2 timestamps
616 * 5 | 7 <---- max recorded
618 * Flush every events below timestamp 4
620 * ============ PASS n + 2 ==============
623 * cnt1 timestamps | cnt2 timestamps
628 * Flush every events below timestamp 7
631 static int process_finished_round(struct perf_tool
*tool __maybe_unused
,
632 union perf_event
*event __maybe_unused
,
633 struct ordered_events
*oe
)
635 return ordered_events__flush(oe
, OE_FLUSH__ROUND
);
638 int perf_session__queue_event(struct perf_session
*s
, union perf_event
*event
,
639 struct perf_sample
*sample
, u64 file_offset
)
641 return ordered_events__queue(&s
->ordered_events
, event
, sample
, file_offset
);
644 static void callchain__lbr_callstack_printf(struct perf_sample
*sample
)
646 struct ip_callchain
*callchain
= sample
->callchain
;
647 struct branch_stack
*lbr_stack
= sample
->branch_stack
;
648 u64 kernel_callchain_nr
= callchain
->nr
;
651 for (i
= 0; i
< kernel_callchain_nr
; i
++) {
652 if (callchain
->ips
[i
] == PERF_CONTEXT_USER
)
656 if ((i
!= kernel_callchain_nr
) && lbr_stack
->nr
) {
659 * LBR callstack can only get user call chain,
660 * i is kernel call chain number,
661 * 1 is PERF_CONTEXT_USER.
663 * The user call chain is stored in LBR registers.
664 * LBR are pair registers. The caller is stored
665 * in "from" register, while the callee is stored
667 * For example, there is a call stack
668 * "A"->"B"->"C"->"D".
669 * The LBR registers will recorde like
670 * "C"->"D", "B"->"C", "A"->"B".
671 * So only the first "to" register and all "from"
672 * registers are needed to construct the whole stack.
674 total_nr
= i
+ 1 + lbr_stack
->nr
+ 1;
675 kernel_callchain_nr
= i
+ 1;
677 printf("... LBR call chain: nr:%" PRIu64
"\n", total_nr
);
679 for (i
= 0; i
< kernel_callchain_nr
; i
++)
680 printf("..... %2d: %016" PRIx64
"\n",
681 i
, callchain
->ips
[i
]);
683 printf("..... %2d: %016" PRIx64
"\n",
684 (int)(kernel_callchain_nr
), lbr_stack
->entries
[0].to
);
685 for (i
= 0; i
< lbr_stack
->nr
; i
++)
686 printf("..... %2d: %016" PRIx64
"\n",
687 (int)(i
+ kernel_callchain_nr
+ 1), lbr_stack
->entries
[i
].from
);
691 static void callchain__printf(struct perf_evsel
*evsel
,
692 struct perf_sample
*sample
)
695 struct ip_callchain
*callchain
= sample
->callchain
;
697 if (has_branch_callstack(evsel
))
698 callchain__lbr_callstack_printf(sample
);
700 printf("... FP chain: nr:%" PRIu64
"\n", callchain
->nr
);
702 for (i
= 0; i
< callchain
->nr
; i
++)
703 printf("..... %2d: %016" PRIx64
"\n",
704 i
, callchain
->ips
[i
]);
707 static void branch_stack__printf(struct perf_sample
*sample
)
711 printf("... branch stack: nr:%" PRIu64
"\n", sample
->branch_stack
->nr
);
713 for (i
= 0; i
< sample
->branch_stack
->nr
; i
++)
714 printf("..... %2"PRIu64
": %016" PRIx64
" -> %016" PRIx64
"\n",
715 i
, sample
->branch_stack
->entries
[i
].from
,
716 sample
->branch_stack
->entries
[i
].to
);
719 static void regs_dump__printf(u64 mask
, u64
*regs
)
723 for_each_set_bit(rid
, (unsigned long *) &mask
, sizeof(mask
) * 8) {
726 printf(".... %-5s 0x%" PRIx64
"\n",
727 perf_reg_name(rid
), val
);
731 static const char *regs_abi
[] = {
732 [PERF_SAMPLE_REGS_ABI_NONE
] = "none",
733 [PERF_SAMPLE_REGS_ABI_32
] = "32-bit",
734 [PERF_SAMPLE_REGS_ABI_64
] = "64-bit",
737 static inline const char *regs_dump_abi(struct regs_dump
*d
)
739 if (d
->abi
> PERF_SAMPLE_REGS_ABI_64
)
742 return regs_abi
[d
->abi
];
745 static void regs__printf(const char *type
, struct regs_dump
*regs
)
747 u64 mask
= regs
->mask
;
749 printf("... %s regs: mask 0x%" PRIx64
" ABI %s\n",
752 regs_dump_abi(regs
));
754 regs_dump__printf(mask
, regs
->regs
);
757 static void regs_user__printf(struct perf_sample
*sample
)
759 struct regs_dump
*user_regs
= &sample
->user_regs
;
762 regs__printf("user", user_regs
);
765 static void regs_intr__printf(struct perf_sample
*sample
)
767 struct regs_dump
*intr_regs
= &sample
->intr_regs
;
770 regs__printf("intr", intr_regs
);
773 static void stack_user__printf(struct stack_dump
*dump
)
775 printf("... ustack: size %" PRIu64
", offset 0x%x\n",
776 dump
->size
, dump
->offset
);
779 static void perf_evlist__print_tstamp(struct perf_evlist
*evlist
,
780 union perf_event
*event
,
781 struct perf_sample
*sample
)
783 u64 sample_type
= __perf_evlist__combined_sample_type(evlist
);
785 if (event
->header
.type
!= PERF_RECORD_SAMPLE
&&
786 !perf_evlist__sample_id_all(evlist
)) {
787 fputs("-1 -1 ", stdout
);
791 if ((sample_type
& PERF_SAMPLE_CPU
))
792 printf("%u ", sample
->cpu
);
794 if (sample_type
& PERF_SAMPLE_TIME
)
795 printf("%" PRIu64
" ", sample
->time
);
798 static void sample_read__printf(struct perf_sample
*sample
, u64 read_format
)
800 printf("... sample_read:\n");
802 if (read_format
& PERF_FORMAT_TOTAL_TIME_ENABLED
)
803 printf("...... time enabled %016" PRIx64
"\n",
804 sample
->read
.time_enabled
);
806 if (read_format
& PERF_FORMAT_TOTAL_TIME_RUNNING
)
807 printf("...... time running %016" PRIx64
"\n",
808 sample
->read
.time_running
);
810 if (read_format
& PERF_FORMAT_GROUP
) {
813 printf(".... group nr %" PRIu64
"\n", sample
->read
.group
.nr
);
815 for (i
= 0; i
< sample
->read
.group
.nr
; i
++) {
816 struct sample_read_value
*value
;
818 value
= &sample
->read
.group
.values
[i
];
819 printf("..... id %016" PRIx64
820 ", value %016" PRIx64
"\n",
821 value
->id
, value
->value
);
824 printf("..... id %016" PRIx64
", value %016" PRIx64
"\n",
825 sample
->read
.one
.id
, sample
->read
.one
.value
);
828 static void dump_event(struct perf_evlist
*evlist
, union perf_event
*event
,
829 u64 file_offset
, struct perf_sample
*sample
)
834 printf("\n%#" PRIx64
" [%#x]: event: %d\n",
835 file_offset
, event
->header
.size
, event
->header
.type
);
840 perf_evlist__print_tstamp(evlist
, event
, sample
);
842 printf("%#" PRIx64
" [%#x]: PERF_RECORD_%s", file_offset
,
843 event
->header
.size
, perf_event__name(event
->header
.type
));
846 static void dump_sample(struct perf_evsel
*evsel
, union perf_event
*event
,
847 struct perf_sample
*sample
)
854 printf("(IP, 0x%x): %d/%d: %#" PRIx64
" period: %" PRIu64
" addr: %#" PRIx64
"\n",
855 event
->header
.misc
, sample
->pid
, sample
->tid
, sample
->ip
,
856 sample
->period
, sample
->addr
);
858 sample_type
= evsel
->attr
.sample_type
;
860 if (sample_type
& PERF_SAMPLE_CALLCHAIN
)
861 callchain__printf(evsel
, sample
);
863 if ((sample_type
& PERF_SAMPLE_BRANCH_STACK
) && !has_branch_callstack(evsel
))
864 branch_stack__printf(sample
);
866 if (sample_type
& PERF_SAMPLE_REGS_USER
)
867 regs_user__printf(sample
);
869 if (sample_type
& PERF_SAMPLE_REGS_INTR
)
870 regs_intr__printf(sample
);
872 if (sample_type
& PERF_SAMPLE_STACK_USER
)
873 stack_user__printf(&sample
->user_stack
);
875 if (sample_type
& PERF_SAMPLE_WEIGHT
)
876 printf("... weight: %" PRIu64
"\n", sample
->weight
);
878 if (sample_type
& PERF_SAMPLE_DATA_SRC
)
879 printf(" . data_src: 0x%"PRIx64
"\n", sample
->data_src
);
881 if (sample_type
& PERF_SAMPLE_TRANSACTION
)
882 printf("... transaction: %" PRIx64
"\n", sample
->transaction
);
884 if (sample_type
& PERF_SAMPLE_READ
)
885 sample_read__printf(sample
, evsel
->attr
.read_format
);
888 static struct machine
*machines__find_for_cpumode(struct machines
*machines
,
889 union perf_event
*event
,
890 struct perf_sample
*sample
)
892 const u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
893 struct machine
*machine
;
896 ((cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
) ||
897 (cpumode
== PERF_RECORD_MISC_GUEST_USER
))) {
900 if (event
->header
.type
== PERF_RECORD_MMAP
901 || event
->header
.type
== PERF_RECORD_MMAP2
)
902 pid
= event
->mmap
.pid
;
906 machine
= machines__find(machines
, pid
);
908 machine
= machines__find(machines
, DEFAULT_GUEST_KERNEL_ID
);
912 return &machines
->host
;
915 static int deliver_sample_value(struct perf_evlist
*evlist
,
916 struct perf_tool
*tool
,
917 union perf_event
*event
,
918 struct perf_sample
*sample
,
919 struct sample_read_value
*v
,
920 struct machine
*machine
)
922 struct perf_sample_id
*sid
= perf_evlist__id2sid(evlist
, v
->id
);
926 sample
->period
= v
->value
- sid
->period
;
927 sid
->period
= v
->value
;
930 if (!sid
|| sid
->evsel
== NULL
) {
931 ++evlist
->stats
.nr_unknown_id
;
935 return tool
->sample(tool
, event
, sample
, sid
->evsel
, machine
);
938 static int deliver_sample_group(struct perf_evlist
*evlist
,
939 struct perf_tool
*tool
,
940 union perf_event
*event
,
941 struct perf_sample
*sample
,
942 struct machine
*machine
)
947 for (i
= 0; i
< sample
->read
.group
.nr
; i
++) {
948 ret
= deliver_sample_value(evlist
, tool
, event
, sample
,
949 &sample
->read
.group
.values
[i
],
959 perf_evlist__deliver_sample(struct perf_evlist
*evlist
,
960 struct perf_tool
*tool
,
961 union perf_event
*event
,
962 struct perf_sample
*sample
,
963 struct perf_evsel
*evsel
,
964 struct machine
*machine
)
966 /* We know evsel != NULL. */
967 u64 sample_type
= evsel
->attr
.sample_type
;
968 u64 read_format
= evsel
->attr
.read_format
;
970 /* Standard sample delievery. */
971 if (!(sample_type
& PERF_SAMPLE_READ
))
972 return tool
->sample(tool
, event
, sample
, evsel
, machine
);
974 /* For PERF_SAMPLE_READ we have either single or group mode. */
975 if (read_format
& PERF_FORMAT_GROUP
)
976 return deliver_sample_group(evlist
, tool
, event
, sample
,
979 return deliver_sample_value(evlist
, tool
, event
, sample
,
980 &sample
->read
.one
, machine
);
983 static int machines__deliver_event(struct machines
*machines
,
984 struct perf_evlist
*evlist
,
985 union perf_event
*event
,
986 struct perf_sample
*sample
,
987 struct perf_tool
*tool
, u64 file_offset
)
989 struct perf_evsel
*evsel
;
990 struct machine
*machine
;
992 dump_event(evlist
, event
, file_offset
, sample
);
994 evsel
= perf_evlist__id2evsel(evlist
, sample
->id
);
996 machine
= machines__find_for_cpumode(machines
, event
, sample
);
998 switch (event
->header
.type
) {
999 case PERF_RECORD_SAMPLE
:
1000 dump_sample(evsel
, event
, sample
);
1001 if (evsel
== NULL
) {
1002 ++evlist
->stats
.nr_unknown_id
;
1005 if (machine
== NULL
) {
1006 ++evlist
->stats
.nr_unprocessable_samples
;
1009 return perf_evlist__deliver_sample(evlist
, tool
, event
, sample
, evsel
, machine
);
1010 case PERF_RECORD_MMAP
:
1011 return tool
->mmap(tool
, event
, sample
, machine
);
1012 case PERF_RECORD_MMAP2
:
1013 return tool
->mmap2(tool
, event
, sample
, machine
);
1014 case PERF_RECORD_COMM
:
1015 return tool
->comm(tool
, event
, sample
, machine
);
1016 case PERF_RECORD_FORK
:
1017 return tool
->fork(tool
, event
, sample
, machine
);
1018 case PERF_RECORD_EXIT
:
1019 return tool
->exit(tool
, event
, sample
, machine
);
1020 case PERF_RECORD_LOST
:
1021 if (tool
->lost
== perf_event__process_lost
)
1022 evlist
->stats
.total_lost
+= event
->lost
.lost
;
1023 return tool
->lost(tool
, event
, sample
, machine
);
1024 case PERF_RECORD_READ
:
1025 return tool
->read(tool
, event
, sample
, evsel
, machine
);
1026 case PERF_RECORD_THROTTLE
:
1027 return tool
->throttle(tool
, event
, sample
, machine
);
1028 case PERF_RECORD_UNTHROTTLE
:
1029 return tool
->unthrottle(tool
, event
, sample
, machine
);
1031 ++evlist
->stats
.nr_unknown_events
;
1036 static int perf_session__deliver_event(struct perf_session
*session
,
1037 union perf_event
*event
,
1038 struct perf_sample
*sample
,
1039 struct perf_tool
*tool
,
1044 ret
= auxtrace__process_event(session
, event
, sample
, tool
);
1050 return machines__deliver_event(&session
->machines
, session
->evlist
,
1051 event
, sample
, tool
, file_offset
);
1054 static s64
perf_session__process_user_event(struct perf_session
*session
,
1055 union perf_event
*event
,
1058 struct ordered_events
*oe
= &session
->ordered_events
;
1059 struct perf_tool
*tool
= session
->tool
;
1060 int fd
= perf_data_file__fd(session
->file
);
1063 dump_event(session
->evlist
, event
, file_offset
, NULL
);
1065 /* These events are processed right away */
1066 switch (event
->header
.type
) {
1067 case PERF_RECORD_HEADER_ATTR
:
1068 err
= tool
->attr(tool
, event
, &session
->evlist
);
1070 perf_session__set_id_hdr_size(session
);
1071 perf_session__set_comm_exec(session
);
1074 case PERF_RECORD_HEADER_EVENT_TYPE
:
1076 * Depreceated, but we need to handle it for sake
1077 * of old data files create in pipe mode.
1080 case PERF_RECORD_HEADER_TRACING_DATA
:
1081 /* setup for reading amidst mmap */
1082 lseek(fd
, file_offset
, SEEK_SET
);
1083 return tool
->tracing_data(tool
, event
, session
);
1084 case PERF_RECORD_HEADER_BUILD_ID
:
1085 return tool
->build_id(tool
, event
, session
);
1086 case PERF_RECORD_FINISHED_ROUND
:
1087 return tool
->finished_round(tool
, event
, oe
);
1088 case PERF_RECORD_ID_INDEX
:
1089 return tool
->id_index(tool
, event
, session
);
1090 case PERF_RECORD_AUXTRACE_INFO
:
1091 return tool
->auxtrace_info(tool
, event
, session
);
1092 case PERF_RECORD_AUXTRACE
:
1093 /* setup for reading amidst mmap */
1094 lseek(fd
, file_offset
+ event
->header
.size
, SEEK_SET
);
1095 return tool
->auxtrace(tool
, event
, session
);
1096 case PERF_RECORD_AUXTRACE_ERROR
:
1097 perf_session__auxtrace_error_inc(session
, event
);
1098 return tool
->auxtrace_error(tool
, event
, session
);
1104 int perf_session__deliver_synth_event(struct perf_session
*session
,
1105 union perf_event
*event
,
1106 struct perf_sample
*sample
)
1108 struct perf_evlist
*evlist
= session
->evlist
;
1109 struct perf_tool
*tool
= session
->tool
;
1111 events_stats__inc(&evlist
->stats
, event
->header
.type
);
1113 if (event
->header
.type
>= PERF_RECORD_USER_TYPE_START
)
1114 return perf_session__process_user_event(session
, event
, 0);
1116 return machines__deliver_event(&session
->machines
, evlist
, event
, sample
, tool
, 0);
1119 static void event_swap(union perf_event
*event
, bool sample_id_all
)
1121 perf_event__swap_op swap
;
1123 swap
= perf_event__swap_ops
[event
->header
.type
];
1125 swap(event
, sample_id_all
);
1128 int perf_session__peek_event(struct perf_session
*session
, off_t file_offset
,
1129 void *buf
, size_t buf_sz
,
1130 union perf_event
**event_ptr
,
1131 struct perf_sample
*sample
)
1133 union perf_event
*event
;
1134 size_t hdr_sz
, rest
;
1137 if (session
->one_mmap
&& !session
->header
.needs_swap
) {
1138 event
= file_offset
- session
->one_mmap_offset
+
1139 session
->one_mmap_addr
;
1140 goto out_parse_sample
;
1143 if (perf_data_file__is_pipe(session
->file
))
1146 fd
= perf_data_file__fd(session
->file
);
1147 hdr_sz
= sizeof(struct perf_event_header
);
1149 if (buf_sz
< hdr_sz
)
1152 if (lseek(fd
, file_offset
, SEEK_SET
) == (off_t
)-1 ||
1153 readn(fd
, &buf
, hdr_sz
) != (ssize_t
)hdr_sz
)
1156 event
= (union perf_event
*)buf
;
1158 if (session
->header
.needs_swap
)
1159 perf_event_header__bswap(&event
->header
);
1161 if (event
->header
.size
< hdr_sz
)
1164 rest
= event
->header
.size
- hdr_sz
;
1166 if (readn(fd
, &buf
, rest
) != (ssize_t
)rest
)
1169 if (session
->header
.needs_swap
)
1170 event_swap(event
, perf_evlist__sample_id_all(session
->evlist
));
1174 if (sample
&& event
->header
.type
< PERF_RECORD_USER_TYPE_START
&&
1175 perf_evlist__parse_sample(session
->evlist
, event
, sample
))
1183 static s64
perf_session__process_event(struct perf_session
*session
,
1184 union perf_event
*event
, u64 file_offset
)
1186 struct perf_evlist
*evlist
= session
->evlist
;
1187 struct perf_tool
*tool
= session
->tool
;
1188 struct perf_sample sample
;
1191 if (session
->header
.needs_swap
)
1192 event_swap(event
, perf_evlist__sample_id_all(evlist
));
1194 if (event
->header
.type
>= PERF_RECORD_HEADER_MAX
)
1197 events_stats__inc(&evlist
->stats
, event
->header
.type
);
1199 if (event
->header
.type
>= PERF_RECORD_USER_TYPE_START
)
1200 return perf_session__process_user_event(session
, event
, file_offset
);
1203 * For all kernel events we get the sample data
1205 ret
= perf_evlist__parse_sample(evlist
, event
, &sample
);
1209 if (tool
->ordered_events
) {
1210 ret
= perf_session__queue_event(session
, event
, &sample
, file_offset
);
1215 return perf_session__deliver_event(session
, event
, &sample
, tool
,
1219 void perf_event_header__bswap(struct perf_event_header
*hdr
)
1221 hdr
->type
= bswap_32(hdr
->type
);
1222 hdr
->misc
= bswap_16(hdr
->misc
);
1223 hdr
->size
= bswap_16(hdr
->size
);
1226 struct thread
*perf_session__findnew(struct perf_session
*session
, pid_t pid
)
1228 return machine__findnew_thread(&session
->machines
.host
, -1, pid
);
1231 static struct thread
*perf_session__register_idle_thread(struct perf_session
*session
)
1233 struct thread
*thread
;
1235 thread
= machine__findnew_thread(&session
->machines
.host
, 0, 0);
1236 if (thread
== NULL
|| thread__set_comm(thread
, "swapper", 0)) {
1237 pr_err("problem inserting idle task.\n");
1244 static void perf_session__warn_about_errors(const struct perf_session
*session
)
1246 const struct events_stats
*stats
= &session
->evlist
->stats
;
1247 const struct ordered_events
*oe
= &session
->ordered_events
;
1249 if (session
->tool
->lost
== perf_event__process_lost
&&
1250 stats
->nr_events
[PERF_RECORD_LOST
] != 0) {
1251 ui__warning("Processed %d events and lost %d chunks!\n\n"
1252 "Check IO/CPU overload!\n\n",
1253 stats
->nr_events
[0],
1254 stats
->nr_events
[PERF_RECORD_LOST
]);
1257 if (stats
->nr_unknown_events
!= 0) {
1258 ui__warning("Found %u unknown events!\n\n"
1259 "Is this an older tool processing a perf.data "
1260 "file generated by a more recent tool?\n\n"
1261 "If that is not the case, consider "
1262 "reporting to linux-kernel@vger.kernel.org.\n\n",
1263 stats
->nr_unknown_events
);
1266 if (stats
->nr_unknown_id
!= 0) {
1267 ui__warning("%u samples with id not present in the header\n",
1268 stats
->nr_unknown_id
);
1271 if (stats
->nr_invalid_chains
!= 0) {
1272 ui__warning("Found invalid callchains!\n\n"
1273 "%u out of %u events were discarded for this reason.\n\n"
1274 "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
1275 stats
->nr_invalid_chains
,
1276 stats
->nr_events
[PERF_RECORD_SAMPLE
]);
1279 if (stats
->nr_unprocessable_samples
!= 0) {
1280 ui__warning("%u unprocessable samples recorded.\n"
1281 "Do you have a KVM guest running and not using 'perf kvm'?\n",
1282 stats
->nr_unprocessable_samples
);
1285 if (oe
->nr_unordered_events
!= 0)
1286 ui__warning("%u out of order events recorded.\n", oe
->nr_unordered_events
);
1288 events_stats__auxtrace_error_warn(stats
);
1291 volatile int session_done
;
1293 static int __perf_session__process_pipe_events(struct perf_session
*session
)
1295 struct ordered_events
*oe
= &session
->ordered_events
;
1296 struct perf_tool
*tool
= session
->tool
;
1297 int fd
= perf_data_file__fd(session
->file
);
1298 union perf_event
*event
;
1299 uint32_t size
, cur_size
= 0;
1306 perf_tool__fill_defaults(tool
);
1309 cur_size
= sizeof(union perf_event
);
1311 buf
= malloc(cur_size
);
1316 err
= readn(fd
, event
, sizeof(struct perf_event_header
));
1321 pr_err("failed to read event header\n");
1325 if (session
->header
.needs_swap
)
1326 perf_event_header__bswap(&event
->header
);
1328 size
= event
->header
.size
;
1329 if (size
< sizeof(struct perf_event_header
)) {
1330 pr_err("bad event header size\n");
1334 if (size
> cur_size
) {
1335 void *new = realloc(buf
, size
);
1337 pr_err("failed to allocate memory to read event\n");
1345 p
+= sizeof(struct perf_event_header
);
1347 if (size
- sizeof(struct perf_event_header
)) {
1348 err
= readn(fd
, p
, size
- sizeof(struct perf_event_header
));
1351 pr_err("unexpected end of event stream\n");
1355 pr_err("failed to read event data\n");
1360 if ((skip
= perf_session__process_event(session
, event
, head
)) < 0) {
1361 pr_err("%#" PRIx64
" [%#x]: failed to process type: %d\n",
1362 head
, event
->header
.size
, event
->header
.type
);
1372 if (!session_done())
1375 /* do the final flush for ordered samples */
1376 err
= ordered_events__flush(oe
, OE_FLUSH__FINAL
);
1379 err
= auxtrace__flush_events(session
, tool
);
1382 perf_session__warn_about_errors(session
);
1383 ordered_events__free(&session
->ordered_events
);
1384 auxtrace__free_events(session
);
1388 static union perf_event
*
1389 fetch_mmaped_event(struct perf_session
*session
,
1390 u64 head
, size_t mmap_size
, char *buf
)
1392 union perf_event
*event
;
1395 * Ensure we have enough space remaining to read
1396 * the size of the event in the headers.
1398 if (head
+ sizeof(event
->header
) > mmap_size
)
1401 event
= (union perf_event
*)(buf
+ head
);
1403 if (session
->header
.needs_swap
)
1404 perf_event_header__bswap(&event
->header
);
1406 if (head
+ event
->header
.size
> mmap_size
) {
1407 /* We're not fetching the event so swap back again */
1408 if (session
->header
.needs_swap
)
1409 perf_event_header__bswap(&event
->header
);
1417 * On 64bit we can mmap the data file in one go. No need for tiny mmap
1418 * slices. On 32bit we use 32MB.
1420 #if BITS_PER_LONG == 64
1421 #define MMAP_SIZE ULLONG_MAX
1424 #define MMAP_SIZE (32 * 1024 * 1024ULL)
1425 #define NUM_MMAPS 128
1428 static int __perf_session__process_events(struct perf_session
*session
,
1429 u64 data_offset
, u64 data_size
,
1432 struct ordered_events
*oe
= &session
->ordered_events
;
1433 struct perf_tool
*tool
= session
->tool
;
1434 int fd
= perf_data_file__fd(session
->file
);
1435 u64 head
, page_offset
, file_offset
, file_pos
, size
;
1436 int err
, mmap_prot
, mmap_flags
, map_idx
= 0;
1438 char *buf
, *mmaps
[NUM_MMAPS
];
1439 union perf_event
*event
;
1440 struct ui_progress prog
;
1443 perf_tool__fill_defaults(tool
);
1445 page_offset
= page_size
* (data_offset
/ page_size
);
1446 file_offset
= page_offset
;
1447 head
= data_offset
- page_offset
;
1449 if (data_size
&& (data_offset
+ data_size
< file_size
))
1450 file_size
= data_offset
+ data_size
;
1452 ui_progress__init(&prog
, file_size
, "Processing events...");
1454 mmap_size
= MMAP_SIZE
;
1455 if (mmap_size
> file_size
) {
1456 mmap_size
= file_size
;
1457 session
->one_mmap
= true;
1460 memset(mmaps
, 0, sizeof(mmaps
));
1462 mmap_prot
= PROT_READ
;
1463 mmap_flags
= MAP_SHARED
;
1465 if (session
->header
.needs_swap
) {
1466 mmap_prot
|= PROT_WRITE
;
1467 mmap_flags
= MAP_PRIVATE
;
1470 buf
= mmap(NULL
, mmap_size
, mmap_prot
, mmap_flags
, fd
,
1472 if (buf
== MAP_FAILED
) {
1473 pr_err("failed to mmap file\n");
1477 mmaps
[map_idx
] = buf
;
1478 map_idx
= (map_idx
+ 1) & (ARRAY_SIZE(mmaps
) - 1);
1479 file_pos
= file_offset
+ head
;
1480 if (session
->one_mmap
) {
1481 session
->one_mmap_addr
= buf
;
1482 session
->one_mmap_offset
= file_offset
;
1486 event
= fetch_mmaped_event(session
, head
, mmap_size
, buf
);
1488 if (mmaps
[map_idx
]) {
1489 munmap(mmaps
[map_idx
], mmap_size
);
1490 mmaps
[map_idx
] = NULL
;
1493 page_offset
= page_size
* (head
/ page_size
);
1494 file_offset
+= page_offset
;
1495 head
-= page_offset
;
1499 size
= event
->header
.size
;
1501 if (size
< sizeof(struct perf_event_header
) ||
1502 (skip
= perf_session__process_event(session
, event
, file_pos
)) < 0) {
1503 pr_err("%#" PRIx64
" [%#x]: failed to process type: %d\n",
1504 file_offset
+ head
, event
->header
.size
,
1505 event
->header
.type
);
1516 ui_progress__update(&prog
, size
);
1521 if (file_pos
< file_size
)
1525 /* do the final flush for ordered samples */
1526 err
= ordered_events__flush(oe
, OE_FLUSH__FINAL
);
1529 err
= auxtrace__flush_events(session
, tool
);
1531 ui_progress__finish();
1532 perf_session__warn_about_errors(session
);
1533 ordered_events__free(&session
->ordered_events
);
1534 auxtrace__free_events(session
);
1535 session
->one_mmap
= false;
1539 int perf_session__process_events(struct perf_session
*session
)
1541 u64 size
= perf_data_file__size(session
->file
);
1544 if (perf_session__register_idle_thread(session
) == NULL
)
1547 if (!perf_data_file__is_pipe(session
->file
))
1548 err
= __perf_session__process_events(session
,
1549 session
->header
.data_offset
,
1550 session
->header
.data_size
, size
);
1552 err
= __perf_session__process_pipe_events(session
);
1557 bool perf_session__has_traces(struct perf_session
*session
, const char *msg
)
1559 struct perf_evsel
*evsel
;
1561 evlist__for_each(session
->evlist
, evsel
) {
1562 if (evsel
->attr
.type
== PERF_TYPE_TRACEPOINT
)
1566 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg
);
1570 int maps__set_kallsyms_ref_reloc_sym(struct map
**maps
,
1571 const char *symbol_name
, u64 addr
)
1575 struct ref_reloc_sym
*ref
;
1577 ref
= zalloc(sizeof(struct ref_reloc_sym
));
1581 ref
->name
= strdup(symbol_name
);
1582 if (ref
->name
== NULL
) {
1587 bracket
= strchr(ref
->name
, ']');
1593 for (i
= 0; i
< MAP__NR_TYPES
; ++i
) {
1594 struct kmap
*kmap
= map__kmap(maps
[i
]);
1598 kmap
->ref_reloc_sym
= ref
;
1604 size_t perf_session__fprintf_dsos(struct perf_session
*session
, FILE *fp
)
1606 return machines__fprintf_dsos(&session
->machines
, fp
);
1609 size_t perf_session__fprintf_dsos_buildid(struct perf_session
*session
, FILE *fp
,
1610 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
1612 return machines__fprintf_dsos_buildid(&session
->machines
, fp
, skip
, parm
);
1615 size_t perf_session__fprintf_nr_events(struct perf_session
*session
, FILE *fp
)
1618 const char *msg
= "";
1620 if (perf_header__has_feat(&session
->header
, HEADER_AUXTRACE
))
1621 msg
= " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)";
1623 ret
= fprintf(fp
, "Aggregated stats:%s\n", msg
);
1625 ret
+= events_stats__fprintf(&session
->evlist
->stats
, fp
);
1629 size_t perf_session__fprintf(struct perf_session
*session
, FILE *fp
)
1632 * FIXME: Here we have to actually print all the machines in this
1633 * session, not just the host...
1635 return machine__fprintf(&session
->machines
.host
, fp
);
1638 struct perf_evsel
*perf_session__find_first_evtype(struct perf_session
*session
,
1641 struct perf_evsel
*pos
;
1643 evlist__for_each(session
->evlist
, pos
) {
1644 if (pos
->attr
.type
== type
)
1650 void perf_evsel__print_ip(struct perf_evsel
*evsel
, struct perf_sample
*sample
,
1651 struct addr_location
*al
,
1652 unsigned int print_opts
, unsigned int stack_depth
)
1654 struct callchain_cursor_node
*node
;
1655 int print_ip
= print_opts
& PRINT_IP_OPT_IP
;
1656 int print_sym
= print_opts
& PRINT_IP_OPT_SYM
;
1657 int print_dso
= print_opts
& PRINT_IP_OPT_DSO
;
1658 int print_symoffset
= print_opts
& PRINT_IP_OPT_SYMOFFSET
;
1659 int print_oneline
= print_opts
& PRINT_IP_OPT_ONELINE
;
1660 int print_srcline
= print_opts
& PRINT_IP_OPT_SRCLINE
;
1661 char s
= print_oneline
? ' ' : '\t';
1663 if (symbol_conf
.use_callchain
&& sample
->callchain
) {
1664 struct addr_location node_al
;
1666 if (thread__resolve_callchain(al
->thread
, evsel
,
1668 PERF_MAX_STACK_DEPTH
) != 0) {
1670 error("Failed to resolve callchain. Skipping\n");
1673 callchain_cursor_commit(&callchain_cursor
);
1675 if (print_symoffset
)
1678 while (stack_depth
) {
1681 node
= callchain_cursor_current(&callchain_cursor
);
1685 if (node
->sym
&& node
->sym
->ignore
)
1689 printf("%c%16" PRIx64
, s
, node
->ip
);
1692 addr
= node
->map
->map_ip(node
->map
, node
->ip
);
1696 if (print_symoffset
) {
1697 node_al
.addr
= addr
;
1698 node_al
.map
= node
->map
;
1699 symbol__fprintf_symname_offs(node
->sym
, &node_al
, stdout
);
1701 symbol__fprintf_symname(node
->sym
, stdout
);
1706 map__fprintf_dsoname(node
->map
, stdout
);
1711 map__fprintf_srcline(node
->map
, addr
, "\n ",
1719 callchain_cursor_advance(&callchain_cursor
);
1723 if (al
->sym
&& al
->sym
->ignore
)
1727 printf("%16" PRIx64
, sample
->ip
);
1731 if (print_symoffset
)
1732 symbol__fprintf_symname_offs(al
->sym
, al
,
1735 symbol__fprintf_symname(al
->sym
, stdout
);
1740 map__fprintf_dsoname(al
->map
, stdout
);
1745 map__fprintf_srcline(al
->map
, al
->addr
, "\n ", stdout
);
1749 int perf_session__cpu_bitmap(struct perf_session
*session
,
1750 const char *cpu_list
, unsigned long *cpu_bitmap
)
1753 struct cpu_map
*map
;
1755 for (i
= 0; i
< PERF_TYPE_MAX
; ++i
) {
1756 struct perf_evsel
*evsel
;
1758 evsel
= perf_session__find_first_evtype(session
, i
);
1762 if (!(evsel
->attr
.sample_type
& PERF_SAMPLE_CPU
)) {
1763 pr_err("File does not contain CPU events. "
1764 "Remove -c option to proceed.\n");
1769 map
= cpu_map__new(cpu_list
);
1771 pr_err("Invalid cpu_list\n");
1775 for (i
= 0; i
< map
->nr
; i
++) {
1776 int cpu
= map
->map
[i
];
1778 if (cpu
>= MAX_NR_CPUS
) {
1779 pr_err("Requested CPU %d too large. "
1780 "Consider raising MAX_NR_CPUS\n", cpu
);
1781 goto out_delete_map
;
1784 set_bit(cpu
, cpu_bitmap
);
1790 cpu_map__delete(map
);
1794 void perf_session__fprintf_info(struct perf_session
*session
, FILE *fp
,
1800 if (session
== NULL
|| fp
== NULL
)
1803 fd
= perf_data_file__fd(session
->file
);
1805 ret
= fstat(fd
, &st
);
1809 fprintf(fp
, "# ========\n");
1810 fprintf(fp
, "# captured on: %s", ctime(&st
.st_ctime
));
1811 perf_header__fprintf_info(session
, fp
, full
);
1812 fprintf(fp
, "# ========\n#\n");
1816 int __perf_session__set_tracepoints_handlers(struct perf_session
*session
,
1817 const struct perf_evsel_str_handler
*assocs
,
1820 struct perf_evsel
*evsel
;
1824 for (i
= 0; i
< nr_assocs
; i
++) {
1826 * Adding a handler for an event not in the session,
1829 evsel
= perf_evlist__find_tracepoint_by_name(session
->evlist
, assocs
[i
].name
);
1834 if (evsel
->handler
!= NULL
)
1836 evsel
->handler
= assocs
[i
].handler
;
1844 int perf_event__process_id_index(struct perf_tool
*tool __maybe_unused
,
1845 union perf_event
*event
,
1846 struct perf_session
*session
)
1848 struct perf_evlist
*evlist
= session
->evlist
;
1849 struct id_index_event
*ie
= &event
->id_index
;
1850 size_t i
, nr
, max_nr
;
1852 max_nr
= (ie
->header
.size
- sizeof(struct id_index_event
)) /
1853 sizeof(struct id_index_entry
);
1859 fprintf(stdout
, " nr: %zu\n", nr
);
1861 for (i
= 0; i
< nr
; i
++) {
1862 struct id_index_entry
*e
= &ie
->entries
[i
];
1863 struct perf_sample_id
*sid
;
1866 fprintf(stdout
, " ... id: %"PRIu64
, e
->id
);
1867 fprintf(stdout
, " idx: %"PRIu64
, e
->idx
);
1868 fprintf(stdout
, " cpu: %"PRId64
, e
->cpu
);
1869 fprintf(stdout
, " tid: %"PRId64
"\n", e
->tid
);
1872 sid
= perf_evlist__id2sid(evlist
, e
->id
);
1882 int perf_event__synthesize_id_index(struct perf_tool
*tool
,
1883 perf_event__handler_t process
,
1884 struct perf_evlist
*evlist
,
1885 struct machine
*machine
)
1887 union perf_event
*ev
;
1888 struct perf_evsel
*evsel
;
1889 size_t nr
= 0, i
= 0, sz
, max_nr
, n
;
1892 pr_debug2("Synthesizing id index\n");
1894 max_nr
= (UINT16_MAX
- sizeof(struct id_index_event
)) /
1895 sizeof(struct id_index_entry
);
1897 evlist__for_each(evlist
, evsel
)
1900 n
= nr
> max_nr
? max_nr
: nr
;
1901 sz
= sizeof(struct id_index_event
) + n
* sizeof(struct id_index_entry
);
1906 ev
->id_index
.header
.type
= PERF_RECORD_ID_INDEX
;
1907 ev
->id_index
.header
.size
= sz
;
1908 ev
->id_index
.nr
= n
;
1910 evlist__for_each(evlist
, evsel
) {
1913 for (j
= 0; j
< evsel
->ids
; j
++) {
1914 struct id_index_entry
*e
;
1915 struct perf_sample_id
*sid
;
1918 err
= process(tool
, ev
, NULL
, machine
);
1925 e
= &ev
->id_index
.entries
[i
++];
1927 e
->id
= evsel
->id
[j
];
1929 sid
= perf_evlist__id2sid(evlist
, e
->id
);
1941 sz
= sizeof(struct id_index_event
) + nr
* sizeof(struct id_index_entry
);
1942 ev
->id_index
.header
.size
= sz
;
1943 ev
->id_index
.nr
= nr
;
1945 err
= process(tool
, ev
, NULL
, machine
);