14 int machine__init(struct machine
*machine
, const char *root_dir
, pid_t pid
)
16 map_groups__init(&machine
->kmaps
);
17 RB_CLEAR_NODE(&machine
->rb_node
);
18 INIT_LIST_HEAD(&machine
->user_dsos
);
19 INIT_LIST_HEAD(&machine
->kernel_dsos
);
21 machine
->threads
= RB_ROOT
;
22 INIT_LIST_HEAD(&machine
->dead_threads
);
23 machine
->last_match
= NULL
;
25 machine
->kmaps
.machine
= machine
;
28 machine
->symbol_filter
= NULL
;
30 machine
->root_dir
= strdup(root_dir
);
31 if (machine
->root_dir
== NULL
)
34 if (pid
!= HOST_KERNEL_ID
) {
35 struct thread
*thread
= machine__findnew_thread(machine
, 0,
42 snprintf(comm
, sizeof(comm
), "[guest/%d]", pid
);
43 thread__set_comm(thread
, comm
, 0);
49 struct machine
*machine__new_host(void)
51 struct machine
*machine
= malloc(sizeof(*machine
));
53 if (machine
!= NULL
) {
54 machine__init(machine
, "", HOST_KERNEL_ID
);
56 if (machine__create_kernel_maps(machine
) < 0)
66 static void dsos__delete(struct list_head
*dsos
)
70 list_for_each_entry_safe(pos
, n
, dsos
, node
) {
76 void machine__delete_dead_threads(struct machine
*machine
)
80 list_for_each_entry_safe(t
, n
, &machine
->dead_threads
, node
) {
86 void machine__delete_threads(struct machine
*machine
)
88 struct rb_node
*nd
= rb_first(&machine
->threads
);
91 struct thread
*t
= rb_entry(nd
, struct thread
, rb_node
);
93 rb_erase(&t
->rb_node
, &machine
->threads
);
99 void machine__exit(struct machine
*machine
)
101 map_groups__exit(&machine
->kmaps
);
102 dsos__delete(&machine
->user_dsos
);
103 dsos__delete(&machine
->kernel_dsos
);
104 free(machine
->root_dir
);
105 machine
->root_dir
= NULL
;
108 void machine__delete(struct machine
*machine
)
110 machine__exit(machine
);
114 void machines__init(struct machines
*machines
)
116 machine__init(&machines
->host
, "", HOST_KERNEL_ID
);
117 machines
->guests
= RB_ROOT
;
118 machines
->symbol_filter
= NULL
;
121 void machines__exit(struct machines
*machines
)
123 machine__exit(&machines
->host
);
127 struct machine
*machines__add(struct machines
*machines
, pid_t pid
,
128 const char *root_dir
)
130 struct rb_node
**p
= &machines
->guests
.rb_node
;
131 struct rb_node
*parent
= NULL
;
132 struct machine
*pos
, *machine
= malloc(sizeof(*machine
));
137 if (machine__init(machine
, root_dir
, pid
) != 0) {
142 machine
->symbol_filter
= machines
->symbol_filter
;
146 pos
= rb_entry(parent
, struct machine
, rb_node
);
153 rb_link_node(&machine
->rb_node
, parent
, p
);
154 rb_insert_color(&machine
->rb_node
, &machines
->guests
);
159 void machines__set_symbol_filter(struct machines
*machines
,
160 symbol_filter_t symbol_filter
)
164 machines
->symbol_filter
= symbol_filter
;
165 machines
->host
.symbol_filter
= symbol_filter
;
167 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
168 struct machine
*machine
= rb_entry(nd
, struct machine
, rb_node
);
170 machine
->symbol_filter
= symbol_filter
;
174 struct machine
*machines__find(struct machines
*machines
, pid_t pid
)
176 struct rb_node
**p
= &machines
->guests
.rb_node
;
177 struct rb_node
*parent
= NULL
;
178 struct machine
*machine
;
179 struct machine
*default_machine
= NULL
;
181 if (pid
== HOST_KERNEL_ID
)
182 return &machines
->host
;
186 machine
= rb_entry(parent
, struct machine
, rb_node
);
187 if (pid
< machine
->pid
)
189 else if (pid
> machine
->pid
)
194 default_machine
= machine
;
197 return default_machine
;
200 struct machine
*machines__findnew(struct machines
*machines
, pid_t pid
)
203 const char *root_dir
= "";
204 struct machine
*machine
= machines__find(machines
, pid
);
206 if (machine
&& (machine
->pid
== pid
))
209 if ((pid
!= HOST_KERNEL_ID
) &&
210 (pid
!= DEFAULT_GUEST_KERNEL_ID
) &&
211 (symbol_conf
.guestmount
)) {
212 sprintf(path
, "%s/%d", symbol_conf
.guestmount
, pid
);
213 if (access(path
, R_OK
)) {
214 static struct strlist
*seen
;
217 seen
= strlist__new(true, NULL
);
219 if (!strlist__has_entry(seen
, path
)) {
220 pr_err("Can't access file %s\n", path
);
221 strlist__add(seen
, path
);
229 machine
= machines__add(machines
, pid
, root_dir
);
234 void machines__process_guests(struct machines
*machines
,
235 machine__process_t process
, void *data
)
239 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
240 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
245 char *machine__mmap_name(struct machine
*machine
, char *bf
, size_t size
)
247 if (machine__is_host(machine
))
248 snprintf(bf
, size
, "[%s]", "kernel.kallsyms");
249 else if (machine__is_default_guest(machine
))
250 snprintf(bf
, size
, "[%s]", "guest.kernel.kallsyms");
252 snprintf(bf
, size
, "[%s.%d]", "guest.kernel.kallsyms",
259 void machines__set_id_hdr_size(struct machines
*machines
, u16 id_hdr_size
)
261 struct rb_node
*node
;
262 struct machine
*machine
;
264 machines
->host
.id_hdr_size
= id_hdr_size
;
266 for (node
= rb_first(&machines
->guests
); node
; node
= rb_next(node
)) {
267 machine
= rb_entry(node
, struct machine
, rb_node
);
268 machine
->id_hdr_size
= id_hdr_size
;
274 static struct thread
*__machine__findnew_thread(struct machine
*machine
,
275 pid_t pid
, pid_t tid
,
278 struct rb_node
**p
= &machine
->threads
.rb_node
;
279 struct rb_node
*parent
= NULL
;
283 * Front-end cache - TID lookups come in blocks,
284 * so most of the time we dont have to look up
287 if (machine
->last_match
&& machine
->last_match
->tid
== tid
) {
288 if (pid
&& pid
!= machine
->last_match
->pid_
)
289 machine
->last_match
->pid_
= pid
;
290 return machine
->last_match
;
295 th
= rb_entry(parent
, struct thread
, rb_node
);
297 if (th
->tid
== tid
) {
298 machine
->last_match
= th
;
299 if (pid
&& pid
!= th
->pid_
)
313 th
= thread__new(pid
, tid
);
315 rb_link_node(&th
->rb_node
, parent
, p
);
316 rb_insert_color(&th
->rb_node
, &machine
->threads
);
317 machine
->last_match
= th
;
323 struct thread
*machine__findnew_thread(struct machine
*machine
, pid_t pid
,
326 return __machine__findnew_thread(machine
, pid
, tid
, true);
329 struct thread
*machine__find_thread(struct machine
*machine
, pid_t tid
)
331 return __machine__findnew_thread(machine
, 0, tid
, false);
334 int machine__process_comm_event(struct machine
*machine
, union perf_event
*event
,
335 struct perf_sample
*sample
)
337 struct thread
*thread
= machine__findnew_thread(machine
,
342 perf_event__fprintf_comm(event
, stdout
);
344 if (thread
== NULL
|| thread__set_comm(thread
, event
->comm
.comm
, sample
->time
)) {
345 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
352 int machine__process_lost_event(struct machine
*machine __maybe_unused
,
353 union perf_event
*event
, struct perf_sample
*sample __maybe_unused
)
355 dump_printf(": id:%" PRIu64
": lost:%" PRIu64
"\n",
356 event
->lost
.id
, event
->lost
.lost
);
360 struct map
*machine__new_module(struct machine
*machine
, u64 start
,
361 const char *filename
)
364 struct dso
*dso
= __dsos__findnew(&machine
->kernel_dsos
, filename
);
369 map
= map__new2(start
, dso
, MAP__FUNCTION
);
373 if (machine__is_host(machine
))
374 dso
->symtab_type
= DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE
;
376 dso
->symtab_type
= DSO_BINARY_TYPE__GUEST_KMODULE
;
377 map_groups__insert(&machine
->kmaps
, map
);
381 size_t machines__fprintf_dsos(struct machines
*machines
, FILE *fp
)
384 size_t ret
= __dsos__fprintf(&machines
->host
.kernel_dsos
, fp
) +
385 __dsos__fprintf(&machines
->host
.user_dsos
, fp
);
387 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
388 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
389 ret
+= __dsos__fprintf(&pos
->kernel_dsos
, fp
);
390 ret
+= __dsos__fprintf(&pos
->user_dsos
, fp
);
396 size_t machine__fprintf_dsos_buildid(struct machine
*machine
, FILE *fp
,
397 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
399 return __dsos__fprintf_buildid(&machine
->kernel_dsos
, fp
, skip
, parm
) +
400 __dsos__fprintf_buildid(&machine
->user_dsos
, fp
, skip
, parm
);
403 size_t machines__fprintf_dsos_buildid(struct machines
*machines
, FILE *fp
,
404 bool (skip
)(struct dso
*dso
, int parm
), int parm
)
407 size_t ret
= machine__fprintf_dsos_buildid(&machines
->host
, fp
, skip
, parm
);
409 for (nd
= rb_first(&machines
->guests
); nd
; nd
= rb_next(nd
)) {
410 struct machine
*pos
= rb_entry(nd
, struct machine
, rb_node
);
411 ret
+= machine__fprintf_dsos_buildid(pos
, fp
, skip
, parm
);
416 size_t machine__fprintf_vmlinux_path(struct machine
*machine
, FILE *fp
)
420 struct dso
*kdso
= machine
->vmlinux_maps
[MAP__FUNCTION
]->dso
;
422 if (kdso
->has_build_id
) {
423 char filename
[PATH_MAX
];
424 if (dso__build_id_filename(kdso
, filename
, sizeof(filename
)))
425 printed
+= fprintf(fp
, "[0] %s\n", filename
);
428 for (i
= 0; i
< vmlinux_path__nr_entries
; ++i
)
429 printed
+= fprintf(fp
, "[%d] %s\n",
430 i
+ kdso
->has_build_id
, vmlinux_path
[i
]);
435 size_t machine__fprintf(struct machine
*machine
, FILE *fp
)
440 for (nd
= rb_first(&machine
->threads
); nd
; nd
= rb_next(nd
)) {
441 struct thread
*pos
= rb_entry(nd
, struct thread
, rb_node
);
443 ret
+= thread__fprintf(pos
, fp
);
449 static struct dso
*machine__get_kernel(struct machine
*machine
)
451 const char *vmlinux_name
= NULL
;
454 if (machine__is_host(machine
)) {
455 vmlinux_name
= symbol_conf
.vmlinux_name
;
457 vmlinux_name
= "[kernel.kallsyms]";
459 kernel
= dso__kernel_findnew(machine
, vmlinux_name
,
465 if (machine__is_default_guest(machine
))
466 vmlinux_name
= symbol_conf
.default_guest_vmlinux_name
;
468 vmlinux_name
= machine__mmap_name(machine
, bf
,
471 kernel
= dso__kernel_findnew(machine
, vmlinux_name
,
473 DSO_TYPE_GUEST_KERNEL
);
476 if (kernel
!= NULL
&& (!kernel
->has_build_id
))
477 dso__read_running_kernel_build_id(kernel
, machine
);
482 struct process_args
{
486 static int symbol__in_kernel(void *arg
, const char *name
,
487 char type __maybe_unused
, u64 start
)
489 struct process_args
*args
= arg
;
491 if (strchr(name
, '['))
498 /* Figure out the start address of kernel map from /proc/kallsyms */
499 static u64
machine__get_kernel_start_addr(struct machine
*machine
)
501 const char *filename
;
503 struct process_args args
;
505 if (machine__is_host(machine
)) {
506 filename
= "/proc/kallsyms";
508 if (machine__is_default_guest(machine
))
509 filename
= (char *)symbol_conf
.default_guest_kallsyms
;
511 sprintf(path
, "%s/proc/kallsyms", machine
->root_dir
);
516 if (symbol__restricted_filename(filename
, "/proc/kallsyms"))
519 if (kallsyms__parse(filename
, &args
, symbol__in_kernel
) <= 0)
525 int __machine__create_kernel_maps(struct machine
*machine
, struct dso
*kernel
)
528 u64 start
= machine__get_kernel_start_addr(machine
);
530 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
533 machine
->vmlinux_maps
[type
] = map__new2(start
, kernel
, type
);
534 if (machine
->vmlinux_maps
[type
] == NULL
)
537 machine
->vmlinux_maps
[type
]->map_ip
=
538 machine
->vmlinux_maps
[type
]->unmap_ip
=
540 kmap
= map__kmap(machine
->vmlinux_maps
[type
]);
541 kmap
->kmaps
= &machine
->kmaps
;
542 map_groups__insert(&machine
->kmaps
,
543 machine
->vmlinux_maps
[type
]);
549 void machine__destroy_kernel_maps(struct machine
*machine
)
553 for (type
= 0; type
< MAP__NR_TYPES
; ++type
) {
556 if (machine
->vmlinux_maps
[type
] == NULL
)
559 kmap
= map__kmap(machine
->vmlinux_maps
[type
]);
560 map_groups__remove(&machine
->kmaps
,
561 machine
->vmlinux_maps
[type
]);
562 if (kmap
->ref_reloc_sym
) {
564 * ref_reloc_sym is shared among all maps, so free just
567 if (type
== MAP__FUNCTION
) {
568 free((char *)kmap
->ref_reloc_sym
->name
);
569 kmap
->ref_reloc_sym
->name
= NULL
;
570 free(kmap
->ref_reloc_sym
);
572 kmap
->ref_reloc_sym
= NULL
;
575 map__delete(machine
->vmlinux_maps
[type
]);
576 machine
->vmlinux_maps
[type
] = NULL
;
580 int machines__create_guest_kernel_maps(struct machines
*machines
)
583 struct dirent
**namelist
= NULL
;
589 if (symbol_conf
.default_guest_vmlinux_name
||
590 symbol_conf
.default_guest_modules
||
591 symbol_conf
.default_guest_kallsyms
) {
592 machines__create_kernel_maps(machines
, DEFAULT_GUEST_KERNEL_ID
);
595 if (symbol_conf
.guestmount
) {
596 items
= scandir(symbol_conf
.guestmount
, &namelist
, NULL
, NULL
);
599 for (i
= 0; i
< items
; i
++) {
600 if (!isdigit(namelist
[i
]->d_name
[0])) {
601 /* Filter out . and .. */
604 pid
= (pid_t
)strtol(namelist
[i
]->d_name
, &endp
, 10);
605 if ((*endp
!= '\0') ||
606 (endp
== namelist
[i
]->d_name
) ||
608 pr_debug("invalid directory (%s). Skipping.\n",
609 namelist
[i
]->d_name
);
612 sprintf(path
, "%s/%s/proc/kallsyms",
613 symbol_conf
.guestmount
,
614 namelist
[i
]->d_name
);
615 ret
= access(path
, R_OK
);
617 pr_debug("Can't access file %s\n", path
);
620 machines__create_kernel_maps(machines
, pid
);
629 void machines__destroy_kernel_maps(struct machines
*machines
)
631 struct rb_node
*next
= rb_first(&machines
->guests
);
633 machine__destroy_kernel_maps(&machines
->host
);
636 struct machine
*pos
= rb_entry(next
, struct machine
, rb_node
);
638 next
= rb_next(&pos
->rb_node
);
639 rb_erase(&pos
->rb_node
, &machines
->guests
);
640 machine__delete(pos
);
644 int machines__create_kernel_maps(struct machines
*machines
, pid_t pid
)
646 struct machine
*machine
= machines__findnew(machines
, pid
);
651 return machine__create_kernel_maps(machine
);
654 int machine__load_kallsyms(struct machine
*machine
, const char *filename
,
655 enum map_type type
, symbol_filter_t filter
)
657 struct map
*map
= machine
->vmlinux_maps
[type
];
658 int ret
= dso__load_kallsyms(map
->dso
, filename
, map
, filter
);
661 dso__set_loaded(map
->dso
, type
);
663 * Since /proc/kallsyms will have multiple sessions for the
664 * kernel, with modules between them, fixup the end of all
667 __map_groups__fixup_end(&machine
->kmaps
, type
);
673 int machine__load_vmlinux_path(struct machine
*machine
, enum map_type type
,
674 symbol_filter_t filter
)
676 struct map
*map
= machine
->vmlinux_maps
[type
];
677 int ret
= dso__load_vmlinux_path(map
->dso
, map
, filter
);
680 dso__set_loaded(map
->dso
, type
);
685 static void map_groups__fixup_end(struct map_groups
*mg
)
688 for (i
= 0; i
< MAP__NR_TYPES
; ++i
)
689 __map_groups__fixup_end(mg
, i
);
692 static char *get_kernel_version(const char *root_dir
)
694 char version
[PATH_MAX
];
697 const char *prefix
= "Linux version ";
699 sprintf(version
, "%s/proc/version", root_dir
);
700 file
= fopen(version
, "r");
705 tmp
= fgets(version
, sizeof(version
), file
);
708 name
= strstr(version
, prefix
);
711 name
+= strlen(prefix
);
712 tmp
= strchr(name
, ' ');
719 static int map_groups__set_modules_path_dir(struct map_groups
*mg
,
720 const char *dir_name
)
723 DIR *dir
= opendir(dir_name
);
727 pr_debug("%s: cannot open %s dir\n", __func__
, dir_name
);
731 while ((dent
= readdir(dir
)) != NULL
) {
735 /*sshfs might return bad dent->d_type, so we have to stat*/
736 snprintf(path
, sizeof(path
), "%s/%s", dir_name
, dent
->d_name
);
740 if (S_ISDIR(st
.st_mode
)) {
741 if (!strcmp(dent
->d_name
, ".") ||
742 !strcmp(dent
->d_name
, ".."))
745 ret
= map_groups__set_modules_path_dir(mg
, path
);
749 char *dot
= strrchr(dent
->d_name
, '.'),
754 if (dot
== NULL
|| strcmp(dot
, ".ko"))
756 snprintf(dso_name
, sizeof(dso_name
), "[%.*s]",
757 (int)(dot
- dent
->d_name
), dent
->d_name
);
759 strxfrchar(dso_name
, '-', '_');
760 map
= map_groups__find_by_name(mg
, MAP__FUNCTION
,
765 long_name
= strdup(path
);
766 if (long_name
== NULL
) {
770 dso__set_long_name(map
->dso
, long_name
);
771 map
->dso
->lname_alloc
= 1;
772 dso__kernel_module_get_build_id(map
->dso
, "");
781 static int machine__set_modules_path(struct machine
*machine
)
784 char modules_path
[PATH_MAX
];
786 version
= get_kernel_version(machine
->root_dir
);
790 snprintf(modules_path
, sizeof(modules_path
), "%s/lib/modules/%s/kernel",
791 machine
->root_dir
, version
);
794 return map_groups__set_modules_path_dir(&machine
->kmaps
, modules_path
);
797 static int machine__create_module(void *arg
, const char *name
, u64 start
)
799 struct machine
*machine
= arg
;
802 map
= machine__new_module(machine
, start
, name
);
806 dso__kernel_module_get_build_id(map
->dso
, machine
->root_dir
);
811 static int machine__create_modules(struct machine
*machine
)
816 if (machine__is_default_guest(machine
)) {
817 modules
= symbol_conf
.default_guest_modules
;
819 snprintf(path
, PATH_MAX
, "%s/proc/modules", machine
->root_dir
);
823 if (symbol__restricted_filename(modules
, "/proc/modules"))
826 if (modules__parse(modules
, machine
, machine__create_module
))
829 if (!machine__set_modules_path(machine
))
832 pr_debug("Problems setting modules path maps, continuing anyway...\n");
837 int machine__create_kernel_maps(struct machine
*machine
)
839 struct dso
*kernel
= machine__get_kernel(machine
);
841 if (kernel
== NULL
||
842 __machine__create_kernel_maps(machine
, kernel
) < 0)
845 if (symbol_conf
.use_modules
&& machine__create_modules(machine
) < 0) {
846 if (machine__is_host(machine
))
847 pr_debug("Problems creating module maps, "
848 "continuing anyway...\n");
850 pr_debug("Problems creating module maps for guest %d, "
851 "continuing anyway...\n", machine
->pid
);
855 * Now that we have all the maps created, just set the ->end of them:
857 map_groups__fixup_end(&machine
->kmaps
);
861 static void machine__set_kernel_mmap_len(struct machine
*machine
,
862 union perf_event
*event
)
866 for (i
= 0; i
< MAP__NR_TYPES
; i
++) {
867 machine
->vmlinux_maps
[i
]->start
= event
->mmap
.start
;
868 machine
->vmlinux_maps
[i
]->end
= (event
->mmap
.start
+
871 * Be a bit paranoid here, some perf.data file came with
872 * a zero sized synthesized MMAP event for the kernel.
874 if (machine
->vmlinux_maps
[i
]->end
== 0)
875 machine
->vmlinux_maps
[i
]->end
= ~0ULL;
879 static bool machine__uses_kcore(struct machine
*machine
)
883 list_for_each_entry(dso
, &machine
->kernel_dsos
, node
) {
884 if (dso__is_kcore(dso
))
891 static int machine__process_kernel_mmap_event(struct machine
*machine
,
892 union perf_event
*event
)
895 char kmmap_prefix
[PATH_MAX
];
896 enum dso_kernel_type kernel_type
;
899 /* If we have maps from kcore then we do not need or want any others */
900 if (machine__uses_kcore(machine
))
903 machine__mmap_name(machine
, kmmap_prefix
, sizeof(kmmap_prefix
));
904 if (machine__is_host(machine
))
905 kernel_type
= DSO_TYPE_KERNEL
;
907 kernel_type
= DSO_TYPE_GUEST_KERNEL
;
909 is_kernel_mmap
= memcmp(event
->mmap
.filename
,
911 strlen(kmmap_prefix
) - 1) == 0;
912 if (event
->mmap
.filename
[0] == '/' ||
913 (!is_kernel_mmap
&& event
->mmap
.filename
[0] == '[')) {
915 char short_module_name
[1024];
918 if (event
->mmap
.filename
[0] == '/') {
919 name
= strrchr(event
->mmap
.filename
, '/');
924 dot
= strrchr(name
, '.');
927 snprintf(short_module_name
, sizeof(short_module_name
),
928 "[%.*s]", (int)(dot
- name
), name
);
929 strxfrchar(short_module_name
, '-', '_');
931 strcpy(short_module_name
, event
->mmap
.filename
);
933 map
= machine__new_module(machine
, event
->mmap
.start
,
934 event
->mmap
.filename
);
938 name
= strdup(short_module_name
);
942 map
->dso
->short_name
= name
;
943 map
->dso
->sname_alloc
= 1;
944 map
->end
= map
->start
+ event
->mmap
.len
;
945 } else if (is_kernel_mmap
) {
946 const char *symbol_name
= (event
->mmap
.filename
+
947 strlen(kmmap_prefix
));
949 * Should be there already, from the build-id table in
952 struct dso
*kernel
= __dsos__findnew(&machine
->kernel_dsos
,
957 kernel
->kernel
= kernel_type
;
958 if (__machine__create_kernel_maps(machine
, kernel
) < 0)
961 machine__set_kernel_mmap_len(machine
, event
);
964 * Avoid using a zero address (kptr_restrict) for the ref reloc
965 * symbol. Effectively having zero here means that at record
966 * time /proc/sys/kernel/kptr_restrict was non zero.
968 if (event
->mmap
.pgoff
!= 0) {
969 maps__set_kallsyms_ref_reloc_sym(machine
->vmlinux_maps
,
974 if (machine__is_default_guest(machine
)) {
976 * preload dso of guest kernel and modules
978 dso__load(kernel
, machine
->vmlinux_maps
[MAP__FUNCTION
],
987 int machine__process_mmap2_event(struct machine
*machine
,
988 union perf_event
*event
,
989 struct perf_sample
*sample __maybe_unused
)
991 u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
992 struct thread
*thread
;
998 perf_event__fprintf_mmap2(event
, stdout
);
1000 if (cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1001 cpumode
== PERF_RECORD_MISC_KERNEL
) {
1002 ret
= machine__process_kernel_mmap_event(machine
, event
);
1008 thread
= machine__findnew_thread(machine
, event
->mmap2
.pid
,
1013 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1014 type
= MAP__VARIABLE
;
1016 type
= MAP__FUNCTION
;
1018 map
= map__new(&machine
->user_dsos
, event
->mmap2
.start
,
1019 event
->mmap2
.len
, event
->mmap2
.pgoff
,
1020 event
->mmap2
.pid
, event
->mmap2
.maj
,
1021 event
->mmap2
.min
, event
->mmap2
.ino
,
1022 event
->mmap2
.ino_generation
,
1023 event
->mmap2
.filename
, type
);
1028 thread__insert_map(thread
, map
);
1032 dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
1036 int machine__process_mmap_event(struct machine
*machine
, union perf_event
*event
,
1037 struct perf_sample
*sample __maybe_unused
)
1039 u8 cpumode
= event
->header
.misc
& PERF_RECORD_MISC_CPUMODE_MASK
;
1040 struct thread
*thread
;
1046 perf_event__fprintf_mmap(event
, stdout
);
1048 if (cpumode
== PERF_RECORD_MISC_GUEST_KERNEL
||
1049 cpumode
== PERF_RECORD_MISC_KERNEL
) {
1050 ret
= machine__process_kernel_mmap_event(machine
, event
);
1056 thread
= machine__findnew_thread(machine
, event
->mmap
.pid
,
1061 if (event
->header
.misc
& PERF_RECORD_MISC_MMAP_DATA
)
1062 type
= MAP__VARIABLE
;
1064 type
= MAP__FUNCTION
;
1066 map
= map__new(&machine
->user_dsos
, event
->mmap
.start
,
1067 event
->mmap
.len
, event
->mmap
.pgoff
,
1068 event
->mmap
.pid
, 0, 0, 0, 0,
1069 event
->mmap
.filename
,
1075 thread__insert_map(thread
, map
);
1079 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
1083 static void machine__remove_thread(struct machine
*machine
, struct thread
*th
)
1085 machine
->last_match
= NULL
;
1086 rb_erase(&th
->rb_node
, &machine
->threads
);
1088 * We may have references to this thread, for instance in some hist_entry
1089 * instances, so just move them to a separate list.
1091 list_add_tail(&th
->node
, &machine
->dead_threads
);
1094 int machine__process_fork_event(struct machine
*machine
, union perf_event
*event
,
1095 struct perf_sample
*sample
)
1097 struct thread
*thread
= machine__find_thread(machine
, event
->fork
.tid
);
1098 struct thread
*parent
= machine__findnew_thread(machine
,
1102 /* if a thread currently exists for the thread id remove it */
1104 machine__remove_thread(machine
, thread
);
1106 thread
= machine__findnew_thread(machine
, event
->fork
.pid
,
1109 perf_event__fprintf_task(event
, stdout
);
1111 if (thread
== NULL
|| parent
== NULL
||
1112 thread__fork(thread
, parent
, sample
->time
) < 0) {
1113 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
1120 int machine__process_exit_event(struct machine
*machine
, union perf_event
*event
,
1121 struct perf_sample
*sample __maybe_unused
)
1123 struct thread
*thread
= machine__find_thread(machine
, event
->fork
.tid
);
1126 perf_event__fprintf_task(event
, stdout
);
1129 thread__exited(thread
);
1134 int machine__process_event(struct machine
*machine
, union perf_event
*event
,
1135 struct perf_sample
*sample
)
1139 switch (event
->header
.type
) {
1140 case PERF_RECORD_COMM
:
1141 ret
= machine__process_comm_event(machine
, event
, sample
); break;
1142 case PERF_RECORD_MMAP
:
1143 ret
= machine__process_mmap_event(machine
, event
, sample
); break;
1144 case PERF_RECORD_MMAP2
:
1145 ret
= machine__process_mmap2_event(machine
, event
, sample
); break;
1146 case PERF_RECORD_FORK
:
1147 ret
= machine__process_fork_event(machine
, event
, sample
); break;
1148 case PERF_RECORD_EXIT
:
1149 ret
= machine__process_exit_event(machine
, event
, sample
); break;
1150 case PERF_RECORD_LOST
:
1151 ret
= machine__process_lost_event(machine
, event
, sample
); break;
1160 static bool symbol__match_regex(struct symbol
*sym
, regex_t
*regex
)
1162 if (sym
->name
&& !regexec(regex
, sym
->name
, 0, NULL
, 0))
1167 static const u8 cpumodes
[] = {
1168 PERF_RECORD_MISC_USER
,
1169 PERF_RECORD_MISC_KERNEL
,
1170 PERF_RECORD_MISC_GUEST_USER
,
1171 PERF_RECORD_MISC_GUEST_KERNEL
1173 #define NCPUMODES (sizeof(cpumodes)/sizeof(u8))
1175 static void ip__resolve_ams(struct machine
*machine
, struct thread
*thread
,
1176 struct addr_map_symbol
*ams
,
1179 struct addr_location al
;
1183 memset(&al
, 0, sizeof(al
));
1185 for (i
= 0; i
< NCPUMODES
; i
++) {
1188 * We cannot use the header.misc hint to determine whether a
1189 * branch stack address is user, kernel, guest, hypervisor.
1190 * Branches may straddle the kernel/user/hypervisor boundaries.
1191 * Thus, we have to try consecutively until we find a match
1192 * or else, the symbol is unknown
1194 thread__find_addr_location(thread
, machine
, m
, MAP__FUNCTION
,
1201 ams
->al_addr
= al
.addr
;
1206 static void ip__resolve_data(struct machine
*machine
, struct thread
*thread
,
1207 u8 m
, struct addr_map_symbol
*ams
, u64 addr
)
1209 struct addr_location al
;
1211 memset(&al
, 0, sizeof(al
));
1213 thread__find_addr_location(thread
, machine
, m
, MAP__VARIABLE
, addr
,
1216 ams
->al_addr
= al
.addr
;
1221 struct mem_info
*machine__resolve_mem(struct machine
*machine
,
1223 struct perf_sample
*sample
,
1226 struct mem_info
*mi
= zalloc(sizeof(*mi
));
1231 ip__resolve_ams(machine
, thr
, &mi
->iaddr
, sample
->ip
);
1232 ip__resolve_data(machine
, thr
, cpumode
, &mi
->daddr
, sample
->addr
);
1233 mi
->data_src
.val
= sample
->data_src
;
1238 struct branch_info
*machine__resolve_bstack(struct machine
*machine
,
1240 struct branch_stack
*bs
)
1242 struct branch_info
*bi
;
1245 bi
= calloc(bs
->nr
, sizeof(struct branch_info
));
1249 for (i
= 0; i
< bs
->nr
; i
++) {
1250 ip__resolve_ams(machine
, thr
, &bi
[i
].to
, bs
->entries
[i
].to
);
1251 ip__resolve_ams(machine
, thr
, &bi
[i
].from
, bs
->entries
[i
].from
);
1252 bi
[i
].flags
= bs
->entries
[i
].flags
;
1257 static int machine__resolve_callchain_sample(struct machine
*machine
,
1258 struct thread
*thread
,
1259 struct ip_callchain
*chain
,
1260 struct symbol
**parent
,
1261 struct addr_location
*root_al
,
1264 u8 cpumode
= PERF_RECORD_MISC_USER
;
1265 int chain_nr
= min(max_stack
, (int)chain
->nr
);
1269 callchain_cursor_reset(&callchain_cursor
);
1271 if (chain
->nr
> PERF_MAX_STACK_DEPTH
) {
1272 pr_warning("corrupted callchain. skipping...\n");
1276 for (i
= 0; i
< chain_nr
; i
++) {
1278 struct addr_location al
;
1280 if (callchain_param
.order
== ORDER_CALLEE
)
1283 ip
= chain
->ips
[chain
->nr
- i
- 1];
1285 if (ip
>= PERF_CONTEXT_MAX
) {
1287 case PERF_CONTEXT_HV
:
1288 cpumode
= PERF_RECORD_MISC_HYPERVISOR
;
1290 case PERF_CONTEXT_KERNEL
:
1291 cpumode
= PERF_RECORD_MISC_KERNEL
;
1293 case PERF_CONTEXT_USER
:
1294 cpumode
= PERF_RECORD_MISC_USER
;
1297 pr_debug("invalid callchain context: "
1298 "%"PRId64
"\n", (s64
) ip
);
1300 * It seems the callchain is corrupted.
1303 callchain_cursor_reset(&callchain_cursor
);
1309 al
.filtered
= false;
1310 thread__find_addr_location(thread
, machine
, cpumode
,
1311 MAP__FUNCTION
, ip
, &al
);
1312 if (al
.sym
!= NULL
) {
1313 if (sort__has_parent
&& !*parent
&&
1314 symbol__match_regex(al
.sym
, &parent_regex
))
1316 else if (have_ignore_callees
&& root_al
&&
1317 symbol__match_regex(al
.sym
, &ignore_callees_regex
)) {
1318 /* Treat this symbol as the root,
1319 forgetting its callees. */
1321 callchain_cursor_reset(&callchain_cursor
);
1323 if (!symbol_conf
.use_callchain
)
1327 err
= callchain_cursor_append(&callchain_cursor
,
1328 ip
, al
.map
, al
.sym
);
1336 static int unwind_entry(struct unwind_entry
*entry
, void *arg
)
1338 struct callchain_cursor
*cursor
= arg
;
1339 return callchain_cursor_append(cursor
, entry
->ip
,
1340 entry
->map
, entry
->sym
);
1343 int machine__resolve_callchain(struct machine
*machine
,
1344 struct perf_evsel
*evsel
,
1345 struct thread
*thread
,
1346 struct perf_sample
*sample
,
1347 struct symbol
**parent
,
1348 struct addr_location
*root_al
,
1353 ret
= machine__resolve_callchain_sample(machine
, thread
,
1354 sample
->callchain
, parent
,
1355 root_al
, max_stack
);
1359 /* Can we do dwarf post unwind? */
1360 if (!((evsel
->attr
.sample_type
& PERF_SAMPLE_REGS_USER
) &&
1361 (evsel
->attr
.sample_type
& PERF_SAMPLE_STACK_USER
)))
1364 /* Bail out if nothing was captured. */
1365 if ((!sample
->user_regs
.regs
) ||
1366 (!sample
->user_stack
.size
))
1369 return unwind__get_entries(unwind_entry
, &callchain_cursor
, machine
,
1370 thread
, evsel
->attr
.sample_regs_user
,
1375 int machine__for_each_thread(struct machine
*machine
,
1376 int (*fn
)(struct thread
*thread
, void *p
),
1380 struct thread
*thread
;
1383 for (nd
= rb_first(&machine
->threads
); nd
; nd
= rb_next(nd
)) {
1384 thread
= rb_entry(nd
, struct thread
, rb_node
);
1385 rc
= fn(thread
, priv
);
1390 list_for_each_entry(thread
, &machine
->dead_threads
, node
) {
1391 rc
= fn(thread
, priv
);