Lines Matching refs:machine
14 #include "machine.h"
44 static void __machine__remove_thread(struct machine *machine, struct thread *th, bool lock);
46 static struct dso *machine__kernel_dso(struct machine *machine)
48 return machine->vmlinux_map->dso;
58 static void machine__threads_init(struct machine *machine)
63 struct threads *threads = &machine->threads[i];
72 static int machine__set_mmap_name(struct machine *machine)
74 if (machine__is_host(machine))
75 machine->mmap_name = strdup("[kernel.kallsyms]");
76 else if (machine__is_default_guest(machine))
77 machine->mmap_name = strdup("[guest.kernel.kallsyms]");
78 else if (asprintf(&machine->mmap_name, "[guest.kernel.kallsyms.%d]",
79 machine->pid) < 0)
80 machine->mmap_name = NULL;
82 return machine->mmap_name ? 0 : -ENOMEM;
85 int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
89 memset(machine, 0, sizeof(*machine));
90 maps__init(&machine->kmaps, machine);
91 RB_CLEAR_NODE(&machine->rb_node);
92 dsos__init(&machine->dsos);
94 machine__threads_init(machine);
96 machine->vdso_info = NULL;
97 machine->env = NULL;
99 machine->pid = pid;
101 machine->id_hdr_size = 0;
102 machine->kptr_restrict_warned = false;
103 machine->comm_exec = false;
104 machine->kernel_start = 0;
105 machine->vmlinux_map = NULL;
107 machine->root_dir = strdup(root_dir);
108 if (machine->root_dir == NULL)
111 if (machine__set_mmap_name(machine))
115 struct thread *thread = machine__findnew_thread(machine, -1,
127 machine->current_tid = NULL;
132 zfree(&machine->root_dir);
133 zfree(&machine->mmap_name);
138 struct machine *machine__new_host(void)
140 struct machine *machine = malloc(sizeof(*machine));
142 if (machine != NULL) {
143 machine__init(machine, "", HOST_KERNEL_ID);
145 if (machine__create_kernel_maps(machine) < 0)
149 return machine;
151 free(machine);
155 struct machine *machine__new_kallsyms(void)
157 struct machine *machine = machine__new_host();
164 if (machine && machine__load_kallsyms(machine, "/proc/kallsyms") <= 0) {
165 machine__delete(machine);
166 machine = NULL;
169 return machine;
194 void machine__delete_threads(struct machine *machine)
200 struct threads *threads = &machine->threads[i];
207 __machine__remove_thread(machine, t, false);
213 void machine__exit(struct machine *machine)
217 if (machine == NULL)
220 machine__destroy_kernel_maps(machine);
221 maps__exit(&machine->kmaps);
222 dsos__exit(&machine->dsos);
223 machine__exit_vdso(machine);
224 zfree(&machine->root_dir);
225 zfree(&machine->mmap_name);
226 zfree(&machine->current_tid);
229 struct threads *threads = &machine->threads[i];
246 void machine__delete(struct machine *machine)
248 if (machine) {
249 machine__exit(machine);
250 free(machine);
266 struct machine *machines__add(struct machines *machines, pid_t pid,
271 struct machine *pos, *machine = malloc(sizeof(*machine));
274 if (machine == NULL)
277 if (machine__init(machine, root_dir, pid) != 0) {
278 free(machine);
284 pos = rb_entry(parent, struct machine, rb_node);
293 rb_link_node(&machine->rb_node, parent, p);
294 rb_insert_color_cached(&machine->rb_node, &machines->guests, leftmost);
296 return machine;
306 struct machine *machine = rb_entry(nd, struct machine, rb_node);
308 machine->comm_exec = comm_exec;
312 struct machine *machines__find(struct machines *machines, pid_t pid)
316 struct machine *machine;
317 struct machine *default_machine = NULL;
324 machine = rb_entry(parent, struct machine, rb_node);
325 if (pid < machine->pid)
327 else if (pid > machine->pid)
330 return machine;
331 if (!machine->pid)
332 default_machine = machine;
338 struct machine *machines__findnew(struct machines *machines, pid_t pid)
342 struct machine *machine = machines__find(machines, pid);
344 if (machine && (machine->pid == pid))
361 machine = NULL;
367 machine = machines__add(machines, pid, root_dir);
369 return machine;
378 struct machine *pos = rb_entry(nd, struct machine, rb_node);
386 struct machine *machine;
392 machine = rb_entry(node, struct machine, rb_node);
393 machine->id_hdr_size = id_hdr_size;
399 static void machine__update_thread_pid(struct machine *machine,
412 leader = __machine__findnew_thread(machine, th->pid_, th->pid_);
417 leader->maps = maps__new(machine);
452 __threads__get_last_match(struct threads *threads, struct machine *machine,
460 machine__update_thread_pid(machine, th, pid);
471 threads__get_last_match(struct threads *threads, struct machine *machine,
477 th = __threads__get_last_match(threads, machine, pid, tid);
499 static struct thread *____machine__findnew_thread(struct machine *machine,
509 th = threads__get_last_match(threads, machine, pid, tid);
519 machine__update_thread_pid(machine, th, pid);
546 if (thread__init_maps(th, machine)) {
563 struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid)
565 return ____machine__findnew_thread(machine, machine__threads(machine, tid), pid, tid, true);
568 struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
571 struct threads *threads = machine__threads(machine, tid);
575 th = __machine__findnew_thread(machine, pid, tid);
580 struct thread *machine__find_thread(struct machine *machine, pid_t pid,
583 struct threads *threads = machine__threads(machine, tid);
587 th = ____machine__findnew_thread(machine, threads, pid, tid, false);
592 struct comm *machine__thread_exec_comm(struct machine *machine,
595 if (machine->comm_exec)
601 int machine__process_comm_event(struct machine *machine, union perf_event *event,
604 struct thread *thread = machine__findnew_thread(machine,
611 machine->comm_exec = true;
627 int machine__process_namespaces_event(struct machine *machine __maybe_unused,
631 struct thread *thread = machine__findnew_thread(machine,
658 int machine__process_cgroup_event(struct machine *machine,
667 cgrp = cgroup__findnew(machine->env, event->cgroup.id, event->cgroup.path);
674 int machine__process_lost_event(struct machine *machine __maybe_unused,
682 int machine__process_lost_samples_event(struct machine *machine __maybe_unused,
690 static struct dso *machine__findnew_module_dso(struct machine *machine,
696 down_write(&machine->dsos.lock);
698 dso = __dsos__find(&machine->dsos, m->name, true);
700 dso = __dsos__addnew(&machine->dsos, m->name);
704 dso__set_module_info(dso, m, machine);
711 up_write(&machine->dsos.lock);
715 int machine__process_aux_event(struct machine *machine __maybe_unused,
723 int machine__process_itrace_start_event(struct machine *machine __maybe_unused,
731 int machine__process_switch_event(struct machine *machine __maybe_unused,
739 static int machine__process_ksymbol_register(struct machine *machine,
744 struct map *map = maps__find(&machine->kmaps, event->ksymbol.addr);
767 maps__insert(&machine->kmaps, map);
785 static int machine__process_ksymbol_unregister(struct machine *machine,
792 map = maps__find(&machine->kmaps, event->ksymbol.addr);
796 if (map != machine->vmlinux_map)
797 maps__remove(&machine->kmaps, map);
807 int machine__process_ksymbol(struct machine *machine __maybe_unused,
815 return machine__process_ksymbol_unregister(machine, event,
817 return machine__process_ksymbol_register(machine, event, sample);
820 int machine__process_text_poke(struct machine *machine, union perf_event *event,
823 struct map *map = maps__find(&machine->kmaps, event->text_poke.addr);
827 perf_event__fprintf_text_poke(event, machine, stdout);
846 ret = dso__data_write_cache_addr(map->dso, map, machine,
861 static struct map *machine__addnew_module_map(struct machine *machine, u64 start,
871 dso = machine__findnew_module_dso(machine, &m, filename);
879 maps__insert(&machine->kmaps, map);
896 struct machine *pos = rb_entry(nd, struct machine, rb_node);
903 size_t machine__fprintf_dsos_buildid(struct machine *m, FILE *fp,
916 struct machine *pos = rb_entry(nd, struct machine, rb_node);
922 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
926 struct dso *kdso = machine__kernel_dso(machine);
942 size_t machine__fprintf(struct machine *machine, FILE *fp)
949 struct threads *threads = &machine->threads[i];
967 static struct dso *machine__get_kernel(struct machine *machine)
969 const char *vmlinux_name = machine->mmap_name;
972 if (machine__is_host(machine)) {
976 kernel = machine__findnew_kernel(machine, vmlinux_name,
982 kernel = machine__findnew_kernel(machine, vmlinux_name,
988 dso__read_running_kernel_build_id(kernel, machine);
997 void machine__get_kallsyms_filename(struct machine *machine, char *buf,
1000 if (machine__is_default_guest(machine))
1003 scnprintf(buf, bufsz, "%s/proc/kallsyms", machine->root_dir);
1012 static int machine__get_running_kernel_start(struct machine *machine,
1021 machine__get_kallsyms_filename(machine, filename, PATH_MAX);
1047 int machine__create_extra_kernel_map(struct machine *machine,
1065 maps__insert(&machine->kmaps, map);
1107 int machine__map_x86_64_entry_trampolines(struct machine *machine,
1110 struct maps *kmaps = &machine->kmaps;
1132 if (found || machine->trampolines_mapped)
1139 nr_cpus_avail = machine__nr_cpus_avail(machine);
1154 if (machine__create_extra_kernel_map(machine, kernel, &xm) < 0)
1158 machine->trampolines_mapped = nr_cpus_avail;
1163 int __weak machine__create_extra_kernel_maps(struct machine *machine __maybe_unused,
1170 __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
1173 machine__destroy_kernel_maps(machine);
1175 machine->vmlinux_map = map__new2(0, kernel);
1176 if (machine->vmlinux_map == NULL)
1179 machine->vmlinux_map->map_ip = machine->vmlinux_map->unmap_ip = identity__map_ip;
1180 maps__insert(&machine->kmaps, machine->vmlinux_map);
1184 void machine__destroy_kernel_maps(struct machine *machine)
1187 struct map *map = machine__kernel_map(machine);
1193 maps__remove(&machine->kmaps, map);
1199 map__zput(machine->vmlinux_map);
1258 struct machine *pos = rb_entry(next, struct machine, rb_node);
1268 struct machine *machine = machines__findnew(machines, pid);
1270 if (machine == NULL)
1273 return machine__create_kernel_maps(machine);
1276 int machine__load_kallsyms(struct machine *machine, const char *filename)
1278 struct map *map = machine__kernel_map(machine);
1288 maps__fixup_end(&machine->kmaps);
1294 int machine__load_vmlinux_path(struct machine *machine)
1296 struct map *map = machine__kernel_map(machine);
1423 static int machine__set_modules_path(struct machine *machine)
1428 version = get_kernel_version(machine->root_dir);
1433 machine->root_dir, version);
1436 return maps__set_modules_path_dir(&machine->kmaps, modules_path, 0);
1448 struct machine *machine = arg;
1454 map = machine__addnew_module_map(machine, start, name);
1459 dso__kernel_module_get_build_id(map->dso, machine->root_dir);
1464 static int machine__create_modules(struct machine *machine)
1469 if (machine__is_default_guest(machine)) {
1472 snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir);
1479 if (modules__parse(modules, machine, machine__create_module))
1482 if (!machine__set_modules_path(machine))
1490 static void machine__set_kernel_mmap(struct machine *machine,
1493 machine->vmlinux_map->start = start;
1494 machine->vmlinux_map->end = end;
1500 machine->vmlinux_map->end = ~0ULL;
1503 static void machine__update_kernel_mmap(struct machine *machine,
1506 struct map *map = machine__kernel_map(machine);
1509 maps__remove(&machine->kmaps, map);
1511 machine__set_kernel_mmap(machine, start, end);
1513 maps__insert(&machine->kmaps, map);
1517 int machine__create_kernel_maps(struct machine *machine)
1519 struct dso *kernel = machine__get_kernel(machine);
1528 ret = __machine__create_kernel_maps(machine, kernel);
1532 if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
1533 if (machine__is_host(machine))
1538 "continuing anyway...\n", machine->pid);
1541 if (!machine__get_running_kernel_start(machine, &name, &start, &end)) {
1543 map__set_kallsyms_ref_reloc_sym(machine->vmlinux_map, name, start)) {
1544 machine__destroy_kernel_maps(machine);
1553 machine__update_kernel_mmap(machine, start, end);
1556 if (machine__create_extra_kernel_maps(machine, kernel))
1561 map = map__next(machine__kernel_map(machine));
1563 machine__set_kernel_mmap(machine, start, map->start);
1571 static bool machine__uses_kcore(struct machine *machine)
1575 list_for_each_entry(dso, &machine->dsos.head, node) {
1583 static bool perf_event__is_extra_kernel_mmap(struct machine *machine,
1586 return machine__is(machine, "x86_64") &&
1590 static int machine__process_extra_kernel_map(struct machine *machine,
1593 struct dso *kernel = machine__kernel_dso(machine);
1605 return machine__create_extra_kernel_map(machine, kernel, &xm);
1608 static int machine__process_kernel_mmap_event(struct machine *machine,
1616 if (machine__uses_kcore(machine))
1619 if (machine__is_host(machine))
1625 machine->mmap_name,
1626 strlen(machine->mmap_name) - 1) == 0;
1629 map = machine__addnew_module_map(machine, event->mmap.start,
1637 strlen(machine->mmap_name));
1645 down_read(&machine->dsos.lock);
1647 list_for_each_entry(dso, &machine->dsos.head, node) {
1675 up_read(&machine->dsos.lock);
1678 kernel = machine__findnew_dso(machine, machine->mmap_name);
1683 if (__machine__create_kernel_maps(machine, kernel) < 0) {
1691 machine__update_kernel_mmap(machine, event->mmap.start,
1700 map__set_kallsyms_ref_reloc_sym(machine->vmlinux_map,
1705 if (machine__is_default_guest(machine)) {
1709 dso__load(kernel, machine__kernel_map(machine));
1711 } else if (perf_event__is_extra_kernel_mmap(machine, event)) {
1712 return machine__process_extra_kernel_map(machine, event);
1719 int machine__process_mmap2_event(struct machine *machine,
1738 ret = machine__process_kernel_mmap_event(machine, event);
1744 thread = machine__findnew_thread(machine, event->mmap2.pid,
1749 map = map__new(machine, event->mmap2.start,
1775 int machine__process_mmap_event(struct machine *machine, union perf_event *event,
1788 ret = machine__process_kernel_mmap_event(machine, event);
1794 thread = machine__findnew_thread(machine, event->mmap.pid,
1802 map = map__new(machine, event->mmap.start,
1826 static void __machine__remove_thread(struct machine *machine, struct thread *th, bool lock)
1828 struct threads *threads = machine__threads(machine, th->tid);
1859 void machine__remove_thread(struct machine *machine, struct thread *th)
1861 return __machine__remove_thread(machine, th, true);
1864 int machine__process_fork_event(struct machine *machine, union perf_event *event,
1867 struct thread *thread = machine__find_thread(machine,
1870 struct thread *parent = machine__findnew_thread(machine,
1888 machine__remove_thread(machine, parent);
1890 parent = machine__findnew_thread(machine, event->fork.ppid,
1896 machine__remove_thread(machine, thread);
1900 thread = machine__findnew_thread(machine, event->fork.pid,
1904 * objects for the already running tasks on the machine.
1930 int machine__process_exit_event(struct machine *machine, union perf_event *event,
1933 struct thread *thread = machine__find_thread(machine,
1948 int machine__process_event(struct machine *machine, union perf_event *event,
1955 ret = machine__process_comm_event(machine, event, sample); break;
1957 ret = machine__process_mmap_event(machine, event, sample); break;
1959 ret = machine__process_namespaces_event(machine, event, sample); break;
1961 ret = machine__process_cgroup_event(machine, event, sample); break;
1963 ret = machine__process_mmap2_event(machine, event, sample); break;
1965 ret = machine__process_fork_event(machine, event, sample); break;
1967 ret = machine__process_exit_event(machine, event, sample); break;
1969 ret = machine__process_lost_event(machine, event, sample); break;
1971 ret = machine__process_aux_event(machine, event); break;
1973 ret = machine__process_itrace_start_event(machine, event); break;
1975 ret = machine__process_lost_samples_event(machine, event, sample); break;
1978 ret = machine__process_switch_event(machine, event); break;
1980 ret = machine__process_ksymbol(machine, event, sample); break;
1982 ret = machine__process_bpf(machine, event, sample); break;
1984 ret = machine__process_text_poke(machine, event, sample); break;
2927 int machine__for_each_thread(struct machine *machine,
2938 threads = &machine->threads[i];
2968 struct machine *machine = rb_entry(nd, struct machine, rb_node);
2970 rc = machine__for_each_thread(machine, fn, priv);
2977 pid_t machine__get_current_tid(struct machine *machine, int cpu)
2979 int nr_cpus = min(machine->env->nr_cpus_avail, MAX_NR_CPUS);
2981 if (cpu < 0 || cpu >= nr_cpus || !machine->current_tid)
2984 return machine->current_tid[cpu];
2987 int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
2991 int nr_cpus = min(machine->env->nr_cpus_avail, MAX_NR_CPUS);
2996 if (!machine->current_tid) {
2999 machine->current_tid = calloc(nr_cpus, sizeof(pid_t));
3000 if (!machine->current_tid)
3003 machine->current_tid[i] = -1;
3012 machine->current_tid[cpu] = tid;
3014 thread = machine__findnew_thread(machine, pid, tid);
3028 bool machine__is(struct machine *machine, const char *arch)
3030 return machine && !strcmp(perf_env__raw_arch(machine->env), arch);
3033 int machine__nr_cpus_avail(struct machine *machine)
3035 return machine ? perf_env__nr_cpus_avail(machine->env) : 0;
3038 int machine__get_kernel_start(struct machine *machine)
3040 struct map *map = machine__kernel_map(machine);
3051 machine->kernel_start = 1ULL << 63;
3059 if (!err && !machine__is(machine, "x86_64"))
3060 machine->kernel_start = map->start;
3065 u8 machine__addr_cpumode(struct machine *machine, u8 cpumode, u64 addr)
3070 if (!machine->single_address_space)
3073 kernel_ip = machine__kernel_ip(machine, addr);
3092 struct dso *machine__findnew_dso_id(struct machine *machine, const char *filename, struct dso_id *id)
3094 return dsos__findnew_id(&machine->dsos, filename, id);
3097 struct dso *machine__findnew_dso(struct machine *machine, const char *filename)
3099 return machine__findnew_dso_id(machine, filename, NULL);
3104 struct machine *machine = vmachine;
3106 struct symbol *sym = machine__find_kernel_symbol(machine, *addrp, &map);
3116 int machine__for_each_dso(struct machine *machine, machine__dso_t fn, void *priv)
3121 list_for_each_entry(pos, &machine->dsos.head, node) {
3122 if (fn(pos, machine, priv))