aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorArnaldo Carvalho de Melo <acme@redhat.com>2010-04-27 20:17:50 -0400
committerArnaldo Carvalho de Melo <acme@redhat.com>2010-04-27 20:17:50 -0400
commit23346f21b277e3aae5e9989e711a11cbe8133a45 (patch)
tree21f11a72cf21d4eb3d824f46e274dc8f9815d749
parent462b04e28a7ec1339c892117c3f20a40e55d0e83 (diff)
perf tools: Rename "kernel_info" to "machine"
struct kernel_info and kerninfo__ are too vague, what they really describe are machines, virtual ones or hosts. There are more changes to introduce helpers to shorten function calls and to make more clear what is really being done, but I left that for subsequent patches. Cc: Avi Kivity <avi@redhat.com> Cc: Frédéric Weisbecker <fweisbec@gmail.com> Cc: Mike Galbraith <efault@gmx.de> Cc: Peter Zijlstra <a.p.zijlstra@chello.nl> Cc: Paul Mackerras <paulus@samba.org> Cc: Zhang, Yanmin <yanmin_zhang@linux.intel.com> LKML-Reference: <new-submission> Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Diffstat
-rw-r--r--tools/perf/builtin-annotate.c2
-rw-r--r--tools/perf/builtin-buildid-list.c2
-rw-r--r--tools/perf/builtin-kmem.c8
-rw-r--r--tools/perf/builtin-record.c36
-rw-r--r--tools/perf/builtin-report.c2
-rw-r--r--tools/perf/builtin-top.c15
-rw-r--r--tools/perf/util/event.c92
-rw-r--r--tools/perf/util/event.h4
-rw-r--r--tools/perf/util/header.c70
-rw-r--r--tools/perf/util/header.h2
-rw-r--r--tools/perf/util/map.c105
-rw-r--r--tools/perf/util/map.h63
-rw-r--r--tools/perf/util/session.c4
-rw-r--r--tools/perf/util/session.h27
-rw-r--r--tools/perf/util/symbol.c132
-rw-r--r--tools/perf/util/symbol.h3
16 files changed, 280 insertions, 287 deletions
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index f924b4332be6..986b2efcef2e 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -571,7 +571,7 @@ static int __cmd_annotate(void)
571 perf_session__fprintf(session, stdout); 571 perf_session__fprintf(session, stdout);
572 572
573 if (verbose > 2) 573 if (verbose > 2)
574 dsos__fprintf(&session->kerninfo_root, stdout); 574 dsos__fprintf(&session->machines, stdout);
575 575
576 perf_session__collapse_resort(&session->hists); 576 perf_session__collapse_resort(&session->hists);
577 perf_session__output_resort(&session->hists, session->event_total[0]); 577 perf_session__output_resort(&session->hists, session->event_total[0]);
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index 623afe3fdcb8..b4a265ae3b98 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -46,7 +46,7 @@ static int __cmd_buildid_list(void)
46 if (with_hits) 46 if (with_hits)
47 perf_session__process_events(session, &build_id__mark_dso_hit_ops); 47 perf_session__process_events(session, &build_id__mark_dso_hit_ops);
48 48
49 dsos__fprintf_buildid(&session->kerninfo_root, stdout, with_hits); 49 dsos__fprintf_buildid(&session->machines, stdout, with_hits);
50 50
51 perf_session__delete(session); 51 perf_session__delete(session);
52 return err; 52 return err;
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index ab906cbd5c79..20674759464e 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -352,7 +352,7 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
352 int n_lines, int is_caller) 352 int n_lines, int is_caller)
353{ 353{
354 struct rb_node *next; 354 struct rb_node *next;
355 struct kernel_info *kerninfo; 355 struct machine *machine;
356 356
357 printf("%.102s\n", graph_dotted_line); 357 printf("%.102s\n", graph_dotted_line);
358 printf(" %-34s |", is_caller ? "Callsite": "Alloc Ptr"); 358 printf(" %-34s |", is_caller ? "Callsite": "Alloc Ptr");
@@ -361,8 +361,8 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
361 361
362 next = rb_first(root); 362 next = rb_first(root);
363 363
364 kerninfo = kerninfo__findhost(&session->kerninfo_root); 364 machine = perf_session__find_host_machine(session);
365 if (!kerninfo) { 365 if (!machine) {
366 pr_err("__print_result: couldn't find kernel information\n"); 366 pr_err("__print_result: couldn't find kernel information\n");
367 return; 367 return;
368 } 368 }
@@ -370,7 +370,7 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
370 struct alloc_stat *data = rb_entry(next, struct alloc_stat, 370 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
371 node); 371 node);
372 struct symbol *sym = NULL; 372 struct symbol *sym = NULL;
373 struct map_groups *kmaps = &kerninfo->kmaps; 373 struct map_groups *kmaps = &machine->kmaps;
374 struct map *map; 374 struct map *map;
375 char buf[BUFSIZ]; 375 char buf[BUFSIZ];
376 u64 addr; 376 u64 addr;
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 27f992aca8b5..83b308a035c2 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -456,14 +456,14 @@ static void atexit_header(void)
456 } 456 }
457} 457}
458 458
459static void event__synthesize_guest_os(struct kernel_info *kerninfo, 459static void event__synthesize_guest_os(struct machine *machine, void *data)
460 void *data __attribute__((unused)))
461{ 460{
462 int err; 461 int err;
463 char *guest_kallsyms; 462 char *guest_kallsyms;
464 char path[PATH_MAX]; 463 char path[PATH_MAX];
464 struct perf_session *psession = data;
465 465
466 if (is_host_kernel(kerninfo)) 466 if (machine__is_host(machine))
467 return; 467 return;
468 468
469 /* 469 /*
@@ -475,16 +475,15 @@ static void event__synthesize_guest_os(struct kernel_info *kerninfo,
475 *in module instead of in guest kernel. 475 *in module instead of in guest kernel.
476 */ 476 */
477 err = event__synthesize_modules(process_synthesized_event, 477 err = event__synthesize_modules(process_synthesized_event,
478 session, 478 psession, machine);
479 kerninfo);
480 if (err < 0) 479 if (err < 0)
481 pr_err("Couldn't record guest kernel [%d]'s reference" 480 pr_err("Couldn't record guest kernel [%d]'s reference"
482 " relocation symbol.\n", kerninfo->pid); 481 " relocation symbol.\n", machine->pid);
483 482
484 if (is_default_guest(kerninfo)) 483 if (machine__is_default_guest(machine))
485 guest_kallsyms = (char *) symbol_conf.default_guest_kallsyms; 484 guest_kallsyms = (char *) symbol_conf.default_guest_kallsyms;
486 else { 485 else {
487 sprintf(path, "%s/proc/kallsyms", kerninfo->root_dir); 486 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
488 guest_kallsyms = path; 487 guest_kallsyms = path;
489 } 488 }
490 489
@@ -493,13 +492,13 @@ static void event__synthesize_guest_os(struct kernel_info *kerninfo,
493 * have no _text sometimes. 492 * have no _text sometimes.
494 */ 493 */
495 err = event__synthesize_kernel_mmap(process_synthesized_event, 494 err = event__synthesize_kernel_mmap(process_synthesized_event,
496 session, kerninfo, "_text"); 495 psession, machine, "_text");
497 if (err < 0) 496 if (err < 0)
498 err = event__synthesize_kernel_mmap(process_synthesized_event, 497 err = event__synthesize_kernel_mmap(process_synthesized_event,
499 session, kerninfo, "_stext"); 498 psession, machine, "_stext");
500 if (err < 0) 499 if (err < 0)
501 pr_err("Couldn't record guest kernel [%d]'s reference" 500 pr_err("Couldn't record guest kernel [%d]'s reference"
502 " relocation symbol.\n", kerninfo->pid); 501 " relocation symbol.\n", machine->pid);
503} 502}
504 503
505static int __cmd_record(int argc, const char **argv) 504static int __cmd_record(int argc, const char **argv)
@@ -513,7 +512,7 @@ static int __cmd_record(int argc, const char **argv)
513 int child_ready_pipe[2], go_pipe[2]; 512 int child_ready_pipe[2], go_pipe[2];
514 const bool forks = argc > 0; 513 const bool forks = argc > 0;
515 char buf; 514 char buf;
516 struct kernel_info *kerninfo; 515 struct machine *machine;
517 516
518 page_size = sysconf(_SC_PAGE_SIZE); 517 page_size = sysconf(_SC_PAGE_SIZE);
519 518
@@ -682,31 +681,30 @@ static int __cmd_record(int argc, const char **argv)
682 advance_output(err); 681 advance_output(err);
683 } 682 }
684 683
685 kerninfo = kerninfo__findhost(&session->kerninfo_root); 684 machine = perf_session__find_host_machine(session);
686 if (!kerninfo) { 685 if (!machine) {
687 pr_err("Couldn't find native kernel information.\n"); 686 pr_err("Couldn't find native kernel information.\n");
688 return -1; 687 return -1;
689 } 688 }
690 689
691 err = event__synthesize_kernel_mmap(process_synthesized_event, 690 err = event__synthesize_kernel_mmap(process_synthesized_event,
692 session, kerninfo, "_text"); 691 session, machine, "_text");
693 if (err < 0) 692 if (err < 0)
694 err = event__synthesize_kernel_mmap(process_synthesized_event, 693 err = event__synthesize_kernel_mmap(process_synthesized_event,
695 session, kerninfo, "_stext"); 694 session, machine, "_stext");
696 if (err < 0) { 695 if (err < 0) {
697 pr_err("Couldn't record kernel reference relocation symbol.\n"); 696 pr_err("Couldn't record kernel reference relocation symbol.\n");
698 return err; 697 return err;
699 } 698 }
700 699
701 err = event__synthesize_modules(process_synthesized_event, 700 err = event__synthesize_modules(process_synthesized_event,
702 session, kerninfo); 701 session, machine);
703 if (err < 0) { 702 if (err < 0) {
704 pr_err("Couldn't record kernel reference relocation symbol.\n"); 703 pr_err("Couldn't record kernel reference relocation symbol.\n");
705 return err; 704 return err;
706 } 705 }
707 if (perf_guest) 706 if (perf_guest)
708 kerninfo__process_allkernels(&session->kerninfo_root, 707 perf_session__process_machines(session, event__synthesize_guest_os);
709 event__synthesize_guest_os, session);
710 708
711 if (!system_wide && profile_cpu == -1) 709 if (!system_wide && profile_cpu == -1)
712 event__synthesize_thread(target_tid, process_synthesized_event, 710 event__synthesize_thread(target_tid, process_synthesized_event,
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 816edae7c5b2..49cc367d8c30 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -313,7 +313,7 @@ static int __cmd_report(void)
313 perf_session__fprintf(session, stdout); 313 perf_session__fprintf(session, stdout);
314 314
315 if (verbose > 2) 315 if (verbose > 2)
316 dsos__fprintf(&session->kerninfo_root, stdout); 316 dsos__fprintf(&session->machines, stdout);
317 317
318 next = rb_first(&session->stats_by_id); 318 next = rb_first(&session->stats_by_id);
319 while (next) { 319 while (next) {
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index dfd7ea7dabdd..c390f340b03d 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -854,7 +854,7 @@ static void handle_keypress(struct perf_session *session, int c)
854 case 'Q': 854 case 'Q':
855 printf("exiting.\n"); 855 printf("exiting.\n");
856 if (dump_symtab) 856 if (dump_symtab)
857 dsos__fprintf(&session->kerninfo_root, stderr); 857 dsos__fprintf(&session->machines, stderr);
858 exit(0); 858 exit(0);
859 case 's': 859 case 's':
860 prompt_symbol(&sym_filter_entry, "Enter details symbol"); 860 prompt_symbol(&sym_filter_entry, "Enter details symbol");
@@ -982,7 +982,7 @@ static void event__process_sample(const event_t *self,
982 u64 ip = self->ip.ip; 982 u64 ip = self->ip.ip;
983 struct sym_entry *syme; 983 struct sym_entry *syme;
984 struct addr_location al; 984 struct addr_location al;
985 struct kernel_info *kerninfo; 985 struct machine *machine;
986 u8 origin = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 986 u8 origin = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
987 987
988 ++samples; 988 ++samples;
@@ -992,18 +992,17 @@ static void event__process_sample(const event_t *self,
992 ++us_samples; 992 ++us_samples;
993 if (hide_user_symbols) 993 if (hide_user_symbols)
994 return; 994 return;
995 kerninfo = kerninfo__findhost(&session->kerninfo_root); 995 machine = perf_session__find_host_machine(session);
996 break; 996 break;
997 case PERF_RECORD_MISC_KERNEL: 997 case PERF_RECORD_MISC_KERNEL:
998 ++kernel_samples; 998 ++kernel_samples;
999 if (hide_kernel_symbols) 999 if (hide_kernel_symbols)
1000 return; 1000 return;
1001 kerninfo = kerninfo__findhost(&session->kerninfo_root); 1001 machine = perf_session__find_host_machine(session);
1002 break; 1002 break;
1003 case PERF_RECORD_MISC_GUEST_KERNEL: 1003 case PERF_RECORD_MISC_GUEST_KERNEL:
1004 ++guest_kernel_samples; 1004 ++guest_kernel_samples;
1005 kerninfo = kerninfo__find(&session->kerninfo_root, 1005 machine = perf_session__find_machine(session, self->ip.pid);
1006 self->ip.pid);
1007 break; 1006 break;
1008 case PERF_RECORD_MISC_GUEST_USER: 1007 case PERF_RECORD_MISC_GUEST_USER:
1009 ++guest_us_samples; 1008 ++guest_us_samples;
@@ -1016,7 +1015,7 @@ static void event__process_sample(const event_t *self,
1016 return; 1015 return;
1017 } 1016 }
1018 1017
1019 if (!kerninfo && perf_guest) { 1018 if (!machine && perf_guest) {
1020 pr_err("Can't find guest [%d]'s kernel information\n", 1019 pr_err("Can't find guest [%d]'s kernel information\n",
1021 self->ip.pid); 1020 self->ip.pid);
1022 return; 1021 return;
@@ -1041,7 +1040,7 @@ static void event__process_sample(const event_t *self,
1041 * --hide-kernel-symbols, even if the user specifies an 1040 * --hide-kernel-symbols, even if the user specifies an
1042 * invalid --vmlinux ;-) 1041 * invalid --vmlinux ;-)
1043 */ 1042 */
1044 if (al.map == kerninfo->vmlinux_maps[MAP__FUNCTION] && 1043 if (al.map == machine->vmlinux_maps[MAP__FUNCTION] &&
1045 RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) { 1044 RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) {
1046 pr_err("The %s file can't be used\n", 1045 pr_err("The %s file can't be used\n",
1047 symbol_conf.vmlinux_name); 1046 symbol_conf.vmlinux_name);
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index e3fa8d3d11b4..2f33ca9899bd 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -172,17 +172,17 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
172 172
173int event__synthesize_modules(event__handler_t process, 173int event__synthesize_modules(event__handler_t process,
174 struct perf_session *session, 174 struct perf_session *session,
175 struct kernel_info *kerninfo) 175 struct machine *machine)
176{ 176{
177 struct rb_node *nd; 177 struct rb_node *nd;
178 struct map_groups *kmaps = &kerninfo->kmaps; 178 struct map_groups *kmaps = &machine->kmaps;
179 u16 misc; 179 u16 misc;
180 180
181 /* 181 /*
182 * kernel uses 0 for user space maps, see kernel/perf_event.c 182 * kernel uses 0 for user space maps, see kernel/perf_event.c
183 * __perf_event_mmap 183 * __perf_event_mmap
184 */ 184 */
185 if (is_host_kernel(kerninfo)) 185 if (machine__is_host(machine))
186 misc = PERF_RECORD_MISC_KERNEL; 186 misc = PERF_RECORD_MISC_KERNEL;
187 else 187 else
188 misc = PERF_RECORD_MISC_GUEST_KERNEL; 188 misc = PERF_RECORD_MISC_GUEST_KERNEL;
@@ -204,7 +204,7 @@ int event__synthesize_modules(event__handler_t process,
204 (sizeof(ev.mmap.filename) - size)); 204 (sizeof(ev.mmap.filename) - size));
205 ev.mmap.start = pos->start; 205 ev.mmap.start = pos->start;
206 ev.mmap.len = pos->end - pos->start; 206 ev.mmap.len = pos->end - pos->start;
207 ev.mmap.pid = kerninfo->pid; 207 ev.mmap.pid = machine->pid;
208 208
209 memcpy(ev.mmap.filename, pos->dso->long_name, 209 memcpy(ev.mmap.filename, pos->dso->long_name,
210 pos->dso->long_name_len + 1); 210 pos->dso->long_name_len + 1);
@@ -267,7 +267,7 @@ static int find_symbol_cb(void *arg, const char *name, char type, u64 start)
267 267
268int event__synthesize_kernel_mmap(event__handler_t process, 268int event__synthesize_kernel_mmap(event__handler_t process,
269 struct perf_session *session, 269 struct perf_session *session,
270 struct kernel_info *kerninfo, 270 struct machine *machine,
271 const char *symbol_name) 271 const char *symbol_name)
272{ 272{
273 size_t size; 273 size_t size;
@@ -288,8 +288,8 @@ int event__synthesize_kernel_mmap(event__handler_t process,
288 */ 288 */
289 struct process_symbol_args args = { .name = symbol_name, }; 289 struct process_symbol_args args = { .name = symbol_name, };
290 290
291 mmap_name = kern_mmap_name(kerninfo, name_buff); 291 mmap_name = machine__mmap_name(machine, name_buff);
292 if (is_host_kernel(kerninfo)) { 292 if (machine__is_host(machine)) {
293 /* 293 /*
294 * kernel uses PERF_RECORD_MISC_USER for user space maps, 294 * kernel uses PERF_RECORD_MISC_USER for user space maps,
295 * see kernel/perf_event.c __perf_event_mmap 295 * see kernel/perf_event.c __perf_event_mmap
@@ -298,10 +298,10 @@ int event__synthesize_kernel_mmap(event__handler_t process,
298 filename = "/proc/kallsyms"; 298 filename = "/proc/kallsyms";
299 } else { 299 } else {
300 ev.header.misc = PERF_RECORD_MISC_GUEST_KERNEL; 300 ev.header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
301 if (is_default_guest(kerninfo)) 301 if (machine__is_default_guest(machine))
302 filename = (char *) symbol_conf.default_guest_kallsyms; 302 filename = (char *) symbol_conf.default_guest_kallsyms;
303 else { 303 else {
304 sprintf(path, "%s/proc/kallsyms", kerninfo->root_dir); 304 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
305 filename = path; 305 filename = path;
306 } 306 }
307 } 307 }
@@ -309,7 +309,7 @@ int event__synthesize_kernel_mmap(event__handler_t process,
309 if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0) 309 if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0)
310 return -ENOENT; 310 return -ENOENT;
311 311
312 map = kerninfo->vmlinux_maps[MAP__FUNCTION]; 312 map = machine->vmlinux_maps[MAP__FUNCTION];
313 size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename), 313 size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
314 "%s%s", mmap_name, symbol_name) + 1; 314 "%s%s", mmap_name, symbol_name) + 1;
315 size = ALIGN(size, sizeof(u64)); 315 size = ALIGN(size, sizeof(u64));
@@ -318,7 +318,7 @@ int event__synthesize_kernel_mmap(event__handler_t process,
318 ev.mmap.pgoff = args.start; 318 ev.mmap.pgoff = args.start;
319 ev.mmap.start = map->start; 319 ev.mmap.start = map->start;
320 ev.mmap.len = map->end - ev.mmap.start; 320 ev.mmap.len = map->end - ev.mmap.start;
321 ev.mmap.pid = kerninfo->pid; 321 ev.mmap.pid = machine->pid;
322 322
323 return process(&ev, session); 323 return process(&ev, session);
324} 324}
@@ -389,18 +389,18 @@ static int event__process_kernel_mmap(event_t *self,
389{ 389{
390 struct map *map; 390 struct map *map;
391 char kmmap_prefix[PATH_MAX]; 391 char kmmap_prefix[PATH_MAX];
392 struct kernel_info *kerninfo; 392 struct machine *machine;
393 enum dso_kernel_type kernel_type; 393 enum dso_kernel_type kernel_type;
394 bool is_kernel_mmap; 394 bool is_kernel_mmap;
395 395
396 kerninfo = kerninfo__findnew(&session->kerninfo_root, self->mmap.pid); 396 machine = perf_session__findnew_machine(session, self->mmap.pid);
397 if (!kerninfo) { 397 if (!machine) {
398 pr_err("Can't find id %d's kerninfo\n", self->mmap.pid); 398 pr_err("Can't find id %d's machine\n", self->mmap.pid);
399 goto out_problem; 399 goto out_problem;
400 } 400 }
401 401
402 kern_mmap_name(kerninfo, kmmap_prefix); 402 machine__mmap_name(machine, kmmap_prefix);
403 if (is_host_kernel(kerninfo)) 403 if (machine__is_host(machine))
404 kernel_type = DSO_TYPE_KERNEL; 404 kernel_type = DSO_TYPE_KERNEL;
405 else 405 else
406 kernel_type = DSO_TYPE_GUEST_KERNEL; 406 kernel_type = DSO_TYPE_GUEST_KERNEL;
@@ -429,10 +429,9 @@ static int event__process_kernel_mmap(event_t *self,
429 } else 429 } else
430 strcpy(short_module_name, self->mmap.filename); 430 strcpy(short_module_name, self->mmap.filename);
431 431
432 map = map_groups__new_module(&kerninfo->kmaps, 432 map = map_groups__new_module(&machine->kmaps,
433 self->mmap.start, 433 self->mmap.start,
434 self->mmap.filename, 434 self->mmap.filename, machine);
435 kerninfo);
436 if (map == NULL) 435 if (map == NULL)
437 goto out_problem; 436 goto out_problem;
438 437
@@ -449,27 +448,27 @@ static int event__process_kernel_mmap(event_t *self,
449 * Should be there already, from the build-id table in 448 * Should be there already, from the build-id table in
450 * the header. 449 * the header.
451 */ 450 */
452 struct dso *kernel = __dsos__findnew(&kerninfo->dsos__kernel, 451 struct dso *kernel = __dsos__findnew(&machine->kernel_dsos,
453 kmmap_prefix); 452 kmmap_prefix);
454 if (kernel == NULL) 453 if (kernel == NULL)
455 goto out_problem; 454 goto out_problem;
456 455
457 kernel->kernel = kernel_type; 456 kernel->kernel = kernel_type;
458 if (__map_groups__create_kernel_maps(&kerninfo->kmaps, 457 if (__map_groups__create_kernel_maps(&machine->kmaps,
459 kerninfo->vmlinux_maps, kernel) < 0) 458 machine->vmlinux_maps,
459 kernel) < 0)
460 goto out_problem; 460 goto out_problem;
461 461
462 event_set_kernel_mmap_len(kerninfo->vmlinux_maps, self); 462 event_set_kernel_mmap_len(machine->vmlinux_maps, self);
463 perf_session__set_kallsyms_ref_reloc_sym(kerninfo->vmlinux_maps, 463 perf_session__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
464 symbol_name, 464 symbol_name,
465 self->mmap.pgoff); 465 self->mmap.pgoff);
466 if (is_default_guest(kerninfo)) { 466 if (machine__is_default_guest(machine)) {
467 /* 467 /*
468 * preload dso of guest kernel and modules 468 * preload dso of guest kernel and modules
469 */ 469 */
470 dso__load(kernel, 470 dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
471 kerninfo->vmlinux_maps[MAP__FUNCTION], 471 NULL);
472 NULL);
473 } 472 }
474 } 473 }
475 return 0; 474 return 0;
@@ -479,7 +478,7 @@ out_problem:
479 478
480int event__process_mmap(event_t *self, struct perf_session *session) 479int event__process_mmap(event_t *self, struct perf_session *session)
481{ 480{
482 struct kernel_info *kerninfo; 481 struct machine *machine;
483 struct thread *thread; 482 struct thread *thread;
484 struct map *map; 483 struct map *map;
485 u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 484 u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
@@ -498,8 +497,8 @@ int event__process_mmap(event_t *self, struct perf_session *session)
498 } 497 }
499 498
500 thread = perf_session__findnew(session, self->mmap.pid); 499 thread = perf_session__findnew(session, self->mmap.pid);
501 kerninfo = kerninfo__findhost(&session->kerninfo_root); 500 machine = perf_session__find_host_machine(session);
502 map = map__new(&kerninfo->dsos__user, self->mmap.start, 501 map = map__new(&machine->user_dsos, self->mmap.start,
503 self->mmap.len, self->mmap.pgoff, 502 self->mmap.len, self->mmap.pgoff,
504 self->mmap.pid, self->mmap.filename, 503 self->mmap.pid, self->mmap.filename,
505 MAP__FUNCTION, session->cwd, session->cwdlen); 504 MAP__FUNCTION, session->cwd, session->cwdlen);
@@ -546,7 +545,7 @@ void thread__find_addr_map(struct thread *self,
546 struct addr_location *al) 545 struct addr_location *al)
547{ 546{
548 struct map_groups *mg = &self->mg; 547 struct map_groups *mg = &self->mg;
549 struct kernel_info *kerninfo = NULL; 548 struct machine *machine = NULL;
550 549
551 al->thread = self; 550 al->thread = self;
552 al->addr = addr; 551 al->addr = addr;
@@ -555,19 +554,19 @@ void thread__find_addr_map(struct thread *self,
555 554
556 if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) { 555 if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
557 al->level = 'k'; 556 al->level = 'k';
558 kerninfo = kerninfo__findhost(&session->kerninfo_root); 557 machine = perf_session__find_host_machine(session);
559 mg = &kerninfo->kmaps; 558 mg = &machine->kmaps;
560 } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) { 559 } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
561 al->level = '.'; 560 al->level = '.';
562 kerninfo = kerninfo__findhost(&session->kerninfo_root); 561 machine = perf_session__find_host_machine(session);
563 } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) { 562 } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
564 al->level = 'g'; 563 al->level = 'g';
565 kerninfo = kerninfo__find(&session->kerninfo_root, pid); 564 machine = perf_session__find_machine(session, pid);
566 if (!kerninfo) { 565 if (!machine) {
567 al->map = NULL; 566 al->map = NULL;
568 return; 567 return;
569 } 568 }
570 mg = &kerninfo->kmaps; 569 mg = &machine->kmaps;
571 } else { 570 } else {
572 /* 571 /*
573 * 'u' means guest os user space. 572 * 'u' means guest os user space.
@@ -603,10 +602,9 @@ try_again:
603 * in the whole kernel symbol list. 602 * in the whole kernel symbol list.
604 */ 603 */
605 if ((long long)al->addr < 0 && 604 if ((long long)al->addr < 0 &&
606 cpumode == PERF_RECORD_MISC_KERNEL && 605 cpumode == PERF_RECORD_MISC_KERNEL &&
607 kerninfo && 606 machine && mg != &machine->kmaps) {
608 mg != &kerninfo->kmaps) { 607 mg = &machine->kmaps;
609 mg = &kerninfo->kmaps;
610 goto try_again; 608 goto try_again;
611 } 609 }
612 } else 610 } else
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 4af2ed5d48ad..b364da5b0cbf 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -156,12 +156,12 @@ void event__synthesize_threads(event__handler_t process,
156 struct perf_session *session); 156 struct perf_session *session);
157int event__synthesize_kernel_mmap(event__handler_t process, 157int event__synthesize_kernel_mmap(event__handler_t process,
158 struct perf_session *session, 158 struct perf_session *session,
159 struct kernel_info *kerninfo, 159 struct machine *machine,
160 const char *symbol_name); 160 const char *symbol_name);
161 161
162int event__synthesize_modules(event__handler_t process, 162int event__synthesize_modules(event__handler_t process,
163 struct perf_session *session, 163 struct perf_session *session,
164 struct kernel_info *kerninfo); 164 struct machine *machine);
165 165
166int event__process_comm(event_t *self, struct perf_session *session); 166int event__process_comm(event_t *self, struct perf_session *session);
167int event__process_lost(event_t *self, struct perf_session *session); 167int event__process_lost(event_t *self, struct perf_session *session);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 75d016768021..6227dc4cb2cf 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -229,10 +229,9 @@ static int dsos__write_buildid_table(struct perf_header *header, int fd)
229 int err = 0; 229 int err = 0;
230 u16 kmisc, umisc; 230 u16 kmisc, umisc;
231 231
232 for (nd = rb_first(&session->kerninfo_root); nd; nd = rb_next(nd)) { 232 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
233 struct kernel_info *pos = rb_entry(nd, struct kernel_info, 233 struct machine *pos = rb_entry(nd, struct machine, rb_node);
234 rb_node); 234 if (machine__is_host(pos)) {
235 if (is_host_kernel(pos)) {
236 kmisc = PERF_RECORD_MISC_KERNEL; 235 kmisc = PERF_RECORD_MISC_KERNEL;
237 umisc = PERF_RECORD_MISC_USER; 236 umisc = PERF_RECORD_MISC_USER;
238 } else { 237 } else {
@@ -240,11 +239,11 @@ static int dsos__write_buildid_table(struct perf_header *header, int fd)
240 umisc = PERF_RECORD_MISC_GUEST_USER; 239 umisc = PERF_RECORD_MISC_GUEST_USER;
241 } 240 }
242 241
243 err = __dsos__write_buildid_table(&pos->dsos__kernel, pos->pid, 242 err = __dsos__write_buildid_table(&pos->kernel_dsos, pos->pid,
244 kmisc, fd); 243 kmisc, fd);
245 if (err == 0) 244 if (err == 0)
246 err = __dsos__write_buildid_table(&pos->dsos__user, 245 err = __dsos__write_buildid_table(&pos->user_dsos,
247 pos->pid, umisc, fd); 246 pos->pid, umisc, fd);
248 if (err) 247 if (err)
249 break; 248 break;
250 } 249 }
@@ -378,11 +377,10 @@ static int dsos__cache_build_ids(struct perf_header *self)
378 if (mkdir(debugdir, 0755) != 0 && errno != EEXIST) 377 if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
379 return -1; 378 return -1;
380 379
381 for (nd = rb_first(&session->kerninfo_root); nd; nd = rb_next(nd)) { 380 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
382 struct kernel_info *pos = rb_entry(nd, struct kernel_info, 381 struct machine *pos = rb_entry(nd, struct machine, rb_node);
383 rb_node); 382 ret |= __dsos__cache_build_ids(&pos->kernel_dsos, debugdir);
384 ret |= __dsos__cache_build_ids(&pos->dsos__kernel, debugdir); 383 ret |= __dsos__cache_build_ids(&pos->user_dsos, debugdir);
385 ret |= __dsos__cache_build_ids(&pos->dsos__user, debugdir);
386 } 384 }
387 return ret ? -1 : 0; 385 return ret ? -1 : 0;
388} 386}
@@ -394,11 +392,10 @@ static bool dsos__read_build_ids(struct perf_header *self, bool with_hits)
394 struct perf_session, header); 392 struct perf_session, header);
395 struct rb_node *nd; 393 struct rb_node *nd;
396 394
397 for (nd = rb_first(&session->kerninfo_root); nd; nd = rb_next(nd)) { 395 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
398 struct kernel_info *pos = rb_entry(nd, struct kernel_info, 396 struct machine *pos = rb_entry(nd, struct machine, rb_node);
399 rb_node); 397 ret |= __dsos__read_build_ids(&pos->kernel_dsos, with_hits);
400 ret |= __dsos__read_build_ids(&pos->dsos__kernel, with_hits); 398 ret |= __dsos__read_build_ids(&pos->user_dsos, with_hits);
401 ret |= __dsos__read_build_ids(&pos->dsos__user, with_hits);
402 } 399 }
403 400
404 return ret; 401 return ret;
@@ -685,13 +682,13 @@ static int __event_process_build_id(struct build_id_event *bev,
685{ 682{
686 int err = -1; 683 int err = -1;
687 struct list_head *head; 684 struct list_head *head;
688 struct kernel_info *kerninfo; 685 struct machine *machine;
689 u16 misc; 686 u16 misc;
690 struct dso *dso; 687 struct dso *dso;
691 enum dso_kernel_type dso_type; 688 enum dso_kernel_type dso_type;
692 689
693 kerninfo = kerninfo__findnew(&session->kerninfo_root, bev->pid); 690 machine = perf_session__findnew_machine(session, bev->pid);
694 if (!kerninfo) 691 if (!machine)
695 goto out; 692 goto out;
696 693
697 misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 694 misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
@@ -699,16 +696,16 @@ static int __event_process_build_id(struct build_id_event *bev,
699 switch (misc) { 696 switch (misc) {
700 case PERF_RECORD_MISC_KERNEL: 697 case PERF_RECORD_MISC_KERNEL:
701 dso_type = DSO_TYPE_KERNEL; 698 dso_type = DSO_TYPE_KERNEL;
702 head = &kerninfo->dsos__kernel; 699 head = &machine->kernel_dsos;
703 break; 700 break;
704 case PERF_RECORD_MISC_GUEST_KERNEL: 701 case PERF_RECORD_MISC_GUEST_KERNEL:
705 dso_type = DSO_TYPE_GUEST_KERNEL; 702 dso_type = DSO_TYPE_GUEST_KERNEL;
706 head = &kerninfo->dsos__kernel; 703 head = &machine->kernel_dsos;
707 break; 704 break;
708 case PERF_RECORD_MISC_USER: 705 case PERF_RECORD_MISC_USER:
709 case PERF_RECORD_MISC_GUEST_USER: 706 case PERF_RECORD_MISC_GUEST_USER:
710 dso_type = DSO_TYPE_USER; 707 dso_type = DSO_TYPE_USER;
711 head = &kerninfo->dsos__user; 708 head = &machine->user_dsos;
712 break; 709 break;
713 default: 710 default:
714 goto out; 711 goto out;
@@ -1113,8 +1110,7 @@ int event__process_tracing_data(event_t *self,
1113} 1110}
1114 1111
1115int event__synthesize_build_id(struct dso *pos, u16 misc, 1112int event__synthesize_build_id(struct dso *pos, u16 misc,
1116 event__handler_t process, 1113 event__handler_t process, struct machine *machine,
1117 struct kernel_info *kerninfo,
1118 struct perf_session *session) 1114 struct perf_session *session)
1119{ 1115{
1120 event_t ev; 1116 event_t ev;
@@ -1131,7 +1127,7 @@ int event__synthesize_build_id(struct dso *pos, u16 misc,
1131 memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id)); 1127 memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
1132 ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID; 1128 ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
1133 ev.build_id.header.misc = misc; 1129 ev.build_id.header.misc = misc;
1134 ev.build_id.pid = kerninfo->pid; 1130 ev.build_id.pid = machine->pid;
1135 ev.build_id.header.size = sizeof(ev.build_id) + len; 1131 ev.build_id.header.size = sizeof(ev.build_id) + len;
1136 memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len); 1132 memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
1137 1133
@@ -1142,7 +1138,7 @@ int event__synthesize_build_id(struct dso *pos, u16 misc,
1142 1138
1143static int __event_synthesize_build_ids(struct list_head *head, u16 misc, 1139static int __event_synthesize_build_ids(struct list_head *head, u16 misc,
1144 event__handler_t process, 1140 event__handler_t process,
1145 struct kernel_info *kerninfo, 1141 struct machine *machine,
1146 struct perf_session *session) 1142 struct perf_session *session)
1147{ 1143{
1148 struct dso *pos; 1144 struct dso *pos;
@@ -1153,7 +1149,7 @@ static int __event_synthesize_build_ids(struct list_head *head, u16 misc,
1153 continue; 1149 continue;
1154 1150
1155 err = event__synthesize_build_id(pos, misc, process, 1151 err = event__synthesize_build_id(pos, misc, process,
1156 kerninfo, session); 1152 machine, session);
1157 if (err < 0) 1153 if (err < 0)
1158 return err; 1154 return err;
1159 } 1155 }
@@ -1166,15 +1162,15 @@ int event__synthesize_build_ids(event__handler_t process,
1166{ 1162{
1167 int err = 0; 1163 int err = 0;
1168 u16 kmisc, umisc; 1164 u16 kmisc, umisc;
1169 struct kernel_info *pos; 1165 struct machine *pos;
1170 struct rb_node *nd; 1166 struct rb_node *nd;
1171 1167
1172 if (!dsos__read_build_ids(&session->header, true)) 1168 if (!dsos__read_build_ids(&session->header, true))
1173 return 0; 1169 return 0;
1174 1170
1175 for (nd = rb_first(&session->kerninfo_root); nd; nd = rb_next(nd)) { 1171 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
1176 pos = rb_entry(nd, struct kernel_info, rb_node); 1172 pos = rb_entry(nd, struct machine, rb_node);
1177 if (is_host_kernel(pos)) { 1173 if (machine__is_host(pos)) {
1178 kmisc = PERF_RECORD_MISC_KERNEL; 1174 kmisc = PERF_RECORD_MISC_KERNEL;
1179 umisc = PERF_RECORD_MISC_USER; 1175 umisc = PERF_RECORD_MISC_USER;
1180 } else { 1176 } else {
@@ -1182,11 +1178,11 @@ int event__synthesize_build_ids(event__handler_t process,
1182 umisc = PERF_RECORD_MISC_GUEST_USER; 1178 umisc = PERF_RECORD_MISC_GUEST_USER;
1183 } 1179 }
1184 1180
1185 err = __event_synthesize_build_ids(&pos->dsos__kernel, 1181 err = __event_synthesize_build_ids(&pos->kernel_dsos, kmisc,
1186 kmisc, process, pos, session); 1182 process, pos, session);
1187 if (err == 0) 1183 if (err == 0)
1188 err = __event_synthesize_build_ids(&pos->dsos__user, 1184 err = __event_synthesize_build_ids(&pos->user_dsos, umisc,
1189 umisc, process, pos, session); 1185 process, pos, session);
1190 if (err) 1186 if (err)
1191 break; 1187 break;
1192 } 1188 }
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 275915458148..f39443db0706 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -120,7 +120,7 @@ int event__process_tracing_data(event_t *self,
120 120
121int event__synthesize_build_id(struct dso *pos, u16 misc, 121int event__synthesize_build_id(struct dso *pos, u16 misc,
122 event__handler_t process, 122 event__handler_t process,
123 struct kernel_info *kerninfo, 123 struct machine *machine,
124 struct perf_session *session); 124 struct perf_session *session);
125int event__synthesize_build_ids(event__handler_t process, 125int event__synthesize_build_ids(event__handler_t process,
126 struct perf_session *session); 126 struct perf_session *session);
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 7facd016ec97..da3d4e826231 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -245,7 +245,7 @@ void map_groups__init(struct map_groups *self)
245 self->maps[i] = RB_ROOT; 245 self->maps[i] = RB_ROOT;
246 INIT_LIST_HEAD(&self->removed_maps[i]); 246 INIT_LIST_HEAD(&self->removed_maps[i]);
247 } 247 }
248 self->this_kerninfo = NULL; 248 self->machine = NULL;
249} 249}
250 250
251void map_groups__flush(struct map_groups *self) 251void map_groups__flush(struct map_groups *self)
@@ -513,133 +513,130 @@ struct map *maps__find(struct rb_root *maps, u64 ip)
513 return NULL; 513 return NULL;
514} 514}
515 515
516struct kernel_info *add_new_kernel_info(struct rb_root *kerninfo_root, 516struct machine *machines__add(struct rb_root *self, pid_t pid,
517 pid_t pid, const char *root_dir) 517 const char *root_dir)
518{ 518{
519 struct rb_node **p = &kerninfo_root->rb_node; 519 struct rb_node **p = &self->rb_node;
520 struct rb_node *parent = NULL; 520 struct rb_node *parent = NULL;
521 struct kernel_info *kerninfo, *pos; 521 struct machine *pos, *machine = malloc(sizeof(*machine));
522 522
523 kerninfo = malloc(sizeof(struct kernel_info)); 523 if (!machine)
524 if (!kerninfo)
525 return NULL; 524 return NULL;
526 525
527 kerninfo->pid = pid; 526 machine->pid = pid;
528 map_groups__init(&kerninfo->kmaps); 527 map_groups__init(&machine->kmaps);
529 kerninfo->root_dir = strdup(root_dir); 528 machine->root_dir = strdup(root_dir);
530 RB_CLEAR_NODE(&kerninfo->rb_node); 529 RB_CLEAR_NODE(&machine->rb_node);
531 INIT_LIST_HEAD(&kerninfo->dsos__user); 530 INIT_LIST_HEAD(&machine->user_dsos);
532 INIT_LIST_HEAD(&kerninfo->dsos__kernel); 531 INIT_LIST_HEAD(&machine->kernel_dsos);
533 kerninfo->kmaps.this_kerninfo = kerninfo; 532 machine->kmaps.machine = machine;
534 533
535 while (*p != NULL) { 534 while (*p != NULL) {
536 parent = *p; 535 parent = *p;
537 pos = rb_entry(parent, struct kernel_info, rb_node); 536 pos = rb_entry(parent, struct machine, rb_node);
538 if (pid < pos->pid) 537 if (pid < pos->pid)
539 p = &(*p)->rb_left; 538 p = &(*p)->rb_left;
540 else 539 else
541 p = &(*p)->rb_right; 540 p = &(*p)->rb_right;
542 } 541 }
543 542
544 rb_link_node(&kerninfo->rb_node, parent, p); 543 rb_link_node(&machine->rb_node, parent, p);
545 rb_insert_color(&kerninfo->rb_node, kerninfo_root); 544 rb_insert_color(&machine->rb_node, self);
546 545
547 return kerninfo; 546 return machine;
548} 547}
549 548
550struct kernel_info *kerninfo__find(struct rb_root *kerninfo_root, pid_t pid) 549struct machine *machines__find(struct rb_root *self, pid_t pid)
551{ 550{
552 struct rb_node **p = &kerninfo_root->rb_node; 551 struct rb_node **p = &self->rb_node;
553 struct rb_node *parent = NULL; 552 struct rb_node *parent = NULL;
554 struct kernel_info *kerninfo; 553 struct machine *machine;
555 struct kernel_info *default_kerninfo = NULL; 554 struct machine *default_machine = NULL;
556 555
557 while (*p != NULL) { 556 while (*p != NULL) {
558 parent = *p; 557 parent = *p;
559 kerninfo = rb_entry(parent, struct kernel_info, rb_node); 558 machine = rb_entry(parent, struct machine, rb_node);
560 if (pid < kerninfo->pid) 559 if (pid < machine->pid)
561 p = &(*p)->rb_left; 560 p = &(*p)->rb_left;
562 else if (pid > kerninfo->pid) 561 else if (pid > machine->pid)
563 p = &(*p)->rb_right; 562 p = &(*p)->rb_right;
564 else 563 else
565 return kerninfo; 564 return machine;
566 if (!kerninfo->pid) 565 if (!machine->pid)
567 default_kerninfo = kerninfo; 566 default_machine = machine;
568 } 567 }
569 568
570 return default_kerninfo; 569 return default_machine;
571} 570}
572 571
573struct kernel_info *kerninfo__findhost(struct rb_root *kerninfo_root) 572/*
573 * FIXME: Why repeatedly search for this?
574 */
575struct machine *machines__find_host(struct rb_root *self)
574{ 576{
575 struct rb_node **p = &kerninfo_root->rb_node; 577 struct rb_node **p = &self->rb_node;
576 struct rb_node *parent = NULL; 578 struct rb_node *parent = NULL;
577 struct kernel_info *kerninfo; 579 struct machine *machine;
578 pid_t pid = HOST_KERNEL_ID; 580 pid_t pid = HOST_KERNEL_ID;
579 581
580 while (*p != NULL) { 582 while (*p != NULL) {
581 parent = *p; 583 parent = *p;
582 kerninfo = rb_entry(parent, struct kernel_info, rb_node); 584 machine = rb_entry(parent, struct machine, rb_node);
583 if (pid < kerninfo->pid) 585 if (pid < machine->pid)
584 p = &(*p)->rb_left; 586 p = &(*p)->rb_left;
585 else if (pid > kerninfo->pid) 587 else if (pid > machine->pid)
586 p = &(*p)->rb_right; 588 p = &(*p)->rb_right;
587 else 589 else
588 return kerninfo; 590 return machine;
589 } 591 }
590 592
591 return NULL; 593 return NULL;
592} 594}
593 595
594struct kernel_info *kerninfo__findnew(struct rb_root *kerninfo_root, pid_t pid) 596struct machine *machines__findnew(struct rb_root *self, pid_t pid)
595{ 597{
596 char path[PATH_MAX]; 598 char path[PATH_MAX];
597 const char *root_dir; 599 const char *root_dir;
598 int ret; 600 struct machine *machine = machines__find(self, pid);
599 struct kernel_info *kerninfo = kerninfo__find(kerninfo_root, pid);
600 601
601 if (!kerninfo || kerninfo->pid != pid) { 602 if (!machine || machine->pid != pid) {
602 if (pid == HOST_KERNEL_ID || pid == DEFAULT_GUEST_KERNEL_ID) 603 if (pid == HOST_KERNEL_ID || pid == DEFAULT_GUEST_KERNEL_ID)
603 root_dir = ""; 604 root_dir = "";
604 else { 605 else {
605 if (!symbol_conf.guestmount) 606 if (!symbol_conf.guestmount)
606 goto out; 607 goto out;
607 sprintf(path, "%s/%d", symbol_conf.guestmount, pid); 608 sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
608 ret = access(path, R_OK); 609 if (access(path, R_OK)) {
609 if (ret) {
610 pr_err("Can't access file %s\n", path); 610 pr_err("Can't access file %s\n", path);
611 goto out; 611 goto out;
612 } 612 }
613 root_dir = path; 613 root_dir = path;
614 } 614 }
615 kerninfo = add_new_kernel_info(kerninfo_root, pid, root_dir); 615 machine = machines__add(self, pid, root_dir);
616 } 616 }
617 617
618out: 618out:
619 return kerninfo; 619 return machine;
620} 620}
621 621
622void kerninfo__process_allkernels(struct rb_root *kerninfo_root, 622void machines__process(struct rb_root *self, machine__process_t process, void *data)
623 process_kernel_info process,
624 void *data)
625{ 623{
626 struct rb_node *nd; 624 struct rb_node *nd;
627 625
628 for (nd = rb_first(kerninfo_root); nd; nd = rb_next(nd)) { 626 for (nd = rb_first(self); nd; nd = rb_next(nd)) {
629 struct kernel_info *pos = rb_entry(nd, struct kernel_info, 627 struct machine *pos = rb_entry(nd, struct machine, rb_node);
630 rb_node);
631 process(pos, data); 628 process(pos, data);
632 } 629 }
633} 630}
634 631
635char *kern_mmap_name(struct kernel_info *kerninfo, char *buff) 632char *machine__mmap_name(struct machine *self, char *buff)
636{ 633{
637 if (is_host_kernel(kerninfo)) 634 if (machine__is_host(self))
638 sprintf(buff, "[%s]", "kernel.kallsyms"); 635 sprintf(buff, "[%s]", "kernel.kallsyms");
639 else if (is_default_guest(kerninfo)) 636 else if (machine__is_default_guest(self))
640 sprintf(buff, "[%s]", "guest.kernel.kallsyms"); 637 sprintf(buff, "[%s]", "guest.kernel.kallsyms");
641 else 638 else
642 sprintf(buff, "[%s.%d]", "guest.kernel.kallsyms", kerninfo->pid); 639 sprintf(buff, "[%s.%d]", "guest.kernel.kallsyms", self->pid);
643 640
644 return buff; 641 return buff;
645} 642}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 30d38d634e09..4c1c2da704b2 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -5,6 +5,7 @@
5#include <linux/list.h> 5#include <linux/list.h>
6#include <linux/rbtree.h> 6#include <linux/rbtree.h>
7#include <stdio.h> 7#include <stdio.h>
8#include <stdbool.h>
8#include "types.h" 9#include "types.h"
9 10
10enum map_type { 11enum map_type {
@@ -19,7 +20,7 @@ extern const char *map_type__name[MAP__NR_TYPES];
19struct dso; 20struct dso;
20struct ref_reloc_sym; 21struct ref_reloc_sym;
21struct map_groups; 22struct map_groups;
22struct kernel_info; 23struct machine;
23 24
24struct map { 25struct map {
25 union { 26 union {
@@ -46,23 +47,23 @@ struct kmap {
46}; 47};
47 48
48struct map_groups { 49struct map_groups {
49 struct rb_root maps[MAP__NR_TYPES]; 50 struct rb_root maps[MAP__NR_TYPES];
50 struct list_head removed_maps[MAP__NR_TYPES]; 51 struct list_head removed_maps[MAP__NR_TYPES];
51 struct kernel_info *this_kerninfo; 52 struct machine *machine;
52}; 53};
53 54
54/* Native host kernel uses -1 as pid index in kernel_info */ 55/* Native host kernel uses -1 as pid index in machine */
55#define HOST_KERNEL_ID (-1) 56#define HOST_KERNEL_ID (-1)
56#define DEFAULT_GUEST_KERNEL_ID (0) 57#define DEFAULT_GUEST_KERNEL_ID (0)
57 58
58struct kernel_info { 59struct machine {
59 struct rb_node rb_node; 60 struct rb_node rb_node;
60 pid_t pid; 61 pid_t pid;
61 char *root_dir; 62 char *root_dir;
62 struct list_head dsos__user; 63 struct list_head user_dsos;
63 struct list_head dsos__kernel; 64 struct list_head kernel_dsos;
64 struct map_groups kmaps; 65 struct map_groups kmaps;
65 struct map *vmlinux_maps[MAP__NR_TYPES]; 66 struct map *vmlinux_maps[MAP__NR_TYPES];
66}; 67};
67 68
68static inline struct kmap *map__kmap(struct map *self) 69static inline struct kmap *map__kmap(struct map *self)
@@ -124,36 +125,30 @@ int map_groups__clone(struct map_groups *self,
124size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp); 125size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp);
125size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp); 126size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp);
126 127
127struct kernel_info *add_new_kernel_info(struct rb_root *kerninfo_root, 128typedef void (*machine__process_t)(struct machine *self, void *data);
128 pid_t pid, const char *root_dir); 129
129struct kernel_info *kerninfo__find(struct rb_root *kerninfo_root, pid_t pid); 130void machines__process(struct rb_root *self, machine__process_t process, void *data);
130struct kernel_info *kerninfo__findnew(struct rb_root *kerninfo_root, pid_t pid); 131struct machine *machines__add(struct rb_root *self, pid_t pid,
131struct kernel_info *kerninfo__findhost(struct rb_root *kerninfo_root); 132 const char *root_dir);
132char *kern_mmap_name(struct kernel_info *kerninfo, char *buff); 133struct machine *machines__find_host(struct rb_root *self);
134struct machine *machines__find(struct rb_root *self, pid_t pid);
135struct machine *machines__findnew(struct rb_root *self, pid_t pid);
136char *machine__mmap_name(struct machine *self, char *buff);
133 137
134/* 138/*
135 * Default guest kernel is defined by parameter --guestkallsyms 139 * Default guest kernel is defined by parameter --guestkallsyms
136 * and --guestmodules 140 * and --guestmodules
137 */ 141 */
138static inline int is_default_guest(struct kernel_info *kerninfo) 142static inline bool machine__is_default_guest(struct machine *self)
139{ 143{
140 if (!kerninfo) 144 return self ? self->pid == DEFAULT_GUEST_KERNEL_ID : false;
141 return 0;
142 return kerninfo->pid == DEFAULT_GUEST_KERNEL_ID;
143} 145}
144 146
145static inline int is_host_kernel(struct kernel_info *kerninfo) 147static inline bool machine__is_host(struct machine *self)
146{ 148{
147 if (!kerninfo) 149 return self ? self->pid == HOST_KERNEL_ID : false;
148 return 0;
149 return kerninfo->pid == HOST_KERNEL_ID;
150} 150}
151 151
152typedef void (*process_kernel_info)(struct kernel_info *kerninfo, void *data);
153void kerninfo__process_allkernels(struct rb_root *kerninfo_root,
154 process_kernel_info process,
155 void *data);
156
157static inline void map_groups__insert(struct map_groups *self, struct map *map) 152static inline void map_groups__insert(struct map_groups *self, struct map *map)
158{ 153{
159 maps__insert(&self->maps[map->type], map); 154 maps__insert(&self->maps[map->type], map);
@@ -197,10 +192,8 @@ int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
197 192
198struct map *map_groups__find_by_name(struct map_groups *self, 193struct map *map_groups__find_by_name(struct map_groups *self,
199 enum map_type type, const char *name); 194 enum map_type type, const char *name);
200struct map *map_groups__new_module(struct map_groups *self, 195struct map *map_groups__new_module(struct map_groups *self, u64 start,
201 u64 start, 196 const char *filename, struct machine *machine);
202 const char *filename,
203 struct kernel_info *kerninfo);
204 197
205void map_groups__flush(struct map_groups *self); 198void map_groups__flush(struct map_groups *self);
206 199
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index b7aade2184b2..b745c1c0b6c7 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -70,7 +70,7 @@ void perf_session__update_sample_type(struct perf_session *self)
70int perf_session__create_kernel_maps(struct perf_session *self) 70int perf_session__create_kernel_maps(struct perf_session *self)
71{ 71{
72 int ret; 72 int ret;
73 struct rb_root *root = &self->kerninfo_root; 73 struct rb_root *root = &self->machines;
74 74
75 ret = map_groups__create_kernel_maps(root, HOST_KERNEL_ID); 75 ret = map_groups__create_kernel_maps(root, HOST_KERNEL_ID);
76 if (ret >= 0) 76 if (ret >= 0)
@@ -97,7 +97,7 @@ struct perf_session *perf_session__new(const char *filename, int mode, bool forc
97 self->cwd = NULL; 97 self->cwd = NULL;
98 self->cwdlen = 0; 98 self->cwdlen = 0;
99 self->unknown_events = 0; 99 self->unknown_events = 0;
100 self->kerninfo_root = RB_ROOT; 100 self->machines = RB_ROOT;
101 self->ordered_samples.flush_limit = ULLONG_MAX; 101 self->ordered_samples.flush_limit = ULLONG_MAX;
102 INIT_LIST_HEAD(&self->ordered_samples.samples_head); 102 INIT_LIST_HEAD(&self->ordered_samples.samples_head);
103 103
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 796e2291ebd7..71252723a17d 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -25,7 +25,7 @@ struct perf_session {
25 unsigned long mmap_window; 25 unsigned long mmap_window;
26 struct rb_root threads; 26 struct rb_root threads;
27 struct thread *last_match; 27 struct thread *last_match;
28 struct rb_root kerninfo_root; 28 struct rb_root machines;
29 struct events_stats events_stats; 29 struct events_stats events_stats;
30 struct rb_root stats_by_id; 30 struct rb_root stats_by_id;
31 unsigned long event_total[PERF_RECORD_MAX]; 31 unsigned long event_total[PERF_RECORD_MAX];
@@ -102,4 +102,29 @@ int perf_session__browse_hists(struct rb_root *hists, u64 nr_hists,
102 u64 session_total, const char *helpline, 102 u64 session_total, const char *helpline,
103 const char *input_name); 103 const char *input_name);
104#endif 104#endif
105
106static inline
107struct machine *perf_session__find_host_machine(struct perf_session *self)
108{
109 return machines__find_host(&self->machines);
110}
111
112static inline
113struct machine *perf_session__find_machine(struct perf_session *self, pid_t pid)
114{
115 return machines__find(&self->machines, pid);
116}
117
118static inline
119struct machine *perf_session__findnew_machine(struct perf_session *self, pid_t pid)
120{
121 return machines__findnew(&self->machines, pid);
122}
123
124static inline
125void perf_session__process_machines(struct perf_session *self,
126 machine__process_t process)
127{
128 return machines__process(&self->machines, process, self);
129}
105#endif /* __PERF_SESSION_H */ 130#endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index e77c33a11de3..dc046368b5cf 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -485,7 +485,7 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
485 symbol_filter_t filter) 485 symbol_filter_t filter)
486{ 486{
487 struct map_groups *kmaps = map__kmap(map)->kmaps; 487 struct map_groups *kmaps = map__kmap(map)->kmaps;
488 struct kernel_info *kerninfo = kmaps->this_kerninfo; 488 struct machine *machine = kmaps->machine;
489 struct map *curr_map = map; 489 struct map *curr_map = map;
490 struct symbol *pos; 490 struct symbol *pos;
491 int count = 0; 491 int count = 0;
@@ -508,8 +508,8 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
508 508
509 if (strcmp(curr_map->dso->short_name, module)) { 509 if (strcmp(curr_map->dso->short_name, module)) {
510 if (curr_map != map && 510 if (curr_map != map &&
511 self->kernel == DSO_TYPE_GUEST_KERNEL && 511 self->kernel == DSO_TYPE_GUEST_KERNEL &&
512 is_default_guest(kerninfo)) { 512 machine__is_default_guest(machine)) {
513 /* 513 /*
514 * We assume all symbols of a module are 514 * We assume all symbols of a module are
515 * continuous in * kallsyms, so curr_map 515 * continuous in * kallsyms, so curr_map
@@ -527,13 +527,13 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
527 pr_err("%s/proc/{kallsyms,modules} " 527 pr_err("%s/proc/{kallsyms,modules} "
528 "inconsistency while looking " 528 "inconsistency while looking "
529 "for \"%s\" module!\n", 529 "for \"%s\" module!\n",
530 kerninfo->root_dir, module); 530 machine->root_dir, module);
531 curr_map = map; 531 curr_map = map;
532 goto discard_symbol; 532 goto discard_symbol;
533 } 533 }
534 534
535 if (curr_map->dso->loaded && 535 if (curr_map->dso->loaded &&
536 !is_default_guest(kmaps->this_kerninfo)) 536 !machine__is_default_guest(machine))
537 goto discard_symbol; 537 goto discard_symbol;
538 } 538 }
539 /* 539 /*
@@ -586,7 +586,7 @@ discard_symbol: rb_erase(&pos->rb_node, root);
586 586
587 if (curr_map != map && 587 if (curr_map != map &&
588 self->kernel == DSO_TYPE_GUEST_KERNEL && 588 self->kernel == DSO_TYPE_GUEST_KERNEL &&
589 is_default_guest(kmaps->this_kerninfo)) { 589 machine__is_default_guest(kmaps->machine)) {
590 dso__set_loaded(curr_map->dso, curr_map->type); 590 dso__set_loaded(curr_map->dso, curr_map->type);
591 } 591 }
592 592
@@ -1291,7 +1291,7 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1291 char build_id_hex[BUILD_ID_SIZE * 2 + 1]; 1291 char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1292 int ret = -1; 1292 int ret = -1;
1293 int fd; 1293 int fd;
1294 struct kernel_info *kerninfo; 1294 struct machine *machine;
1295 const char *root_dir; 1295 const char *root_dir;
1296 1296
1297 dso__set_loaded(self, map->type); 1297 dso__set_loaded(self, map->type);
@@ -1301,10 +1301,10 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1301 else if (self->kernel == DSO_TYPE_GUEST_KERNEL) 1301 else if (self->kernel == DSO_TYPE_GUEST_KERNEL)
1302 return dso__load_guest_kernel_sym(self, map, filter); 1302 return dso__load_guest_kernel_sym(self, map, filter);
1303 1303
1304 if (map->groups && map->groups->this_kerninfo) 1304 if (map->groups && map->groups->machine)
1305 kerninfo = map->groups->this_kerninfo; 1305 machine = map->groups->machine;
1306 else 1306 else
1307 kerninfo = NULL; 1307 machine = NULL;
1308 1308
1309 name = malloc(size); 1309 name = malloc(size);
1310 if (!name) 1310 if (!name)
@@ -1359,8 +1359,8 @@ more:
1359 snprintf(name, size, "%s", self->long_name); 1359 snprintf(name, size, "%s", self->long_name);
1360 break; 1360 break;
1361 case DSO__ORIG_GUEST_KMODULE: 1361 case DSO__ORIG_GUEST_KMODULE:
1362 if (map->groups && map->groups->this_kerninfo) 1362 if (map->groups && map->groups->machine)
1363 root_dir = map->groups->this_kerninfo->root_dir; 1363 root_dir = map->groups->machine->root_dir;
1364 else 1364 else
1365 root_dir = ""; 1365 root_dir = "";
1366 snprintf(name, size, "%s%s", root_dir, self->long_name); 1366 snprintf(name, size, "%s%s", root_dir, self->long_name);
@@ -1566,12 +1566,12 @@ static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1566 1566
1567struct map *map_groups__new_module(struct map_groups *self, u64 start, 1567struct map *map_groups__new_module(struct map_groups *self, u64 start,
1568 const char *filename, 1568 const char *filename,
1569 struct kernel_info *kerninfo) 1569 struct machine *machine)
1570{ 1570{
1571 struct map *map; 1571 struct map *map;
1572 struct dso *dso; 1572 struct dso *dso;
1573 1573
1574 dso = __dsos__findnew(&kerninfo->dsos__kernel, filename); 1574 dso = __dsos__findnew(&machine->kernel_dsos, filename);
1575 if (dso == NULL) 1575 if (dso == NULL)
1576 return NULL; 1576 return NULL;
1577 1577
@@ -1579,7 +1579,7 @@ struct map *map_groups__new_module(struct map_groups *self, u64 start,
1579 if (map == NULL) 1579 if (map == NULL)
1580 return NULL; 1580 return NULL;
1581 1581
1582 if (is_host_kernel(kerninfo)) 1582 if (machine__is_host(machine))
1583 dso->origin = DSO__ORIG_KMODULE; 1583 dso->origin = DSO__ORIG_KMODULE;
1584 else 1584 else
1585 dso->origin = DSO__ORIG_GUEST_KMODULE; 1585 dso->origin = DSO__ORIG_GUEST_KMODULE;
@@ -1587,7 +1587,7 @@ struct map *map_groups__new_module(struct map_groups *self, u64 start,
1587 return map; 1587 return map;
1588} 1588}
1589 1589
1590static int map_groups__create_modules(struct kernel_info *kerninfo) 1590static int map_groups__create_modules(struct machine *machine)
1591{ 1591{
1592 char *line = NULL; 1592 char *line = NULL;
1593 size_t n; 1593 size_t n;
@@ -1597,10 +1597,10 @@ static int map_groups__create_modules(struct kernel_info *kerninfo)
1597 const char *modules; 1597 const char *modules;
1598 char path[PATH_MAX]; 1598 char path[PATH_MAX];
1599 1599
1600 if (is_default_guest(kerninfo)) 1600 if (machine__is_default_guest(machine))
1601 modules = symbol_conf.default_guest_modules; 1601 modules = symbol_conf.default_guest_modules;
1602 else { 1602 else {
1603 sprintf(path, "%s/proc/modules", kerninfo->root_dir); 1603 sprintf(path, "%s/proc/modules", machine->root_dir);
1604 modules = path; 1604 modules = path;
1605 } 1605 }
1606 1606
@@ -1608,7 +1608,7 @@ static int map_groups__create_modules(struct kernel_info *kerninfo)
1608 if (file == NULL) 1608 if (file == NULL)
1609 return -1; 1609 return -1;
1610 1610
1611 root_dir = kerninfo->root_dir; 1611 root_dir = machine->root_dir;
1612 1612
1613 while (!feof(file)) { 1613 while (!feof(file)) {
1614 char name[PATH_MAX]; 1614 char name[PATH_MAX];
@@ -1638,8 +1638,8 @@ static int map_groups__create_modules(struct kernel_info *kerninfo)
1638 *sep = '\0'; 1638 *sep = '\0';
1639 1639
1640 snprintf(name, sizeof(name), "[%s]", line); 1640 snprintf(name, sizeof(name), "[%s]", line);
1641 map = map_groups__new_module(&kerninfo->kmaps, 1641 map = map_groups__new_module(&machine->kmaps, start,
1642 start, name, kerninfo); 1642 name, machine);
1643 if (map == NULL) 1643 if (map == NULL)
1644 goto out_delete_line; 1644 goto out_delete_line;
1645 dso__kernel_module_get_build_id(map->dso, root_dir); 1645 dso__kernel_module_get_build_id(map->dso, root_dir);
@@ -1648,7 +1648,7 @@ static int map_groups__create_modules(struct kernel_info *kerninfo)
1648 free(line); 1648 free(line);
1649 fclose(file); 1649 fclose(file);
1650 1650
1651 return map_groups__set_modules_path(&kerninfo->kmaps, root_dir); 1651 return map_groups__set_modules_path(&machine->kmaps, root_dir);
1652 1652
1653out_delete_line: 1653out_delete_line:
1654 free(line); 1654 free(line);
@@ -1820,16 +1820,16 @@ static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
1820{ 1820{
1821 int err; 1821 int err;
1822 const char *kallsyms_filename = NULL; 1822 const char *kallsyms_filename = NULL;
1823 struct kernel_info *kerninfo; 1823 struct machine *machine;
1824 char path[PATH_MAX]; 1824 char path[PATH_MAX];
1825 1825
1826 if (!map->groups) { 1826 if (!map->groups) {
1827 pr_debug("Guest kernel map hasn't the point to groups\n"); 1827 pr_debug("Guest kernel map hasn't the point to groups\n");
1828 return -1; 1828 return -1;
1829 } 1829 }
1830 kerninfo = map->groups->this_kerninfo; 1830 machine = map->groups->machine;
1831 1831
1832 if (is_default_guest(kerninfo)) { 1832 if (machine__is_default_guest(machine)) {
1833 /* 1833 /*
1834 * if the user specified a vmlinux filename, use it and only 1834 * if the user specified a vmlinux filename, use it and only
1835 * it, reporting errors to the user if it cannot be used. 1835 * it, reporting errors to the user if it cannot be used.
@@ -1845,7 +1845,7 @@ static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
1845 if (!kallsyms_filename) 1845 if (!kallsyms_filename)
1846 return -1; 1846 return -1;
1847 } else { 1847 } else {
1848 sprintf(path, "%s/proc/kallsyms", kerninfo->root_dir); 1848 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1849 kallsyms_filename = path; 1849 kallsyms_filename = path;
1850 } 1850 }
1851 1851
@@ -1856,9 +1856,8 @@ static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
1856out_try_fixup: 1856out_try_fixup:
1857 if (err > 0) { 1857 if (err > 0) {
1858 if (kallsyms_filename != NULL) { 1858 if (kallsyms_filename != NULL) {
1859 kern_mmap_name(kerninfo, path); 1859 machine__mmap_name(machine, path);
1860 dso__set_long_name(self, 1860 dso__set_long_name(self, strdup(path));
1861 strdup(path));
1862 } 1861 }
1863 map__fixup_start(map); 1862 map__fixup_start(map);
1864 map__fixup_end(map); 1863 map__fixup_end(map);
@@ -1908,15 +1907,14 @@ static void __dsos__fprintf(struct list_head *head, FILE *fp)
1908 } 1907 }
1909} 1908}
1910 1909
1911void dsos__fprintf(struct rb_root *kerninfo_root, FILE *fp) 1910void dsos__fprintf(struct rb_root *machines, FILE *fp)
1912{ 1911{
1913 struct rb_node *nd; 1912 struct rb_node *nd;
1914 1913
1915 for (nd = rb_first(kerninfo_root); nd; nd = rb_next(nd)) { 1914 for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
1916 struct kernel_info *pos = rb_entry(nd, struct kernel_info, 1915 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1917 rb_node); 1916 __dsos__fprintf(&pos->kernel_dsos, fp);
1918 __dsos__fprintf(&pos->dsos__kernel, fp); 1917 __dsos__fprintf(&pos->user_dsos, fp);
1919 __dsos__fprintf(&pos->dsos__user, fp);
1920 } 1918 }
1921} 1919}
1922 1920
@@ -1935,19 +1933,15 @@ static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
1935 return ret; 1933 return ret;
1936} 1934}
1937 1935
1938size_t dsos__fprintf_buildid(struct rb_root *kerninfo_root, 1936size_t dsos__fprintf_buildid(struct rb_root *machines, FILE *fp, bool with_hits)
1939 FILE *fp, bool with_hits)
1940{ 1937{
1941 struct rb_node *nd; 1938 struct rb_node *nd;
1942 size_t ret = 0; 1939 size_t ret = 0;
1943 1940
1944 for (nd = rb_first(kerninfo_root); nd; nd = rb_next(nd)) { 1941 for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
1945 struct kernel_info *pos = rb_entry(nd, struct kernel_info, 1942 struct machine *pos = rb_entry(nd, struct machine, rb_node);
1946 rb_node); 1943 ret += __dsos__fprintf_buildid(&pos->kernel_dsos, fp, with_hits);
1947 ret += __dsos__fprintf_buildid(&pos->dsos__kernel, 1944 ret += __dsos__fprintf_buildid(&pos->user_dsos, fp, with_hits);
1948 fp, with_hits);
1949 ret += __dsos__fprintf_buildid(&pos->dsos__user,
1950 fp, with_hits);
1951 } 1945 }
1952 return ret; 1946 return ret;
1953} 1947}
@@ -1964,14 +1958,12 @@ struct dso *dso__new_kernel(const char *name)
1964 return self; 1958 return self;
1965} 1959}
1966 1960
1967static struct dso *dso__new_guest_kernel(struct kernel_info *kerninfo, 1961static struct dso *dso__new_guest_kernel(struct machine *machine,
1968 const char *name) 1962 const char *name)
1969{ 1963{
1970 char buff[PATH_MAX]; 1964 char buff[PATH_MAX];
1971 struct dso *self; 1965 struct dso *self = dso__new(name ?: machine__mmap_name(machine, buff));
1972 1966
1973 kern_mmap_name(kerninfo, buff);
1974 self = dso__new(name ?: buff);
1975 if (self != NULL) { 1967 if (self != NULL) {
1976 dso__set_short_name(self, "[guest.kernel]"); 1968 dso__set_short_name(self, "[guest.kernel]");
1977 self->kernel = DSO_TYPE_GUEST_KERNEL; 1969 self->kernel = DSO_TYPE_GUEST_KERNEL;
@@ -1980,36 +1972,35 @@ static struct dso *dso__new_guest_kernel(struct kernel_info *kerninfo,
1980 return self; 1972 return self;
1981} 1973}
1982 1974
1983void dso__read_running_kernel_build_id(struct dso *self, 1975void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine)
1984 struct kernel_info *kerninfo)
1985{ 1976{
1986 char path[PATH_MAX]; 1977 char path[PATH_MAX];
1987 1978
1988 if (is_default_guest(kerninfo)) 1979 if (machine__is_default_guest(machine))
1989 return; 1980 return;
1990 sprintf(path, "%s/sys/kernel/notes", kerninfo->root_dir); 1981 sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
1991 if (sysfs__read_build_id(path, self->build_id, 1982 if (sysfs__read_build_id(path, self->build_id,
1992 sizeof(self->build_id)) == 0) 1983 sizeof(self->build_id)) == 0)
1993 self->has_build_id = true; 1984 self->has_build_id = true;
1994} 1985}
1995 1986
1996static struct dso *dsos__create_kernel(struct kernel_info *kerninfo) 1987static struct dso *dsos__create_kernel(struct machine *machine)
1997{ 1988{
1998 const char *vmlinux_name = NULL; 1989 const char *vmlinux_name = NULL;
1999 struct dso *kernel; 1990 struct dso *kernel;
2000 1991
2001 if (is_host_kernel(kerninfo)) { 1992 if (machine__is_host(machine)) {
2002 vmlinux_name = symbol_conf.vmlinux_name; 1993 vmlinux_name = symbol_conf.vmlinux_name;
2003 kernel = dso__new_kernel(vmlinux_name); 1994 kernel = dso__new_kernel(vmlinux_name);
2004 } else { 1995 } else {
2005 if (is_default_guest(kerninfo)) 1996 if (machine__is_default_guest(machine))
2006 vmlinux_name = symbol_conf.default_guest_vmlinux_name; 1997 vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2007 kernel = dso__new_guest_kernel(kerninfo, vmlinux_name); 1998 kernel = dso__new_guest_kernel(machine, vmlinux_name);
2008 } 1999 }
2009 2000
2010 if (kernel != NULL) { 2001 if (kernel != NULL) {
2011 dso__read_running_kernel_build_id(kernel, kerninfo); 2002 dso__read_running_kernel_build_id(kernel, machine);
2012 dsos__add(&kerninfo->dsos__kernel, kernel); 2003 dsos__add(&machine->kernel_dsos, kernel);
2013 } 2004 }
2014 return kernel; 2005 return kernel;
2015} 2006}
@@ -2154,29 +2145,28 @@ out_free_comm_list:
2154 return -1; 2145 return -1;
2155} 2146}
2156 2147
2157int map_groups__create_kernel_maps(struct rb_root *kerninfo_root, pid_t pid) 2148int map_groups__create_kernel_maps(struct rb_root *machines, pid_t pid)
2158{ 2149{
2159 struct kernel_info *kerninfo;
2160 struct dso *kernel; 2150 struct dso *kernel;
2151 struct machine *machine = machines__findnew(machines, pid);
2161 2152
2162 kerninfo = kerninfo__findnew(kerninfo_root, pid); 2153 if (machine == NULL)
2163 if (kerninfo == NULL)
2164 return -1; 2154 return -1;
2165 kernel = dsos__create_kernel(kerninfo); 2155 kernel = dsos__create_kernel(machine);
2166 if (kernel == NULL) 2156 if (kernel == NULL)
2167 return -1; 2157 return -1;
2168 2158
2169 if (__map_groups__create_kernel_maps(&kerninfo->kmaps, 2159 if (__map_groups__create_kernel_maps(&machine->kmaps,
2170 kerninfo->vmlinux_maps, kernel) < 0) 2160 machine->vmlinux_maps, kernel) < 0)
2171 return -1; 2161 return -1;
2172 2162
2173 if (symbol_conf.use_modules && 2163 if (symbol_conf.use_modules &&
2174 map_groups__create_modules(kerninfo) < 0) 2164 map_groups__create_modules(machine) < 0)
2175 pr_debug("Problems creating module maps, continuing anyway...\n"); 2165 pr_debug("Problems creating module maps, continuing anyway...\n");
2176 /* 2166 /*
2177 * Now that we have all the maps created, just set the ->end of them: 2167 * Now that we have all the maps created, just set the ->end of them:
2178 */ 2168 */
2179 map_groups__fixup_end(&kerninfo->kmaps); 2169 map_groups__fixup_end(&machine->kmaps);
2180 return 0; 2170 return 0;
2181} 2171}
2182 2172
@@ -2223,7 +2213,7 @@ char *strxfrchar(char *s, char from, char to)
2223 return s; 2213 return s;
2224} 2214}
2225 2215
2226int map_groups__create_guest_kernel_maps(struct rb_root *kerninfo_root) 2216int map_groups__create_guest_kernel_maps(struct rb_root *machines)
2227{ 2217{
2228 int ret = 0; 2218 int ret = 0;
2229 struct dirent **namelist = NULL; 2219 struct dirent **namelist = NULL;
@@ -2234,8 +2224,7 @@ int map_groups__create_guest_kernel_maps(struct rb_root *kerninfo_root)
2234 if (symbol_conf.default_guest_vmlinux_name || 2224 if (symbol_conf.default_guest_vmlinux_name ||
2235 symbol_conf.default_guest_modules || 2225 symbol_conf.default_guest_modules ||
2236 symbol_conf.default_guest_kallsyms) { 2226 symbol_conf.default_guest_kallsyms) {
2237 map_groups__create_kernel_maps(kerninfo_root, 2227 map_groups__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
2238 DEFAULT_GUEST_KERNEL_ID);
2239 } 2228 }
2240 2229
2241 if (symbol_conf.guestmount) { 2230 if (symbol_conf.guestmount) {
@@ -2256,8 +2245,7 @@ int map_groups__create_guest_kernel_maps(struct rb_root *kerninfo_root)
2256 pr_debug("Can't access file %s\n", path); 2245 pr_debug("Can't access file %s\n", path);
2257 goto failure; 2246 goto failure;
2258 } 2247 }
2259 map_groups__create_kernel_maps(kerninfo_root, 2248 map_groups__create_kernel_maps(machines, pid);
2260 pid);
2261 } 2249 }
2262failure: 2250failure:
2263 free(namelist); 2251 free(namelist);
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 478f5ab37787..ed885b06a023 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -186,8 +186,7 @@ enum dso_origin {
186char dso__symtab_origin(const struct dso *self); 186char dso__symtab_origin(const struct dso *self);
187void dso__set_long_name(struct dso *self, char *name); 187void dso__set_long_name(struct dso *self, char *name);
188void dso__set_build_id(struct dso *self, void *build_id); 188void dso__set_build_id(struct dso *self, void *build_id);
189void dso__read_running_kernel_build_id(struct dso *self, 189void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine);
190 struct kernel_info *kerninfo);
191struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr); 190struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr);
192struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type, 191struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
193 const char *name); 192 const char *name);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-25 12:55:46 -0500