13 #include <symbol/kallsyms.h>
16 int machine__init(struct machine
*machine
, const char *root_dir
, pid_t pid
)
18 map_groups__init(&machine
->kmaps
);
19 RB_CLEAR_NODE(&machine
->rb_node
);
20 INIT_LIST_HEAD(&machine
->user_dsos
);
21 INIT_LIST_HEAD(&machine
->kernel_dsos
);
23 machine
->threads
= RB_ROOT
;
24 INIT_LIST_HEAD(&machine
->dead_threads
);
25 machine
->last_match
= NULL
;
27 machine
->vdso_info
= NULL
;
29 machine
->kmaps
.machine
= machine
;
32 machine
->symbol_filter
= NULL
;
33 machine
->id_hdr_size
= 0;
35 machine
->root_dir
= strdup(root_dir
);
36 if (machine
->root_dir
== NULL
)
39 if (pid
!= HOST_KERNEL_ID
) {
40 struct thread
*thread
= machine__findnew_thread(machine
, -1,
47 snprintf(comm
, sizeof(comm
), "[guest/%d]", pid
);
48 thread__set_comm(thread
, comm
, 0);
51 machine
->current_tid
= NULL
;
56 struct machine
*machine__new_host(void)
58 struct machine
*machine
= malloc(sizeof(*machine
));
60 if (machine
!= NULL
) {
61 machine__init(machine
, "", HOST_KERNEL_ID
);
63 if (machine__create_kernel_maps(machine
) < 0)
73 static void dsos__delete(struct list_head
*dsos
)
77 list_for_each_entry_safe(pos
, n
, dsos
, node
) {
83 void machine__delete_dead_threads(struct machine
*machine
)
87 list_for_each_entry_safe(t
, n
, &machine
->dead_threads
, node
) {
93 void machine__delete_threads(struct machine
*machine
)
95 struct rb_node
*nd
= rb_first(&machine
->threads
);
98 struct thread
*t
= rb_entry(nd
, struct thread
, rb_node
);
100 rb_erase(&t
->rb_node
, &machine
->threads
);
106 void machine__exit(struct machine
*machine
)
108 map_groups__exit(&machine
->kmaps
);
109 dsos__delete(&machine
->user_dsos
);
110 dsos__delete(&machine
->kernel_dsos
);
112 zfree(&machine
->root_dir
);
113 zfree(&machine
->current_tid
);
116 void machine__delete(struct machine
*machine
)
118 machine__exit(machine
);
122 void machines__init(struct machines
*machines
)
124 machine__init(&machines
->host
, "", HOST_KERNEL_ID
);
125 machines
->guests
= RB_ROOT
;
126 machines
->symbol_filter
= NULL
;
129 void machines__exit(struct machines
*machines
)
131 machine__exit(&machines
->host
);
135 struct machine
*machines__add(struct machines
*machines
, pid_t pid
,
136 const char *root_dir
)
138 struct rb_node
**p
= &machines
->guests
.rb_node
;
139 struct rb_node
*parent
= NULL
;
140 struct machine
*pos
, *machine
= malloc(sizeof(*machine
));
145 if (machine__init(machine
, root_dir
, pid
) != 0) {
150 machine
->symbol_filter
= machines
->symbol_filter
;
154 pos
= rb_entry(parent
, struct machine
, rb_node
);
161 rb_link_node(&machine
->rb_node
, parent
, p
);
162 rb_insert_color(&machine
->rb_node
, &machines
->guests
);
167 void machines__set_symbol_filter(struct machines
*machines
,
168 symbol_filter_t symbol_filter
)
172 machines
->symbol_filter
= symbol_filter
;
173 machines
->host
.symbol_filter
= symbol_filter
;
175 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
176 struct machine
*machine
= rb_entry(nd
, struct machine
, rb_node
);
178 machine
->symbol_filter
= symbol_filter
;
182 struct machine
*machines__find(struct machines
*machines
, pid_t pid
)
184 struct rb_node
**p
= &machines
->guests
.rb_node
;
185 struct rb_node
*parent
= NULL
;
186 struct machine
*machine
;
187 struct machine
*default_machine
= NULL
;
189 if (pid
== HOST_KERNEL_ID
)
190 return &machines
->host
;
194 machine
= rb_entry(parent
, struct machine
, rb_node
);
195 if (pid
< machine
->pid
)
197 else if (pid
> machine
->pid
)
202 default_machine
= machine
;
205 return default_machine
;
208 struct machine
*machines__findnew(struct machines
*machines
, pid_t pid
)
211 const char *root_dir
= "";
212 struct machine
*machine
= machines__find(machines
, pid
);
214 if (machine
&& (machine
->pid
== pid
))
217 if ((pid
!= HOST_KERNEL_ID
) &&
218 (pid
!= DEFAULT_GUEST_KERNEL_ID
) &&
219 (symbol_conf
.guestmount
)) {
220 sprintf(path
, "%s/%d", symbol_conf
.guestmount
, pid
);
221 if (access(path
, R_OK
)) {
222 static struct strlist
*seen
;
225 seen
= strlist__new(true, NULL
);
227 if (!strlist__has_entry(seen
, path
)) {
228 pr_err("Can't access file %s\n", path
);
229 strlist__add(seen
, path
);
237 machine
= machines__add(machines
, pid
, root_dir
);
242 void machines__process_guests(struct machines
*machines
,
243 machine__process_t process
, void *data
)
247 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
248 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
253 char *machine__mmap_name(struct machine
*machine
, char *bf
, size_t size
)
255 if (machine__is_host(machine
))
256 snprintf(bf
, size
, "[%s]", "kernel.kallsyms");
257 else if (machine__is_default_guest(machine
))
258 snprintf(bf
, size
, "[%s]", "guest.kernel.kallsyms");
260 snprintf(bf
, size
, "[%s.%d]", "guest.kernel.kallsyms",
267 void machines__set_id_hdr_size(struct machines
*machines
, u16 id_hdr_size
)
269 struct rb_node
*node
;
270 struct machine
*machine
;
272 machines
->host
.id_hdr_size
= id_hdr_size
;
274 for (node
= rb_first(&machines
->guests
); node
; node
= rb_next(node
)) {
275 machine
= rb_entry(node
, struct machine
, rb_node
);
276 machine
->id_hdr_size
= id_hdr_size
;
282 static void machine__update_thread_pid(struct machine
*machine
,
283 struct thread
*th
, pid_t pid
)
285 struct thread
*leader
;
287 if (pid
== th
->pid_
|| pid
== -1 || th
->pid_
!= -1)
292 if (th
->pid_
== th
->tid
)
295 leader
= machine__findnew_thread(machine
, th
->pid_
, th
->pid_
);
300 leader
->mg
= map_groups__new();
305 if (th
->mg
== leader
->mg
)
310 * Maps are created from MMAP events which provide the pid and
311 * tid. Consequently there never should be any maps on a thread
312 * with an unknown pid. Just print an error if there are.
314 if (!map_groups__empty(th
->mg
))
315 pr_err("Discarding thread maps for %d:%d\n",
317 map_groups__delete(th
->mg
);
320 th
->mg
= map_groups__get(leader
->mg
);
325 pr_err("Failed to join map groups for %d:%d\n", th
->pid_
, th
->tid
);
328 static struct thread
*__machine__findnew_thread(struct machine
*machine
,
329 pid_t pid
, pid_t tid
,
332 struct rb_node
**p
= &machine
->threads
.rb_node
;
333 struct rb_node
*parent
= NULL
;
337 * Front-end cache - TID lookups come in blocks,
338 * so most of the time we dont have to look up
341 th
= machine
->last_match
;
342 if (th
&& th
->tid
== tid
) {
343 machine__update_thread_pid(machine
, th
, pid
);
349 th
= rb_entry(parent
, struct thread
, rb_node
);
351 if (th
->tid
== tid
) {
352 machine
->last_match
= th
;
353 machine__update_thread_pid(machine
, th
, pid
);
366 th
= thread__new(pid
, tid
);
368 rb_link_node(&th
->rb_node
, parent
, p
);
369 rb_insert_color(&th
->rb_node
, &machine
->threads
);
370 machine
->last_match
= th
;
373 * We have to initialize map_groups separately
374 * after rb tree is updated.
376 * The reason is that we call machine__findnew_thread
377 * within thread__init_map_groups to find the thread
378 * leader and that would screwed the rb tree.
380 if (thread__init_map_groups(th
, machine
)) {
389 struct thread
*machine__findnew_thread(struct machine
*machine
, pid_t pid
,
392 return __machine__findnew_thread(machine
, pid
, tid
, true);
395 struct thread
*machine__find_thread(struct machine
*machine
, pid_t pid
,
398 return __machine__findnew_thread(machine
, pid
, tid
, false);
401 int machine__process_comm_event(struct machine
*machine
, union perf_event
*event
,
402 struct perf_sample
*sample
)
404 struct thread
*thread
= machine__findnew_thread(machine
,
409 perf_event__fprintf_comm(event
, stdout
);
411 if (thread
== NULL
|| thread__set_comm(thread
, event
->comm
.comm
, sample
->time
)) {
412 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
419 int machine__process_lost_event(struct machine
*machine __maybe_unused
,
420 union perf_event
*event
, struct perf_sample
*sample __maybe_unused
)
422 dump_printf(": id:%" PRIu64
": lost:%" PRIu64
"\n",
423 event
->lost
.id
, event
->lost
.lost
);
427 struct map
*machine__new_module(struct machine
*machine
, u64 start
,
428 const char *filename
)
431 struct dso
*dso
= __dsos__findnew(&machine
->kernel_dsos
, filename
);
436 map
= map__new2(start
, dso
, MAP__FUNCTION
);
440 if (machine__is_host(machine
))
441 dso
->symtab_type
= DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE
;
443 dso
->symtab_type
= DSO_BINARY_TYPE__GUEST_KMODULE
;
444 map_groups__insert(&machine
->kmaps
, map
);
448 size_t machines__fprintf_dsos(struct machines
*machines
, FILE *fp
)
451 size_t ret
= __dsos__fprintf(&machines
->host
.kernel_dsos
, fp
) +
452 __dsos__fprintf(&machines
->host
.user_dsos
, fp
);
454 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
455 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
456 ret
+= __dsos__fprintf(&pos
->kernel_dsos
, fp
);
457 ret
+= __dsos__fprintf(&pos
->user_dsos
, fp
);
463 size_t machine__fprintf_dsos_buildid(struct machine
*machine
, FILE *fp
,
464 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
466 return __dsos__fprintf_buildid(&machine
->kernel_dsos
, fp
, skip
, parm
) +
467 __dsos__fprintf_buildid(&machine
->user_dsos
, fp
, skip
, parm
);
470 size_t machines__fprintf_dsos_buildid(struct machines
*machines
, FILE *fp
,
471 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
474 size_t ret
= machine__fprintf_dsos_buildid(&machines
->host
, fp
, skip
, parm
);
476 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
477 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
478 ret
+= machine__fprintf_dsos_buildid(pos
, fp
, skip
, parm
);
483 size_t machine__fprintf_vmlinux_path(struct machine
*machine
, FILE *fp
)
487 struct dso
*kdso
= machine
->vmlinux_maps
[MAP__FUNCTION
]->dso
;
489 if (kdso
->has_build_id
) {
490 char filename
[PATH_MAX
];
491 if (dso__build_id_filename(kdso
, filename
, sizeof(filename
)))
492 printed
+= fprintf(fp
, "[0] %s\n", filename
);
495 for (i
= 0; i
< vmlinux_path__nr_entries
; ++i
)
496 printed
+= fprintf(fp
, "[%d] %s\n",
497 i
+ kdso
->has_build_id
, vmlinux_path
[i
]);
502 size_t machine__fprintf(struct machine
*machine
, FILE *fp
)
507 for (nd
= rb_first(&machine
->threads
); nd
; nd
= rb_next(nd
)) {
508 struct thread
*pos
= rb_entry(nd
, struct thread
, rb_node
);
510 ret
+= thread__fprintf(pos
, fp
);
516 static struct dso
*machine__get_kernel(struct machine
*machine
)
518 const char *vmlinux_name
= NULL
;
521 if (machine__is_host(machine
)) {
522 vmlinux_name
= symbol_conf
.vmlinux_name
;
524 vmlinux_name
= "[kernel.kallsyms]";
526 kernel
= dso__kernel_findnew(machine
, vmlinux_name
,
532 if (machine__is_default_guest(machine
))
533 vmlinux_name
= symbol_conf
.default_guest_vmlinux_name
;
535 vmlinux_name
= machine__mmap_name(machine
, bf
,
538 kernel
= dso__kernel_findnew(machine
, vmlinux_name
,
540 DSO_TYPE_GUEST_KERNEL
);
543 if (kernel
!= NULL
&& (!kernel
->has_build_id
))
544 dso__read_running_kernel_build_id(kernel
, machine
);
549 struct process_args
{
553 static void machine__get_kallsyms_filename(struct machine
*machine
, char *buf
,
556 if (machine__is_default_guest(machine
))
557 scnprintf(buf
, bufsz
, "%s", symbol_conf
.default_guest_kallsyms
);
559 scnprintf(buf
, bufsz
, "%s/proc/kallsyms", machine
->root_dir
);
562 const char *ref_reloc_sym_names
[] = {"_text", "_stext", NULL
};
564 /* Figure out the start address of kernel map from /proc/kallsyms.
565 * Returns the name of the start symbol in *symbol_name. Pass in NULL as
566 * symbol_name if it's not that important.
568 static u64
machine__get_kernel_start_addr(struct machine
*machine
,
569 const char **symbol_name
)
571 char filename
[PATH_MAX
];
576 machine__get_kallsyms_filename(machine
, filename
, PATH_MAX
);
578 if (symbol__restricted_filename(filename
, "/proc/kallsyms"))
581 for (i
= 0; (name
= ref_reloc_sym_names
[i
]) != NULL
; i
++) {
582 addr
= kallsyms__get_function_start(filename
, name
);
593 int __machine__create_kernel_maps(struct machine
*machine
, struct dso
*kernel
)
596 u64 start
= machine__get_kernel_start_addr(machine
, NULL
);
598 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
601 machine
->vmlinux_maps
[type
] = map__new2(start
, kernel
, type
);
602 if (machine
->vmlinux_maps
[type
] == NULL
)
605 machine
->vmlinux_maps
[type
]->map_ip
=
606 machine
->vmlinux_maps
[type
]->unmap_ip
=
608 kmap
= map__kmap(machine
->vmlinux_maps
[type
]);
609 kmap
->kmaps
= &machine
->kmaps
;
610 map_groups__insert(&machine
->kmaps
,
611 machine
->vmlinux_maps
[type
]);
617 void machine__destroy_kernel_maps(struct machine
*machine
)
621 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
624 if (machine
->vmlinux_maps
[type
] == NULL
)
627 kmap
= map__kmap(machine
->vmlinux_maps
[type
]);
628 map_groups__remove(&machine
->kmaps
,
629 machine
->vmlinux_maps
[type
]);
630 if (kmap
->ref_reloc_sym
) {
632 * ref_reloc_sym is shared among all maps, so free just
635 if (type
== MAP__FUNCTION
) {
636 zfree((char **)&kmap
->ref_reloc_sym
->name
);
637 zfree(&kmap
->ref_reloc_sym
);
639 kmap
->ref_reloc_sym
= NULL
;
642 map__delete(machine
->vmlinux_maps
[type
]);
643 machine
->vmlinux_maps
[type
] = NULL
;
647 int machines__create_guest_kernel_maps(struct machines
*machines
)
650 struct dirent
**namelist
= NULL
;
656 if (symbol_conf
.default_guest_vmlinux_name
||
657 symbol_conf
.default_guest_modules
||
658 symbol_conf
.default_guest_kallsyms
) {
659 machines__create_kernel_maps(machines
, DEFAULT_GUEST_KERNEL_ID
);
662 if (symbol_conf
.guestmount
) {
663 items
= scandir(symbol_conf
.guestmount
, &namelist
, NULL
, NULL
);
666 for (i
= 0; i
< items
; i
++) {
667 if (!isdigit(namelist
[i
]->d_name
[0])) {
668 /* Filter out . and .. */
671 pid
= (pid_t
)strtol(namelist
[i
]->d_name
, &endp
, 10);
672 if ((*endp
!= '\0') ||
673 (endp
== namelist
[i
]->d_name
) ||
675 pr_debug("invalid directory (%s). Skipping.\n",
676 namelist
[i
]->d_name
);
679 sprintf(path
, "%s/%s/proc/kallsyms",
680 symbol_conf
.guestmount
,
681 namelist
[i
]->d_name
);
682 ret
= access(path
, R_OK
);
684 pr_debug("Can't access file %s\n", path
);
687 machines__create_kernel_maps(machines
, pid
);
696 void machines__destroy_kernel_maps(struct machines
*machines
)
698 struct rb_node
*next
= rb_first(&machines
->guests
);
700 machine__destroy_kernel_maps(&machines
->host
);
703 struct machine
*pos
= rb_entry(next
, struct machine
, rb_node
);
705 next
= rb_next(&pos
->rb_node
);
706 rb_erase(&pos
->rb_node
, &machines
->guests
);
707 machine__delete(pos
);
711 int machines__create_kernel_maps(struct machines
*machines
, pid_t pid
)
713 struct machine
*machine
= machines__findnew(machines
, pid
);
718 return machine__create_kernel_maps(machine
);
721 int machine__load_kallsyms(struct machine
*machine
, const char *filename
,
722 enum map_type type
, symbol_filter_t filter
)
724 struct map
*map
= machine
->vmlinux_maps
[type
];
725 int ret
= dso__load_kallsyms(map
->dso
, filename
, map
, filter
);
728 dso__set_loaded(map
->dso
, type
);
730 * Since /proc/kallsyms will have multiple sessions for the
731 * kernel, with modules between them, fixup the end of all
734 __map_groups__fixup_end(&machine
->kmaps
, type
);
740 int machine__load_vmlinux_path(struct machine
*machine
, enum map_type type
,
741 symbol_filter_t filter
)
743 struct map
*map
= machine
->vmlinux_maps
[type
];
744 int ret
= dso__load_vmlinux_path(map
->dso
, map
, filter
);
747 dso__set_loaded(map
->dso
, type
);
752 static void map_groups__fixup_end(struct map_groups
*mg
)
755 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
756 __map_groups__fixup_end(mg
, i
);
759 static char *get_kernel_version(const char *root_dir
)
761 char version
[PATH_MAX
];
764 const char *prefix
= "Linux version ";
766 sprintf(version
, "%s/proc/version", root_dir
);
767 file
= fopen(version
, "r");
772 tmp
= fgets(version
, sizeof(version
), file
);
775 name
= strstr(version
, prefix
);
778 name
+= strlen(prefix
);
779 tmp
= strchr(name
, ' ');
786 static int map_groups__set_modules_path_dir(struct map_groups
*mg
,
787 const char *dir_name
, int depth
)
790 DIR *dir
= opendir(dir_name
);
794 pr_debug("%s: cannot open %s dir\n", __func__
, dir_name
);
798 while ((dent
= readdir(dir
)) != NULL
) {
802 /*sshfs might return bad dent->d_type, so we have to stat*/
803 snprintf(path
, sizeof(path
), "%s/%s", dir_name
, dent
->d_name
);
807 if (S_ISDIR(st
.st_mode
)) {
808 if (!strcmp(dent
->d_name
, ".") ||
809 !strcmp(dent
->d_name
, ".."))
812 /* Do not follow top-level source and build symlinks */
814 if (!strcmp(dent
->d_name
, "source") ||
815 !strcmp(dent
->d_name
, "build"))
819 ret
= map_groups__set_modules_path_dir(mg
, path
,
824 char *dot
= strrchr(dent
->d_name
, '.'),
829 if (dot
== NULL
|| strcmp(dot
, ".ko"))
831 snprintf(dso_name
, sizeof(dso_name
), "[%.*s]",
832 (int)(dot
- dent
->d_name
), dent
->d_name
);
834 strxfrchar(dso_name
, '-', '_');
835 map
= map_groups__find_by_name(mg
, MAP__FUNCTION
,
840 long_name
= strdup(path
);
841 if (long_name
== NULL
) {
845 dso__set_long_name(map
->dso
, long_name
, true);
846 dso__kernel_module_get_build_id(map
->dso
, "");
855 static int machine__set_modules_path(struct machine
*machine
)
858 char modules_path
[PATH_MAX
];
860 version
= get_kernel_version(machine
->root_dir
);
864 snprintf(modules_path
, sizeof(modules_path
), "%s/lib/modules/%s",
865 machine
->root_dir
, version
);
868 return map_groups__set_modules_path_dir(&machine
->kmaps
, modules_path
, 0);
871 static int machine__create_module(void *arg
, const char *name
, u64 start
)
873 struct machine
*machine
= arg
;
876 map
= machine__new_module(machine
, start
, name
);
880 dso__kernel_module_get_build_id(map
->dso
, machine
->root_dir
);
885 static int machine__create_modules(struct machine
*machine
)
890 if (machine__is_default_guest(machine
)) {
891 modules
= symbol_conf
.default_guest_modules
;
893 snprintf(path
, PATH_MAX
, "%s/proc/modules", machine
->root_dir
);
897 if (symbol__restricted_filename(modules
, "/proc/modules"))
900 if (modules__parse(modules
, machine
, machine__create_module
))
903 if (!machine__set_modules_path(machine
))
906 pr_debug("Problems setting modules path maps, continuing anyway...\n");
911 int machine__create_kernel_maps(struct machine
*machine
)
913 struct dso
*kernel
= machine__get_kernel(machine
);
915 u64 addr
= machine__get_kernel_start_addr(machine
, &name
);
919 if (kernel
== NULL
||
920 __machine__create_kernel_maps(machine
, kernel
) < 0)
923 if (symbol_conf
.use_modules
&& machine__create_modules(machine
) < 0) {
924 if (machine__is_host(machine
))
925 pr_debug("Problems creating module maps, "
926 "continuing anyway...\n");
928 pr_debug("Problems creating module maps for guest %d, "
929 "continuing anyway...\n", machine
->pid
);
933 * Now that we have all the maps created, just set the ->end of them:
935 map_groups__fixup_end(&machine
->kmaps
);
937 if (maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
, name
,
939 machine__destroy_kernel_maps(machine
);
946 static void machine__set_kernel_mmap_len(struct machine
*machine
,
947 union perf_event
*event
)
951 for (i
= 0; i
< MAP__NR_TYPES
; i
++) {
952 machine
->vmlinux_maps
[i
]->start
= event
->mmap
.start
;
953 machine
->vmlinux_maps
[i
]->end
= (event
->mmap
.start
+
956 * Be a bit paranoid here, some perf.data file came with
957 * a zero sized synthesized MMAP event for the kernel.
959 if (machine
->vmlinux_maps
[i
]->end
== 0)
960 machine
->vmlinux_maps
[i
]->end
= ~0ULL;
964 static bool machine__uses_kcore(struct machine
*machine
)
968 list_for_each_entry(dso
, &machine
->kernel_dsos
, node
) {
969 if (dso__is_kcore(dso
))
976 static int machine__process_kernel_mmap_event(struct machine
*machine
,
977 union perf_event
*event
)
980 char kmmap_prefix
[PATH_MAX
];
981 enum dso_kernel_type kernel_type
;
984 /* If we have maps from kcore then we do not need or want any others */
985 if (machine__uses_kcore(machine
))
988 machine__mmap_name(machine
, kmmap_prefix
, sizeof(kmmap_prefix
));
989 if (machine__is_host(machine
))
990 kernel_type
= DSO_TYPE_KERNEL
;
992 kernel_type
= DSO_TYPE_GUEST_KERNEL
;
994 is_kernel_mmap
= memcmp(event
->mmap
.filename
,
996 strlen(kmmap_prefix
) - 1) == 0;
997 if (event
->mmap
.filename
[0] == '/' ||
998 (!is_kernel_mmap
&& event
->mmap
.filename
[0] == '[')) {
1000 char short_module_name
[1024];
1003 if (event
->mmap
.filename
[0] == '/') {
1004 name
= strrchr(event
->mmap
.filename
, '/');
1008 ++name
; /* skip / */
1009 dot
= strrchr(name
, '.');
1012 snprintf(short_module_name
, sizeof(short_module_name
),
1013 "[%.*s]", (int)(dot
- name
), name
);
1014 strxfrchar(short_module_name
, '-', '_');
1016 strcpy(short_module_name
, event
->mmap
.filename
);
1018 map
= machine__new_module(machine
, event
->mmap
.start
,
1019 event
->mmap
.filename
);
1023 name
= strdup(short_module_name
);
1027 dso__set_short_name(map
->dso
, name
, true);
1028 map
->end
= map
->start
+ event
->mmap
.len
;
1029 } else if (is_kernel_mmap
) {
1030 const char *symbol_name
= (event
->mmap
.filename
+
1031 strlen(kmmap_prefix
));
1033 * Should be there already, from the build-id table in
1036 struct dso
*kernel
= __dsos__findnew(&machine
->kernel_dsos
,
1041 kernel
->kernel
= kernel_type
;
1042 if (__machine__create_kernel_maps(machine
, kernel
) < 0)
1045 machine__set_kernel_mmap_len(machine
, event
);
1048 * Avoid using a zero address (kptr_restrict) for the ref reloc
1049 * symbol. Effectively having zero here means that at record
1050 * time /proc/sys/kernel/kptr_restrict was non zero.
1052 if (event
->mmap
.pgoff
!= 0) {
1053 maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
,
1058 if (machine__is_default_guest(machine
)) {
1060 * preload dso of guest kernel and modules
1062 dso__load(kernel
, machine
->vmlinux_maps
[MAP__FUNCTION
],
1071 int machine__process_mmap2_event(struct machine
*machine
,
1072 union perf_event
*event
,
1073 struct perf_sample
*sample __maybe_unused
)
1075 u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
1076 struct thread
*thread
;
1082 perf_event__fprintf_mmap2(event
, stdout
);
1084 if (cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1085 cpumode
== PERF_RECORD_MISC_KERNEL
) {
1086 ret
= machine__process_kernel_mmap_event(machine
, event
);
1092 thread
= machine__findnew_thread(machine
, event
->mmap2
.pid
,
1097 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1098 type
= MAP__VARIABLE
;
1100 type
= MAP__FUNCTION
;
1102 map
= map__new(machine
, event
->mmap2
.start
,
1103 event
->mmap2
.len
, event
->mmap2
.pgoff
,
1104 event
->mmap2
.pid
, event
->mmap2
.maj
,
1105 event
->mmap2
.min
, event
->mmap2
.ino
,
1106 event
->mmap2
.ino_generation
,
1109 event
->mmap2
.filename
, type
);
1114 thread__insert_map(thread
, map
);
1118 dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
1122 int machine__process_mmap_event(struct machine
*machine
, union perf_event
*event
,
1123 struct perf_sample
*sample __maybe_unused
)
1125 u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
1126 struct thread
*thread
;
1132 perf_event__fprintf_mmap(event
, stdout
);
1134 if (cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1135 cpumode
== PERF_RECORD_MISC_KERNEL
) {
1136 ret
= machine__process_kernel_mmap_event(machine
, event
);
1142 thread
= machine__findnew_thread(machine
, event
->mmap
.pid
,
1147 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1148 type
= MAP__VARIABLE
;
1150 type
= MAP__FUNCTION
;
1152 map
= map__new(machine
, event
->mmap
.start
,
1153 event
->mmap
.len
, event
->mmap
.pgoff
,
1154 event
->mmap
.pid
, 0, 0, 0, 0, 0, 0,
1155 event
->mmap
.filename
,
1161 thread__insert_map(thread
, map
);
1165 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
1169 static void machine__remove_thread(struct machine
*machine
, struct thread
*th
)
1171 machine
->last_match
= NULL
;
1172 rb_erase(&th
->rb_node
, &machine
->threads
);
1174 * We may have references to this thread, for instance in some hist_entry
1175 * instances, so just move them to a separate list.
1177 list_add_tail(&th
->node
, &machine
->dead_threads
);
1180 int machine__process_fork_event(struct machine
*machine
, union perf_event
*event
,
1181 struct perf_sample
*sample
)
1183 struct thread
*thread
= machine__find_thread(machine
,
1186 struct thread
*parent
= machine__findnew_thread(machine
,
1190 /* if a thread currently exists for the thread id remove it */
1192 machine__remove_thread(machine
, thread
);
1194 thread
= machine__findnew_thread(machine
, event
->fork
.pid
,
1197 perf_event__fprintf_task(event
, stdout
);
1199 if (thread
== NULL
|| parent
== NULL
||
1200 thread__fork(thread
, parent
, sample
->time
) < 0) {
1201 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
1208 int machine__process_exit_event(struct machine
*machine
, union perf_event
*event
,
1209 struct perf_sample
*sample __maybe_unused
)
1211 struct thread
*thread
= machine__find_thread(machine
,
1216 perf_event__fprintf_task(event
, stdout
);
1219 thread__exited(thread
);
1224 int machine__process_event(struct machine
*machine
, union perf_event
*event
,
1225 struct perf_sample
*sample
)
1229 switch (event
->header
.type
) {
1230 case PERF_RECORD_COMM
:
1231 ret
= machine__process_comm_event(machine
, event
, sample
); break;
1232 case PERF_RECORD_MMAP
:
1233 ret
= machine__process_mmap_event(machine
, event
, sample
); break;
1234 case PERF_RECORD_MMAP2
:
1235 ret
= machine__process_mmap2_event(machine
, event
, sample
); break;
1236 case PERF_RECORD_FORK
:
1237 ret
= machine__process_fork_event(machine
, event
, sample
); break;
1238 case PERF_RECORD_EXIT
:
1239 ret
= machine__process_exit_event(machine
, event
, sample
); break;
1240 case PERF_RECORD_LOST
:
1241 ret
= machine__process_lost_event(machine
, event
, sample
); break;
1250 static bool symbol__match_regex(struct symbol
*sym
, regex_t
*regex
)
1252 if (sym
->name
&& !regexec(regex
, sym
->name
, 0, NULL
, 0))
1257 static void ip__resolve_ams(struct machine
*machine
, struct thread
*thread
,
1258 struct addr_map_symbol
*ams
,
1261 struct addr_location al
;
1263 memset(&al
, 0, sizeof(al
));
1265 * We cannot use the header.misc hint to determine whether a
1266 * branch stack address is user, kernel, guest, hypervisor.
1267 * Branches may straddle the kernel/user/hypervisor boundaries.
1268 * Thus, we have to try consecutively until we find a match
1269 * or else, the symbol is unknown
1271 thread__find_cpumode_addr_location(thread
, machine
, MAP__FUNCTION
, ip
, &al
);
1274 ams
->al_addr
= al
.addr
;
1279 static void ip__resolve_data(struct machine
*machine
, struct thread
*thread
,
1280 u8 m
, struct addr_map_symbol
*ams
, u64 addr
)
1282 struct addr_location al
;
1284 memset(&al
, 0, sizeof(al
));
1286 thread__find_addr_location(thread
, machine
, m
, MAP__VARIABLE
, addr
,
1289 ams
->al_addr
= al
.addr
;
1294 struct mem_info
*sample__resolve_mem(struct perf_sample
*sample
,
1295 struct addr_location
*al
)
1297 struct mem_info
*mi
= zalloc(sizeof(*mi
));
1302 ip__resolve_ams(al
->machine
, al
->thread
, &mi
->iaddr
, sample
->ip
);
1303 ip__resolve_data(al
->machine
, al
->thread
, al
->cpumode
,
1304 &mi
->daddr
, sample
->addr
);
1305 mi
->data_src
.val
= sample
->data_src
;
1310 struct branch_info
*sample__resolve_bstack(struct perf_sample
*sample
,
1311 struct addr_location
*al
)
1314 const struct branch_stack
*bs
= sample
->branch_stack
;
1315 struct branch_info
*bi
= calloc(bs
->nr
, sizeof(struct branch_info
));
1320 for (i
= 0; i
< bs
->nr
; i
++) {
1321 ip__resolve_ams(al
->machine
, al
->thread
, &bi
[i
].to
, bs
->entries
[i
].to
);
1322 ip__resolve_ams(al
->machine
, al
->thread
, &bi
[i
].from
, bs
->entries
[i
].from
);
1323 bi
[i
].flags
= bs
->entries
[i
].flags
;
1328 static int machine__resolve_callchain_sample(struct machine
*machine
,
1329 struct thread
*thread
,
1330 struct ip_callchain
*chain
,
1331 struct symbol
**parent
,
1332 struct addr_location
*root_al
,
1335 u8 cpumode
= PERF_RECORD_MISC_USER
;
1336 int chain_nr
= min(max_stack
, (int)chain
->nr
);
1340 int skip_idx __maybe_unused
;
1342 callchain_cursor_reset(&callchain_cursor
);
1344 if (chain
->nr
> PERF_MAX_STACK_DEPTH
) {
1345 pr_warning("corrupted callchain. skipping...\n");
1350 * Based on DWARF debug information, some architectures skip
1351 * a callchain entry saved by the kernel.
1353 skip_idx
= arch_skip_callchain_idx(machine
, thread
, chain
);
1355 for (i
= 0; i
< chain_nr
; i
++) {
1357 struct addr_location al
;
1359 if (callchain_param
.order
== ORDER_CALLEE
)
1362 j
= chain
->nr
- i
- 1;
1364 #ifdef HAVE_SKIP_CALLCHAIN_IDX
1370 if (ip
>= PERF_CONTEXT_MAX
) {
1372 case PERF_CONTEXT_HV
:
1373 cpumode
= PERF_RECORD_MISC_HYPERVISOR
;
1375 case PERF_CONTEXT_KERNEL
:
1376 cpumode
= PERF_RECORD_MISC_KERNEL
;
1378 case PERF_CONTEXT_USER
:
1379 cpumode
= PERF_RECORD_MISC_USER
;
1382 pr_debug("invalid callchain context: "
1383 "%"PRId64
"\n", (s64
) ip
);
1385 * It seems the callchain is corrupted.
1388 callchain_cursor_reset(&callchain_cursor
);
1395 thread__find_addr_location(thread
, machine
, cpumode
,
1396 MAP__FUNCTION
, ip
, &al
);
1397 if (al
.sym
!= NULL
) {
1398 if (sort__has_parent
&& !*parent
&&
1399 symbol__match_regex(al
.sym
, &parent_regex
))
1401 else if (have_ignore_callees
&& root_al
&&
1402 symbol__match_regex(al
.sym
, &ignore_callees_regex
)) {
1403 /* Treat this symbol as the root,
1404 forgetting its callees. */
1406 callchain_cursor_reset(&callchain_cursor
);
1410 err
= callchain_cursor_append(&callchain_cursor
,
1411 ip
, al
.map
, al
.sym
);
1419 static int unwind_entry(struct unwind_entry
*entry
, void *arg
)
1421 struct callchain_cursor
*cursor
= arg
;
1422 return callchain_cursor_append(cursor
, entry
->ip
,
1423 entry
->map
, entry
->sym
);
1426 int machine__resolve_callchain(struct machine
*machine
,
1427 struct perf_evsel
*evsel
,
1428 struct thread
*thread
,
1429 struct perf_sample
*sample
,
1430 struct symbol
**parent
,
1431 struct addr_location
*root_al
,
1436 ret
= machine__resolve_callchain_sample(machine
, thread
,
1437 sample
->callchain
, parent
,
1438 root_al
, max_stack
);
1442 /* Can we do dwarf post unwind? */
1443 if (!((evsel
->attr
.sample_type
& PERF_SAMPLE_REGS_USER
) &&
1444 (evsel
->attr
.sample_type
& PERF_SAMPLE_STACK_USER
)))
1447 /* Bail out if nothing was captured. */
1448 if ((!sample
->user_regs
.regs
) ||
1449 (!sample
->user_stack
.size
))
1452 return unwind__get_entries(unwind_entry
, &callchain_cursor
, machine
,
1453 thread
, sample
, max_stack
);
1457 int machine__for_each_thread(struct machine
*machine
,
1458 int (*fn
)(struct thread
*thread
, void *p
),
1462 struct thread
*thread
;
1465 for (nd
= rb_first(&machine
->threads
); nd
; nd
= rb_next(nd
)) {
1466 thread
= rb_entry(nd
, struct thread
, rb_node
);
1467 rc
= fn(thread
, priv
);
1472 list_for_each_entry(thread
, &machine
->dead_threads
, node
) {
1473 rc
= fn(thread
, priv
);
1480 int __machine__synthesize_threads(struct machine
*machine
, struct perf_tool
*tool
,
1481 struct target
*target
, struct thread_map
*threads
,
1482 perf_event__handler_t process
, bool data_mmap
)
1484 if (target__has_task(target
))
1485 return perf_event__synthesize_thread_map(tool
, threads
, process
, machine
, data_mmap
);
1486 else if (target__has_cpu(target
))
1487 return perf_event__synthesize_threads(tool
, process
, machine
, data_mmap
);
1488 /* command specified */
1492 pid_t
machine__get_current_tid(struct machine
*machine
, int cpu
)
1494 if (cpu
< 0 || cpu
>= MAX_NR_CPUS
|| !machine
->current_tid
)
1497 return machine
->current_tid
[cpu
];
1500 int machine__set_current_tid(struct machine
*machine
, int cpu
, pid_t pid
,
1503 struct thread
*thread
;
1508 if (!machine
->current_tid
) {
1511 machine
->current_tid
= calloc(MAX_NR_CPUS
, sizeof(pid_t
));
1512 if (!machine
->current_tid
)
1514 for (i
= 0; i
< MAX_NR_CPUS
; i
++)
1515 machine
->current_tid
[i
] = -1;
1518 if (cpu
>= MAX_NR_CPUS
) {
1519 pr_err("Requested CPU %d too large. ", cpu
);
1520 pr_err("Consider raising MAX_NR_CPUS\n");
1524 machine
->current_tid
[cpu
] = tid
;
1526 thread
= machine__findnew_thread(machine
, pid
, tid
);