13 #include <symbol/kallsyms.h>
15 #include "linux/hash.h"
17 static void dsos__init(struct dsos
*dsos
)
19 INIT_LIST_HEAD(&dsos
->head
);
23 int machine__init(struct machine
*machine
, const char *root_dir
, pid_t pid
)
25 map_groups__init(&machine
->kmaps
, machine
);
26 RB_CLEAR_NODE(&machine
->rb_node
);
27 dsos__init(&machine
->user_dsos
);
28 dsos__init(&machine
->kernel_dsos
);
30 machine
->threads
= RB_ROOT
;
31 INIT_LIST_HEAD(&machine
->dead_threads
);
32 machine
->last_match
= NULL
;
34 machine
->vdso_info
= NULL
;
38 machine
->symbol_filter
= NULL
;
39 machine
->id_hdr_size
= 0;
40 machine
->comm_exec
= false;
41 machine
->kernel_start
= 0;
43 machine
->root_dir
= strdup(root_dir
);
44 if (machine
->root_dir
== NULL
)
47 if (pid
!= HOST_KERNEL_ID
) {
48 struct thread
*thread
= machine__findnew_thread(machine
, -1,
55 snprintf(comm
, sizeof(comm
), "[guest/%d]", pid
);
56 thread__set_comm(thread
, comm
, 0);
59 machine
->current_tid
= NULL
;
64 struct machine
*machine__new_host(void)
66 struct machine
*machine
= malloc(sizeof(*machine
));
68 if (machine
!= NULL
) {
69 machine__init(machine
, "", HOST_KERNEL_ID
);
71 if (machine__create_kernel_maps(machine
) < 0)
81 static void dsos__delete(struct dsos
*dsos
)
85 list_for_each_entry_safe(pos
, n
, &dsos
->head
, node
) {
86 RB_CLEAR_NODE(&pos
->rb_node
);
92 void machine__delete_threads(struct machine
*machine
)
94 struct rb_node
*nd
= rb_first(&machine
->threads
);
97 struct thread
*t
= rb_entry(nd
, struct thread
, rb_node
);
100 machine__remove_thread(machine
, t
);
104 void machine__exit(struct machine
*machine
)
106 map_groups__exit(&machine
->kmaps
);
107 dsos__delete(&machine
->user_dsos
);
108 dsos__delete(&machine
->kernel_dsos
);
110 zfree(&machine
->root_dir
);
111 zfree(&machine
->current_tid
);
114 void machine__delete(struct machine
*machine
)
116 machine__exit(machine
);
120 void machines__init(struct machines
*machines
)
122 machine__init(&machines
->host
, "", HOST_KERNEL_ID
);
123 machines
->guests
= RB_ROOT
;
124 machines
->symbol_filter
= NULL
;
127 void machines__exit(struct machines
*machines
)
129 machine__exit(&machines
->host
);
133 struct machine
*machines__add(struct machines
*machines
, pid_t pid
,
134 const char *root_dir
)
136 struct rb_node
**p
= &machines
->guests
.rb_node
;
137 struct rb_node
*parent
= NULL
;
138 struct machine
*pos
, *machine
= malloc(sizeof(*machine
));
143 if (machine__init(machine
, root_dir
, pid
) != 0) {
148 machine
->symbol_filter
= machines
->symbol_filter
;
152 pos
= rb_entry(parent
, struct machine
, rb_node
);
159 rb_link_node(&machine
->rb_node
, parent
, p
);
160 rb_insert_color(&machine
->rb_node
, &machines
->guests
);
165 void machines__set_symbol_filter(struct machines
*machines
,
166 symbol_filter_t symbol_filter
)
170 machines
->symbol_filter
= symbol_filter
;
171 machines
->host
.symbol_filter
= symbol_filter
;
173 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
174 struct machine
*machine
= rb_entry(nd
, struct machine
, rb_node
);
176 machine
->symbol_filter
= symbol_filter
;
180 void machines__set_comm_exec(struct machines
*machines
, bool comm_exec
)
184 machines
->host
.comm_exec
= comm_exec
;
186 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
187 struct machine
*machine
= rb_entry(nd
, struct machine
, rb_node
);
189 machine
->comm_exec
= comm_exec
;
193 struct machine
*machines__find(struct machines
*machines
, pid_t pid
)
195 struct rb_node
**p
= &machines
->guests
.rb_node
;
196 struct rb_node
*parent
= NULL
;
197 struct machine
*machine
;
198 struct machine
*default_machine
= NULL
;
200 if (pid
== HOST_KERNEL_ID
)
201 return &machines
->host
;
205 machine
= rb_entry(parent
, struct machine
, rb_node
);
206 if (pid
< machine
->pid
)
208 else if (pid
> machine
->pid
)
213 default_machine
= machine
;
216 return default_machine
;
219 struct machine
*machines__findnew(struct machines
*machines
, pid_t pid
)
222 const char *root_dir
= "";
223 struct machine
*machine
= machines__find(machines
, pid
);
225 if (machine
&& (machine
->pid
== pid
))
228 if ((pid
!= HOST_KERNEL_ID
) &&
229 (pid
!= DEFAULT_GUEST_KERNEL_ID
) &&
230 (symbol_conf
.guestmount
)) {
231 sprintf(path
, "%s/%d", symbol_conf
.guestmount
, pid
);
232 if (access(path
, R_OK
)) {
233 static struct strlist
*seen
;
236 seen
= strlist__new(true, NULL
);
238 if (!strlist__has_entry(seen
, path
)) {
239 pr_err("Can't access file %s\n", path
);
240 strlist__add(seen
, path
);
248 machine
= machines__add(machines
, pid
, root_dir
);
253 void machines__process_guests(struct machines
*machines
,
254 machine__process_t process
, void *data
)
258 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
259 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
264 char *machine__mmap_name(struct machine
*machine
, char *bf
, size_t size
)
266 if (machine__is_host(machine
))
267 snprintf(bf
, size
, "[%s]", "kernel.kallsyms");
268 else if (machine__is_default_guest(machine
))
269 snprintf(bf
, size
, "[%s]", "guest.kernel.kallsyms");
271 snprintf(bf
, size
, "[%s.%d]", "guest.kernel.kallsyms",
278 void machines__set_id_hdr_size(struct machines
*machines
, u16 id_hdr_size
)
280 struct rb_node
*node
;
281 struct machine
*machine
;
283 machines
->host
.id_hdr_size
= id_hdr_size
;
285 for (node
= rb_first(&machines
->guests
); node
; node
= rb_next(node
)) {
286 machine
= rb_entry(node
, struct machine
, rb_node
);
287 machine
->id_hdr_size
= id_hdr_size
;
293 static void machine__update_thread_pid(struct machine
*machine
,
294 struct thread
*th
, pid_t pid
)
296 struct thread
*leader
;
298 if (pid
== th
->pid_
|| pid
== -1 || th
->pid_
!= -1)
303 if (th
->pid_
== th
->tid
)
306 leader
= machine__findnew_thread(machine
, th
->pid_
, th
->pid_
);
311 leader
->mg
= map_groups__new(machine
);
316 if (th
->mg
== leader
->mg
)
321 * Maps are created from MMAP events which provide the pid and
322 * tid. Consequently there never should be any maps on a thread
323 * with an unknown pid. Just print an error if there are.
325 if (!map_groups__empty(th
->mg
))
326 pr_err("Discarding thread maps for %d:%d\n",
328 map_groups__delete(th
->mg
);
331 th
->mg
= map_groups__get(leader
->mg
);
336 pr_err("Failed to join map groups for %d:%d\n", th
->pid_
, th
->tid
);
339 static struct thread
*__machine__findnew_thread(struct machine
*machine
,
340 pid_t pid
, pid_t tid
,
343 struct rb_node
**p
= &machine
->threads
.rb_node
;
344 struct rb_node
*parent
= NULL
;
348 * Front-end cache - TID lookups come in blocks,
349 * so most of the time we dont have to look up
352 th
= machine
->last_match
;
354 if (th
->tid
== tid
) {
355 machine__update_thread_pid(machine
, th
, pid
);
359 thread__zput(machine
->last_match
);
364 th
= rb_entry(parent
, struct thread
, rb_node
);
366 if (th
->tid
== tid
) {
367 machine
->last_match
= thread__get(th
);
368 machine__update_thread_pid(machine
, th
, pid
);
381 th
= thread__new(pid
, tid
);
383 rb_link_node(&th
->rb_node
, parent
, p
);
384 rb_insert_color(&th
->rb_node
, &machine
->threads
);
387 * We have to initialize map_groups separately
388 * after rb tree is updated.
390 * The reason is that we call machine__findnew_thread
391 * within thread__init_map_groups to find the thread
392 * leader and that would screwed the rb tree.
394 if (thread__init_map_groups(th
, machine
)) {
395 rb_erase(&th
->rb_node
, &machine
->threads
);
400 * It is now in the rbtree, get a ref
403 machine
->last_match
= thread__get(th
);
409 struct thread
*machine__findnew_thread(struct machine
*machine
, pid_t pid
,
412 return __machine__findnew_thread(machine
, pid
, tid
, true);
415 struct thread
*machine__find_thread(struct machine
*machine
, pid_t pid
,
418 return __machine__findnew_thread(machine
, pid
, tid
, false);
421 struct comm
*machine__thread_exec_comm(struct machine
*machine
,
422 struct thread
*thread
)
424 if (machine
->comm_exec
)
425 return thread__exec_comm(thread
);
427 return thread__comm(thread
);
430 int machine__process_comm_event(struct machine
*machine
, union perf_event
*event
,
431 struct perf_sample
*sample
)
433 struct thread
*thread
= machine__findnew_thread(machine
,
436 bool exec
= event
->header
.misc
& PERF_RECORD_MISC_COMM_EXEC
;
439 machine
->comm_exec
= true;
442 perf_event__fprintf_comm(event
, stdout
);
444 if (thread
== NULL
||
445 __thread__set_comm(thread
, event
->comm
.comm
, sample
->time
, exec
)) {
446 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
453 int machine__process_lost_event(struct machine
*machine __maybe_unused
,
454 union perf_event
*event
, struct perf_sample
*sample __maybe_unused
)
456 dump_printf(": id:%" PRIu64
": lost:%" PRIu64
"\n",
457 event
->lost
.id
, event
->lost
.lost
);
462 machine__module_dso(struct machine
*machine
, struct kmod_path
*m
,
463 const char *filename
)
467 dso
= dsos__find(&machine
->kernel_dsos
, m
->name
, true);
469 dso
= dsos__addnew(&machine
->kernel_dsos
, m
->name
);
473 if (machine__is_host(machine
))
474 dso
->symtab_type
= DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE
;
476 dso
->symtab_type
= DSO_BINARY_TYPE__GUEST_KMODULE
;
478 /* _KMODULE_COMP should be next to _KMODULE */
479 if (m
->kmod
&& m
->comp
)
482 dso__set_short_name(dso
, strdup(m
->name
), true);
483 dso__set_long_name(dso
, strdup(filename
), true);
489 struct map
*machine__new_module(struct machine
*machine
, u64 start
,
490 const char *filename
)
492 struct map
*map
= NULL
;
496 if (kmod_path__parse_name(&m
, filename
))
499 map
= map_groups__find_by_name(&machine
->kmaps
, MAP__FUNCTION
,
504 dso
= machine__module_dso(machine
, &m
, filename
);
508 map
= map__new2(start
, dso
, MAP__FUNCTION
);
512 map_groups__insert(&machine
->kmaps
, map
);
519 size_t machines__fprintf_dsos(struct machines
*machines
, FILE *fp
)
522 size_t ret
= __dsos__fprintf(&machines
->host
.kernel_dsos
.head
, fp
) +
523 __dsos__fprintf(&machines
->host
.user_dsos
.head
, fp
);
525 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
526 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
527 ret
+= __dsos__fprintf(&pos
->kernel_dsos
.head
, fp
);
528 ret
+= __dsos__fprintf(&pos
->user_dsos
.head
, fp
);
534 size_t machine__fprintf_dsos_buildid(struct machine
*m
, FILE *fp
,
535 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
537 return __dsos__fprintf_buildid(&m
->kernel_dsos
.head
, fp
, skip
, parm
) +
538 __dsos__fprintf_buildid(&m
->user_dsos
.head
, fp
, skip
, parm
);
541 size_t machines__fprintf_dsos_buildid(struct machines
*machines
, FILE *fp
,
542 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
545 size_t ret
= machine__fprintf_dsos_buildid(&machines
->host
, fp
, skip
, parm
);
547 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
548 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
549 ret
+= machine__fprintf_dsos_buildid(pos
, fp
, skip
, parm
);
554 size_t machine__fprintf_vmlinux_path(struct machine
*machine
, FILE *fp
)
558 struct dso
*kdso
= machine
->vmlinux_maps
[MAP__FUNCTION
]->dso
;
560 if (kdso
->has_build_id
) {
561 char filename
[PATH_MAX
];
562 if (dso__build_id_filename(kdso
, filename
, sizeof(filename
)))
563 printed
+= fprintf(fp
, "[0] %s\n", filename
);
566 for (i
= 0; i
< vmlinux_path__nr_entries
; ++i
)
567 printed
+= fprintf(fp
, "[%d] %s\n",
568 i
+ kdso
->has_build_id
, vmlinux_path
[i
]);
573 size_t machine__fprintf(struct machine
*machine
, FILE *fp
)
578 for (nd
= rb_first(&machine
->threads
); nd
; nd
= rb_next(nd
)) {
579 struct thread
*pos
= rb_entry(nd
, struct thread
, rb_node
);
581 ret
+= thread__fprintf(pos
, fp
);
587 static struct dso
*machine__get_kernel(struct machine
*machine
)
589 const char *vmlinux_name
= NULL
;
592 if (machine__is_host(machine
)) {
593 vmlinux_name
= symbol_conf
.vmlinux_name
;
595 vmlinux_name
= "[kernel.kallsyms]";
597 kernel
= dso__kernel_findnew(machine
, vmlinux_name
,
603 if (machine__is_default_guest(machine
))
604 vmlinux_name
= symbol_conf
.default_guest_vmlinux_name
;
606 vmlinux_name
= machine__mmap_name(machine
, bf
,
609 kernel
= dso__kernel_findnew(machine
, vmlinux_name
,
611 DSO_TYPE_GUEST_KERNEL
);
614 if (kernel
!= NULL
&& (!kernel
->has_build_id
))
615 dso__read_running_kernel_build_id(kernel
, machine
);
620 struct process_args
{
624 static void machine__get_kallsyms_filename(struct machine
*machine
, char *buf
,
627 if (machine__is_default_guest(machine
))
628 scnprintf(buf
, bufsz
, "%s", symbol_conf
.default_guest_kallsyms
);
630 scnprintf(buf
, bufsz
, "%s/proc/kallsyms", machine
->root_dir
);
633 const char *ref_reloc_sym_names
[] = {"_text", "_stext", NULL
};
635 /* Figure out the start address of kernel map from /proc/kallsyms.
636 * Returns the name of the start symbol in *symbol_name. Pass in NULL as
637 * symbol_name if it's not that important.
639 static u64
machine__get_running_kernel_start(struct machine
*machine
,
640 const char **symbol_name
)
642 char filename
[PATH_MAX
];
647 machine__get_kallsyms_filename(machine
, filename
, PATH_MAX
);
649 if (symbol__restricted_filename(filename
, "/proc/kallsyms"))
652 for (i
= 0; (name
= ref_reloc_sym_names
[i
]) != NULL
; i
++) {
653 addr
= kallsyms__get_function_start(filename
, name
);
664 int __machine__create_kernel_maps(struct machine
*machine
, struct dso
*kernel
)
667 u64 start
= machine__get_running_kernel_start(machine
, NULL
);
669 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
672 machine
->vmlinux_maps
[type
] = map__new2(start
, kernel
, type
);
673 if (machine
->vmlinux_maps
[type
] == NULL
)
676 machine
->vmlinux_maps
[type
]->map_ip
=
677 machine
->vmlinux_maps
[type
]->unmap_ip
=
679 kmap
= map__kmap(machine
->vmlinux_maps
[type
]);
683 kmap
->kmaps
= &machine
->kmaps
;
684 map_groups__insert(&machine
->kmaps
,
685 machine
->vmlinux_maps
[type
]);
691 void machine__destroy_kernel_maps(struct machine
*machine
)
695 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
698 if (machine
->vmlinux_maps
[type
] == NULL
)
701 kmap
= map__kmap(machine
->vmlinux_maps
[type
]);
702 map_groups__remove(&machine
->kmaps
,
703 machine
->vmlinux_maps
[type
]);
704 if (kmap
&& kmap
->ref_reloc_sym
) {
706 * ref_reloc_sym is shared among all maps, so free just
709 if (type
== MAP__FUNCTION
) {
710 zfree((char **)&kmap
->ref_reloc_sym
->name
);
711 zfree(&kmap
->ref_reloc_sym
);
713 kmap
->ref_reloc_sym
= NULL
;
716 map__delete(machine
->vmlinux_maps
[type
]);
717 machine
->vmlinux_maps
[type
] = NULL
;
721 int machines__create_guest_kernel_maps(struct machines
*machines
)
724 struct dirent
**namelist
= NULL
;
730 if (symbol_conf
.default_guest_vmlinux_name
||
731 symbol_conf
.default_guest_modules
||
732 symbol_conf
.default_guest_kallsyms
) {
733 machines__create_kernel_maps(machines
, DEFAULT_GUEST_KERNEL_ID
);
736 if (symbol_conf
.guestmount
) {
737 items
= scandir(symbol_conf
.guestmount
, &namelist
, NULL
, NULL
);
740 for (i
= 0; i
< items
; i
++) {
741 if (!isdigit(namelist
[i
]->d_name
[0])) {
742 /* Filter out . and .. */
745 pid
= (pid_t
)strtol(namelist
[i
]->d_name
, &endp
, 10);
746 if ((*endp
!= '\0') ||
747 (endp
== namelist
[i
]->d_name
) ||
749 pr_debug("invalid directory (%s). Skipping.\n",
750 namelist
[i
]->d_name
);
753 sprintf(path
, "%s/%s/proc/kallsyms",
754 symbol_conf
.guestmount
,
755 namelist
[i
]->d_name
);
756 ret
= access(path
, R_OK
);
758 pr_debug("Can't access file %s\n", path
);
761 machines__create_kernel_maps(machines
, pid
);
770 void machines__destroy_kernel_maps(struct machines
*machines
)
772 struct rb_node
*next
= rb_first(&machines
->guests
);
774 machine__destroy_kernel_maps(&machines
->host
);
777 struct machine
*pos
= rb_entry(next
, struct machine
, rb_node
);
779 next
= rb_next(&pos
->rb_node
);
780 rb_erase(&pos
->rb_node
, &machines
->guests
);
781 machine__delete(pos
);
785 int machines__create_kernel_maps(struct machines
*machines
, pid_t pid
)
787 struct machine
*machine
= machines__findnew(machines
, pid
);
792 return machine__create_kernel_maps(machine
);
795 int machine__load_kallsyms(struct machine
*machine
, const char *filename
,
796 enum map_type type
, symbol_filter_t filter
)
798 struct map
*map
= machine
->vmlinux_maps
[type
];
799 int ret
= dso__load_kallsyms(map
->dso
, filename
, map
, filter
);
802 dso__set_loaded(map
->dso
, type
);
804 * Since /proc/kallsyms will have multiple sessions for the
805 * kernel, with modules between them, fixup the end of all
808 __map_groups__fixup_end(&machine
->kmaps
, type
);
814 int machine__load_vmlinux_path(struct machine
*machine
, enum map_type type
,
815 symbol_filter_t filter
)
817 struct map
*map
= machine
->vmlinux_maps
[type
];
818 int ret
= dso__load_vmlinux_path(map
->dso
, map
, filter
);
821 dso__set_loaded(map
->dso
, type
);
826 static void map_groups__fixup_end(struct map_groups
*mg
)
829 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
830 __map_groups__fixup_end(mg
, i
);
833 static char *get_kernel_version(const char *root_dir
)
835 char version
[PATH_MAX
];
838 const char *prefix
= "Linux version ";
840 sprintf(version
, "%s/proc/version", root_dir
);
841 file
= fopen(version
, "r");
846 tmp
= fgets(version
, sizeof(version
), file
);
849 name
= strstr(version
, prefix
);
852 name
+= strlen(prefix
);
853 tmp
= strchr(name
, ' ');
860 static bool is_kmod_dso(struct dso
*dso
)
862 return dso
->symtab_type
== DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE
||
863 dso
->symtab_type
== DSO_BINARY_TYPE__GUEST_KMODULE
;
866 static int map_groups__set_module_path(struct map_groups
*mg
, const char *path
,
872 map
= map_groups__find_by_name(mg
, MAP__FUNCTION
, m
->name
);
876 long_name
= strdup(path
);
877 if (long_name
== NULL
)
880 dso__set_long_name(map
->dso
, long_name
, true);
881 dso__kernel_module_get_build_id(map
->dso
, "");
884 * Full name could reveal us kmod compression, so
885 * we need to update the symtab_type if needed.
887 if (m
->comp
&& is_kmod_dso(map
->dso
))
888 map
->dso
->symtab_type
++;
893 static int map_groups__set_modules_path_dir(struct map_groups
*mg
,
894 const char *dir_name
, int depth
)
897 DIR *dir
= opendir(dir_name
);
901 pr_debug("%s: cannot open %s dir\n", __func__
, dir_name
);
905 while ((dent
= readdir(dir
)) != NULL
) {
909 /*sshfs might return bad dent->d_type, so we have to stat*/
910 snprintf(path
, sizeof(path
), "%s/%s", dir_name
, dent
->d_name
);
914 if (S_ISDIR(st
.st_mode
)) {
915 if (!strcmp(dent
->d_name
, ".") ||
916 !strcmp(dent
->d_name
, ".."))
919 /* Do not follow top-level source and build symlinks */
921 if (!strcmp(dent
->d_name
, "source") ||
922 !strcmp(dent
->d_name
, "build"))
926 ret
= map_groups__set_modules_path_dir(mg
, path
,
933 ret
= kmod_path__parse_name(&m
, dent
->d_name
);
938 ret
= map_groups__set_module_path(mg
, path
, &m
);
952 static int machine__set_modules_path(struct machine
*machine
)
955 char modules_path
[PATH_MAX
];
957 version
= get_kernel_version(machine
->root_dir
);
961 snprintf(modules_path
, sizeof(modules_path
), "%s/lib/modules/%s",
962 machine
->root_dir
, version
);
965 return map_groups__set_modules_path_dir(&machine
->kmaps
, modules_path
, 0);
968 static int machine__create_module(void *arg
, const char *name
, u64 start
)
970 struct machine
*machine
= arg
;
973 map
= machine__new_module(machine
, start
, name
);
977 dso__kernel_module_get_build_id(map
->dso
, machine
->root_dir
);
982 static int machine__create_modules(struct machine
*machine
)
987 if (machine__is_default_guest(machine
)) {
988 modules
= symbol_conf
.default_guest_modules
;
990 snprintf(path
, PATH_MAX
, "%s/proc/modules", machine
->root_dir
);
994 if (symbol__restricted_filename(modules
, "/proc/modules"))
997 if (modules__parse(modules
, machine
, machine__create_module
))
1000 if (!machine__set_modules_path(machine
))
1003 pr_debug("Problems setting modules path maps, continuing anyway...\n");
1008 int machine__create_kernel_maps(struct machine
*machine
)
1010 struct dso
*kernel
= machine__get_kernel(machine
);
1012 u64 addr
= machine__get_running_kernel_start(machine
, &name
);
1016 if (kernel
== NULL
||
1017 __machine__create_kernel_maps(machine
, kernel
) < 0)
1020 if (symbol_conf
.use_modules
&& machine__create_modules(machine
) < 0) {
1021 if (machine__is_host(machine
))
1022 pr_debug("Problems creating module maps, "
1023 "continuing anyway...\n");
1025 pr_debug("Problems creating module maps for guest %d, "
1026 "continuing anyway...\n", machine
->pid
);
1030 * Now that we have all the maps created, just set the ->end of them:
1032 map_groups__fixup_end(&machine
->kmaps
);
1034 if (maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
, name
,
1036 machine__destroy_kernel_maps(machine
);
1043 static void machine__set_kernel_mmap_len(struct machine
*machine
,
1044 union perf_event
*event
)
1048 for (i
= 0; i
< MAP__NR_TYPES
; i
++) {
1049 machine
->vmlinux_maps
[i
]->start
= event
->mmap
.start
;
1050 machine
->vmlinux_maps
[i
]->end
= (event
->mmap
.start
+
1053 * Be a bit paranoid here, some perf.data file came with
1054 * a zero sized synthesized MMAP event for the kernel.
1056 if (machine
->vmlinux_maps
[i
]->end
== 0)
1057 machine
->vmlinux_maps
[i
]->end
= ~0ULL;
1061 static bool machine__uses_kcore(struct machine
*machine
)
1065 list_for_each_entry(dso
, &machine
->kernel_dsos
.head
, node
) {
1066 if (dso__is_kcore(dso
))
1073 static int machine__process_kernel_mmap_event(struct machine
*machine
,
1074 union perf_event
*event
)
1077 char kmmap_prefix
[PATH_MAX
];
1078 enum dso_kernel_type kernel_type
;
1079 bool is_kernel_mmap
;
1081 /* If we have maps from kcore then we do not need or want any others */
1082 if (machine__uses_kcore(machine
))
1085 machine__mmap_name(machine
, kmmap_prefix
, sizeof(kmmap_prefix
));
1086 if (machine__is_host(machine
))
1087 kernel_type
= DSO_TYPE_KERNEL
;
1089 kernel_type
= DSO_TYPE_GUEST_KERNEL
;
1091 is_kernel_mmap
= memcmp(event
->mmap
.filename
,
1093 strlen(kmmap_prefix
) - 1) == 0;
1094 if (event
->mmap
.filename
[0] == '/' ||
1095 (!is_kernel_mmap
&& event
->mmap
.filename
[0] == '[')) {
1096 map
= machine__new_module(machine
, event
->mmap
.start
,
1097 event
->mmap
.filename
);
1101 map
->end
= map
->start
+ event
->mmap
.len
;
1102 } else if (is_kernel_mmap
) {
1103 const char *symbol_name
= (event
->mmap
.filename
+
1104 strlen(kmmap_prefix
));
1106 * Should be there already, from the build-id table in
1109 struct dso
*kernel
= NULL
;
1112 list_for_each_entry(dso
, &machine
->kernel_dsos
.head
, node
) {
1113 if (is_kernel_module(dso
->long_name
))
1121 kernel
= __dsos__findnew(&machine
->kernel_dsos
,
1126 kernel
->kernel
= kernel_type
;
1127 if (__machine__create_kernel_maps(machine
, kernel
) < 0)
1130 if (strstr(kernel
->long_name
, "vmlinux"))
1131 dso__set_short_name(kernel
, "[kernel.vmlinux]", false);
1133 machine__set_kernel_mmap_len(machine
, event
);
1136 * Avoid using a zero address (kptr_restrict) for the ref reloc
1137 * symbol. Effectively having zero here means that at record
1138 * time /proc/sys/kernel/kptr_restrict was non zero.
1140 if (event
->mmap
.pgoff
!= 0) {
1141 maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
,
1146 if (machine__is_default_guest(machine
)) {
1148 * preload dso of guest kernel and modules
1150 dso__load(kernel
, machine
->vmlinux_maps
[MAP__FUNCTION
],
1159 int machine__process_mmap2_event(struct machine
*machine
,
1160 union perf_event
*event
,
1161 struct perf_sample
*sample __maybe_unused
)
1163 u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
1164 struct thread
*thread
;
1170 perf_event__fprintf_mmap2(event
, stdout
);
1172 if (cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1173 cpumode
== PERF_RECORD_MISC_KERNEL
) {
1174 ret
= machine__process_kernel_mmap_event(machine
, event
);
1180 thread
= machine__findnew_thread(machine
, event
->mmap2
.pid
,
1185 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1186 type
= MAP__VARIABLE
;
1188 type
= MAP__FUNCTION
;
1190 map
= map__new(machine
, event
->mmap2
.start
,
1191 event
->mmap2
.len
, event
->mmap2
.pgoff
,
1192 event
->mmap2
.pid
, event
->mmap2
.maj
,
1193 event
->mmap2
.min
, event
->mmap2
.ino
,
1194 event
->mmap2
.ino_generation
,
1197 event
->mmap2
.filename
, type
, thread
);
1202 thread__insert_map(thread
, map
);
1206 dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
1210 int machine__process_mmap_event(struct machine
*machine
, union perf_event
*event
,
1211 struct perf_sample
*sample __maybe_unused
)
1213 u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
1214 struct thread
*thread
;
1220 perf_event__fprintf_mmap(event
, stdout
);
1222 if (cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1223 cpumode
== PERF_RECORD_MISC_KERNEL
) {
1224 ret
= machine__process_kernel_mmap_event(machine
, event
);
1230 thread
= machine__findnew_thread(machine
, event
->mmap
.pid
,
1235 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1236 type
= MAP__VARIABLE
;
1238 type
= MAP__FUNCTION
;
1240 map
= map__new(machine
, event
->mmap
.start
,
1241 event
->mmap
.len
, event
->mmap
.pgoff
,
1242 event
->mmap
.pid
, 0, 0, 0, 0, 0, 0,
1243 event
->mmap
.filename
,
1249 thread__insert_map(thread
, map
);
1253 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
1257 void machine__remove_thread(struct machine
*machine
, struct thread
*th
)
1259 if (machine
->last_match
== th
)
1260 thread__zput(machine
->last_match
);
1262 rb_erase(&th
->rb_node
, &machine
->threads
);
1264 * Move it first to the dead_threads list, then drop the reference,
1265 * if this is the last reference, then the thread__delete destructor
1266 * will be called and we will remove it from the dead_threads list.
1268 list_add_tail(&th
->node
, &machine
->dead_threads
);
1272 int machine__process_fork_event(struct machine
*machine
, union perf_event
*event
,
1273 struct perf_sample
*sample
)
1275 struct thread
*thread
= machine__find_thread(machine
,
1278 struct thread
*parent
= machine__findnew_thread(machine
,
1282 /* if a thread currently exists for the thread id remove it */
1284 machine__remove_thread(machine
, thread
);
1286 thread
= machine__findnew_thread(machine
, event
->fork
.pid
,
1289 perf_event__fprintf_task(event
, stdout
);
1291 if (thread
== NULL
|| parent
== NULL
||
1292 thread__fork(thread
, parent
, sample
->time
) < 0) {
1293 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
1300 int machine__process_exit_event(struct machine
*machine
, union perf_event
*event
,
1301 struct perf_sample
*sample __maybe_unused
)
1303 struct thread
*thread
= machine__find_thread(machine
,
1308 perf_event__fprintf_task(event
, stdout
);
1311 thread__exited(thread
);
1316 int machine__process_event(struct machine
*machine
, union perf_event
*event
,
1317 struct perf_sample
*sample
)
1321 switch (event
->header
.type
) {
1322 case PERF_RECORD_COMM
:
1323 ret
= machine__process_comm_event(machine
, event
, sample
); break;
1324 case PERF_RECORD_MMAP
:
1325 ret
= machine__process_mmap_event(machine
, event
, sample
); break;
1326 case PERF_RECORD_MMAP2
:
1327 ret
= machine__process_mmap2_event(machine
, event
, sample
); break;
1328 case PERF_RECORD_FORK
:
1329 ret
= machine__process_fork_event(machine
, event
, sample
); break;
1330 case PERF_RECORD_EXIT
:
1331 ret
= machine__process_exit_event(machine
, event
, sample
); break;
1332 case PERF_RECORD_LOST
:
1333 ret
= machine__process_lost_event(machine
, event
, sample
); break;
1342 static bool symbol__match_regex(struct symbol
*sym
, regex_t
*regex
)
1344 if (sym
->name
&& !regexec(regex
, sym
->name
, 0, NULL
, 0))
1349 static void ip__resolve_ams(struct thread
*thread
,
1350 struct addr_map_symbol
*ams
,
1353 struct addr_location al
;
1355 memset(&al
, 0, sizeof(al
));
1357 * We cannot use the header.misc hint to determine whether a
1358 * branch stack address is user, kernel, guest, hypervisor.
1359 * Branches may straddle the kernel/user/hypervisor boundaries.
1360 * Thus, we have to try consecutively until we find a match
1361 * or else, the symbol is unknown
1363 thread__find_cpumode_addr_location(thread
, MAP__FUNCTION
, ip
, &al
);
1366 ams
->al_addr
= al
.addr
;
1371 static void ip__resolve_data(struct thread
*thread
,
1372 u8 m
, struct addr_map_symbol
*ams
, u64 addr
)
1374 struct addr_location al
;
1376 memset(&al
, 0, sizeof(al
));
1378 thread__find_addr_location(thread
, m
, MAP__VARIABLE
, addr
, &al
);
1379 if (al
.map
== NULL
) {
1381 * some shared data regions have execute bit set which puts
1382 * their mapping in the MAP__FUNCTION type array.
1383 * Check there as a fallback option before dropping the sample.
1385 thread__find_addr_location(thread
, m
, MAP__FUNCTION
, addr
, &al
);
1389 ams
->al_addr
= al
.addr
;
1394 struct mem_info
*sample__resolve_mem(struct perf_sample
*sample
,
1395 struct addr_location
*al
)
1397 struct mem_info
*mi
= zalloc(sizeof(*mi
));
1402 ip__resolve_ams(al
->thread
, &mi
->iaddr
, sample
->ip
);
1403 ip__resolve_data(al
->thread
, al
->cpumode
, &mi
->daddr
, sample
->addr
);
1404 mi
->data_src
.val
= sample
->data_src
;
1409 static int add_callchain_ip(struct thread
*thread
,
1410 struct symbol
**parent
,
1411 struct addr_location
*root_al
,
1415 struct addr_location al
;
1420 thread__find_cpumode_addr_location(thread
, MAP__FUNCTION
,
1423 if (ip
>= PERF_CONTEXT_MAX
) {
1425 case PERF_CONTEXT_HV
:
1426 *cpumode
= PERF_RECORD_MISC_HYPERVISOR
;
1428 case PERF_CONTEXT_KERNEL
:
1429 *cpumode
= PERF_RECORD_MISC_KERNEL
;
1431 case PERF_CONTEXT_USER
:
1432 *cpumode
= PERF_RECORD_MISC_USER
;
1435 pr_debug("invalid callchain context: "
1436 "%"PRId64
"\n", (s64
) ip
);
1438 * It seems the callchain is corrupted.
1441 callchain_cursor_reset(&callchain_cursor
);
1446 thread__find_addr_location(thread
, *cpumode
, MAP__FUNCTION
,
1450 if (al
.sym
!= NULL
) {
1451 if (sort__has_parent
&& !*parent
&&
1452 symbol__match_regex(al
.sym
, &parent_regex
))
1454 else if (have_ignore_callees
&& root_al
&&
1455 symbol__match_regex(al
.sym
, &ignore_callees_regex
)) {
1456 /* Treat this symbol as the root,
1457 forgetting its callees. */
1459 callchain_cursor_reset(&callchain_cursor
);
1463 return callchain_cursor_append(&callchain_cursor
, al
.addr
, al
.map
, al
.sym
);
1466 struct branch_info
*sample__resolve_bstack(struct perf_sample
*sample
,
1467 struct addr_location
*al
)
1470 const struct branch_stack
*bs
= sample
->branch_stack
;
1471 struct branch_info
*bi
= calloc(bs
->nr
, sizeof(struct branch_info
));
1476 for (i
= 0; i
< bs
->nr
; i
++) {
1477 ip__resolve_ams(al
->thread
, &bi
[i
].to
, bs
->entries
[i
].to
);
1478 ip__resolve_ams(al
->thread
, &bi
[i
].from
, bs
->entries
[i
].from
);
1479 bi
[i
].flags
= bs
->entries
[i
].flags
;
1486 #define NO_ENTRY 0xff
1488 #define PERF_MAX_BRANCH_DEPTH 127
1491 static int remove_loops(struct branch_entry
*l
, int nr
)
1494 unsigned char chash
[CHASHSZ
];
1496 memset(chash
, NO_ENTRY
, sizeof(chash
));
1498 BUG_ON(PERF_MAX_BRANCH_DEPTH
> 255);
1500 for (i
= 0; i
< nr
; i
++) {
1501 int h
= hash_64(l
[i
].from
, CHASHBITS
) % CHASHSZ
;
1503 /* no collision handling for now */
1504 if (chash
[h
] == NO_ENTRY
) {
1506 } else if (l
[chash
[h
]].from
== l
[i
].from
) {
1507 bool is_loop
= true;
1508 /* check if it is a real loop */
1510 for (j
= chash
[h
]; j
< i
&& i
+ off
< nr
; j
++, off
++)
1511 if (l
[j
].from
!= l
[i
+ off
].from
) {
1516 memmove(l
+ i
, l
+ i
+ off
,
1517 (nr
- (i
+ off
)) * sizeof(*l
));
1526 * Recolve LBR callstack chain sample
1528 * 1 on success get LBR callchain information
1529 * 0 no available LBR callchain information, should try fp
1530 * negative error code on other errors.
1532 static int resolve_lbr_callchain_sample(struct thread
*thread
,
1533 struct perf_sample
*sample
,
1534 struct symbol
**parent
,
1535 struct addr_location
*root_al
,
1538 struct ip_callchain
*chain
= sample
->callchain
;
1539 int chain_nr
= min(max_stack
, (int)chain
->nr
);
1540 u8 cpumode
= PERF_RECORD_MISC_USER
;
1544 for (i
= 0; i
< chain_nr
; i
++) {
1545 if (chain
->ips
[i
] == PERF_CONTEXT_USER
)
1549 /* LBR only affects the user callchain */
1550 if (i
!= chain_nr
) {
1551 struct branch_stack
*lbr_stack
= sample
->branch_stack
;
1552 int lbr_nr
= lbr_stack
->nr
;
1554 * LBR callstack can only get user call chain.
1555 * The mix_chain_nr is kernel call chain
1556 * number plus LBR user call chain number.
1557 * i is kernel call chain number,
1558 * 1 is PERF_CONTEXT_USER,
1559 * lbr_nr + 1 is the user call chain number.
1560 * For details, please refer to the comments
1561 * in callchain__printf
1563 int mix_chain_nr
= i
+ 1 + lbr_nr
+ 1;
1565 if (mix_chain_nr
> PERF_MAX_STACK_DEPTH
+ PERF_MAX_BRANCH_DEPTH
) {
1566 pr_warning("corrupted callchain. skipping...\n");
1570 for (j
= 0; j
< mix_chain_nr
; j
++) {
1571 if (callchain_param
.order
== ORDER_CALLEE
) {
1575 ip
= lbr_stack
->entries
[j
- i
- 2].from
;
1577 ip
= lbr_stack
->entries
[0].to
;
1580 ip
= lbr_stack
->entries
[lbr_nr
- j
- 1].from
;
1581 else if (j
> lbr_nr
)
1582 ip
= chain
->ips
[i
+ 1 - (j
- lbr_nr
)];
1584 ip
= lbr_stack
->entries
[0].to
;
1587 err
= add_callchain_ip(thread
, parent
, root_al
, &cpumode
, ip
);
1589 return (err
< 0) ? err
: 0;
1597 static int thread__resolve_callchain_sample(struct thread
*thread
,
1598 struct perf_evsel
*evsel
,
1599 struct perf_sample
*sample
,
1600 struct symbol
**parent
,
1601 struct addr_location
*root_al
,
1604 struct branch_stack
*branch
= sample
->branch_stack
;
1605 struct ip_callchain
*chain
= sample
->callchain
;
1606 int chain_nr
= min(max_stack
, (int)chain
->nr
);
1607 u8 cpumode
= PERF_RECORD_MISC_USER
;
1612 callchain_cursor_reset(&callchain_cursor
);
1614 if (has_branch_callstack(evsel
)) {
1615 err
= resolve_lbr_callchain_sample(thread
, sample
, parent
,
1616 root_al
, max_stack
);
1618 return (err
< 0) ? err
: 0;
1622 * Based on DWARF debug information, some architectures skip
1623 * a callchain entry saved by the kernel.
1625 if (chain
->nr
< PERF_MAX_STACK_DEPTH
)
1626 skip_idx
= arch_skip_callchain_idx(thread
, chain
);
1629 * Add branches to call stack for easier browsing. This gives
1630 * more context for a sample than just the callers.
1632 * This uses individual histograms of paths compared to the
1633 * aggregated histograms the normal LBR mode uses.
1635 * Limitations for now:
1636 * - No extra filters
1637 * - No annotations (should annotate somehow)
1640 if (branch
&& callchain_param
.branch_callstack
) {
1641 int nr
= min(max_stack
, (int)branch
->nr
);
1642 struct branch_entry be
[nr
];
1644 if (branch
->nr
> PERF_MAX_BRANCH_DEPTH
) {
1645 pr_warning("corrupted branch chain. skipping...\n");
1649 for (i
= 0; i
< nr
; i
++) {
1650 if (callchain_param
.order
== ORDER_CALLEE
) {
1651 be
[i
] = branch
->entries
[i
];
1653 * Check for overlap into the callchain.
1654 * The return address is one off compared to
1655 * the branch entry. To adjust for this
1656 * assume the calling instruction is not longer
1659 if (i
== skip_idx
||
1660 chain
->ips
[first_call
] >= PERF_CONTEXT_MAX
)
1662 else if (be
[i
].from
< chain
->ips
[first_call
] &&
1663 be
[i
].from
>= chain
->ips
[first_call
] - 8)
1666 be
[i
] = branch
->entries
[branch
->nr
- i
- 1];
1669 nr
= remove_loops(be
, nr
);
1671 for (i
= 0; i
< nr
; i
++) {
1672 err
= add_callchain_ip(thread
, parent
, root_al
,
1675 err
= add_callchain_ip(thread
, parent
, root_al
,
1686 if (chain
->nr
> PERF_MAX_STACK_DEPTH
) {
1687 pr_warning("corrupted callchain. skipping...\n");
1691 for (i
= first_call
; i
< chain_nr
; i
++) {
1694 if (callchain_param
.order
== ORDER_CALLEE
)
1697 j
= chain
->nr
- i
- 1;
1699 #ifdef HAVE_SKIP_CALLCHAIN_IDX
1705 err
= add_callchain_ip(thread
, parent
, root_al
, &cpumode
, ip
);
1708 return (err
< 0) ? err
: 0;
1714 static int unwind_entry(struct unwind_entry
*entry
, void *arg
)
1716 struct callchain_cursor
*cursor
= arg
;
1717 return callchain_cursor_append(cursor
, entry
->ip
,
1718 entry
->map
, entry
->sym
);
1721 int thread__resolve_callchain(struct thread
*thread
,
1722 struct perf_evsel
*evsel
,
1723 struct perf_sample
*sample
,
1724 struct symbol
**parent
,
1725 struct addr_location
*root_al
,
1728 int ret
= thread__resolve_callchain_sample(thread
, evsel
,
1730 root_al
, max_stack
);
1734 /* Can we do dwarf post unwind? */
1735 if (!((evsel
->attr
.sample_type
& PERF_SAMPLE_REGS_USER
) &&
1736 (evsel
->attr
.sample_type
& PERF_SAMPLE_STACK_USER
)))
1739 /* Bail out if nothing was captured. */
1740 if ((!sample
->user_regs
.regs
) ||
1741 (!sample
->user_stack
.size
))
1744 return unwind__get_entries(unwind_entry
, &callchain_cursor
,
1745 thread
, sample
, max_stack
);
1749 int machine__for_each_thread(struct machine
*machine
,
1750 int (*fn
)(struct thread
*thread
, void *p
),
1754 struct thread
*thread
;
1757 for (nd
= rb_first(&machine
->threads
); nd
; nd
= rb_next(nd
)) {
1758 thread
= rb_entry(nd
, struct thread
, rb_node
);
1759 rc
= fn(thread
, priv
);
1764 list_for_each_entry(thread
, &machine
->dead_threads
, node
) {
1765 rc
= fn(thread
, priv
);
1772 int __machine__synthesize_threads(struct machine
*machine
, struct perf_tool
*tool
,
1773 struct target
*target
, struct thread_map
*threads
,
1774 perf_event__handler_t process
, bool data_mmap
)
1776 if (target__has_task(target
))
1777 return perf_event__synthesize_thread_map(tool
, threads
, process
, machine
, data_mmap
);
1778 else if (target__has_cpu(target
))
1779 return perf_event__synthesize_threads(tool
, process
, machine
, data_mmap
);
1780 /* command specified */
1784 pid_t
machine__get_current_tid(struct machine
*machine
, int cpu
)
1786 if (cpu
< 0 || cpu
>= MAX_NR_CPUS
|| !machine
->current_tid
)
1789 return machine
->current_tid
[cpu
];
1792 int machine__set_current_tid(struct machine
*machine
, int cpu
, pid_t pid
,
1795 struct thread
*thread
;
1800 if (!machine
->current_tid
) {
1803 machine
->current_tid
= calloc(MAX_NR_CPUS
, sizeof(pid_t
));
1804 if (!machine
->current_tid
)
1806 for (i
= 0; i
< MAX_NR_CPUS
; i
++)
1807 machine
->current_tid
[i
] = -1;
1810 if (cpu
>= MAX_NR_CPUS
) {
1811 pr_err("Requested CPU %d too large. ", cpu
);
1812 pr_err("Consider raising MAX_NR_CPUS\n");
1816 machine
->current_tid
[cpu
] = tid
;
1818 thread
= machine__findnew_thread(machine
, pid
, tid
);
1827 int machine__get_kernel_start(struct machine
*machine
)
1829 struct map
*map
= machine__kernel_map(machine
, MAP__FUNCTION
);
1833 * The only addresses above 2^63 are kernel addresses of a 64-bit
1834 * kernel. Note that addresses are unsigned so that on a 32-bit system
1835 * all addresses including kernel addresses are less than 2^32. In
1836 * that case (32-bit system), if the kernel mapping is unknown, all
1837 * addresses will be assumed to be in user space - see
1838 * machine__kernel_ip().
1840 machine
->kernel_start
= 1ULL << 63;
1842 err
= map__load(map
, machine
->symbol_filter
);
1844 machine
->kernel_start
= map
->start
;