Lines Matching refs:machine
14 #include "machine.h"
46 static void __machine__remove_thread(struct machine *machine, struct thread_rb_node *nd,
49 static struct dso *machine__kernel_dso(struct machine *machine)
51 return map__dso(machine->vmlinux_map);
61 static void machine__threads_init(struct machine *machine)
66 struct threads *threads = &machine->threads[i];
91 static int machine__set_mmap_name(struct machine *machine)
93 if (machine__is_host(machine))
94 machine->mmap_name = strdup("[kernel.kallsyms]");
95 else if (machine__is_default_guest(machine))
96 machine->mmap_name = strdup("[guest.kernel.kallsyms]");
97 else if (asprintf(&machine->mmap_name, "[guest.kernel.kallsyms.%d]",
98 machine->pid) < 0)
99 machine->mmap_name = NULL;
101 return machine->mmap_name ? 0 : -ENOMEM;
112 int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
116 memset(machine, 0, sizeof(*machine));
117 machine->kmaps = maps__new(machine);
118 if (machine->kmaps == NULL)
121 RB_CLEAR_NODE(&machine->rb_node);
122 dsos__init(&machine->dsos);
124 machine__threads_init(machine);
126 machine->vdso_info = NULL;
127 machine->env = NULL;
129 machine->pid = pid;
131 machine->id_hdr_size = 0;
132 machine->kptr_restrict_warned = false;
133 machine->comm_exec = false;
134 machine->kernel_start = 0;
135 machine->vmlinux_map = NULL;
137 machine->root_dir = strdup(root_dir);
138 if (machine->root_dir == NULL)
141 if (machine__set_mmap_name(machine))
145 struct thread *thread = machine__findnew_thread(machine, -1,
155 machine->current_tid = NULL;
160 zfree(&machine->kmaps);
161 zfree(&machine->root_dir);
162 zfree(&machine->mmap_name);
167 struct machine *machine__new_host(void)
169 struct machine *machine = malloc(sizeof(*machine));
171 if (machine != NULL) {
172 machine__init(machine, "", HOST_KERNEL_ID);
174 if (machine__create_kernel_maps(machine) < 0)
178 return machine;
180 free(machine);
184 struct machine *machine__new_kallsyms(void)
186 struct machine *machine = machine__new_host();
193 if (machine && machine__load_kallsyms(machine, "/proc/kallsyms") <= 0) {
194 machine__delete(machine);
195 machine = NULL;
198 return machine;
223 void machine__delete_threads(struct machine *machine)
229 struct threads *threads = &machine->threads[i];
236 __machine__remove_thread(machine, trb, trb->thread, false);
242 void machine__exit(struct machine *machine)
246 if (machine == NULL)
249 machine__destroy_kernel_maps(machine);
250 maps__zput(machine->kmaps);
251 dsos__exit(&machine->dsos);
252 machine__exit_vdso(machine);
253 zfree(&machine->root_dir);
254 zfree(&machine->mmap_name);
255 zfree(&machine->current_tid);
256 zfree(&machine->kallsyms_filename);
258 machine__delete_threads(machine);
260 struct threads *threads = &machine->threads[i];
266 void machine__delete(struct machine *machine)
268 if (machine) {
269 machine__exit(machine);
270 free(machine);
286 struct machine *machines__add(struct machines *machines, pid_t pid,
291 struct machine *pos, *machine = malloc(sizeof(*machine));
294 if (machine == NULL)
297 if (machine__init(machine, root_dir, pid) != 0) {
298 free(machine);
304 pos = rb_entry(parent, struct machine, rb_node);
313 rb_link_node(&machine->rb_node, parent, p);
314 rb_insert_color_cached(&machine->rb_node, &machines->guests, leftmost);
316 machine->machines = machines;
318 return machine;
328 struct machine *machine = rb_entry(nd, struct machine, rb_node);
330 machine->comm_exec = comm_exec;
334 struct machine *machines__find(struct machines *machines, pid_t pid)
338 struct machine *machine;
339 struct machine *default_machine = NULL;
346 machine = rb_entry(parent, struct machine, rb_node);
347 if (pid < machine->pid)
349 else if (pid > machine->pid)
352 return machine;
353 if (!machine->pid)
354 default_machine = machine;
360 struct machine *machines__findnew(struct machines *machines, pid_t pid)
364 struct machine *machine = machines__find(machines, pid);
366 if (machine && (machine->pid == pid))
383 machine = NULL;
389 machine = machines__add(machines, pid, root_dir);
391 return machine;
394 struct machine *machines__find_guest(struct machines *machines, pid_t pid)
396 struct machine *machine = machines__find(machines, pid);
398 if (!machine)
399 machine = machines__findnew(machines, DEFAULT_GUEST_KERNEL_ID);
400 return machine;
405 * hypervisor, creating, running and destroying the virtual machine, and
424 * structures sane, using a thread belonging to the guest machine, instead
428 static struct thread *findnew_guest_code(struct machine *machine,
429 struct machine *host_machine,
436 if (!machine)
439 thread = machine__findnew_thread(machine, -1, pid);
471 struct machine *host_machine = machines__find(machines, HOST_KERNEL_ID);
472 struct machine *machine = machines__findnew(machines, pid);
474 return findnew_guest_code(machine, host_machine, pid);
477 struct thread *machine__findnew_guest_code(struct machine *machine, pid_t pid)
479 struct machines *machines = machine->machines;
480 struct machine *host_machine;
487 return findnew_guest_code(machine, host_machine, pid);
496 struct machine *pos = rb_entry(nd, struct machine, rb_node);
504 struct machine *machine;
510 machine = rb_entry(node, struct machine, rb_node);
511 machine->id_hdr_size = id_hdr_size;
517 static void machine__update_thread_pid(struct machine *machine,
530 leader = __machine__findnew_thread(machine, thread__pid(th), thread__pid(th));
535 thread__set_maps(leader, maps__new(machine));
570 __threads__get_last_match(struct threads *threads, struct machine *machine,
578 machine__update_thread_pid(machine, th, pid);
589 threads__get_last_match(struct threads *threads, struct machine *machine,
595 th = __threads__get_last_match(threads, machine, pid, tid);
618 static struct thread *____machine__findnew_thread(struct machine *machine,
629 th = threads__get_last_match(threads, machine, pid, tid);
639 machine__update_thread_pid(machine, th, pid);
674 if (thread__init_maps(th, machine)) {
691 struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid)
693 return ____machine__findnew_thread(machine, machine__threads(machine, tid), pid, tid, true);
696 struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
699 struct threads *threads = machine__threads(machine, tid);
703 th = __machine__findnew_thread(machine, pid, tid);
708 struct thread *machine__find_thread(struct machine *machine, pid_t pid,
711 struct threads *threads = machine__threads(machine, tid);
715 th = ____machine__findnew_thread(machine, threads, pid, tid, false);
727 struct thread *machine__idle_thread(struct machine *machine)
729 struct thread *thread = machine__findnew_thread(machine, 0, 0);
733 pr_err("problem inserting idle task for machine pid %d\n", machine->pid);
738 struct comm *machine__thread_exec_comm(struct machine *machine,
741 if (machine->comm_exec)
747 int machine__process_comm_event(struct machine *machine, union perf_event *event,
750 struct thread *thread = machine__findnew_thread(machine,
757 machine->comm_exec = true;
773 int machine__process_namespaces_event(struct machine *machine __maybe_unused,
777 struct thread *thread = machine__findnew_thread(machine,
804 int machine__process_cgroup_event(struct machine *machine,
813 cgrp = cgroup__findnew(machine->env, event->cgroup.id, event->cgroup.path);
820 int machine__process_lost_event(struct machine *machine __maybe_unused,
828 int machine__process_lost_samples_event(struct machine *machine __maybe_unused,
836 static struct dso *machine__findnew_module_dso(struct machine *machine,
842 down_write(&machine->dsos.lock);
844 dso = __dsos__find(&machine->dsos, m->name, true);
846 dso = __dsos__addnew(&machine->dsos, m->name);
850 dso__set_module_info(dso, m, machine);
857 up_write(&machine->dsos.lock);
861 int machine__process_aux_event(struct machine *machine __maybe_unused,
869 int machine__process_itrace_start_event(struct machine *machine __maybe_unused,
877 int machine__process_aux_output_hw_id_event(struct machine *machine __maybe_unused,
885 int machine__process_switch_event(struct machine *machine __maybe_unused,
893 static int machine__process_ksymbol_register(struct machine *machine,
899 struct map *map = maps__find(machine__kernel_maps(machine), event->ksymbol.addr);
931 err = maps__insert(machine__kernel_maps(machine), map);
961 static int machine__process_ksymbol_unregister(struct machine *machine,
968 map = maps__find(machine__kernel_maps(machine), event->ksymbol.addr);
972 if (RC_CHK_ACCESS(map) != RC_CHK_ACCESS(machine->vmlinux_map))
973 maps__remove(machine__kernel_maps(machine), map);
985 int machine__process_ksymbol(struct machine *machine __maybe_unused,
993 return machine__process_ksymbol_unregister(machine, event,
995 return machine__process_ksymbol_register(machine, event, sample);
998 int machine__process_text_poke(struct machine *machine, union perf_event *event,
1001 struct map *map = maps__find(machine__kernel_maps(machine), event->text_poke.addr);
1006 perf_event__fprintf_text_poke(event, machine, stdout);
1025 ret = dso__data_write_cache_addr(dso, map, machine,
1040 static struct map *machine__addnew_module_map(struct machine *machine, u64 start,
1051 dso = machine__findnew_module_dso(machine, &m, filename);
1059 err = maps__insert(machine__kernel_maps(machine), map);
1078 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1085 size_t machine__fprintf_dsos_buildid(struct machine *m, FILE *fp,
1098 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1104 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
1108 struct dso *kdso = machine__kernel_dso(machine);
1124 size_t machine__fprintf(struct machine *machine, FILE *fp)
1131 struct threads *threads = &machine->threads[i];
1149 static struct dso *machine__get_kernel(struct machine *machine)
1151 const char *vmlinux_name = machine->mmap_name;
1154 if (machine__is_host(machine)) {
1158 kernel = machine__findnew_kernel(machine, vmlinux_name,
1164 kernel = machine__findnew_kernel(machine, vmlinux_name,
1170 dso__read_running_kernel_build_id(kernel, machine);
1175 void machine__get_kallsyms_filename(struct machine *machine, char *buf,
1178 if (machine__is_default_guest(machine))
1181 scnprintf(buf, bufsz, "%s/proc/kallsyms", machine->root_dir);
1190 static int machine__get_running_kernel_start(struct machine *machine,
1199 machine__get_kallsyms_filename(machine, filename, PATH_MAX);
1227 int machine__create_extra_kernel_map(struct machine *machine,
1246 err = maps__insert(machine__kernel_maps(machine), map);
1290 int machine__map_x86_64_entry_trampolines(struct machine *machine,
1293 struct maps *kmaps = machine__kernel_maps(machine);
1315 if (found || machine->trampolines_mapped)
1322 nr_cpus_avail = machine__nr_cpus_avail(machine);
1337 if (machine__create_extra_kernel_map(machine, kernel, &xm) < 0)
1341 machine->trampolines_mapped = nr_cpus_avail;
1346 int __weak machine__create_extra_kernel_maps(struct machine *machine __maybe_unused,
1353 __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
1356 machine__destroy_kernel_maps(machine);
1358 map__put(machine->vmlinux_map);
1359 machine->vmlinux_map = map__new2(0, kernel);
1360 if (machine->vmlinux_map == NULL)
1363 map__set_map_ip(machine->vmlinux_map, identity__map_ip);
1364 map__set_unmap_ip(machine->vmlinux_map, identity__map_ip);
1365 return maps__insert(machine__kernel_maps(machine), machine->vmlinux_map);
1368 void machine__destroy_kernel_maps(struct machine *machine)
1371 struct map *map = machine__kernel_map(machine);
1377 maps__remove(machine__kernel_maps(machine), map);
1383 map__zput(machine->vmlinux_map);
1442 struct machine *pos = rb_entry(next, struct machine, rb_node);
1452 struct machine *machine = machines__findnew(machines, pid);
1454 if (machine == NULL)
1457 return machine__create_kernel_maps(machine);
1460 int machine__load_kallsyms(struct machine *machine, const char *filename)
1462 struct map *map = machine__kernel_map(machine);
1473 maps__fixup_end(machine__kernel_maps(machine));
1479 int machine__load_vmlinux_path(struct machine *machine)
1481 struct map *map = machine__kernel_map(machine);
1611 static int machine__set_modules_path(struct machine *machine)
1616 version = get_kernel_version(machine->root_dir);
1621 machine->root_dir, version);
1624 return maps__set_modules_path_dir(machine__kernel_maps(machine), modules_path, 0);
1636 struct machine *machine = arg;
1642 map = machine__addnew_module_map(machine, start, name);
1647 dso__kernel_module_get_build_id(map__dso(map), machine->root_dir);
1652 static int machine__create_modules(struct machine *machine)
1657 if (machine__is_default_guest(machine)) {
1660 snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir);
1667 if (modules__parse(modules, machine, machine__create_module))
1670 if (!machine__set_modules_path(machine))
1678 static void machine__set_kernel_mmap(struct machine *machine,
1681 map__set_start(machine->vmlinux_map, start);
1682 map__set_end(machine->vmlinux_map, end);
1688 map__set_end(machine->vmlinux_map, ~0ULL);
1691 static int machine__update_kernel_mmap(struct machine *machine,
1697 orig = machine->vmlinux_map;
1700 machine->vmlinux_map = updated;
1701 machine__set_kernel_mmap(machine, start, end);
1702 maps__remove(machine__kernel_maps(machine), orig);
1703 err = maps__insert(machine__kernel_maps(machine), updated);
1709 int machine__create_kernel_maps(struct machine *machine)
1711 struct dso *kernel = machine__get_kernel(machine);
1719 ret = __machine__create_kernel_maps(machine, kernel);
1723 if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
1724 if (machine__is_host(machine))
1729 "continuing anyway...\n", machine->pid);
1732 if (!machine__get_running_kernel_start(machine, &name, &start, &end)) {
1734 map__set_kallsyms_ref_reloc_sym(machine->vmlinux_map, name, start)) {
1735 machine__destroy_kernel_maps(machine);
1744 ret = machine__update_kernel_mmap(machine, start, end);
1749 if (machine__create_extra_kernel_maps(machine, kernel))
1754 struct map_rb_node *rb_node = maps__find_node(machine__kernel_maps(machine),
1755 machine__kernel_map(machine));
1759 machine__set_kernel_mmap(machine, start, map__start(next->map));
1767 static bool machine__uses_kcore(struct machine *machine)
1771 list_for_each_entry(dso, &machine->dsos.head, node) {
1779 static bool perf_event__is_extra_kernel_mmap(struct machine *machine,
1782 return machine__is(machine, "x86_64") &&
1786 static int machine__process_extra_kernel_map(struct machine *machine,
1789 struct dso *kernel = machine__kernel_dso(machine);
1794 return machine__create_extra_kernel_map(machine, kernel, xm);
1797 static int machine__process_kernel_mmap_event(struct machine *machine,
1803 const char *mmap_name = machine->mmap_name;
1806 if (machine__uses_kcore(machine))
1809 if (machine__is_host(machine))
1815 if (!is_kernel_mmap && !machine__is_host(machine)) {
1826 struct map *map = machine__addnew_module_map(machine, xm->start, xm->name);
1846 down_read(&machine->dsos.lock);
1848 list_for_each_entry(dso, &machine->dsos.head, node) {
1876 up_read(&machine->dsos.lock);
1879 kernel = machine__findnew_dso(machine, machine->mmap_name);
1884 if (__machine__create_kernel_maps(machine, kernel) < 0) {
1892 if (machine__update_kernel_mmap(machine, xm->start, xm->end) < 0) {
1906 map__set_kallsyms_ref_reloc_sym(machine->vmlinux_map,
1911 if (machine__is_default_guest(machine)) {
1915 dso__load(kernel, machine__kernel_map(machine));
1918 } else if (perf_event__is_extra_kernel_mmap(machine, xm)) {
1919 return machine__process_extra_kernel_map(machine, xm);
1926 int machine__process_mmap2_event(struct machine *machine,
1958 ret = machine__process_kernel_mmap_event(machine, &xm, bid);
1964 thread = machine__findnew_thread(machine, event->mmap2.pid,
1969 map = map__new(machine, event->mmap2.start,
1995 int machine__process_mmap_event(struct machine *machine, union perf_event *event,
2015 ret = machine__process_kernel_mmap_event(machine, &xm, NULL);
2021 thread = machine__findnew_thread(machine, event->mmap.pid,
2029 map = map__new(machine, event->mmap.start,
2053 static void __machine__remove_thread(struct machine *machine, struct thread_rb_node *nd,
2056 struct threads *threads = machine__threads(machine, thread__tid(th));
2080 void machine__remove_thread(struct machine *machine, struct thread *th)
2082 return __machine__remove_thread(machine, NULL, th, true);
2085 int machine__process_fork_event(struct machine *machine, union perf_event *event,
2088 struct thread *thread = machine__find_thread(machine,
2091 struct thread *parent = machine__findnew_thread(machine,
2109 machine__remove_thread(machine, parent);
2111 parent = machine__findnew_thread(machine, event->fork.ppid,
2117 machine__remove_thread(machine, thread);
2121 thread = machine__findnew_thread(machine, event->fork.pid,
2125 * objects for the already running tasks on the machine.
2151 int machine__process_exit_event(struct machine *machine, union perf_event *event,
2154 struct thread *thread = machine__find_thread(machine,
2167 int machine__process_event(struct machine *machine, union perf_event *event,
2174 ret = machine__process_comm_event(machine, event, sample); break;
2176 ret = machine__process_mmap_event(machine, event, sample); break;
2178 ret = machine__process_namespaces_event(machine, event, sample); break;
2180 ret = machine__process_cgroup_event(machine, event, sample); break;
2182 ret = machine__process_mmap2_event(machine, event, sample); break;
2184 ret = machine__process_fork_event(machine, event, sample); break;
2186 ret = machine__process_exit_event(machine, event, sample); break;
2188 ret = machine__process_lost_event(machine, event, sample); break;
2190 ret = machine__process_aux_event(machine, event); break;
2192 ret = machine__process_itrace_start_event(machine, event); break;
2194 ret = machine__process_lost_samples_event(machine, event, sample); break;
2197 ret = machine__process_switch_event(machine, event); break;
2199 ret = machine__process_ksymbol(machine, event, sample); break;
2201 ret = machine__process_bpf(machine, event, sample); break;
2203 ret = machine__process_text_poke(machine, event, sample); break;
2205 ret = machine__process_aux_output_hw_id_event(machine, event); break;
3212 int machine__for_each_thread(struct machine *machine,
3222 threads = &machine->threads[i];
3247 struct machine *machine = rb_entry(nd, struct machine, rb_node);
3249 rc = machine__for_each_thread(machine, fn, priv);
3256 pid_t machine__get_current_tid(struct machine *machine, int cpu)
3258 if (cpu < 0 || (size_t)cpu >= machine->current_tid_sz)
3261 return machine->current_tid[cpu];
3264 int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
3273 if (realloc_array_as_needed(machine->current_tid,
3274 machine->current_tid_sz,
3279 machine->current_tid[cpu] = tid;
3281 thread = machine__findnew_thread(machine, pid, tid);
3295 bool machine__is(struct machine *machine, const char *arch)
3297 return machine && !strcmp(perf_env__raw_arch(machine->env), arch);
3300 bool machine__normalized_is(struct machine *machine, const char *arch)
3302 return machine && !strcmp(perf_env__arch(machine->env), arch);
3305 int machine__nr_cpus_avail(struct machine *machine)
3307 return machine ? perf_env__nr_cpus_avail(machine->env) : 0;
3310 int machine__get_kernel_start(struct machine *machine)
3312 struct map *map = machine__kernel_map(machine);
3323 machine->kernel_start = 1ULL << 63;
3331 if (!err && !machine__is(machine, "x86_64"))
3332 machine->kernel_start = map__start(map);
3337 u8 machine__addr_cpumode(struct machine *machine, u8 cpumode, u64 addr)
3342 if (!machine->single_address_space)
3345 kernel_ip = machine__kernel_ip(machine, addr);
3364 struct dso *machine__findnew_dso_id(struct machine *machine, const char *filename, struct dso_id *id)
3366 return dsos__findnew_id(&machine->dsos, filename, id);
3369 struct dso *machine__findnew_dso(struct machine *machine, const char *filename)
3371 return machine__findnew_dso_id(machine, filename, NULL);
3376 struct machine *machine = vmachine;
3378 struct symbol *sym = machine__find_kernel_symbol(machine, *addrp, &map);
3388 int machine__for_each_dso(struct machine *machine, machine__dso_t fn, void *priv)
3393 list_for_each_entry(pos, &machine->dsos.head, node) {
3394 if (fn(pos, machine, priv))
3400 int machine__for_each_kernel_map(struct machine *machine, machine__map_t fn, void *priv)
3402 struct maps *maps = machine__kernel_maps(machine);
3415 bool machine__is_lock_function(struct machine *machine, u64 addr)
3417 if (!machine->sched.text_start) {
3419 struct symbol *sym = machine__find_kernel_symbol_by_name(machine, "__sched_text_start", &kmap);
3423 machine->sched.text_start = 1;
3427 machine->sched.text_start = map__unmap_ip(kmap, sym->start);
3430 sym = machine__find_kernel_symbol_by_name(machine, "__sched_text_end", &kmap);
3431 machine->sched.text_end = map__unmap_ip(kmap, sym->start);
3433 sym = machine__find_kernel_symbol_by_name(machine, "__lock_text_start", &kmap);
3434 machine->lock.text_start = map__unmap_ip(kmap, sym->start);
3436 sym = machine__find_kernel_symbol_by_name(machine, "__lock_text_end", &kmap);
3437 machine->lock.text_end = map__unmap_ip(kmap, sym->start);
3441 if (machine->sched.text_start == 1)
3445 if (machine->sched.text_start <= addr && addr < machine->sched.text_end)
3449 if (machine->lock.text_start <= addr && addr < machine->lock.text_end)