Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
61d4290
Documentation
arch
block
crypto
drivers
firmware
fs
include
init
ipc
kernel
lib
mm
net
samples
scripts
security
sound
tools
cgroup
firewire
hv
include
lguest
lib
net
nfsd
perf
Documentation
arch
bench
config
python
scripts
tests
ui
util
include
scripting-engines
PERF-VERSION-GEN
abspath.c
alias.c
annotate.c
annotate.h
bitmap.c
build-id.c
build-id.h
cache.h
callchain.c
callchain.h
cgroup.c
cgroup.h
color.c
color.h
comm.c
comm.h
config.c
cpumap.c
cpumap.h
ctype.c
data.c
data.h
debug.c
debug.h
dso.c
dso.h
dwarf-aux.c
dwarf-aux.h
environment.c
event.c
event.h
evlist.c
evlist.h
evsel.c
evsel.h
exec_cmd.c
exec_cmd.h
generate-cmdlist.sh
header.c
header.h
help.c
help.h
hist.c
hist.h
hweight.c
intlist.c
intlist.h
levenshtein.c
levenshtein.h
machine.c
machine.h
map.c
map.h
pager.c
parse-events.c
parse-events.h
parse-events.l
parse-events.y
parse-options.c
parse-options.h
path.c
perf_regs.c
perf_regs.h
pmu.c
pmu.h
pmu.l
pmu.y
probe-event.c
probe-event.h
probe-finder.c
probe-finder.h
pstack.c
pstack.h
python-ext-sources
python.c
quote.c
quote.h
rblist.c
rblist.h
record.c
run-command.c
run-command.h
session.c
session.h
setup.py
sigchain.c
sigchain.h
sort.c
sort.h
srcline.c
stat.c
stat.h
strbuf.c
strbuf.h
strfilter.c
strfilter.h
string.c
strlist.c
strlist.h
svghelper.c
svghelper.h
symbol-elf.c
symbol-minimal.c
symbol.c
symbol.h
target.c
target.h
thread.c
thread.h
thread_map.c
thread_map.h
tool.h
top.c
top.h
trace-event-info.c
trace-event-parse.c
trace-event-read.c
trace-event-scripting.c
trace-event.c
trace-event.h
types.h
unwind-libdw.c
unwind-libdw.h
unwind-libunwind.c
unwind.h
usage.c
util.c
util.h
values.c
values.h
vdso.c
vdso.h
wrapper.c
xyarray.c
xyarray.h
.gitignore
CREDITS
MANIFEST
Makefile
Makefile.perf
builtin-annotate.c
builtin-bench.c
builtin-buildid-cache.c
builtin-buildid-list.c
builtin-diff.c
builtin-evlist.c
builtin-help.c
builtin-inject.c
builtin-kmem.c
builtin-kvm.c
builtin-list.c
builtin-lock.c
builtin-mem.c
builtin-probe.c
builtin-record.c
builtin-report.c
builtin-sched.c
builtin-script.c
builtin-stat.c
builtin-timechart.c
builtin-top.c
builtin-trace.c
builtin.h
command-list.txt
design.txt
perf-archive.sh
perf-completion.sh
perf.c
perf.h
power
scripts
testing
thermal
usb
virtio
vm
Makefile
usr
virt
.gitignore
.mailmap
COPYING
CREDITS
Kbuild
Kconfig
MAINTAINERS
Makefile
README
REPORTING-BUGS
Breadcrumbs
linux
/
tools
/
perf
/
util
/
machine.c
Blame
Blame
Latest commit
History
History
1419 lines (1164 loc) · 33.8 KB
Breadcrumbs
linux
/
tools
/
perf
/
util
/
machine.c
Top
File metadata and controls
Code
Blame
1419 lines (1164 loc) · 33.8 KB
Raw
#include "callchain.h" #include "debug.h" #include "event.h" #include "evsel.h" #include "hist.h" #include "machine.h" #include "map.h" #include "sort.h" #include "strlist.h" #include "thread.h" #include <stdbool.h> #include <symbol/kallsyms.h> #include "unwind.h" int machine__init(struct machine *machine, const char *root_dir, pid_t pid) { map_groups__init(&machine->kmaps); RB_CLEAR_NODE(&machine->rb_node); INIT_LIST_HEAD(&machine->user_dsos); INIT_LIST_HEAD(&machine->kernel_dsos); machine->threads = RB_ROOT; INIT_LIST_HEAD(&machine->dead_threads); machine->last_match = NULL; machine->kmaps.machine = machine; machine->pid = pid; machine->symbol_filter = NULL; machine->id_hdr_size = 0; machine->root_dir = strdup(root_dir); if (machine->root_dir == NULL) return -ENOMEM; if (pid != HOST_KERNEL_ID) { struct thread *thread = machine__findnew_thread(machine, 0, pid); char comm[64]; if (thread == NULL) return -ENOMEM; snprintf(comm, sizeof(comm), "[guest/%d]", pid); thread__set_comm(thread, comm, 0); } return 0; } struct machine *machine__new_host(void) { struct machine *machine = malloc(sizeof(*machine)); if (machine != NULL) { machine__init(machine, "", HOST_KERNEL_ID); if (machine__create_kernel_maps(machine) < 0) goto out_delete; } return machine; out_delete: free(machine); return NULL; } static void dsos__delete(struct list_head *dsos) { struct dso *pos, *n; list_for_each_entry_safe(pos, n, dsos, node) { list_del(&pos->node); dso__delete(pos); } } void machine__delete_dead_threads(struct machine *machine) { struct thread *n, *t; list_for_each_entry_safe(t, n, &machine->dead_threads, node) { list_del(&t->node); thread__delete(t); } } void machine__delete_threads(struct machine *machine) { struct rb_node *nd = rb_first(&machine->threads); while (nd) { struct thread *t = rb_entry(nd, struct thread, rb_node); rb_erase(&t->rb_node, &machine->threads); nd = rb_next(nd); thread__delete(t); } } void machine__exit(struct machine *machine) { map_groups__exit(&machine->kmaps); dsos__delete(&machine->user_dsos); dsos__delete(&machine->kernel_dsos); zfree(&machine->root_dir); } void machine__delete(struct machine *machine) { machine__exit(machine); free(machine); } void machines__init(struct machines *machines) { machine__init(&machines->host, "", HOST_KERNEL_ID); machines->guests = RB_ROOT; machines->symbol_filter = NULL; } void machines__exit(struct machines *machines) { machine__exit(&machines->host); /* XXX exit guest */ } struct machine *machines__add(struct machines *machines, pid_t pid, const char *root_dir) { struct rb_node **p = &machines->guests.rb_node; struct rb_node *parent = NULL; struct machine *pos, *machine = malloc(sizeof(*machine)); if (machine == NULL) return NULL; if (machine__init(machine, root_dir, pid) != 0) { free(machine); return NULL; } machine->symbol_filter = machines->symbol_filter; while (*p != NULL) { parent = *p; pos = rb_entry(parent, struct machine, rb_node); if (pid < pos->pid) p = &(*p)->rb_left; else p = &(*p)->rb_right; } rb_link_node(&machine->rb_node, parent, p); rb_insert_color(&machine->rb_node, &machines->guests); return machine; } void machines__set_symbol_filter(struct machines *machines, symbol_filter_t symbol_filter) { struct rb_node *nd; machines->symbol_filter = symbol_filter; machines->host.symbol_filter = symbol_filter; for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { struct machine *machine = rb_entry(nd, struct machine, rb_node); machine->symbol_filter = symbol_filter; } } struct machine *machines__find(struct machines *machines, pid_t pid) { struct rb_node **p = &machines->guests.rb_node; struct rb_node *parent = NULL; struct machine *machine; struct machine *default_machine = NULL; if (pid == HOST_KERNEL_ID) return &machines->host; while (*p != NULL) { parent = *p; machine = rb_entry(parent, struct machine, rb_node); if (pid < machine->pid) p = &(*p)->rb_left; else if (pid > machine->pid) p = &(*p)->rb_right; else return machine; if (!machine->pid) default_machine = machine; } return default_machine; } struct machine *machines__findnew(struct machines *machines, pid_t pid) { char path[PATH_MAX]; const char *root_dir = ""; struct machine *machine = machines__find(machines, pid); if (machine && (machine->pid == pid)) goto out; if ((pid != HOST_KERNEL_ID) && (pid != DEFAULT_GUEST_KERNEL_ID) && (symbol_conf.guestmount)) { sprintf(path, "%s/%d", symbol_conf.guestmount, pid); if (access(path, R_OK)) { static struct strlist *seen; if (!seen) seen = strlist__new(true, NULL); if (!strlist__has_entry(seen, path)) { pr_err("Can't access file %s\n", path); strlist__add(seen, path); } machine = NULL; goto out; } root_dir = path; } machine = machines__add(machines, pid, root_dir); out: return machine; } void machines__process_guests(struct machines *machines, machine__process_t process, void *data) { struct rb_node *nd; for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { struct machine *pos = rb_entry(nd, struct machine, rb_node); process(pos, data); } } char *machine__mmap_name(struct machine *machine, char *bf, size_t size) { if (machine__is_host(machine)) snprintf(bf, size, "[%s]", "kernel.kallsyms"); else if (machine__is_default_guest(machine)) snprintf(bf, size, "[%s]", "guest.kernel.kallsyms"); else { snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms", machine->pid); } return bf; } void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size) { struct rb_node *node; struct machine *machine; machines->host.id_hdr_size = id_hdr_size; for (node = rb_first(&machines->guests); node; node = rb_next(node)) { machine = rb_entry(node, struct machine, rb_node); machine->id_hdr_size = id_hdr_size; } return; } static struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid, bool create) { struct rb_node **p = &machine->threads.rb_node; struct rb_node *parent = NULL; struct thread *th; /* * Front-end cache - TID lookups come in blocks, * so most of the time we dont have to look up * the full rbtree: */ if (machine->last_match && machine->last_match->tid == tid) { if (pid && pid != machine->last_match->pid_) machine->last_match->pid_ = pid; return machine->last_match; } while (*p != NULL) { parent = *p; th = rb_entry(parent, struct thread, rb_node); if (th->tid == tid) { machine->last_match = th; if (pid && pid != th->pid_) th->pid_ = pid; return th; } if (tid < th->tid) p = &(*p)->rb_left; else p = &(*p)->rb_right; } if (!create) return NULL; th = thread__new(pid, tid); if (th != NULL) { rb_link_node(&th->rb_node, parent, p); rb_insert_color(&th->rb_node, &machine->threads); machine->last_match = th; } return th; } struct thread *machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid) { return __machine__findnew_thread(machine, pid, tid, true); } struct thread *machine__find_thread(struct machine *machine, pid_t pid, pid_t tid) { return __machine__findnew_thread(machine, pid, tid, false); } int machine__process_comm_event(struct machine *machine, union perf_event *event, struct perf_sample *sample) { struct thread *thread = machine__findnew_thread(machine, event->comm.pid, event->comm.tid); if (dump_trace) perf_event__fprintf_comm(event, stdout); if (thread == NULL || thread__set_comm(thread, event->comm.comm, sample->time)) { dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n"); return -1; } return 0; } int machine__process_lost_event(struct machine *machine __maybe_unused, union perf_event *event, struct perf_sample *sample __maybe_unused) { dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n", event->lost.id, event->lost.lost); return 0; } struct map *machine__new_module(struct machine *machine, u64 start, const char *filename) { struct map *map; struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename); if (dso == NULL) return NULL; map = map__new2(start, dso, MAP__FUNCTION); if (map == NULL) return NULL; if (machine__is_host(machine)) dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE; else dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE; map_groups__insert(&machine->kmaps, map); return map; } size_t machines__fprintf_dsos(struct machines *machines, FILE *fp) { struct rb_node *nd; size_t ret = __dsos__fprintf(&machines->host.kernel_dsos, fp) + __dsos__fprintf(&machines->host.user_dsos, fp); for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { struct machine *pos = rb_entry(nd, struct machine, rb_node); ret += __dsos__fprintf(&pos->kernel_dsos, fp); ret += __dsos__fprintf(&pos->user_dsos, fp); } return ret; } size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp, bool (skip)(struct dso *dso, int parm), int parm) { return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, skip, parm) + __dsos__fprintf_buildid(&machine->user_dsos, fp, skip, parm); } size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp, bool (skip)(struct dso *dso, int parm), int parm) { struct rb_node *nd; size_t ret = machine__fprintf_dsos_buildid(&machines->host, fp, skip, parm); for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { struct machine *pos = rb_entry(nd, struct machine, rb_node); ret += machine__fprintf_dsos_buildid(pos, fp, skip, parm); } return ret; } size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp) { int i; size_t printed = 0; struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso; if (kdso->has_build_id) { char filename[PATH_MAX]; if (dso__build_id_filename(kdso, filename, sizeof(filename))) printed += fprintf(fp, "[0] %s\n", filename); } for (i = 0; i < vmlinux_path__nr_entries; ++i) printed += fprintf(fp, "[%d] %s\n", i + kdso->has_build_id, vmlinux_path[i]); return printed; } size_t machine__fprintf(struct machine *machine, FILE *fp) { size_t ret = 0; struct rb_node *nd; for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) { struct thread *pos = rb_entry(nd, struct thread, rb_node); ret += thread__fprintf(pos, fp); } return ret; } static struct dso *machine__get_kernel(struct machine *machine) { const char *vmlinux_name = NULL; struct dso *kernel; if (machine__is_host(machine)) { vmlinux_name = symbol_conf.vmlinux_name; if (!vmlinux_name) vmlinux_name = "[kernel.kallsyms]"; kernel = dso__kernel_findnew(machine, vmlinux_name, "[kernel]", DSO_TYPE_KERNEL); } else { char bf[PATH_MAX]; if (machine__is_default_guest(machine)) vmlinux_name = symbol_conf.default_guest_vmlinux_name; if (!vmlinux_name) vmlinux_name = machine__mmap_name(machine, bf, sizeof(bf)); kernel = dso__kernel_findnew(machine, vmlinux_name, "[guest.kernel]", DSO_TYPE_GUEST_KERNEL); } if (kernel != NULL && (!kernel->has_build_id)) dso__read_running_kernel_build_id(kernel, machine); return kernel; } struct process_args { u64 start; }; static int symbol__in_kernel(void *arg, const char *name, char type __maybe_unused, u64 start) { struct process_args *args = arg; if (strchr(name, '[')) return 0; args->start = start; return 1; } static void machine__get_kallsyms_filename(struct machine *machine, char *buf, size_t bufsz) { if (machine__is_default_guest(machine)) scnprintf(buf, bufsz, "%s", symbol_conf.default_guest_kallsyms); else scnprintf(buf, bufsz, "%s/proc/kallsyms", machine->root_dir); } /* Figure out the start address of kernel map from /proc/kallsyms */ static u64 machine__get_kernel_start_addr(struct machine *machine) { char filename[PATH_MAX]; struct process_args args; machine__get_kallsyms_filename(machine, filename, PATH_MAX); if (symbol__restricted_filename(filename, "/proc/kallsyms")) return 0; if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0) return 0; return args.start; } int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel) { enum map_type type; u64 start = machine__get_kernel_start_addr(machine); for (type = 0; type < MAP__NR_TYPES; ++type) { struct kmap *kmap; machine->vmlinux_maps[type] = map__new2(start, kernel, type); if (machine->vmlinux_maps[type] == NULL) return -1; machine->vmlinux_maps[type]->map_ip = machine->vmlinux_maps[type]->unmap_ip = identity__map_ip; kmap = map__kmap(machine->vmlinux_maps[type]); kmap->kmaps = &machine->kmaps; map_groups__insert(&machine->kmaps, machine->vmlinux_maps[type]); } return 0; } void machine__destroy_kernel_maps(struct machine *machine) { enum map_type type; for (type = 0; type < MAP__NR_TYPES; ++type) { struct kmap *kmap; if (machine->vmlinux_maps[type] == NULL) continue; kmap = map__kmap(machine->vmlinux_maps[type]); map_groups__remove(&machine->kmaps, machine->vmlinux_maps[type]); if (kmap->ref_reloc_sym) { /* * ref_reloc_sym is shared among all maps, so free just * on one of them. */ if (type == MAP__FUNCTION) { zfree((char **)&kmap->ref_reloc_sym->name); zfree(&kmap->ref_reloc_sym); } else kmap->ref_reloc_sym = NULL; } map__delete(machine->vmlinux_maps[type]); machine->vmlinux_maps[type] = NULL; } } int machines__create_guest_kernel_maps(struct machines *machines) { int ret = 0; struct dirent **namelist = NULL; int i, items = 0; char path[PATH_MAX]; pid_t pid; char *endp; if (symbol_conf.default_guest_vmlinux_name || symbol_conf.default_guest_modules || symbol_conf.default_guest_kallsyms) { machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID); } if (symbol_conf.guestmount) { items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL); if (items <= 0) return -ENOENT; for (i = 0; i < items; i++) { if (!isdigit(namelist[i]->d_name[0])) { /* Filter out . and .. */ continue; } pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10); if ((*endp != '\0') || (endp == namelist[i]->d_name) || (errno == ERANGE)) { pr_debug("invalid directory (%s). Skipping.\n", namelist[i]->d_name); continue; } sprintf(path, "%s/%s/proc/kallsyms", symbol_conf.guestmount, namelist[i]->d_name); ret = access(path, R_OK); if (ret) { pr_debug("Can't access file %s\n", path); goto failure; } machines__create_kernel_maps(machines, pid); } failure: free(namelist); } return ret; } void machines__destroy_kernel_maps(struct machines *machines) { struct rb_node *next = rb_first(&machines->guests); machine__destroy_kernel_maps(&machines->host); while (next) { struct machine *pos = rb_entry(next, struct machine, rb_node); next = rb_next(&pos->rb_node); rb_erase(&pos->rb_node, &machines->guests); machine__delete(pos); } } int machines__create_kernel_maps(struct machines *machines, pid_t pid) { struct machine *machine = machines__findnew(machines, pid); if (machine == NULL) return -1; return machine__create_kernel_maps(machine); } int machine__load_kallsyms(struct machine *machine, const char *filename, enum map_type type, symbol_filter_t filter) { struct map *map = machine->vmlinux_maps[type]; int ret = dso__load_kallsyms(map->dso, filename, map, filter); if (ret > 0) { dso__set_loaded(map->dso, type); /* * Since /proc/kallsyms will have multiple sessions for the * kernel, with modules between them, fixup the end of all * sections. */ __map_groups__fixup_end(&machine->kmaps, type); } return ret; } int machine__load_vmlinux_path(struct machine *machine, enum map_type type, symbol_filter_t filter) { struct map *map = machine->vmlinux_maps[type]; int ret = dso__load_vmlinux_path(map->dso, map, filter); if (ret > 0) dso__set_loaded(map->dso, type); return ret; } static void map_groups__fixup_end(struct map_groups *mg) { int i; for (i = 0; i < MAP__NR_TYPES; ++i) __map_groups__fixup_end(mg, i); } static char *get_kernel_version(const char *root_dir) { char version[PATH_MAX]; FILE *file; char *name, *tmp; const char *prefix = "Linux version "; sprintf(version, "%s/proc/version", root_dir); file = fopen(version, "r"); if (!file) return NULL; version[0] = '\0'; tmp = fgets(version, sizeof(version), file); fclose(file); name = strstr(version, prefix); if (!name) return NULL; name += strlen(prefix); tmp = strchr(name, ' '); if (tmp) *tmp = '\0'; return strdup(name); } static int map_groups__set_modules_path_dir(struct map_groups *mg, const char *dir_name, int depth) { struct dirent *dent; DIR *dir = opendir(dir_name); int ret = 0; if (!dir) { pr_debug("%s: cannot open %s dir\n", __func__, dir_name); return -1; } while ((dent = readdir(dir)) != NULL) { char path[PATH_MAX]; struct stat st; /*sshfs might return bad dent->d_type, so we have to stat*/ snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name); if (stat(path, &st)) continue; if (S_ISDIR(st.st_mode)) { if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..")) continue; /* Do not follow top-level source and build symlinks */ if (depth == 0) { if (!strcmp(dent->d_name, "source") || !strcmp(dent->d_name, "build")) continue; } ret = map_groups__set_modules_path_dir(mg, path, depth + 1); if (ret < 0) goto out; } else { char *dot = strrchr(dent->d_name, '.'), dso_name[PATH_MAX]; struct map *map; char *long_name; if (dot == NULL || strcmp(dot, ".ko")) continue; snprintf(dso_name, sizeof(dso_name), "[%.*s]", (int)(dot - dent->d_name), dent->d_name); strxfrchar(dso_name, '-', '_'); map = map_groups__find_by_name(mg, MAP__FUNCTION, dso_name); if (map == NULL) continue; long_name = strdup(path); if (long_name == NULL) { ret = -1; goto out; } dso__set_long_name(map->dso, long_name, true); dso__kernel_module_get_build_id(map->dso, ""); } } out: closedir(dir); return ret; } static int machine__set_modules_path(struct machine *machine) { char *version; char modules_path[PATH_MAX]; version = get_kernel_version(machine->root_dir); if (!version) return -1; snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s", machine->root_dir, version); free(version); return map_groups__set_modules_path_dir(&machine->kmaps, modules_path, 0); } static int machine__create_module(void *arg, const char *name, u64 start) { struct machine *machine = arg; struct map *map; map = machine__new_module(machine, start, name); if (map == NULL) return -1; dso__kernel_module_get_build_id(map->dso, machine->root_dir); return 0; } static int machine__create_modules(struct machine *machine) { const char *modules; char path[PATH_MAX]; if (machine__is_default_guest(machine)) { modules = symbol_conf.default_guest_modules; } else { snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir); modules = path; } if (symbol__restricted_filename(modules, "/proc/modules")) return -1; if (modules__parse(modules, machine, machine__create_module)) return -1; if (!machine__set_modules_path(machine)) return 0; pr_debug("Problems setting modules path maps, continuing anyway...\n"); return 0; } const char *ref_reloc_sym_names[] = {"_text", "_stext", NULL}; int machine__create_kernel_maps(struct machine *machine) { struct dso *kernel = machine__get_kernel(machine); char filename[PATH_MAX]; const char *name; u64 addr = 0; int i; machine__get_kallsyms_filename(machine, filename, PATH_MAX); for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) { addr = kallsyms__get_function_start(filename, name); if (addr) break; } if (!addr) return -1; if (kernel == NULL || __machine__create_kernel_maps(machine, kernel) < 0) return -1; if (symbol_conf.use_modules && machine__create_modules(machine) < 0) { if (machine__is_host(machine)) pr_debug("Problems creating module maps, " "continuing anyway...\n"); else pr_debug("Problems creating module maps for guest %d, " "continuing anyway...\n", machine->pid); } /* * Now that we have all the maps created, just set the ->end of them: */ map_groups__fixup_end(&machine->kmaps); if (maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, name, addr)) { machine__destroy_kernel_maps(machine); return -1; } return 0; } static void machine__set_kernel_mmap_len(struct machine *machine, union perf_event *event) { int i; for (i = 0; i < MAP__NR_TYPES; i++) { machine->vmlinux_maps[i]->start = event->mmap.start; machine->vmlinux_maps[i]->end = (event->mmap.start + event->mmap.len); /* * Be a bit paranoid here, some perf.data file came with * a zero sized synthesized MMAP event for the kernel. */ if (machine->vmlinux_maps[i]->end == 0) machine->vmlinux_maps[i]->end = ~0ULL; } } static bool machine__uses_kcore(struct machine *machine) { struct dso *dso; list_for_each_entry(dso, &machine->kernel_dsos, node) { if (dso__is_kcore(dso)) return true; } return false; } static int machine__process_kernel_mmap_event(struct machine *machine, union perf_event *event) { struct map *map; char kmmap_prefix[PATH_MAX]; enum dso_kernel_type kernel_type; bool is_kernel_mmap; /* If we have maps from kcore then we do not need or want any others */ if (machine__uses_kcore(machine)) return 0; machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix)); if (machine__is_host(machine)) kernel_type = DSO_TYPE_KERNEL; else kernel_type = DSO_TYPE_GUEST_KERNEL; is_kernel_mmap = memcmp(event->mmap.filename, kmmap_prefix, strlen(kmmap_prefix) - 1) == 0; if (event->mmap.filename[0] == '/' || (!is_kernel_mmap && event->mmap.filename[0] == '[')) { char short_module_name[1024]; char *name, *dot; if (event->mmap.filename[0] == '/') { name = strrchr(event->mmap.filename, '/'); if (name == NULL) goto out_problem; ++name; /* skip / */ dot = strrchr(name, '.'); if (dot == NULL) goto out_problem; snprintf(short_module_name, sizeof(short_module_name), "[%.*s]", (int)(dot - name), name); strxfrchar(short_module_name, '-', '_'); } else strcpy(short_module_name, event->mmap.filename); map = machine__new_module(machine, event->mmap.start, event->mmap.filename); if (map == NULL) goto out_problem; name = strdup(short_module_name); if (name == NULL) goto out_problem; dso__set_short_name(map->dso, name, true); map->end = map->start + event->mmap.len; } else if (is_kernel_mmap) { const char *symbol_name = (event->mmap.filename + strlen(kmmap_prefix)); /* * Should be there already, from the build-id table in * the header. */ struct dso *kernel = __dsos__findnew(&machine->kernel_dsos, kmmap_prefix); if (kernel == NULL) goto out_problem; kernel->kernel = kernel_type; if (__machine__create_kernel_maps(machine, kernel) < 0) goto out_problem; machine__set_kernel_mmap_len(machine, event); /* * Avoid using a zero address (kptr_restrict) for the ref reloc * symbol. Effectively having zero here means that at record * time /proc/sys/kernel/kptr_restrict was non zero. */ if (event->mmap.pgoff != 0) { maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, symbol_name, event->mmap.pgoff); } if (machine__is_default_guest(machine)) { /* * preload dso of guest kernel and modules */ dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION], NULL); } } return 0; out_problem: return -1; } int machine__process_mmap2_event(struct machine *machine, union perf_event *event, struct perf_sample *sample __maybe_unused) { u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; struct thread *thread; struct map *map; enum map_type type; int ret = 0; if (dump_trace) perf_event__fprintf_mmap2(event, stdout); if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL || cpumode == PERF_RECORD_MISC_KERNEL) { ret = machine__process_kernel_mmap_event(machine, event); if (ret < 0) goto out_problem; return 0; } thread = machine__findnew_thread(machine, event->mmap2.pid, event->mmap2.tid); if (thread == NULL) goto out_problem; if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) type = MAP__VARIABLE; else type = MAP__FUNCTION; map = map__new(&machine->user_dsos, event->mmap2.start, event->mmap2.len, event->mmap2.pgoff, event->mmap2.pid, event->mmap2.maj, event->mmap2.min, event->mmap2.ino, event->mmap2.ino_generation, event->mmap2.filename, type); if (map == NULL) goto out_problem; thread__insert_map(thread, map); return 0; out_problem: dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n"); return 0; } int machine__process_mmap_event(struct machine *machine, union perf_event *event, struct perf_sample *sample __maybe_unused) { u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; struct thread *thread; struct map *map; enum map_type type; int ret = 0; if (dump_trace) perf_event__fprintf_mmap(event, stdout); if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL || cpumode == PERF_RECORD_MISC_KERNEL) { ret = machine__process_kernel_mmap_event(machine, event); if (ret < 0) goto out_problem; return 0; } thread = machine__findnew_thread(machine, event->mmap.pid, event->mmap.tid); if (thread == NULL) goto out_problem; if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) type = MAP__VARIABLE; else type = MAP__FUNCTION; map = map__new(&machine->user_dsos, event->mmap.start, event->mmap.len, event->mmap.pgoff, event->mmap.pid, 0, 0, 0, 0, event->mmap.filename, type); if (map == NULL) goto out_problem; thread__insert_map(thread, map); return 0; out_problem: dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n"); return 0; } static void machine__remove_thread(struct machine *machine, struct thread *th) { machine->last_match = NULL; rb_erase(&th->rb_node, &machine->threads); /* * We may have references to this thread, for instance in some hist_entry * instances, so just move them to a separate list. */ list_add_tail(&th->node, &machine->dead_threads); } int machine__process_fork_event(struct machine *machine, union perf_event *event, struct perf_sample *sample) { struct thread *thread = machine__find_thread(machine, event->fork.pid, event->fork.tid); struct thread *parent = machine__findnew_thread(machine, event->fork.ppid, event->fork.ptid); /* if a thread currently exists for the thread id remove it */ if (thread != NULL) machine__remove_thread(machine, thread); thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid); if (dump_trace) perf_event__fprintf_task(event, stdout); if (thread == NULL || parent == NULL || thread__fork(thread, parent, sample->time) < 0) { dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n"); return -1; } return 0; } int machine__process_exit_event(struct machine *machine, union perf_event *event, struct perf_sample *sample __maybe_unused) { struct thread *thread = machine__find_thread(machine, event->fork.pid, event->fork.tid); if (dump_trace) perf_event__fprintf_task(event, stdout); if (thread != NULL) thread__exited(thread); return 0; } int machine__process_event(struct machine *machine, union perf_event *event, struct perf_sample *sample) { int ret; switch (event->header.type) { case PERF_RECORD_COMM: ret = machine__process_comm_event(machine, event, sample); break; case PERF_RECORD_MMAP: ret = machine__process_mmap_event(machine, event, sample); break; case PERF_RECORD_MMAP2: ret = machine__process_mmap2_event(machine, event, sample); break; case PERF_RECORD_FORK: ret = machine__process_fork_event(machine, event, sample); break; case PERF_RECORD_EXIT: ret = machine__process_exit_event(machine, event, sample); break; case PERF_RECORD_LOST: ret = machine__process_lost_event(machine, event, sample); break; default: ret = -1; break; } return ret; } static bool symbol__match_regex(struct symbol *sym, regex_t *regex) { if (sym->name && !regexec(regex, sym->name, 0, NULL, 0)) return 1; return 0; } static void ip__resolve_ams(struct machine *machine, struct thread *thread, struct addr_map_symbol *ams, u64 ip) { struct addr_location al; memset(&al, 0, sizeof(al)); /* * We cannot use the header.misc hint to determine whether a * branch stack address is user, kernel, guest, hypervisor. * Branches may straddle the kernel/user/hypervisor boundaries. * Thus, we have to try consecutively until we find a match * or else, the symbol is unknown */ thread__find_cpumode_addr_location(thread, machine, MAP__FUNCTION, ip, &al); ams->addr = ip; ams->al_addr = al.addr; ams->sym = al.sym; ams->map = al.map; } static void ip__resolve_data(struct machine *machine, struct thread *thread, u8 m, struct addr_map_symbol *ams, u64 addr) { struct addr_location al; memset(&al, 0, sizeof(al)); thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr, &al); ams->addr = addr; ams->al_addr = al.addr; ams->sym = al.sym; ams->map = al.map; } struct mem_info *sample__resolve_mem(struct perf_sample *sample, struct addr_location *al) { struct mem_info *mi = zalloc(sizeof(*mi)); if (!mi) return NULL; ip__resolve_ams(al->machine, al->thread, &mi->iaddr, sample->ip); ip__resolve_data(al->machine, al->thread, al->cpumode, &mi->daddr, sample->addr); mi->data_src.val = sample->data_src; return mi; } struct branch_info *sample__resolve_bstack(struct perf_sample *sample, struct addr_location *al) { unsigned int i; const struct branch_stack *bs = sample->branch_stack; struct branch_info *bi = calloc(bs->nr, sizeof(struct branch_info)); if (!bi) return NULL; for (i = 0; i < bs->nr; i++) { ip__resolve_ams(al->machine, al->thread, &bi[i].to, bs->entries[i].to); ip__resolve_ams(al->machine, al->thread, &bi[i].from, bs->entries[i].from); bi[i].flags = bs->entries[i].flags; } return bi; } static int machine__resolve_callchain_sample(struct machine *machine, struct thread *thread, struct ip_callchain *chain, struct symbol **parent, struct addr_location *root_al, int max_stack) { u8 cpumode = PERF_RECORD_MISC_USER; int chain_nr = min(max_stack, (int)chain->nr); int i; int err; callchain_cursor_reset(&callchain_cursor); if (chain->nr > PERF_MAX_STACK_DEPTH) { pr_warning("corrupted callchain. skipping...\n"); return 0; } for (i = 0; i < chain_nr; i++) { u64 ip; struct addr_location al; if (callchain_param.order == ORDER_CALLEE) ip = chain->ips[i]; else ip = chain->ips[chain->nr - i - 1]; if (ip >= PERF_CONTEXT_MAX) { switch (ip) { case PERF_CONTEXT_HV: cpumode = PERF_RECORD_MISC_HYPERVISOR; break; case PERF_CONTEXT_KERNEL: cpumode = PERF_RECORD_MISC_KERNEL; break; case PERF_CONTEXT_USER: cpumode = PERF_RECORD_MISC_USER; break; default: pr_debug("invalid callchain context: " "%"PRId64"\n", (s64) ip); /* * It seems the callchain is corrupted. * Discard all. */ callchain_cursor_reset(&callchain_cursor); return 0; } continue; } al.filtered = 0; thread__find_addr_location(thread, machine, cpumode, MAP__FUNCTION, ip, &al); if (al.sym != NULL) { if (sort__has_parent && !*parent && symbol__match_regex(al.sym, &parent_regex)) *parent = al.sym; else if (have_ignore_callees && root_al && symbol__match_regex(al.sym, &ignore_callees_regex)) { /* Treat this symbol as the root, forgetting its callees. */ *root_al = al; callchain_cursor_reset(&callchain_cursor); } } err = callchain_cursor_append(&callchain_cursor, ip, al.map, al.sym); if (err) return err; } return 0; } static int unwind_entry(struct unwind_entry *entry, void *arg) { struct callchain_cursor *cursor = arg; return callchain_cursor_append(cursor, entry->ip, entry->map, entry->sym); } int machine__resolve_callchain(struct machine *machine, struct perf_evsel *evsel, struct thread *thread, struct perf_sample *sample, struct symbol **parent, struct addr_location *root_al, int max_stack) { int ret; ret = machine__resolve_callchain_sample(machine, thread, sample->callchain, parent, root_al, max_stack); if (ret) return ret; /* Can we do dwarf post unwind? */ if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) && (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER))) return 0; /* Bail out if nothing was captured. */ if ((!sample->user_regs.regs) || (!sample->user_stack.size)) return 0; return unwind__get_entries(unwind_entry, &callchain_cursor, machine, thread, sample, max_stack); } int machine__for_each_thread(struct machine *machine, int (*fn)(struct thread *thread, void *p), void *priv) { struct rb_node *nd; struct thread *thread; int rc = 0; for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) { thread = rb_entry(nd, struct thread, rb_node); rc = fn(thread, priv); if (rc != 0) return rc; } list_for_each_entry(thread, &machine->dead_threads, node) { rc = fn(thread, priv); if (rc != 0) return rc; } return rc; } int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool, struct target *target, struct thread_map *threads, perf_event__handler_t process, bool data_mmap) { if (target__has_task(target)) return perf_event__synthesize_thread_map(tool, threads, process, machine, data_mmap); else if (target__has_cpu(target)) return perf_event__synthesize_threads(tool, process, machine, data_mmap); /* command specified */ return 0; }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
You can’t perform that action at this time.