12 #include <symbol/kallsyms.h>
15 int machine__init(struct machine
*machine
, const char *root_dir
, pid_t pid
)
17 map_groups__init(&machine
->kmaps
);
18 RB_CLEAR_NODE(&machine
->rb_node
);
19 INIT_LIST_HEAD(&machine
->user_dsos
);
20 INIT_LIST_HEAD(&machine
->kernel_dsos
);
22 machine
->threads
= RB_ROOT
;
23 INIT_LIST_HEAD(&machine
->dead_threads
);
24 machine
->last_match
= NULL
;
26 machine
->kmaps
.machine
= machine
;
29 machine
->symbol_filter
= NULL
;
30 machine
->id_hdr_size
= 0;
32 machine
->root_dir
= strdup(root_dir
);
33 if (machine
->root_dir
== NULL
)
36 if (pid
!= HOST_KERNEL_ID
) {
37 struct thread
*thread
= machine__findnew_thread(machine
, 0,
44 snprintf(comm
, sizeof(comm
), "[guest/%d]", pid
);
45 thread__set_comm(thread
, comm
, 0);
51 struct machine
*machine__new_host(void)
53 struct machine
*machine
= malloc(sizeof(*machine
));
55 if (machine
!= NULL
) {
56 machine__init(machine
, "", HOST_KERNEL_ID
);
58 if (machine__create_kernel_maps(machine
) < 0)
68 static void dsos__delete(struct list_head
*dsos
)
72 list_for_each_entry_safe(pos
, n
, dsos
, node
) {
78 void machine__delete_dead_threads(struct machine
*machine
)
82 list_for_each_entry_safe(t
, n
, &machine
->dead_threads
, node
) {
88 void machine__delete_threads(struct machine
*machine
)
90 struct rb_node
*nd
= rb_first(&machine
->threads
);
93 struct thread
*t
= rb_entry(nd
, struct thread
, rb_node
);
95 rb_erase(&t
->rb_node
, &machine
->threads
);
101 void machine__exit(struct machine
*machine
)
103 map_groups__exit(&machine
->kmaps
);
104 dsos__delete(&machine
->user_dsos
);
105 dsos__delete(&machine
->kernel_dsos
);
106 zfree(&machine
->root_dir
);
109 void machine__delete(struct machine
*machine
)
111 machine__exit(machine
);
115 void machines__init(struct machines
*machines
)
117 machine__init(&machines
->host
, "", HOST_KERNEL_ID
);
118 machines
->guests
= RB_ROOT
;
119 machines
->symbol_filter
= NULL
;
122 void machines__exit(struct machines
*machines
)
124 machine__exit(&machines
->host
);
128 struct machine
*machines__add(struct machines
*machines
, pid_t pid
,
129 const char *root_dir
)
131 struct rb_node
**p
= &machines
->guests
.rb_node
;
132 struct rb_node
*parent
= NULL
;
133 struct machine
*pos
, *machine
= malloc(sizeof(*machine
));
138 if (machine__init(machine
, root_dir
, pid
) != 0) {
143 machine
->symbol_filter
= machines
->symbol_filter
;
147 pos
= rb_entry(parent
, struct machine
, rb_node
);
154 rb_link_node(&machine
->rb_node
, parent
, p
);
155 rb_insert_color(&machine
->rb_node
, &machines
->guests
);
160 void machines__set_symbol_filter(struct machines
*machines
,
161 symbol_filter_t symbol_filter
)
165 machines
->symbol_filter
= symbol_filter
;
166 machines
->host
.symbol_filter
= symbol_filter
;
168 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
169 struct machine
*machine
= rb_entry(nd
, struct machine
, rb_node
);
171 machine
->symbol_filter
= symbol_filter
;
175 struct machine
*machines__find(struct machines
*machines
, pid_t pid
)
177 struct rb_node
**p
= &machines
->guests
.rb_node
;
178 struct rb_node
*parent
= NULL
;
179 struct machine
*machine
;
180 struct machine
*default_machine
= NULL
;
182 if (pid
== HOST_KERNEL_ID
)
183 return &machines
->host
;
187 machine
= rb_entry(parent
, struct machine
, rb_node
);
188 if (pid
< machine
->pid
)
190 else if (pid
> machine
->pid
)
195 default_machine
= machine
;
198 return default_machine
;
201 struct machine
*machines__findnew(struct machines
*machines
, pid_t pid
)
204 const char *root_dir
= "";
205 struct machine
*machine
= machines__find(machines
, pid
);
207 if (machine
&& (machine
->pid
== pid
))
210 if ((pid
!= HOST_KERNEL_ID
) &&
211 (pid
!= DEFAULT_GUEST_KERNEL_ID
) &&
212 (symbol_conf
.guestmount
)) {
213 sprintf(path
, "%s/%d", symbol_conf
.guestmount
, pid
);
214 if (access(path
, R_OK
)) {
215 static struct strlist
*seen
;
218 seen
= strlist__new(true, NULL
);
220 if (!strlist__has_entry(seen
, path
)) {
221 pr_err("Can't access file %s\n", path
);
222 strlist__add(seen
, path
);
230 machine
= machines__add(machines
, pid
, root_dir
);
235 void machines__process_guests(struct machines
*machines
,
236 machine__process_t process
, void *data
)
240 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
241 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
246 char *machine__mmap_name(struct machine
*machine
, char *bf
, size_t size
)
248 if (machine__is_host(machine
))
249 snprintf(bf
, size
, "[%s]", "kernel.kallsyms");
250 else if (machine__is_default_guest(machine
))
251 snprintf(bf
, size
, "[%s]", "guest.kernel.kallsyms");
253 snprintf(bf
, size
, "[%s.%d]", "guest.kernel.kallsyms",
260 void machines__set_id_hdr_size(struct machines
*machines
, u16 id_hdr_size
)
262 struct rb_node
*node
;
263 struct machine
*machine
;
265 machines
->host
.id_hdr_size
= id_hdr_size
;
267 for (node
= rb_first(&machines
->guests
); node
; node
= rb_next(node
)) {
268 machine
= rb_entry(node
, struct machine
, rb_node
);
269 machine
->id_hdr_size
= id_hdr_size
;
275 static struct thread
*__machine__findnew_thread(struct machine
*machine
,
276 pid_t pid
, pid_t tid
,
279 struct rb_node
**p
= &machine
->threads
.rb_node
;
280 struct rb_node
*parent
= NULL
;
284 * Front-end cache - TID lookups come in blocks,
285 * so most of the time we dont have to look up
288 if (machine
->last_match
&& machine
->last_match
->tid
== tid
) {
289 if (pid
&& pid
!= machine
->last_match
->pid_
)
290 machine
->last_match
->pid_
= pid
;
291 return machine
->last_match
;
296 th
= rb_entry(parent
, struct thread
, rb_node
);
298 if (th
->tid
== tid
) {
299 machine
->last_match
= th
;
300 if (pid
&& pid
!= th
->pid_
)
314 th
= thread__new(pid
, tid
);
316 rb_link_node(&th
->rb_node
, parent
, p
);
317 rb_insert_color(&th
->rb_node
, &machine
->threads
);
318 machine
->last_match
= th
;
321 * We have to initialize map_groups separately
322 * after rb tree is updated.
324 * The reason is that we call machine__findnew_thread
325 * within thread__init_map_groups to find the thread
326 * leader and that would screwed the rb tree.
328 if (thread__init_map_groups(th
, machine
))
335 struct thread
*machine__findnew_thread(struct machine
*machine
, pid_t pid
,
338 return __machine__findnew_thread(machine
, pid
, tid
, true);
341 struct thread
*machine__find_thread(struct machine
*machine
, pid_t pid
,
344 return __machine__findnew_thread(machine
, pid
, tid
, false);
347 int machine__process_comm_event(struct machine
*machine
, union perf_event
*event
,
348 struct perf_sample
*sample
)
350 struct thread
*thread
= machine__findnew_thread(machine
,
355 perf_event__fprintf_comm(event
, stdout
);
357 if (thread
== NULL
|| thread__set_comm(thread
, event
->comm
.comm
, sample
->time
)) {
358 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
365 int machine__process_lost_event(struct machine
*machine __maybe_unused
,
366 union perf_event
*event
, struct perf_sample
*sample __maybe_unused
)
368 dump_printf(": id:%" PRIu64
": lost:%" PRIu64
"\n",
369 event
->lost
.id
, event
->lost
.lost
);
373 struct map
*machine__new_module(struct machine
*machine
, u64 start
,
374 const char *filename
)
377 struct dso
*dso
= __dsos__findnew(&machine
->kernel_dsos
, filename
);
382 map
= map__new2(start
, dso
, MAP__FUNCTION
);
386 if (machine__is_host(machine
))
387 dso
->symtab_type
= DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE
;
389 dso
->symtab_type
= DSO_BINARY_TYPE__GUEST_KMODULE
;
390 map_groups__insert(&machine
->kmaps
, map
);
394 size_t machines__fprintf_dsos(struct machines
*machines
, FILE *fp
)
397 size_t ret
= __dsos__fprintf(&machines
->host
.kernel_dsos
, fp
) +
398 __dsos__fprintf(&machines
->host
.user_dsos
, fp
);
400 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
401 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
402 ret
+= __dsos__fprintf(&pos
->kernel_dsos
, fp
);
403 ret
+= __dsos__fprintf(&pos
->user_dsos
, fp
);
409 size_t machine__fprintf_dsos_buildid(struct machine
*machine
, FILE *fp
,
410 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
412 return __dsos__fprintf_buildid(&machine
->kernel_dsos
, fp
, skip
, parm
) +
413 __dsos__fprintf_buildid(&machine
->user_dsos
, fp
, skip
, parm
);
416 size_t machines__fprintf_dsos_buildid(struct machines
*machines
, FILE *fp
,
417 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
420 size_t ret
= machine__fprintf_dsos_buildid(&machines
->host
, fp
, skip
, parm
);
422 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
423 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
424 ret
+= machine__fprintf_dsos_buildid(pos
, fp
, skip
, parm
);
429 size_t machine__fprintf_vmlinux_path(struct machine
*machine
, FILE *fp
)
433 struct dso
*kdso
= machine
->vmlinux_maps
[MAP__FUNCTION
]->dso
;
435 if (kdso
->has_build_id
) {
436 char filename
[PATH_MAX
];
437 if (dso__build_id_filename(kdso
, filename
, sizeof(filename
)))
438 printed
+= fprintf(fp
, "[0] %s\n", filename
);
441 for (i
= 0; i
< vmlinux_path__nr_entries
; ++i
)
442 printed
+= fprintf(fp
, "[%d] %s\n",
443 i
+ kdso
->has_build_id
, vmlinux_path
[i
]);
448 size_t machine__fprintf(struct machine
*machine
, FILE *fp
)
453 for (nd
= rb_first(&machine
->threads
); nd
; nd
= rb_next(nd
)) {
454 struct thread
*pos
= rb_entry(nd
, struct thread
, rb_node
);
456 ret
+= thread__fprintf(pos
, fp
);
462 static struct dso
*machine__get_kernel(struct machine
*machine
)
464 const char *vmlinux_name
= NULL
;
467 if (machine__is_host(machine
)) {
468 vmlinux_name
= symbol_conf
.vmlinux_name
;
470 vmlinux_name
= "[kernel.kallsyms]";
472 kernel
= dso__kernel_findnew(machine
, vmlinux_name
,
478 if (machine__is_default_guest(machine
))
479 vmlinux_name
= symbol_conf
.default_guest_vmlinux_name
;
481 vmlinux_name
= machine__mmap_name(machine
, bf
,
484 kernel
= dso__kernel_findnew(machine
, vmlinux_name
,
486 DSO_TYPE_GUEST_KERNEL
);
489 if (kernel
!= NULL
&& (!kernel
->has_build_id
))
490 dso__read_running_kernel_build_id(kernel
, machine
);
495 struct process_args
{
499 static int symbol__in_kernel(void *arg
, const char *name
,
500 char type __maybe_unused
, u64 start
)
502 struct process_args
*args
= arg
;
504 if (strchr(name
, '['))
511 static void machine__get_kallsyms_filename(struct machine
*machine
, char *buf
,
514 if (machine__is_default_guest(machine
))
515 scnprintf(buf
, bufsz
, "%s", symbol_conf
.default_guest_kallsyms
);
517 scnprintf(buf
, bufsz
, "%s/proc/kallsyms", machine
->root_dir
);
520 /* Figure out the start address of kernel map from /proc/kallsyms */
521 static u64
machine__get_kernel_start_addr(struct machine
*machine
)
523 char filename
[PATH_MAX
];
524 struct process_args args
;
526 machine__get_kallsyms_filename(machine
, filename
, PATH_MAX
);
528 if (symbol__restricted_filename(filename
, "/proc/kallsyms"))
531 if (kallsyms__parse(filename
, &args
, symbol__in_kernel
) <= 0)
537 int __machine__create_kernel_maps(struct machine
*machine
, struct dso
*kernel
)
540 u64 start
= machine__get_kernel_start_addr(machine
);
542 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
545 machine
->vmlinux_maps
[type
] = map__new2(start
, kernel
, type
);
546 if (machine
->vmlinux_maps
[type
] == NULL
)
549 machine
->vmlinux_maps
[type
]->map_ip
=
550 machine
->vmlinux_maps
[type
]->unmap_ip
=
552 kmap
= map__kmap(machine
->vmlinux_maps
[type
]);
553 kmap
->kmaps
= &machine
->kmaps
;
554 map_groups__insert(&machine
->kmaps
,
555 machine
->vmlinux_maps
[type
]);
561 void machine__destroy_kernel_maps(struct machine
*machine
)
565 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
568 if (machine
->vmlinux_maps
[type
] == NULL
)
571 kmap
= map__kmap(machine
->vmlinux_maps
[type
]);
572 map_groups__remove(&machine
->kmaps
,
573 machine
->vmlinux_maps
[type
]);
574 if (kmap
->ref_reloc_sym
) {
576 * ref_reloc_sym is shared among all maps, so free just
579 if (type
== MAP__FUNCTION
) {
580 zfree((char **)&kmap
->ref_reloc_sym
->name
);
581 zfree(&kmap
->ref_reloc_sym
);
583 kmap
->ref_reloc_sym
= NULL
;
586 map__delete(machine
->vmlinux_maps
[type
]);
587 machine
->vmlinux_maps
[type
] = NULL
;
591 int machines__create_guest_kernel_maps(struct machines
*machines
)
594 struct dirent
**namelist
= NULL
;
600 if (symbol_conf
.default_guest_vmlinux_name
||
601 symbol_conf
.default_guest_modules
||
602 symbol_conf
.default_guest_kallsyms
) {
603 machines__create_kernel_maps(machines
, DEFAULT_GUEST_KERNEL_ID
);
606 if (symbol_conf
.guestmount
) {
607 items
= scandir(symbol_conf
.guestmount
, &namelist
, NULL
, NULL
);
610 for (i
= 0; i
< items
; i
++) {
611 if (!isdigit(namelist
[i
]->d_name
[0])) {
612 /* Filter out . and .. */
615 pid
= (pid_t
)strtol(namelist
[i
]->d_name
, &endp
, 10);
616 if ((*endp
!= '\0') ||
617 (endp
== namelist
[i
]->d_name
) ||
619 pr_debug("invalid directory (%s). Skipping.\n",
620 namelist
[i
]->d_name
);
623 sprintf(path
, "%s/%s/proc/kallsyms",
624 symbol_conf
.guestmount
,
625 namelist
[i
]->d_name
);
626 ret
= access(path
, R_OK
);
628 pr_debug("Can't access file %s\n", path
);
631 machines__create_kernel_maps(machines
, pid
);
640 void machines__destroy_kernel_maps(struct machines
*machines
)
642 struct rb_node
*next
= rb_first(&machines
->guests
);
644 machine__destroy_kernel_maps(&machines
->host
);
647 struct machine
*pos
= rb_entry(next
, struct machine
, rb_node
);
649 next
= rb_next(&pos
->rb_node
);
650 rb_erase(&pos
->rb_node
, &machines
->guests
);
651 machine__delete(pos
);
655 int machines__create_kernel_maps(struct machines
*machines
, pid_t pid
)
657 struct machine
*machine
= machines__findnew(machines
, pid
);
662 return machine__create_kernel_maps(machine
);
665 int machine__load_kallsyms(struct machine
*machine
, const char *filename
,
666 enum map_type type
, symbol_filter_t filter
)
668 struct map
*map
= machine
->vmlinux_maps
[type
];
669 int ret
= dso__load_kallsyms(map
->dso
, filename
, map
, filter
);
672 dso__set_loaded(map
->dso
, type
);
674 * Since /proc/kallsyms will have multiple sessions for the
675 * kernel, with modules between them, fixup the end of all
678 __map_groups__fixup_end(&machine
->kmaps
, type
);
684 int machine__load_vmlinux_path(struct machine
*machine
, enum map_type type
,
685 symbol_filter_t filter
)
687 struct map
*map
= machine
->vmlinux_maps
[type
];
688 int ret
= dso__load_vmlinux_path(map
->dso
, map
, filter
);
691 dso__set_loaded(map
->dso
, type
);
696 static void map_groups__fixup_end(struct map_groups
*mg
)
699 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
700 __map_groups__fixup_end(mg
, i
);
703 static char *get_kernel_version(const char *root_dir
)
705 char version
[PATH_MAX
];
708 const char *prefix
= "Linux version ";
710 sprintf(version
, "%s/proc/version", root_dir
);
711 file
= fopen(version
, "r");
716 tmp
= fgets(version
, sizeof(version
), file
);
719 name
= strstr(version
, prefix
);
722 name
+= strlen(prefix
);
723 tmp
= strchr(name
, ' ');
730 static int map_groups__set_modules_path_dir(struct map_groups
*mg
,
731 const char *dir_name
, int depth
)
734 DIR *dir
= opendir(dir_name
);
738 pr_debug("%s: cannot open %s dir\n", __func__
, dir_name
);
742 while ((dent
= readdir(dir
)) != NULL
) {
746 /*sshfs might return bad dent->d_type, so we have to stat*/
747 snprintf(path
, sizeof(path
), "%s/%s", dir_name
, dent
->d_name
);
751 if (S_ISDIR(st
.st_mode
)) {
752 if (!strcmp(dent
->d_name
, ".") ||
753 !strcmp(dent
->d_name
, ".."))
756 /* Do not follow top-level source and build symlinks */
758 if (!strcmp(dent
->d_name
, "source") ||
759 !strcmp(dent
->d_name
, "build"))
763 ret
= map_groups__set_modules_path_dir(mg
, path
,
768 char *dot
= strrchr(dent
->d_name
, '.'),
773 if (dot
== NULL
|| strcmp(dot
, ".ko"))
775 snprintf(dso_name
, sizeof(dso_name
), "[%.*s]",
776 (int)(dot
- dent
->d_name
), dent
->d_name
);
778 strxfrchar(dso_name
, '-', '_');
779 map
= map_groups__find_by_name(mg
, MAP__FUNCTION
,
784 long_name
= strdup(path
);
785 if (long_name
== NULL
) {
789 dso__set_long_name(map
->dso
, long_name
, true);
790 dso__kernel_module_get_build_id(map
->dso
, "");
799 static int machine__set_modules_path(struct machine
*machine
)
802 char modules_path
[PATH_MAX
];
804 version
= get_kernel_version(machine
->root_dir
);
808 snprintf(modules_path
, sizeof(modules_path
), "%s/lib/modules/%s",
809 machine
->root_dir
, version
);
812 return map_groups__set_modules_path_dir(&machine
->kmaps
, modules_path
, 0);
815 static int machine__create_module(void *arg
, const char *name
, u64 start
)
817 struct machine
*machine
= arg
;
820 map
= machine__new_module(machine
, start
, name
);
824 dso__kernel_module_get_build_id(map
->dso
, machine
->root_dir
);
829 static int machine__create_modules(struct machine
*machine
)
834 if (machine__is_default_guest(machine
)) {
835 modules
= symbol_conf
.default_guest_modules
;
837 snprintf(path
, PATH_MAX
, "%s/proc/modules", machine
->root_dir
);
841 if (symbol__restricted_filename(modules
, "/proc/modules"))
844 if (modules__parse(modules
, machine
, machine__create_module
))
847 if (!machine__set_modules_path(machine
))
850 pr_debug("Problems setting modules path maps, continuing anyway...\n");
855 const char *ref_reloc_sym_names
[] = {"_text", "_stext", NULL
};
857 int machine__create_kernel_maps(struct machine
*machine
)
859 struct dso
*kernel
= machine__get_kernel(machine
);
860 char filename
[PATH_MAX
];
865 machine__get_kallsyms_filename(machine
, filename
, PATH_MAX
);
867 for (i
= 0; (name
= ref_reloc_sym_names
[i
]) != NULL
; i
++) {
868 addr
= kallsyms__get_function_start(filename
, name
);
875 if (kernel
== NULL
||
876 __machine__create_kernel_maps(machine
, kernel
) < 0)
879 if (symbol_conf
.use_modules
&& machine__create_modules(machine
) < 0) {
880 if (machine__is_host(machine
))
881 pr_debug("Problems creating module maps, "
882 "continuing anyway...\n");
884 pr_debug("Problems creating module maps for guest %d, "
885 "continuing anyway...\n", machine
->pid
);
889 * Now that we have all the maps created, just set the ->end of them:
891 map_groups__fixup_end(&machine
->kmaps
);
893 if (maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
, name
,
895 machine__destroy_kernel_maps(machine
);
902 static void machine__set_kernel_mmap_len(struct machine
*machine
,
903 union perf_event
*event
)
907 for (i
= 0; i
< MAP__NR_TYPES
; i
++) {
908 machine
->vmlinux_maps
[i
]->start
= event
->mmap
.start
;
909 machine
->vmlinux_maps
[i
]->end
= (event
->mmap
.start
+
912 * Be a bit paranoid here, some perf.data file came with
913 * a zero sized synthesized MMAP event for the kernel.
915 if (machine
->vmlinux_maps
[i
]->end
== 0)
916 machine
->vmlinux_maps
[i
]->end
= ~0ULL;
920 static bool machine__uses_kcore(struct machine
*machine
)
924 list_for_each_entry(dso
, &machine
->kernel_dsos
, node
) {
925 if (dso__is_kcore(dso
))
932 static int machine__process_kernel_mmap_event(struct machine
*machine
,
933 union perf_event
*event
)
936 char kmmap_prefix
[PATH_MAX
];
937 enum dso_kernel_type kernel_type
;
940 /* If we have maps from kcore then we do not need or want any others */
941 if (machine__uses_kcore(machine
))
944 machine__mmap_name(machine
, kmmap_prefix
, sizeof(kmmap_prefix
));
945 if (machine__is_host(machine
))
946 kernel_type
= DSO_TYPE_KERNEL
;
948 kernel_type
= DSO_TYPE_GUEST_KERNEL
;
950 is_kernel_mmap
= memcmp(event
->mmap
.filename
,
952 strlen(kmmap_prefix
) - 1) == 0;
953 if (event
->mmap
.filename
[0] == '/' ||
954 (!is_kernel_mmap
&& event
->mmap
.filename
[0] == '[')) {
956 char short_module_name
[1024];
959 if (event
->mmap
.filename
[0] == '/') {
960 name
= strrchr(event
->mmap
.filename
, '/');
965 dot
= strrchr(name
, '.');
968 snprintf(short_module_name
, sizeof(short_module_name
),
969 "[%.*s]", (int)(dot
- name
), name
);
970 strxfrchar(short_module_name
, '-', '_');
972 strcpy(short_module_name
, event
->mmap
.filename
);
974 map
= machine__new_module(machine
, event
->mmap
.start
,
975 event
->mmap
.filename
);
979 name
= strdup(short_module_name
);
983 dso__set_short_name(map
->dso
, name
, true);
984 map
->end
= map
->start
+ event
->mmap
.len
;
985 } else if (is_kernel_mmap
) {
986 const char *symbol_name
= (event
->mmap
.filename
+
987 strlen(kmmap_prefix
));
989 * Should be there already, from the build-id table in
992 struct dso
*kernel
= __dsos__findnew(&machine
->kernel_dsos
,
997 kernel
->kernel
= kernel_type
;
998 if (__machine__create_kernel_maps(machine
, kernel
) < 0)
1001 machine__set_kernel_mmap_len(machine
, event
);
1004 * Avoid using a zero address (kptr_restrict) for the ref reloc
1005 * symbol. Effectively having zero here means that at record
1006 * time /proc/sys/kernel/kptr_restrict was non zero.
1008 if (event
->mmap
.pgoff
!= 0) {
1009 maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
,
1014 if (machine__is_default_guest(machine
)) {
1016 * preload dso of guest kernel and modules
1018 dso__load(kernel
, machine
->vmlinux_maps
[MAP__FUNCTION
],
1027 int machine__process_mmap2_event(struct machine
*machine
,
1028 union perf_event
*event
,
1029 struct perf_sample
*sample __maybe_unused
)
1031 u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
1032 struct thread
*thread
;
1038 perf_event__fprintf_mmap2(event
, stdout
);
1040 if (cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1041 cpumode
== PERF_RECORD_MISC_KERNEL
) {
1042 ret
= machine__process_kernel_mmap_event(machine
, event
);
1048 thread
= machine__findnew_thread(machine
, event
->mmap2
.pid
,
1053 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1054 type
= MAP__VARIABLE
;
1056 type
= MAP__FUNCTION
;
1058 map
= map__new(&machine
->user_dsos
, event
->mmap2
.start
,
1059 event
->mmap2
.len
, event
->mmap2
.pgoff
,
1060 event
->mmap2
.pid
, event
->mmap2
.maj
,
1061 event
->mmap2
.min
, event
->mmap2
.ino
,
1062 event
->mmap2
.ino_generation
,
1065 event
->mmap2
.filename
, type
);
1070 thread__insert_map(thread
, map
);
1074 dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
1078 int machine__process_mmap_event(struct machine
*machine
, union perf_event
*event
,
1079 struct perf_sample
*sample __maybe_unused
)
1081 u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
1082 struct thread
*thread
;
1088 perf_event__fprintf_mmap(event
, stdout
);
1090 if (cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1091 cpumode
== PERF_RECORD_MISC_KERNEL
) {
1092 ret
= machine__process_kernel_mmap_event(machine
, event
);
1098 thread
= machine__findnew_thread(machine
, event
->mmap
.pid
,
1103 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1104 type
= MAP__VARIABLE
;
1106 type
= MAP__FUNCTION
;
1108 map
= map__new(&machine
->user_dsos
, event
->mmap
.start
,
1109 event
->mmap
.len
, event
->mmap
.pgoff
,
1110 event
->mmap
.pid
, 0, 0, 0, 0, 0, 0,
1111 event
->mmap
.filename
,
1117 thread__insert_map(thread
, map
);
1121 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
1125 static void machine__remove_thread(struct machine
*machine
, struct thread
*th
)
1127 machine
->last_match
= NULL
;
1128 rb_erase(&th
->rb_node
, &machine
->threads
);
1130 * We may have references to this thread, for instance in some hist_entry
1131 * instances, so just move them to a separate list.
1133 list_add_tail(&th
->node
, &machine
->dead_threads
);
1136 int machine__process_fork_event(struct machine
*machine
, union perf_event
*event
,
1137 struct perf_sample
*sample
)
1139 struct thread
*thread
= machine__find_thread(machine
,
1142 struct thread
*parent
= machine__findnew_thread(machine
,
1146 /* if a thread currently exists for the thread id remove it */
1148 machine__remove_thread(machine
, thread
);
1150 thread
= machine__findnew_thread(machine
, event
->fork
.pid
,
1153 perf_event__fprintf_task(event
, stdout
);
1155 if (thread
== NULL
|| parent
== NULL
||
1156 thread__fork(thread
, parent
, sample
->time
) < 0) {
1157 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
1164 int machine__process_exit_event(struct machine
*machine
, union perf_event
*event
,
1165 struct perf_sample
*sample __maybe_unused
)
1167 struct thread
*thread
= machine__find_thread(machine
,
1172 perf_event__fprintf_task(event
, stdout
);
1175 thread__exited(thread
);
1180 int machine__process_event(struct machine
*machine
, union perf_event
*event
,
1181 struct perf_sample
*sample
)
1185 switch (event
->header
.type
) {
1186 case PERF_RECORD_COMM
:
1187 ret
= machine__process_comm_event(machine
, event
, sample
); break;
1188 case PERF_RECORD_MMAP
:
1189 ret
= machine__process_mmap_event(machine
, event
, sample
); break;
1190 case PERF_RECORD_MMAP2
:
1191 ret
= machine__process_mmap2_event(machine
, event
, sample
); break;
1192 case PERF_RECORD_FORK
:
1193 ret
= machine__process_fork_event(machine
, event
, sample
); break;
1194 case PERF_RECORD_EXIT
:
1195 ret
= machine__process_exit_event(machine
, event
, sample
); break;
1196 case PERF_RECORD_LOST
:
1197 ret
= machine__process_lost_event(machine
, event
, sample
); break;
1206 static bool symbol__match_regex(struct symbol
*sym
, regex_t
*regex
)
1208 if (sym
->name
&& !regexec(regex
, sym
->name
, 0, NULL
, 0))
1213 static void ip__resolve_ams(struct machine
*machine
, struct thread
*thread
,
1214 struct addr_map_symbol
*ams
,
1217 struct addr_location al
;
1219 memset(&al
, 0, sizeof(al
));
1221 * We cannot use the header.misc hint to determine whether a
1222 * branch stack address is user, kernel, guest, hypervisor.
1223 * Branches may straddle the kernel/user/hypervisor boundaries.
1224 * Thus, we have to try consecutively until we find a match
1225 * or else, the symbol is unknown
1227 thread__find_cpumode_addr_location(thread
, machine
, MAP__FUNCTION
, ip
, &al
);
1230 ams
->al_addr
= al
.addr
;
1235 static void ip__resolve_data(struct machine
*machine
, struct thread
*thread
,
1236 u8 m
, struct addr_map_symbol
*ams
, u64 addr
)
1238 struct addr_location al
;
1240 memset(&al
, 0, sizeof(al
));
1242 thread__find_addr_location(thread
, machine
, m
, MAP__VARIABLE
, addr
,
1245 ams
->al_addr
= al
.addr
;
1250 struct mem_info
*sample__resolve_mem(struct perf_sample
*sample
,
1251 struct addr_location
*al
)
1253 struct mem_info
*mi
= zalloc(sizeof(*mi
));
1258 ip__resolve_ams(al
->machine
, al
->thread
, &mi
->iaddr
, sample
->ip
);
1259 ip__resolve_data(al
->machine
, al
->thread
, al
->cpumode
,
1260 &mi
->daddr
, sample
->addr
);
1261 mi
->data_src
.val
= sample
->data_src
;
1266 struct branch_info
*sample__resolve_bstack(struct perf_sample
*sample
,
1267 struct addr_location
*al
)
1270 const struct branch_stack
*bs
= sample
->branch_stack
;
1271 struct branch_info
*bi
= calloc(bs
->nr
, sizeof(struct branch_info
));
1276 for (i
= 0; i
< bs
->nr
; i
++) {
1277 ip__resolve_ams(al
->machine
, al
->thread
, &bi
[i
].to
, bs
->entries
[i
].to
);
1278 ip__resolve_ams(al
->machine
, al
->thread
, &bi
[i
].from
, bs
->entries
[i
].from
);
1279 bi
[i
].flags
= bs
->entries
[i
].flags
;
1284 static int machine__resolve_callchain_sample(struct machine
*machine
,
1285 struct thread
*thread
,
1286 struct ip_callchain
*chain
,
1287 struct symbol
**parent
,
1288 struct addr_location
*root_al
,
1291 u8 cpumode
= PERF_RECORD_MISC_USER
;
1292 int chain_nr
= min(max_stack
, (int)chain
->nr
);
1296 callchain_cursor_reset(&callchain_cursor
);
1298 if (chain
->nr
> PERF_MAX_STACK_DEPTH
) {
1299 pr_warning("corrupted callchain. skipping...\n");
1303 for (i
= 0; i
< chain_nr
; i
++) {
1305 struct addr_location al
;
1307 if (callchain_param
.order
== ORDER_CALLEE
)
1310 ip
= chain
->ips
[chain
->nr
- i
- 1];
1312 if (ip
>= PERF_CONTEXT_MAX
) {
1314 case PERF_CONTEXT_HV
:
1315 cpumode
= PERF_RECORD_MISC_HYPERVISOR
;
1317 case PERF_CONTEXT_KERNEL
:
1318 cpumode
= PERF_RECORD_MISC_KERNEL
;
1320 case PERF_CONTEXT_USER
:
1321 cpumode
= PERF_RECORD_MISC_USER
;
1324 pr_debug("invalid callchain context: "
1325 "%"PRId64
"\n", (s64
) ip
);
1327 * It seems the callchain is corrupted.
1330 callchain_cursor_reset(&callchain_cursor
);
1337 thread__find_addr_location(thread
, machine
, cpumode
,
1338 MAP__FUNCTION
, ip
, &al
);
1339 if (al
.sym
!= NULL
) {
1340 if (sort__has_parent
&& !*parent
&&
1341 symbol__match_regex(al
.sym
, &parent_regex
))
1343 else if (have_ignore_callees
&& root_al
&&
1344 symbol__match_regex(al
.sym
, &ignore_callees_regex
)) {
1345 /* Treat this symbol as the root,
1346 forgetting its callees. */
1348 callchain_cursor_reset(&callchain_cursor
);
1352 err
= callchain_cursor_append(&callchain_cursor
,
1353 ip
, al
.map
, al
.sym
);
1361 static int unwind_entry(struct unwind_entry
*entry
, void *arg
)
1363 struct callchain_cursor
*cursor
= arg
;
1364 return callchain_cursor_append(cursor
, entry
->ip
,
1365 entry
->map
, entry
->sym
);
1368 int machine__resolve_callchain(struct machine
*machine
,
1369 struct perf_evsel
*evsel
,
1370 struct thread
*thread
,
1371 struct perf_sample
*sample
,
1372 struct symbol
**parent
,
1373 struct addr_location
*root_al
,
1378 ret
= machine__resolve_callchain_sample(machine
, thread
,
1379 sample
->callchain
, parent
,
1380 root_al
, max_stack
);
1384 /* Can we do dwarf post unwind? */
1385 if (!((evsel
->attr
.sample_type
& PERF_SAMPLE_REGS_USER
) &&
1386 (evsel
->attr
.sample_type
& PERF_SAMPLE_STACK_USER
)))
1389 /* Bail out if nothing was captured. */
1390 if ((!sample
->user_regs
.regs
) ||
1391 (!sample
->user_stack
.size
))
1394 return unwind__get_entries(unwind_entry
, &callchain_cursor
, machine
,
1395 thread
, sample
, max_stack
);
1399 int machine__for_each_thread(struct machine
*machine
,
1400 int (*fn
)(struct thread
*thread
, void *p
),
1404 struct thread
*thread
;
1407 for (nd
= rb_first(&machine
->threads
); nd
; nd
= rb_next(nd
)) {
1408 thread
= rb_entry(nd
, struct thread
, rb_node
);
1409 rc
= fn(thread
, priv
);
1414 list_for_each_entry(thread
, &machine
->dead_threads
, node
) {
1415 rc
= fn(thread
, priv
);
1422 int __machine__synthesize_threads(struct machine
*machine
, struct perf_tool
*tool
,
1423 struct target
*target
, struct thread_map
*threads
,
1424 perf_event__handler_t process
, bool data_mmap
)
1426 if (target__has_task(target
))
1427 return perf_event__synthesize_thread_map(tool
, threads
, process
, machine
, data_mmap
);
1428 else if (target__has_cpu(target
))
1429 return perf_event__synthesize_threads(tool
, process
, machine
, data_mmap
);
1430 /* command specified */