1 // SPDX-License-Identifier: GPL-2.0
18 #include <sys/types.h>
22 #include "linux/hash.h"
25 #include "sane_ctype.h"
26 #include <symbol/kallsyms.h>
28 static void __machine__remove_thread(struct machine
*machine
, struct thread
*th
, bool lock
);
30 static void dsos__init(struct dsos
*dsos
)
32 INIT_LIST_HEAD(&dsos
->head
);
34 init_rwsem(&dsos
->lock
);
37 static void machine__threads_init(struct machine
*machine
)
41 for (i
= 0; i
< THREADS__TABLE_SIZE
; i
++) {
42 struct threads
*threads
= &machine
->threads
[i
];
43 threads
->entries
= RB_ROOT
;
44 init_rwsem(&threads
->lock
);
46 INIT_LIST_HEAD(&threads
->dead
);
47 threads
->last_match
= NULL
;
51 int machine__init(struct machine
*machine
, const char *root_dir
, pid_t pid
)
53 memset(machine
, 0, sizeof(*machine
));
54 map_groups__init(&machine
->kmaps
, machine
);
55 RB_CLEAR_NODE(&machine
->rb_node
);
56 dsos__init(&machine
->dsos
);
58 machine__threads_init(machine
);
60 machine
->vdso_info
= NULL
;
65 machine
->id_hdr_size
= 0;
66 machine
->kptr_restrict_warned
= false;
67 machine
->comm_exec
= false;
68 machine
->kernel_start
= 0;
70 memset(machine
->vmlinux_maps
, 0, sizeof(machine
->vmlinux_maps
));
72 machine
->root_dir
= strdup(root_dir
);
73 if (machine
->root_dir
== NULL
)
76 if (pid
!= HOST_KERNEL_ID
) {
77 struct thread
*thread
= machine__findnew_thread(machine
, -1,
84 snprintf(comm
, sizeof(comm
), "[guest/%d]", pid
);
85 thread__set_comm(thread
, comm
, 0);
89 machine
->current_tid
= NULL
;
94 struct machine
*machine__new_host(void)
96 struct machine
*machine
= malloc(sizeof(*machine
));
98 if (machine
!= NULL
) {
99 machine__init(machine
, "", HOST_KERNEL_ID
);
101 if (machine__create_kernel_maps(machine
) < 0)
111 struct machine
*machine__new_kallsyms(void)
113 struct machine
*machine
= machine__new_host();
116 * 1) MAP__FUNCTION will go away when we stop loading separate maps for
117 * functions and data objects.
118 * 2) We should switch to machine__load_kallsyms(), i.e. not explicitely
119 * ask for not using the kcore parsing code, once this one is fixed
120 * to create a map per module.
122 if (machine
&& __machine__load_kallsyms(machine
, "/proc/kallsyms", MAP__FUNCTION
, true) <= 0) {
123 machine__delete(machine
);
130 static void dsos__purge(struct dsos
*dsos
)
134 down_write(&dsos
->lock
);
136 list_for_each_entry_safe(pos
, n
, &dsos
->head
, node
) {
137 RB_CLEAR_NODE(&pos
->rb_node
);
139 list_del_init(&pos
->node
);
143 up_write(&dsos
->lock
);
146 static void dsos__exit(struct dsos
*dsos
)
149 exit_rwsem(&dsos
->lock
);
152 void machine__delete_threads(struct machine
*machine
)
157 for (i
= 0; i
< THREADS__TABLE_SIZE
; i
++) {
158 struct threads
*threads
= &machine
->threads
[i
];
159 down_write(&threads
->lock
);
160 nd
= rb_first(&threads
->entries
);
162 struct thread
*t
= rb_entry(nd
, struct thread
, rb_node
);
165 __machine__remove_thread(machine
, t
, false);
167 up_write(&threads
->lock
);
171 void machine__exit(struct machine
*machine
)
178 machine__destroy_kernel_maps(machine
);
179 map_groups__exit(&machine
->kmaps
);
180 dsos__exit(&machine
->dsos
);
181 machine__exit_vdso(machine
);
182 zfree(&machine
->root_dir
);
183 zfree(&machine
->current_tid
);
185 for (i
= 0; i
< THREADS__TABLE_SIZE
; i
++) {
186 struct threads
*threads
= &machine
->threads
[i
];
187 exit_rwsem(&threads
->lock
);
191 void machine__delete(struct machine
*machine
)
194 machine__exit(machine
);
199 void machines__init(struct machines
*machines
)
201 machine__init(&machines
->host
, "", HOST_KERNEL_ID
);
202 machines
->guests
= RB_ROOT
;
205 void machines__exit(struct machines
*machines
)
207 machine__exit(&machines
->host
);
211 struct machine
*machines__add(struct machines
*machines
, pid_t pid
,
212 const char *root_dir
)
214 struct rb_node
**p
= &machines
->guests
.rb_node
;
215 struct rb_node
*parent
= NULL
;
216 struct machine
*pos
, *machine
= malloc(sizeof(*machine
));
221 if (machine__init(machine
, root_dir
, pid
) != 0) {
228 pos
= rb_entry(parent
, struct machine
, rb_node
);
235 rb_link_node(&machine
->rb_node
, parent
, p
);
236 rb_insert_color(&machine
->rb_node
, &machines
->guests
);
241 void machines__set_comm_exec(struct machines
*machines
, bool comm_exec
)
245 machines
->host
.comm_exec
= comm_exec
;
247 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
248 struct machine
*machine
= rb_entry(nd
, struct machine
, rb_node
);
250 machine
->comm_exec
= comm_exec
;
254 struct machine
*machines__find(struct machines
*machines
, pid_t pid
)
256 struct rb_node
**p
= &machines
->guests
.rb_node
;
257 struct rb_node
*parent
= NULL
;
258 struct machine
*machine
;
259 struct machine
*default_machine
= NULL
;
261 if (pid
== HOST_KERNEL_ID
)
262 return &machines
->host
;
266 machine
= rb_entry(parent
, struct machine
, rb_node
);
267 if (pid
< machine
->pid
)
269 else if (pid
> machine
->pid
)
274 default_machine
= machine
;
277 return default_machine
;
280 struct machine
*machines__findnew(struct machines
*machines
, pid_t pid
)
283 const char *root_dir
= "";
284 struct machine
*machine
= machines__find(machines
, pid
);
286 if (machine
&& (machine
->pid
== pid
))
289 if ((pid
!= HOST_KERNEL_ID
) &&
290 (pid
!= DEFAULT_GUEST_KERNEL_ID
) &&
291 (symbol_conf
.guestmount
)) {
292 sprintf(path
, "%s/%d", symbol_conf
.guestmount
, pid
);
293 if (access(path
, R_OK
)) {
294 static struct strlist
*seen
;
297 seen
= strlist__new(NULL
, NULL
);
299 if (!strlist__has_entry(seen
, path
)) {
300 pr_err("Can't access file %s\n", path
);
301 strlist__add(seen
, path
);
309 machine
= machines__add(machines
, pid
, root_dir
);
314 void machines__process_guests(struct machines
*machines
,
315 machine__process_t process
, void *data
)
319 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
320 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
325 char *machine__mmap_name(struct machine
*machine
, char *bf
, size_t size
)
327 if (machine__is_host(machine
))
328 snprintf(bf
, size
, "[%s]", "kernel.kallsyms");
329 else if (machine__is_default_guest(machine
))
330 snprintf(bf
, size
, "[%s]", "guest.kernel.kallsyms");
332 snprintf(bf
, size
, "[%s.%d]", "guest.kernel.kallsyms",
339 void machines__set_id_hdr_size(struct machines
*machines
, u16 id_hdr_size
)
341 struct rb_node
*node
;
342 struct machine
*machine
;
344 machines
->host
.id_hdr_size
= id_hdr_size
;
346 for (node
= rb_first(&machines
->guests
); node
; node
= rb_next(node
)) {
347 machine
= rb_entry(node
, struct machine
, rb_node
);
348 machine
->id_hdr_size
= id_hdr_size
;
354 static void machine__update_thread_pid(struct machine
*machine
,
355 struct thread
*th
, pid_t pid
)
357 struct thread
*leader
;
359 if (pid
== th
->pid_
|| pid
== -1 || th
->pid_
!= -1)
364 if (th
->pid_
== th
->tid
)
367 leader
= __machine__findnew_thread(machine
, th
->pid_
, th
->pid_
);
372 leader
->mg
= map_groups__new(machine
);
377 if (th
->mg
== leader
->mg
)
382 * Maps are created from MMAP events which provide the pid and
383 * tid. Consequently there never should be any maps on a thread
384 * with an unknown pid. Just print an error if there are.
386 if (!map_groups__empty(th
->mg
))
387 pr_err("Discarding thread maps for %d:%d\n",
389 map_groups__put(th
->mg
);
392 th
->mg
= map_groups__get(leader
->mg
);
397 pr_err("Failed to join map groups for %d:%d\n", th
->pid_
, th
->tid
);
402 * Caller must eventually drop thread->refcnt returned with a successful
403 * lookup/new thread inserted.
405 static struct thread
*____machine__findnew_thread(struct machine
*machine
,
406 struct threads
*threads
,
407 pid_t pid
, pid_t tid
,
410 struct rb_node
**p
= &threads
->entries
.rb_node
;
411 struct rb_node
*parent
= NULL
;
415 * Front-end cache - TID lookups come in blocks,
416 * so most of the time we dont have to look up
419 th
= threads
->last_match
;
421 if (th
->tid
== tid
) {
422 machine__update_thread_pid(machine
, th
, pid
);
423 return thread__get(th
);
426 threads
->last_match
= NULL
;
431 th
= rb_entry(parent
, struct thread
, rb_node
);
433 if (th
->tid
== tid
) {
434 threads
->last_match
= th
;
435 machine__update_thread_pid(machine
, th
, pid
);
436 return thread__get(th
);
448 th
= thread__new(pid
, tid
);
450 rb_link_node(&th
->rb_node
, parent
, p
);
451 rb_insert_color(&th
->rb_node
, &threads
->entries
);
454 * We have to initialize map_groups separately
455 * after rb tree is updated.
457 * The reason is that we call machine__findnew_thread
458 * within thread__init_map_groups to find the thread
459 * leader and that would screwed the rb tree.
461 if (thread__init_map_groups(th
, machine
)) {
462 rb_erase_init(&th
->rb_node
, &threads
->entries
);
463 RB_CLEAR_NODE(&th
->rb_node
);
468 * It is now in the rbtree, get a ref
471 threads
->last_match
= th
;
478 struct thread
*__machine__findnew_thread(struct machine
*machine
, pid_t pid
, pid_t tid
)
480 return ____machine__findnew_thread(machine
, machine__threads(machine
, tid
), pid
, tid
, true);
483 struct thread
*machine__findnew_thread(struct machine
*machine
, pid_t pid
,
486 struct threads
*threads
= machine__threads(machine
, tid
);
489 down_write(&threads
->lock
);
490 th
= __machine__findnew_thread(machine
, pid
, tid
);
491 up_write(&threads
->lock
);
495 struct thread
*machine__find_thread(struct machine
*machine
, pid_t pid
,
498 struct threads
*threads
= machine__threads(machine
, tid
);
501 down_read(&threads
->lock
);
502 th
= ____machine__findnew_thread(machine
, threads
, pid
, tid
, false);
503 up_read(&threads
->lock
);
507 struct comm
*machine__thread_exec_comm(struct machine
*machine
,
508 struct thread
*thread
)
510 if (machine
->comm_exec
)
511 return thread__exec_comm(thread
);
513 return thread__comm(thread
);
516 int machine__process_comm_event(struct machine
*machine
, union perf_event
*event
,
517 struct perf_sample
*sample
)
519 struct thread
*thread
= machine__findnew_thread(machine
,
522 bool exec
= event
->header
.misc
& PERF_RECORD_MISC_COMM_EXEC
;
526 machine
->comm_exec
= true;
529 perf_event__fprintf_comm(event
, stdout
);
531 if (thread
== NULL
||
532 __thread__set_comm(thread
, event
->comm
.comm
, sample
->time
, exec
)) {
533 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
542 int machine__process_namespaces_event(struct machine
*machine __maybe_unused
,
543 union perf_event
*event
,
544 struct perf_sample
*sample __maybe_unused
)
546 struct thread
*thread
= machine__findnew_thread(machine
,
547 event
->namespaces
.pid
,
548 event
->namespaces
.tid
);
551 WARN_ONCE(event
->namespaces
.nr_namespaces
> NR_NAMESPACES
,
552 "\nWARNING: kernel seems to support more namespaces than perf"
553 " tool.\nTry updating the perf tool..\n\n");
555 WARN_ONCE(event
->namespaces
.nr_namespaces
< NR_NAMESPACES
,
556 "\nWARNING: perf tool seems to support more namespaces than"
557 " the kernel.\nTry updating the kernel..\n\n");
560 perf_event__fprintf_namespaces(event
, stdout
);
562 if (thread
== NULL
||
563 thread__set_namespaces(thread
, sample
->time
, &event
->namespaces
)) {
564 dump_printf("problem processing PERF_RECORD_NAMESPACES, skipping event.\n");
573 int machine__process_lost_event(struct machine
*machine __maybe_unused
,
574 union perf_event
*event
, struct perf_sample
*sample __maybe_unused
)
576 dump_printf(": id:%" PRIu64
": lost:%" PRIu64
"\n",
577 event
->lost
.id
, event
->lost
.lost
);
581 int machine__process_lost_samples_event(struct machine
*machine __maybe_unused
,
582 union perf_event
*event
, struct perf_sample
*sample
)
584 dump_printf(": id:%" PRIu64
": lost samples :%" PRIu64
"\n",
585 sample
->id
, event
->lost_samples
.lost
);
589 static struct dso
*machine__findnew_module_dso(struct machine
*machine
,
591 const char *filename
)
595 down_write(&machine
->dsos
.lock
);
597 dso
= __dsos__find(&machine
->dsos
, m
->name
, true);
599 dso
= __dsos__addnew(&machine
->dsos
, m
->name
);
603 dso__set_module_info(dso
, m
, machine
);
604 dso__set_long_name(dso
, strdup(filename
), true);
609 up_write(&machine
->dsos
.lock
);
613 int machine__process_aux_event(struct machine
*machine __maybe_unused
,
614 union perf_event
*event
)
617 perf_event__fprintf_aux(event
, stdout
);
621 int machine__process_itrace_start_event(struct machine
*machine __maybe_unused
,
622 union perf_event
*event
)
625 perf_event__fprintf_itrace_start(event
, stdout
);
629 int machine__process_switch_event(struct machine
*machine __maybe_unused
,
630 union perf_event
*event
)
633 perf_event__fprintf_switch(event
, stdout
);
637 struct map
*machine__findnew_module_map(struct machine
*machine
, u64 start
,
638 const char *filename
)
640 struct map
*map
= NULL
;
641 struct dso
*dso
= NULL
;
644 if (kmod_path__parse_name(&m
, filename
))
647 map
= map_groups__find_by_name(&machine
->kmaps
, MAP__FUNCTION
,
652 dso
= machine__findnew_module_dso(machine
, &m
, filename
);
656 map
= map__new2(start
, dso
, MAP__FUNCTION
);
660 map_groups__insert(&machine
->kmaps
, map
);
662 /* Put the map here because map_groups__insert alread got it */
665 /* put the dso here, corresponding to machine__findnew_module_dso */
671 size_t machines__fprintf_dsos(struct machines
*machines
, FILE *fp
)
674 size_t ret
= __dsos__fprintf(&machines
->host
.dsos
.head
, fp
);
676 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
677 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
678 ret
+= __dsos__fprintf(&pos
->dsos
.head
, fp
);
684 size_t machine__fprintf_dsos_buildid(struct machine
*m
, FILE *fp
,
685 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
687 return __dsos__fprintf_buildid(&m
->dsos
.head
, fp
, skip
, parm
);
690 size_t machines__fprintf_dsos_buildid(struct machines
*machines
, FILE *fp
,
691 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
694 size_t ret
= machine__fprintf_dsos_buildid(&machines
->host
, fp
, skip
, parm
);
696 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
697 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
698 ret
+= machine__fprintf_dsos_buildid(pos
, fp
, skip
, parm
);
703 size_t machine__fprintf_vmlinux_path(struct machine
*machine
, FILE *fp
)
707 struct dso
*kdso
= machine__kernel_map(machine
)->dso
;
709 if (kdso
->has_build_id
) {
710 char filename
[PATH_MAX
];
711 if (dso__build_id_filename(kdso
, filename
, sizeof(filename
),
713 printed
+= fprintf(fp
, "[0] %s\n", filename
);
716 for (i
= 0; i
< vmlinux_path__nr_entries
; ++i
)
717 printed
+= fprintf(fp
, "[%d] %s\n",
718 i
+ kdso
->has_build_id
, vmlinux_path
[i
]);
723 size_t machine__fprintf(struct machine
*machine
, FILE *fp
)
729 for (i
= 0; i
< THREADS__TABLE_SIZE
; i
++) {
730 struct threads
*threads
= &machine
->threads
[i
];
732 down_read(&threads
->lock
);
734 ret
= fprintf(fp
, "Threads: %u\n", threads
->nr
);
736 for (nd
= rb_first(&threads
->entries
); nd
; nd
= rb_next(nd
)) {
737 struct thread
*pos
= rb_entry(nd
, struct thread
, rb_node
);
739 ret
+= thread__fprintf(pos
, fp
);
742 up_read(&threads
->lock
);
747 static struct dso
*machine__get_kernel(struct machine
*machine
)
749 const char *vmlinux_name
= NULL
;
752 if (machine__is_host(machine
)) {
753 vmlinux_name
= symbol_conf
.vmlinux_name
;
755 vmlinux_name
= DSO__NAME_KALLSYMS
;
757 kernel
= machine__findnew_kernel(machine
, vmlinux_name
,
758 "[kernel]", DSO_TYPE_KERNEL
);
762 if (machine__is_default_guest(machine
))
763 vmlinux_name
= symbol_conf
.default_guest_vmlinux_name
;
765 vmlinux_name
= machine__mmap_name(machine
, bf
,
768 kernel
= machine__findnew_kernel(machine
, vmlinux_name
,
770 DSO_TYPE_GUEST_KERNEL
);
773 if (kernel
!= NULL
&& (!kernel
->has_build_id
))
774 dso__read_running_kernel_build_id(kernel
, machine
);
779 struct process_args
{
783 static void machine__get_kallsyms_filename(struct machine
*machine
, char *buf
,
786 if (machine__is_default_guest(machine
))
787 scnprintf(buf
, bufsz
, "%s", symbol_conf
.default_guest_kallsyms
);
789 scnprintf(buf
, bufsz
, "%s/proc/kallsyms", machine
->root_dir
);
792 const char *ref_reloc_sym_names
[] = {"_text", "_stext", NULL
};
794 /* Figure out the start address of kernel map from /proc/kallsyms.
795 * Returns the name of the start symbol in *symbol_name. Pass in NULL as
796 * symbol_name if it's not that important.
798 static int machine__get_running_kernel_start(struct machine
*machine
,
799 const char **symbol_name
, u64
*start
)
801 char filename
[PATH_MAX
];
806 machine__get_kallsyms_filename(machine
, filename
, PATH_MAX
);
808 if (symbol__restricted_filename(filename
, "/proc/kallsyms"))
811 for (i
= 0; (name
= ref_reloc_sym_names
[i
]) != NULL
; i
++) {
812 err
= kallsyms__get_function_start(filename
, name
, &addr
);
827 /* Kernel-space maps for symbols that are outside the main kernel map and module maps */
828 struct extra_kernel_map
{
834 static int machine__create_extra_kernel_map(struct machine
*machine
,
836 struct extra_kernel_map
*xm
)
841 map
= map__new2(xm
->start
, kernel
, MAP__FUNCTION
);
846 map
->pgoff
= xm
->pgoff
;
848 kmap
= map__kmap(map
);
850 kmap
->kmaps
= &machine
->kmaps
;
852 map_groups__insert(&machine
->kmaps
, map
);
854 pr_debug2("Added extra kernel map %" PRIx64
"-%" PRIx64
"\n",
855 map
->start
, map
->end
);
862 static u64
find_entry_trampoline(struct dso
*dso
)
864 /* Duplicates are removed so lookup all aliases */
865 const char *syms
[] = {
867 "__entry_trampoline_start",
868 "entry_SYSCALL_64_trampoline",
870 struct symbol
*sym
= dso__first_symbol(dso
, MAP__FUNCTION
);
873 for (; sym
; sym
= dso__next_symbol(sym
)) {
874 if (sym
->binding
!= STB_GLOBAL
)
876 for (i
= 0; i
< ARRAY_SIZE(syms
); i
++) {
877 if (!strcmp(sym
->name
, syms
[i
]))
886 * These values can be used for kernels that do not have symbols for the entry
887 * trampolines in kallsyms.
889 #define X86_64_CPU_ENTRY_AREA_PER_CPU 0xfffffe0000000000ULL
890 #define X86_64_CPU_ENTRY_AREA_SIZE 0x2c000
891 #define X86_64_ENTRY_TRAMPOLINE 0x6000
893 /* Map x86_64 PTI entry trampolines */
894 int machine__map_x86_64_entry_trampolines(struct machine
*machine
,
897 u64 pgoff
= find_entry_trampoline(kernel
);
898 int nr_cpus_avail
, cpu
;
903 nr_cpus_avail
= machine__nr_cpus_avail(machine
);
905 /* Add a 1 page map for each CPU's entry trampoline */
906 for (cpu
= 0; cpu
< nr_cpus_avail
; cpu
++) {
907 u64 va
= X86_64_CPU_ENTRY_AREA_PER_CPU
+
908 cpu
* X86_64_CPU_ENTRY_AREA_SIZE
+
909 X86_64_ENTRY_TRAMPOLINE
;
910 struct extra_kernel_map xm
= {
912 .end
= va
+ page_size
,
916 if (machine__create_extra_kernel_map(machine
, kernel
, &xm
) < 0)
923 int __machine__create_kernel_maps(struct machine
*machine
, struct dso
*kernel
)
928 if (machine__get_running_kernel_start(machine
, NULL
, &start
))
931 /* In case of renewal the kernel map, destroy previous one */
932 machine__destroy_kernel_maps(machine
);
934 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
938 machine
->vmlinux_maps
[type
] = map__new2(start
, kernel
, type
);
939 if (machine
->vmlinux_maps
[type
] == NULL
)
942 machine
->vmlinux_maps
[type
]->map_ip
=
943 machine
->vmlinux_maps
[type
]->unmap_ip
=
945 map
= __machine__kernel_map(machine
, type
);
946 kmap
= map__kmap(map
);
950 kmap
->kmaps
= &machine
->kmaps
;
951 map_groups__insert(&machine
->kmaps
, map
);
957 void machine__destroy_kernel_maps(struct machine
*machine
)
961 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
963 struct map
*map
= __machine__kernel_map(machine
, type
);
968 kmap
= map__kmap(map
);
969 map_groups__remove(&machine
->kmaps
, map
);
970 if (kmap
&& kmap
->ref_reloc_sym
) {
972 * ref_reloc_sym is shared among all maps, so free just
975 if (type
== MAP__FUNCTION
) {
976 zfree((char **)&kmap
->ref_reloc_sym
->name
);
977 zfree(&kmap
->ref_reloc_sym
);
979 kmap
->ref_reloc_sym
= NULL
;
982 map__put(machine
->vmlinux_maps
[type
]);
983 machine
->vmlinux_maps
[type
] = NULL
;
987 int machines__create_guest_kernel_maps(struct machines
*machines
)
990 struct dirent
**namelist
= NULL
;
996 if (symbol_conf
.default_guest_vmlinux_name
||
997 symbol_conf
.default_guest_modules
||
998 symbol_conf
.default_guest_kallsyms
) {
999 machines__create_kernel_maps(machines
, DEFAULT_GUEST_KERNEL_ID
);
1002 if (symbol_conf
.guestmount
) {
1003 items
= scandir(symbol_conf
.guestmount
, &namelist
, NULL
, NULL
);
1006 for (i
= 0; i
< items
; i
++) {
1007 if (!isdigit(namelist
[i
]->d_name
[0])) {
1008 /* Filter out . and .. */
1011 pid
= (pid_t
)strtol(namelist
[i
]->d_name
, &endp
, 10);
1012 if ((*endp
!= '\0') ||
1013 (endp
== namelist
[i
]->d_name
) ||
1014 (errno
== ERANGE
)) {
1015 pr_debug("invalid directory (%s). Skipping.\n",
1016 namelist
[i
]->d_name
);
1019 sprintf(path
, "%s/%s/proc/kallsyms",
1020 symbol_conf
.guestmount
,
1021 namelist
[i
]->d_name
);
1022 ret
= access(path
, R_OK
);
1024 pr_debug("Can't access file %s\n", path
);
1027 machines__create_kernel_maps(machines
, pid
);
1036 void machines__destroy_kernel_maps(struct machines
*machines
)
1038 struct rb_node
*next
= rb_first(&machines
->guests
);
1040 machine__destroy_kernel_maps(&machines
->host
);
1043 struct machine
*pos
= rb_entry(next
, struct machine
, rb_node
);
1045 next
= rb_next(&pos
->rb_node
);
1046 rb_erase(&pos
->rb_node
, &machines
->guests
);
1047 machine__delete(pos
);
1051 int machines__create_kernel_maps(struct machines
*machines
, pid_t pid
)
1053 struct machine
*machine
= machines__findnew(machines
, pid
);
1055 if (machine
== NULL
)
1058 return machine__create_kernel_maps(machine
);
1061 int __machine__load_kallsyms(struct machine
*machine
, const char *filename
,
1062 enum map_type type
, bool no_kcore
)
1064 struct map
*map
= machine__kernel_map(machine
);
1065 int ret
= __dso__load_kallsyms(map
->dso
, filename
, map
, no_kcore
);
1068 dso__set_loaded(map
->dso
, type
);
1070 * Since /proc/kallsyms will have multiple sessions for the
1071 * kernel, with modules between them, fixup the end of all
1074 __map_groups__fixup_end(&machine
->kmaps
, type
);
1080 int machine__load_kallsyms(struct machine
*machine
, const char *filename
,
1083 return __machine__load_kallsyms(machine
, filename
, type
, false);
1086 int machine__load_vmlinux_path(struct machine
*machine
, enum map_type type
)
1088 struct map
*map
= machine__kernel_map(machine
);
1089 int ret
= dso__load_vmlinux_path(map
->dso
, map
);
1092 dso__set_loaded(map
->dso
, type
);
1097 static void map_groups__fixup_end(struct map_groups
*mg
)
1100 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
1101 __map_groups__fixup_end(mg
, i
);
1104 static char *get_kernel_version(const char *root_dir
)
1106 char version
[PATH_MAX
];
1109 const char *prefix
= "Linux version ";
1111 sprintf(version
, "%s/proc/version", root_dir
);
1112 file
= fopen(version
, "r");
1117 tmp
= fgets(version
, sizeof(version
), file
);
1120 name
= strstr(version
, prefix
);
1123 name
+= strlen(prefix
);
1124 tmp
= strchr(name
, ' ');
1128 return strdup(name
);
1131 static bool is_kmod_dso(struct dso
*dso
)
1133 return dso
->symtab_type
== DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE
||
1134 dso
->symtab_type
== DSO_BINARY_TYPE__GUEST_KMODULE
;
1137 static int map_groups__set_module_path(struct map_groups
*mg
, const char *path
,
1138 struct kmod_path
*m
)
1143 map
= map_groups__find_by_name(mg
, MAP__FUNCTION
, m
->name
);
1147 long_name
= strdup(path
);
1148 if (long_name
== NULL
)
1151 dso__set_long_name(map
->dso
, long_name
, true);
1152 dso__kernel_module_get_build_id(map
->dso
, "");
1155 * Full name could reveal us kmod compression, so
1156 * we need to update the symtab_type if needed.
1158 if (m
->comp
&& is_kmod_dso(map
->dso
))
1159 map
->dso
->symtab_type
++;
1164 static int map_groups__set_modules_path_dir(struct map_groups
*mg
,
1165 const char *dir_name
, int depth
)
1167 struct dirent
*dent
;
1168 DIR *dir
= opendir(dir_name
);
1172 pr_debug("%s: cannot open %s dir\n", __func__
, dir_name
);
1176 while ((dent
= readdir(dir
)) != NULL
) {
1177 char path
[PATH_MAX
];
1180 /*sshfs might return bad dent->d_type, so we have to stat*/
1181 snprintf(path
, sizeof(path
), "%s/%s", dir_name
, dent
->d_name
);
1182 if (stat(path
, &st
))
1185 if (S_ISDIR(st
.st_mode
)) {
1186 if (!strcmp(dent
->d_name
, ".") ||
1187 !strcmp(dent
->d_name
, ".."))
1190 /* Do not follow top-level source and build symlinks */
1192 if (!strcmp(dent
->d_name
, "source") ||
1193 !strcmp(dent
->d_name
, "build"))
1197 ret
= map_groups__set_modules_path_dir(mg
, path
,
1204 ret
= kmod_path__parse_name(&m
, dent
->d_name
);
1209 ret
= map_groups__set_module_path(mg
, path
, &m
);
1223 static int machine__set_modules_path(struct machine
*machine
)
1226 char modules_path
[PATH_MAX
];
1228 version
= get_kernel_version(machine
->root_dir
);
1232 snprintf(modules_path
, sizeof(modules_path
), "%s/lib/modules/%s",
1233 machine
->root_dir
, version
);
1236 return map_groups__set_modules_path_dir(&machine
->kmaps
, modules_path
, 0);
1238 int __weak
arch__fix_module_text_start(u64
*start __maybe_unused
,
1239 u64
*size __maybe_unused
,
1240 const char *name __maybe_unused
)
1245 static int machine__create_module(void *arg
, const char *name
, u64 start
,
1248 struct machine
*machine
= arg
;
1251 if (arch__fix_module_text_start(&start
, &size
, name
) < 0)
1254 map
= machine__findnew_module_map(machine
, start
, name
);
1257 map
->end
= start
+ size
;
1259 dso__kernel_module_get_build_id(map
->dso
, machine
->root_dir
);
1264 static int machine__create_modules(struct machine
*machine
)
1266 const char *modules
;
1267 char path
[PATH_MAX
];
1269 if (machine__is_default_guest(machine
)) {
1270 modules
= symbol_conf
.default_guest_modules
;
1272 snprintf(path
, PATH_MAX
, "%s/proc/modules", machine
->root_dir
);
1276 if (symbol__restricted_filename(modules
, "/proc/modules"))
1279 if (modules__parse(modules
, machine
, machine__create_module
))
1282 if (!machine__set_modules_path(machine
))
1285 pr_debug("Problems setting modules path maps, continuing anyway...\n");
1290 int machine__create_kernel_maps(struct machine
*machine
)
1292 struct dso
*kernel
= machine__get_kernel(machine
);
1293 const char *name
= NULL
;
1300 ret
= __machine__create_kernel_maps(machine
, kernel
);
1305 if (symbol_conf
.use_modules
&& machine__create_modules(machine
) < 0) {
1306 if (machine__is_host(machine
))
1307 pr_debug("Problems creating module maps, "
1308 "continuing anyway...\n");
1310 pr_debug("Problems creating module maps for guest %d, "
1311 "continuing anyway...\n", machine
->pid
);
1315 * Now that we have all the maps created, just set the ->end of them:
1317 map_groups__fixup_end(&machine
->kmaps
);
1319 if (!machine__get_running_kernel_start(machine
, &name
, &addr
)) {
1321 maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
, name
, addr
)) {
1322 machine__destroy_kernel_maps(machine
);
1330 static void machine__set_kernel_mmap_len(struct machine
*machine
,
1331 union perf_event
*event
)
1335 for (i
= 0; i
< MAP__NR_TYPES
; i
++) {
1336 machine
->vmlinux_maps
[i
]->start
= event
->mmap
.start
;
1337 machine
->vmlinux_maps
[i
]->end
= (event
->mmap
.start
+
1340 * Be a bit paranoid here, some perf.data file came with
1341 * a zero sized synthesized MMAP event for the kernel.
1343 if (machine
->vmlinux_maps
[i
]->end
== 0)
1344 machine
->vmlinux_maps
[i
]->end
= ~0ULL;
1348 static bool machine__uses_kcore(struct machine
*machine
)
1352 list_for_each_entry(dso
, &machine
->dsos
.head
, node
) {
1353 if (dso__is_kcore(dso
))
1360 static int machine__process_kernel_mmap_event(struct machine
*machine
,
1361 union perf_event
*event
)
1364 char kmmap_prefix
[PATH_MAX
];
1365 enum dso_kernel_type kernel_type
;
1366 bool is_kernel_mmap
;
1368 /* If we have maps from kcore then we do not need or want any others */
1369 if (machine__uses_kcore(machine
))
1372 machine__mmap_name(machine
, kmmap_prefix
, sizeof(kmmap_prefix
));
1373 if (machine__is_host(machine
))
1374 kernel_type
= DSO_TYPE_KERNEL
;
1376 kernel_type
= DSO_TYPE_GUEST_KERNEL
;
1378 is_kernel_mmap
= memcmp(event
->mmap
.filename
,
1380 strlen(kmmap_prefix
) - 1) == 0;
1381 if (event
->mmap
.filename
[0] == '/' ||
1382 (!is_kernel_mmap
&& event
->mmap
.filename
[0] == '[')) {
1383 map
= machine__findnew_module_map(machine
, event
->mmap
.start
,
1384 event
->mmap
.filename
);
1388 map
->end
= map
->start
+ event
->mmap
.len
;
1389 } else if (is_kernel_mmap
) {
1390 const char *symbol_name
= (event
->mmap
.filename
+
1391 strlen(kmmap_prefix
));
1393 * Should be there already, from the build-id table in
1396 struct dso
*kernel
= NULL
;
1399 down_read(&machine
->dsos
.lock
);
1401 list_for_each_entry(dso
, &machine
->dsos
.head
, node
) {
1404 * The cpumode passed to is_kernel_module is not the
1405 * cpumode of *this* event. If we insist on passing
1406 * correct cpumode to is_kernel_module, we should
1407 * record the cpumode when we adding this dso to the
1410 * However we don't really need passing correct
1411 * cpumode. We know the correct cpumode must be kernel
1412 * mode (if not, we should not link it onto kernel_dsos
1415 * Therefore, we pass PERF_RECORD_MISC_CPUMODE_UNKNOWN.
1416 * is_kernel_module() treats it as a kernel cpumode.
1420 is_kernel_module(dso
->long_name
,
1421 PERF_RECORD_MISC_CPUMODE_UNKNOWN
))
1429 up_read(&machine
->dsos
.lock
);
1432 kernel
= machine__findnew_dso(machine
, kmmap_prefix
);
1436 kernel
->kernel
= kernel_type
;
1437 if (__machine__create_kernel_maps(machine
, kernel
) < 0) {
1442 if (strstr(kernel
->long_name
, "vmlinux"))
1443 dso__set_short_name(kernel
, "[kernel.vmlinux]", false);
1445 machine__set_kernel_mmap_len(machine
, event
);
1448 * Avoid using a zero address (kptr_restrict) for the ref reloc
1449 * symbol. Effectively having zero here means that at record
1450 * time /proc/sys/kernel/kptr_restrict was non zero.
1452 if (event
->mmap
.pgoff
!= 0) {
1453 maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
,
1458 if (machine__is_default_guest(machine
)) {
1460 * preload dso of guest kernel and modules
1462 dso__load(kernel
, machine__kernel_map(machine
));
1470 int machine__process_mmap2_event(struct machine
*machine
,
1471 union perf_event
*event
,
1472 struct perf_sample
*sample
)
1474 struct thread
*thread
;
1480 perf_event__fprintf_mmap2(event
, stdout
);
1482 if (sample
->cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1483 sample
->cpumode
== PERF_RECORD_MISC_KERNEL
) {
1484 ret
= machine__process_kernel_mmap_event(machine
, event
);
1490 thread
= machine__findnew_thread(machine
, event
->mmap2
.pid
,
1495 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1496 type
= MAP__VARIABLE
;
1498 type
= MAP__FUNCTION
;
1500 map
= map__new(machine
, event
->mmap2
.start
,
1501 event
->mmap2
.len
, event
->mmap2
.pgoff
,
1503 event
->mmap2
.min
, event
->mmap2
.ino
,
1504 event
->mmap2
.ino_generation
,
1507 event
->mmap2
.filename
, type
, thread
);
1510 goto out_problem_map
;
1512 ret
= thread__insert_map(thread
, map
);
1514 goto out_problem_insert
;
1516 thread__put(thread
);
1523 thread__put(thread
);
1525 dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
1529 int machine__process_mmap_event(struct machine
*machine
, union perf_event
*event
,
1530 struct perf_sample
*sample
)
1532 struct thread
*thread
;
1538 perf_event__fprintf_mmap(event
, stdout
);
1540 if (sample
->cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1541 sample
->cpumode
== PERF_RECORD_MISC_KERNEL
) {
1542 ret
= machine__process_kernel_mmap_event(machine
, event
);
1548 thread
= machine__findnew_thread(machine
, event
->mmap
.pid
,
1553 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1554 type
= MAP__VARIABLE
;
1556 type
= MAP__FUNCTION
;
1558 map
= map__new(machine
, event
->mmap
.start
,
1559 event
->mmap
.len
, event
->mmap
.pgoff
,
1561 event
->mmap
.filename
,
1565 goto out_problem_map
;
1567 ret
= thread__insert_map(thread
, map
);
1569 goto out_problem_insert
;
1571 thread__put(thread
);
1578 thread__put(thread
);
1580 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
1584 static void __machine__remove_thread(struct machine
*machine
, struct thread
*th
, bool lock
)
1586 struct threads
*threads
= machine__threads(machine
, th
->tid
);
1588 if (threads
->last_match
== th
)
1589 threads
->last_match
= NULL
;
1591 BUG_ON(refcount_read(&th
->refcnt
) == 0);
1593 down_write(&threads
->lock
);
1594 rb_erase_init(&th
->rb_node
, &threads
->entries
);
1595 RB_CLEAR_NODE(&th
->rb_node
);
1598 * Move it first to the dead_threads list, then drop the reference,
1599 * if this is the last reference, then the thread__delete destructor
1600 * will be called and we will remove it from the dead_threads list.
1602 list_add_tail(&th
->node
, &threads
->dead
);
1604 up_write(&threads
->lock
);
1608 void machine__remove_thread(struct machine
*machine
, struct thread
*th
)
1610 return __machine__remove_thread(machine
, th
, true);
1613 int machine__process_fork_event(struct machine
*machine
, union perf_event
*event
,
1614 struct perf_sample
*sample
)
1616 struct thread
*thread
= machine__find_thread(machine
,
1619 struct thread
*parent
= machine__findnew_thread(machine
,
1625 perf_event__fprintf_task(event
, stdout
);
1628 * There may be an existing thread that is not actually the parent,
1629 * either because we are processing events out of order, or because the
1630 * (fork) event that would have removed the thread was lost. Assume the
1631 * latter case and continue on as best we can.
1633 if (parent
->pid_
!= (pid_t
)event
->fork
.ppid
) {
1634 dump_printf("removing erroneous parent thread %d/%d\n",
1635 parent
->pid_
, parent
->tid
);
1636 machine__remove_thread(machine
, parent
);
1637 thread__put(parent
);
1638 parent
= machine__findnew_thread(machine
, event
->fork
.ppid
,
1642 /* if a thread currently exists for the thread id remove it */
1643 if (thread
!= NULL
) {
1644 machine__remove_thread(machine
, thread
);
1645 thread__put(thread
);
1648 thread
= machine__findnew_thread(machine
, event
->fork
.pid
,
1651 if (thread
== NULL
|| parent
== NULL
||
1652 thread__fork(thread
, parent
, sample
->time
) < 0) {
1653 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
1656 thread__put(thread
);
1657 thread__put(parent
);
1662 int machine__process_exit_event(struct machine
*machine
, union perf_event
*event
,
1663 struct perf_sample
*sample __maybe_unused
)
1665 struct thread
*thread
= machine__find_thread(machine
,
1670 perf_event__fprintf_task(event
, stdout
);
1672 if (thread
!= NULL
) {
1673 thread__exited(thread
);
1674 thread__put(thread
);
1680 int machine__process_event(struct machine
*machine
, union perf_event
*event
,
1681 struct perf_sample
*sample
)
1685 switch (event
->header
.type
) {
1686 case PERF_RECORD_COMM
:
1687 ret
= machine__process_comm_event(machine
, event
, sample
); break;
1688 case PERF_RECORD_MMAP
:
1689 ret
= machine__process_mmap_event(machine
, event
, sample
); break;
1690 case PERF_RECORD_NAMESPACES
:
1691 ret
= machine__process_namespaces_event(machine
, event
, sample
); break;
1692 case PERF_RECORD_MMAP2
:
1693 ret
= machine__process_mmap2_event(machine
, event
, sample
); break;
1694 case PERF_RECORD_FORK
:
1695 ret
= machine__process_fork_event(machine
, event
, sample
); break;
1696 case PERF_RECORD_EXIT
:
1697 ret
= machine__process_exit_event(machine
, event
, sample
); break;
1698 case PERF_RECORD_LOST
:
1699 ret
= machine__process_lost_event(machine
, event
, sample
); break;
1700 case PERF_RECORD_AUX
:
1701 ret
= machine__process_aux_event(machine
, event
); break;
1702 case PERF_RECORD_ITRACE_START
:
1703 ret
= machine__process_itrace_start_event(machine
, event
); break;
1704 case PERF_RECORD_LOST_SAMPLES
:
1705 ret
= machine__process_lost_samples_event(machine
, event
, sample
); break;
1706 case PERF_RECORD_SWITCH
:
1707 case PERF_RECORD_SWITCH_CPU_WIDE
:
1708 ret
= machine__process_switch_event(machine
, event
); break;
1717 static bool symbol__match_regex(struct symbol
*sym
, regex_t
*regex
)
1719 if (!regexec(regex
, sym
->name
, 0, NULL
, 0))
1724 static void ip__resolve_ams(struct thread
*thread
,
1725 struct addr_map_symbol
*ams
,
1728 struct addr_location al
;
1730 memset(&al
, 0, sizeof(al
));
1732 * We cannot use the header.misc hint to determine whether a
1733 * branch stack address is user, kernel, guest, hypervisor.
1734 * Branches may straddle the kernel/user/hypervisor boundaries.
1735 * Thus, we have to try consecutively until we find a match
1736 * or else, the symbol is unknown
1738 thread__find_cpumode_addr_location(thread
, MAP__FUNCTION
, ip
, &al
);
1741 ams
->al_addr
= al
.addr
;
1747 static void ip__resolve_data(struct thread
*thread
,
1748 u8 m
, struct addr_map_symbol
*ams
,
1749 u64 addr
, u64 phys_addr
)
1751 struct addr_location al
;
1753 memset(&al
, 0, sizeof(al
));
1755 thread__find_addr_location(thread
, m
, MAP__VARIABLE
, addr
, &al
);
1756 if (al
.map
== NULL
) {
1758 * some shared data regions have execute bit set which puts
1759 * their mapping in the MAP__FUNCTION type array.
1760 * Check there as a fallback option before dropping the sample.
1762 thread__find_addr_location(thread
, m
, MAP__FUNCTION
, addr
, &al
);
1766 ams
->al_addr
= al
.addr
;
1769 ams
->phys_addr
= phys_addr
;
1772 struct mem_info
*sample__resolve_mem(struct perf_sample
*sample
,
1773 struct addr_location
*al
)
1775 struct mem_info
*mi
= zalloc(sizeof(*mi
));
1780 ip__resolve_ams(al
->thread
, &mi
->iaddr
, sample
->ip
);
1781 ip__resolve_data(al
->thread
, al
->cpumode
, &mi
->daddr
,
1782 sample
->addr
, sample
->phys_addr
);
1783 mi
->data_src
.val
= sample
->data_src
;
1788 static char *callchain_srcline(struct map
*map
, struct symbol
*sym
, u64 ip
)
1790 char *srcline
= NULL
;
1792 if (!map
|| callchain_param
.key
== CCKEY_FUNCTION
)
1795 srcline
= srcline__tree_find(&map
->dso
->srclines
, ip
);
1797 bool show_sym
= false;
1798 bool show_addr
= callchain_param
.key
== CCKEY_ADDRESS
;
1800 srcline
= get_srcline(map
->dso
, map__rip_2objdump(map
, ip
),
1801 sym
, show_sym
, show_addr
);
1802 srcline__tree_insert(&map
->dso
->srclines
, ip
, srcline
);
1813 static int add_callchain_ip(struct thread
*thread
,
1814 struct callchain_cursor
*cursor
,
1815 struct symbol
**parent
,
1816 struct addr_location
*root_al
,
1820 struct branch_flags
*flags
,
1821 struct iterations
*iter
,
1824 struct addr_location al
;
1825 int nr_loop_iter
= 0;
1826 u64 iter_cycles
= 0;
1827 const char *srcline
= NULL
;
1832 thread__find_cpumode_addr_location(thread
, MAP__FUNCTION
,
1835 if (ip
>= PERF_CONTEXT_MAX
) {
1837 case PERF_CONTEXT_HV
:
1838 *cpumode
= PERF_RECORD_MISC_HYPERVISOR
;
1840 case PERF_CONTEXT_KERNEL
:
1841 *cpumode
= PERF_RECORD_MISC_KERNEL
;
1843 case PERF_CONTEXT_USER
:
1844 *cpumode
= PERF_RECORD_MISC_USER
;
1847 pr_debug("invalid callchain context: "
1848 "%"PRId64
"\n", (s64
) ip
);
1850 * It seems the callchain is corrupted.
1853 callchain_cursor_reset(cursor
);
1858 thread__find_addr_location(thread
, *cpumode
, MAP__FUNCTION
,
1862 if (al
.sym
!= NULL
) {
1863 if (perf_hpp_list
.parent
&& !*parent
&&
1864 symbol__match_regex(al
.sym
, &parent_regex
))
1866 else if (have_ignore_callees
&& root_al
&&
1867 symbol__match_regex(al
.sym
, &ignore_callees_regex
)) {
1868 /* Treat this symbol as the root,
1869 forgetting its callees. */
1871 callchain_cursor_reset(cursor
);
1875 if (symbol_conf
.hide_unresolved
&& al
.sym
== NULL
)
1879 nr_loop_iter
= iter
->nr_loop_iter
;
1880 iter_cycles
= iter
->cycles
;
1883 srcline
= callchain_srcline(al
.map
, al
.sym
, al
.addr
);
1884 return callchain_cursor_append(cursor
, al
.addr
, al
.map
, al
.sym
,
1885 branch
, flags
, nr_loop_iter
,
1886 iter_cycles
, branch_from
, srcline
);
1889 struct branch_info
*sample__resolve_bstack(struct perf_sample
*sample
,
1890 struct addr_location
*al
)
1893 const struct branch_stack
*bs
= sample
->branch_stack
;
1894 struct branch_info
*bi
= calloc(bs
->nr
, sizeof(struct branch_info
));
1899 for (i
= 0; i
< bs
->nr
; i
++) {
1900 ip__resolve_ams(al
->thread
, &bi
[i
].to
, bs
->entries
[i
].to
);
1901 ip__resolve_ams(al
->thread
, &bi
[i
].from
, bs
->entries
[i
].from
);
1902 bi
[i
].flags
= bs
->entries
[i
].flags
;
1907 static void save_iterations(struct iterations
*iter
,
1908 struct branch_entry
*be
, int nr
)
1912 iter
->nr_loop_iter
++;
1915 for (i
= 0; i
< nr
; i
++)
1916 iter
->cycles
+= be
[i
].flags
.cycles
;
1921 #define NO_ENTRY 0xff
1923 #define PERF_MAX_BRANCH_DEPTH 127
1926 static int remove_loops(struct branch_entry
*l
, int nr
,
1927 struct iterations
*iter
)
1930 unsigned char chash
[CHASHSZ
];
1932 memset(chash
, NO_ENTRY
, sizeof(chash
));
1934 BUG_ON(PERF_MAX_BRANCH_DEPTH
> 255);
1936 for (i
= 0; i
< nr
; i
++) {
1937 int h
= hash_64(l
[i
].from
, CHASHBITS
) % CHASHSZ
;
1939 /* no collision handling for now */
1940 if (chash
[h
] == NO_ENTRY
) {
1942 } else if (l
[chash
[h
]].from
== l
[i
].from
) {
1943 bool is_loop
= true;
1944 /* check if it is a real loop */
1946 for (j
= chash
[h
]; j
< i
&& i
+ off
< nr
; j
++, off
++)
1947 if (l
[j
].from
!= l
[i
+ off
].from
) {
1954 save_iterations(iter
+ i
+ off
,
1957 memmove(iter
+ i
, iter
+ i
+ off
,
1960 memmove(l
+ i
, l
+ i
+ off
,
1972 * Recolve LBR callstack chain sample
1974 * 1 on success get LBR callchain information
1975 * 0 no available LBR callchain information, should try fp
1976 * negative error code on other errors.
1978 static int resolve_lbr_callchain_sample(struct thread
*thread
,
1979 struct callchain_cursor
*cursor
,
1980 struct perf_sample
*sample
,
1981 struct symbol
**parent
,
1982 struct addr_location
*root_al
,
1985 struct ip_callchain
*chain
= sample
->callchain
;
1986 int chain_nr
= min(max_stack
, (int)chain
->nr
), i
;
1987 u8 cpumode
= PERF_RECORD_MISC_USER
;
1988 u64 ip
, branch_from
= 0;
1990 for (i
= 0; i
< chain_nr
; i
++) {
1991 if (chain
->ips
[i
] == PERF_CONTEXT_USER
)
1995 /* LBR only affects the user callchain */
1996 if (i
!= chain_nr
) {
1997 struct branch_stack
*lbr_stack
= sample
->branch_stack
;
1998 int lbr_nr
= lbr_stack
->nr
, j
, k
;
2000 struct branch_flags
*flags
;
2002 * LBR callstack can only get user call chain.
2003 * The mix_chain_nr is kernel call chain
2004 * number plus LBR user call chain number.
2005 * i is kernel call chain number,
2006 * 1 is PERF_CONTEXT_USER,
2007 * lbr_nr + 1 is the user call chain number.
2008 * For details, please refer to the comments
2009 * in callchain__printf
2011 int mix_chain_nr
= i
+ 1 + lbr_nr
+ 1;
2013 for (j
= 0; j
< mix_chain_nr
; j
++) {
2018 if (callchain_param
.order
== ORDER_CALLEE
) {
2021 else if (j
> i
+ 1) {
2023 ip
= lbr_stack
->entries
[k
].from
;
2025 flags
= &lbr_stack
->entries
[k
].flags
;
2027 ip
= lbr_stack
->entries
[0].to
;
2029 flags
= &lbr_stack
->entries
[0].flags
;
2031 lbr_stack
->entries
[0].from
;
2036 ip
= lbr_stack
->entries
[k
].from
;
2038 flags
= &lbr_stack
->entries
[k
].flags
;
2040 else if (j
> lbr_nr
)
2041 ip
= chain
->ips
[i
+ 1 - (j
- lbr_nr
)];
2043 ip
= lbr_stack
->entries
[0].to
;
2045 flags
= &lbr_stack
->entries
[0].flags
;
2047 lbr_stack
->entries
[0].from
;
2051 err
= add_callchain_ip(thread
, cursor
, parent
,
2052 root_al
, &cpumode
, ip
,
2053 branch
, flags
, NULL
,
2056 return (err
< 0) ? err
: 0;
2064 static int thread__resolve_callchain_sample(struct thread
*thread
,
2065 struct callchain_cursor
*cursor
,
2066 struct perf_evsel
*evsel
,
2067 struct perf_sample
*sample
,
2068 struct symbol
**parent
,
2069 struct addr_location
*root_al
,
2072 struct branch_stack
*branch
= sample
->branch_stack
;
2073 struct ip_callchain
*chain
= sample
->callchain
;
2075 u8 cpumode
= PERF_RECORD_MISC_USER
;
2076 int i
, j
, err
, nr_entries
;
2081 chain_nr
= chain
->nr
;
2083 if (perf_evsel__has_branch_callstack(evsel
)) {
2084 err
= resolve_lbr_callchain_sample(thread
, cursor
, sample
, parent
,
2085 root_al
, max_stack
);
2087 return (err
< 0) ? err
: 0;
2091 * Based on DWARF debug information, some architectures skip
2092 * a callchain entry saved by the kernel.
2094 skip_idx
= arch_skip_callchain_idx(thread
, chain
);
2097 * Add branches to call stack for easier browsing. This gives
2098 * more context for a sample than just the callers.
2100 * This uses individual histograms of paths compared to the
2101 * aggregated histograms the normal LBR mode uses.
2103 * Limitations for now:
2104 * - No extra filters
2105 * - No annotations (should annotate somehow)
2108 if (branch
&& callchain_param
.branch_callstack
) {
2109 int nr
= min(max_stack
, (int)branch
->nr
);
2110 struct branch_entry be
[nr
];
2111 struct iterations iter
[nr
];
2113 if (branch
->nr
> PERF_MAX_BRANCH_DEPTH
) {
2114 pr_warning("corrupted branch chain. skipping...\n");
2118 for (i
= 0; i
< nr
; i
++) {
2119 if (callchain_param
.order
== ORDER_CALLEE
) {
2120 be
[i
] = branch
->entries
[i
];
2126 * Check for overlap into the callchain.
2127 * The return address is one off compared to
2128 * the branch entry. To adjust for this
2129 * assume the calling instruction is not longer
2132 if (i
== skip_idx
||
2133 chain
->ips
[first_call
] >= PERF_CONTEXT_MAX
)
2135 else if (be
[i
].from
< chain
->ips
[first_call
] &&
2136 be
[i
].from
>= chain
->ips
[first_call
] - 8)
2139 be
[i
] = branch
->entries
[branch
->nr
- i
- 1];
2142 memset(iter
, 0, sizeof(struct iterations
) * nr
);
2143 nr
= remove_loops(be
, nr
, iter
);
2145 for (i
= 0; i
< nr
; i
++) {
2146 err
= add_callchain_ip(thread
, cursor
, parent
,
2153 err
= add_callchain_ip(thread
, cursor
, parent
, root_al
,
2170 for (i
= first_call
, nr_entries
= 0;
2171 i
< chain_nr
&& nr_entries
< max_stack
; i
++) {
2174 if (callchain_param
.order
== ORDER_CALLEE
)
2177 j
= chain
->nr
- i
- 1;
2179 #ifdef HAVE_SKIP_CALLCHAIN_IDX
2185 if (ip
< PERF_CONTEXT_MAX
)
2188 err
= add_callchain_ip(thread
, cursor
, parent
,
2189 root_al
, &cpumode
, ip
,
2190 false, NULL
, NULL
, 0);
2193 return (err
< 0) ? err
: 0;
2199 static int append_inlines(struct callchain_cursor
*cursor
,
2200 struct map
*map
, struct symbol
*sym
, u64 ip
)
2202 struct inline_node
*inline_node
;
2203 struct inline_list
*ilist
;
2207 if (!symbol_conf
.inline_name
|| !map
|| !sym
)
2210 addr
= map__map_ip(map
, ip
);
2211 addr
= map__rip_2objdump(map
, addr
);
2213 inline_node
= inlines__tree_find(&map
->dso
->inlined_nodes
, addr
);
2215 inline_node
= dso__parse_addr_inlines(map
->dso
, addr
, sym
);
2218 inlines__tree_insert(&map
->dso
->inlined_nodes
, inline_node
);
2221 list_for_each_entry(ilist
, &inline_node
->val
, list
) {
2222 ret
= callchain_cursor_append(cursor
, ip
, map
,
2223 ilist
->symbol
, false,
2224 NULL
, 0, 0, 0, ilist
->srcline
);
2233 static int unwind_entry(struct unwind_entry
*entry
, void *arg
)
2235 struct callchain_cursor
*cursor
= arg
;
2236 const char *srcline
= NULL
;
2237 u64 addr
= entry
->ip
;
2239 if (symbol_conf
.hide_unresolved
&& entry
->sym
== NULL
)
2242 if (append_inlines(cursor
, entry
->map
, entry
->sym
, entry
->ip
) == 0)
2246 * Convert entry->ip from a virtual address to an offset in
2247 * its corresponding binary.
2250 addr
= map__map_ip(entry
->map
, entry
->ip
);
2252 srcline
= callchain_srcline(entry
->map
, entry
->sym
, addr
);
2253 return callchain_cursor_append(cursor
, entry
->ip
,
2254 entry
->map
, entry
->sym
,
2255 false, NULL
, 0, 0, 0, srcline
);
2258 static int thread__resolve_callchain_unwind(struct thread
*thread
,
2259 struct callchain_cursor
*cursor
,
2260 struct perf_evsel
*evsel
,
2261 struct perf_sample
*sample
,
2264 /* Can we do dwarf post unwind? */
2265 if (!((evsel
->attr
.sample_type
& PERF_SAMPLE_REGS_USER
) &&
2266 (evsel
->attr
.sample_type
& PERF_SAMPLE_STACK_USER
)))
2269 /* Bail out if nothing was captured. */
2270 if ((!sample
->user_regs
.regs
) ||
2271 (!sample
->user_stack
.size
))
2274 return unwind__get_entries(unwind_entry
, cursor
,
2275 thread
, sample
, max_stack
);
2278 int thread__resolve_callchain(struct thread
*thread
,
2279 struct callchain_cursor
*cursor
,
2280 struct perf_evsel
*evsel
,
2281 struct perf_sample
*sample
,
2282 struct symbol
**parent
,
2283 struct addr_location
*root_al
,
2288 callchain_cursor_reset(&callchain_cursor
);
2290 if (callchain_param
.order
== ORDER_CALLEE
) {
2291 ret
= thread__resolve_callchain_sample(thread
, cursor
,
2297 ret
= thread__resolve_callchain_unwind(thread
, cursor
,
2301 ret
= thread__resolve_callchain_unwind(thread
, cursor
,
2306 ret
= thread__resolve_callchain_sample(thread
, cursor
,
2315 int machine__for_each_thread(struct machine
*machine
,
2316 int (*fn
)(struct thread
*thread
, void *p
),
2319 struct threads
*threads
;
2321 struct thread
*thread
;
2325 for (i
= 0; i
< THREADS__TABLE_SIZE
; i
++) {
2326 threads
= &machine
->threads
[i
];
2327 for (nd
= rb_first(&threads
->entries
); nd
; nd
= rb_next(nd
)) {
2328 thread
= rb_entry(nd
, struct thread
, rb_node
);
2329 rc
= fn(thread
, priv
);
2334 list_for_each_entry(thread
, &threads
->dead
, node
) {
2335 rc
= fn(thread
, priv
);
2343 int machines__for_each_thread(struct machines
*machines
,
2344 int (*fn
)(struct thread
*thread
, void *p
),
2350 rc
= machine__for_each_thread(&machines
->host
, fn
, priv
);
2354 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
2355 struct machine
*machine
= rb_entry(nd
, struct machine
, rb_node
);
2357 rc
= machine__for_each_thread(machine
, fn
, priv
);
2364 int __machine__synthesize_threads(struct machine
*machine
, struct perf_tool
*tool
,
2365 struct target
*target
, struct thread_map
*threads
,
2366 perf_event__handler_t process
, bool data_mmap
,
2367 unsigned int proc_map_timeout
,
2368 unsigned int nr_threads_synthesize
)
2370 if (target__has_task(target
))
2371 return perf_event__synthesize_thread_map(tool
, threads
, process
, machine
, data_mmap
, proc_map_timeout
);
2372 else if (target__has_cpu(target
))
2373 return perf_event__synthesize_threads(tool
, process
,
2376 nr_threads_synthesize
);
2377 /* command specified */
2381 pid_t
machine__get_current_tid(struct machine
*machine
, int cpu
)
2383 if (cpu
< 0 || cpu
>= MAX_NR_CPUS
|| !machine
->current_tid
)
2386 return machine
->current_tid
[cpu
];
2389 int machine__set_current_tid(struct machine
*machine
, int cpu
, pid_t pid
,
2392 struct thread
*thread
;
2397 if (!machine
->current_tid
) {
2400 machine
->current_tid
= calloc(MAX_NR_CPUS
, sizeof(pid_t
));
2401 if (!machine
->current_tid
)
2403 for (i
= 0; i
< MAX_NR_CPUS
; i
++)
2404 machine
->current_tid
[i
] = -1;
2407 if (cpu
>= MAX_NR_CPUS
) {
2408 pr_err("Requested CPU %d too large. ", cpu
);
2409 pr_err("Consider raising MAX_NR_CPUS\n");
2413 machine
->current_tid
[cpu
] = tid
;
2415 thread
= machine__findnew_thread(machine
, pid
, tid
);
2420 thread__put(thread
);
2426 * Compares the raw arch string. N.B. see instead perf_env__arch() if a
2427 * normalized arch is needed.
2429 bool machine__is(struct machine
*machine
, const char *arch
)
2431 return machine
&& !strcmp(perf_env__raw_arch(machine
->env
), arch
);
2434 int machine__nr_cpus_avail(struct machine
*machine
)
2436 return machine
? perf_env__nr_cpus_avail(machine
->env
) : 0;
2439 int machine__get_kernel_start(struct machine
*machine
)
2441 struct map
*map
= machine__kernel_map(machine
);
2445 * The only addresses above 2^63 are kernel addresses of a 64-bit
2446 * kernel. Note that addresses are unsigned so that on a 32-bit system
2447 * all addresses including kernel addresses are less than 2^32. In
2448 * that case (32-bit system), if the kernel mapping is unknown, all
2449 * addresses will be assumed to be in user space - see
2450 * machine__kernel_ip().
2452 machine
->kernel_start
= 1ULL << 63;
2454 err
= map__load(map
);
2456 * On x86_64, PTI entry trampolines are less than the
2457 * start of kernel text, but still above 2^63. So leave
2458 * kernel_start = 1ULL << 63 for x86_64.
2460 if (!err
&& !machine__is(machine
, "x86_64"))
2461 machine
->kernel_start
= map
->start
;
2466 struct dso
*machine__findnew_dso(struct machine
*machine
, const char *filename
)
2468 return dsos__findnew(&machine
->dsos
, filename
);
2471 char *machine__resolve_kernel_addr(void *vmachine
, unsigned long long *addrp
, char **modp
)
2473 struct machine
*machine
= vmachine
;
2475 struct symbol
*sym
= map_groups__find_symbol(&machine
->kmaps
, MAP__FUNCTION
, *addrp
, &map
);
2480 *modp
= __map__is_kmodule(map
) ? (char *)map
->dso
->short_name
: NULL
;
2481 *addrp
= map
->unmap_ip(map
, sym
->start
);