perf report: Allow user to specify path to kallsyms file
[linux-2.6.git] / tools / perf / util / symbol.c
index 9cf6dbc..f40c076 100644 (file)
@@ -1,10 +1,20 @@
-#include "util.h"
-#include "../perf.h"
-#include "string.h"
-#include "symbol.h"
-#include "thread.h"
-
+#define _GNU_SOURCE
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <libgen.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "build-id.h"
 #include "debug.h"
+#include "symbol.h"
+#include "strlist.h"
 
 #include <libelf.h>
 #include <gelf.h>
 #include <limits.h>
 #include <sys/utsname.h>
 
-enum dso_origin {
-       DSO__ORIG_KERNEL = 0,
-       DSO__ORIG_JAVA_JIT,
-       DSO__ORIG_FEDORA,
-       DSO__ORIG_UBUNTU,
-       DSO__ORIG_BUILDID,
-       DSO__ORIG_DSO,
-       DSO__ORIG_KMODULE,
-       DSO__ORIG_NOT_FOUND,
-};
+#ifndef NT_GNU_BUILD_ID
+#define NT_GNU_BUILD_ID 3
+#endif
 
-static void dsos__add(struct dso *dso);
-static struct dso *dsos__find(const char *name);
-static struct map *map__new2(u64 start, struct dso *dso);
-static void kernel_maps__insert(struct map *map);
+static bool dso__build_id_equal(const struct dso *self, u8 *build_id);
+static int elf_read_build_id(Elf *elf, void *bf, size_t size);
+static void dsos__add(struct list_head *head, struct dso *dso);
+static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 static int dso__load_kernel_sym(struct dso *self, struct map *map,
                                symbol_filter_t filter);
-unsigned int symbol__priv_size;
+static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
+                       symbol_filter_t filter);
+static int vmlinux_path__nr_entries;
+static char **vmlinux_path;
+
+struct symbol_conf symbol_conf = {
+       .exclude_other    = true,
+       .use_modules      = true,
+       .try_vmlinux_path = true,
+};
+
+int dso__name_len(const struct dso *self)
+{
+       if (verbose)
+               return self->long_name_len;
+
+       return self->short_name_len;
+}
+
+bool dso__loaded(const struct dso *self, enum map_type type)
+{
+       return self->loaded & (1 << type);
+}
+
+bool dso__sorted_by_name(const struct dso *self, enum map_type type)
+{
+       return self->sorted_by_name & (1 << type);
+}
 
-static struct rb_root kernel_maps;
+static void dso__set_sorted_by_name(struct dso *self, enum map_type type)
+{
+       self->sorted_by_name |= (1 << type);
+}
 
-static void dso__fixup_sym_end(struct dso *self)
+bool symbol_type__is_a(char symbol_type, enum map_type map_type)
 {
-       struct rb_node *nd, *prevnd = rb_first(&self->syms);
+       switch (map_type) {
+       case MAP__FUNCTION:
+               return symbol_type == 'T' || symbol_type == 'W';
+       case MAP__VARIABLE:
+               return symbol_type == 'D' || symbol_type == 'd';
+       default:
+               return false;
+       }
+}
+
+static void symbols__fixup_end(struct rb_root *self)
+{
+       struct rb_node *nd, *prevnd = rb_first(self);
        struct symbol *curr, *prev;
 
        if (prevnd == NULL)
@@ -56,10 +101,10 @@ static void dso__fixup_sym_end(struct dso *self)
                curr->end = roundup(curr->start, 4096);
 }
 
-static void kernel_maps__fixup_end(void)
+static void __map_groups__fixup_end(struct map_groups *self, enum map_type type)
 {
        struct map *prev, *curr;
-       struct rb_node *nd, *prevnd = rb_first(&kernel_maps);
+       struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
 
        if (prevnd == NULL)
                return;
@@ -71,88 +116,124 @@ static void kernel_maps__fixup_end(void)
                curr = rb_entry(nd, struct map, rb_node);
                prev->end = curr->start - 1;
        }
+
+       /*
+        * We still haven't the actual symbols, so guess the
+        * last map final address.
+        */
+       curr->end = ~0ULL;
+}
+
+static void map_groups__fixup_end(struct map_groups *self)
+{
+       int i;
+       for (i = 0; i < MAP__NR_TYPES; ++i)
+               __map_groups__fixup_end(self, i);
 }
 
-static struct symbol *symbol__new(u64 start, u64 len, const char *name)
+static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
+                                 const char *name)
 {
        size_t namelen = strlen(name) + 1;
-       struct symbol *self = calloc(1, (symbol__priv_size +
+       struct symbol *self = calloc(1, (symbol_conf.priv_size +
                                         sizeof(*self) + namelen));
-       if (!self)
+       if (self == NULL)
                return NULL;
 
-       if (symbol__priv_size) {
-               memset(self, 0, symbol__priv_size);
-               self = ((void *)self) + symbol__priv_size;
-       }
-       self->start = start;
-       self->end   = len ? start + len - 1 : start;
+       if (symbol_conf.priv_size)
+               self = ((void *)self) + symbol_conf.priv_size;
 
-       pr_debug3("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
+       self->start   = start;
+       self->end     = len ? start + len - 1 : start;
+       self->binding = binding;
+       self->namelen = namelen - 1;
+
+       pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
 
        memcpy(self->name, name, namelen);
 
        return self;
 }
 
-static void symbol__delete(struct symbol *self)
+void symbol__delete(struct symbol *self)
 {
-       free(((void *)self) - symbol__priv_size);
+       free(((void *)self) - symbol_conf.priv_size);
 }
 
 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
 {
-       return fprintf(fp, " %llx-%llx %s\n",
-                      self->start, self->end, self->name);
+       return fprintf(fp, " %llx-%llx %c %s\n",
+                      self->start, self->end,
+                      self->binding == STB_GLOBAL ? 'g' :
+                      self->binding == STB_LOCAL  ? 'l' : 'w',
+                      self->name);
 }
 
-static void dso__set_long_name(struct dso *self, char *name)
+void dso__set_long_name(struct dso *self, char *name)
 {
+       if (name == NULL)
+               return;
        self->long_name = name;
        self->long_name_len = strlen(name);
 }
 
+static void dso__set_short_name(struct dso *self, const char *name)
+{
+       if (name == NULL)
+               return;
+       self->short_name = name;
+       self->short_name_len = strlen(name);
+}
+
 static void dso__set_basename(struct dso *self)
 {
-       self->short_name = basename(self->long_name);
+       dso__set_short_name(self, basename(self->long_name));
 }
 
 struct dso *dso__new(const char *name)
 {
-       struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
+       struct dso *self = calloc(1, sizeof(*self) + strlen(name) + 1);
 
        if (self != NULL) {
+               int i;
                strcpy(self->name, name);
                dso__set_long_name(self, self->name);
-               self->short_name = self->name;
-               self->syms = RB_ROOT;
-               self->find_symbol = dso__find_symbol;
+               dso__set_short_name(self, self->name);
+               for (i = 0; i < MAP__NR_TYPES; ++i)
+                       self->symbols[i] = self->symbol_names[i] = RB_ROOT;
                self->slen_calculated = 0;
                self->origin = DSO__ORIG_NOT_FOUND;
                self->loaded = 0;
+               self->sorted_by_name = 0;
                self->has_build_id = 0;
+               self->kernel = DSO_TYPE_USER;
+               INIT_LIST_HEAD(&self->node);
        }
 
        return self;
 }
 
-static void dso__delete_symbols(struct dso *self)
+static void symbols__delete(struct rb_root *self)
 {
        struct symbol *pos;
-       struct rb_node *next = rb_first(&self->syms);
+       struct rb_node *next = rb_first(self);
 
        while (next) {
                pos = rb_entry(next, struct symbol, rb_node);
                next = rb_next(&pos->rb_node);
-               rb_erase(&pos->rb_node, &self->syms);
+               rb_erase(&pos->rb_node, self);
                symbol__delete(pos);
        }
 }
 
 void dso__delete(struct dso *self)
 {
-       dso__delete_symbols(self);
-       if (self->long_name != self->name)
+       int i;
+       for (i = 0; i < MAP__NR_TYPES; ++i)
+               symbols__delete(&self->symbols[i]);
+       if (self->sname_alloc)
+               free((char *)self->short_name);
+       if (self->lname_alloc)
                free(self->long_name);
        free(self);
 }
@@ -163,9 +244,9 @@ void dso__set_build_id(struct dso *self, void *build_id)
        self->has_build_id = 1;
 }
 
-static void dso__insert_symbol(struct dso *self, struct symbol *sym)
+static void symbols__insert(struct rb_root *self, struct symbol *sym)
 {
-       struct rb_node **p = &self->syms.rb_node;
+       struct rb_node **p = &self->rb_node;
        struct rb_node *parent = NULL;
        const u64 ip = sym->start;
        struct symbol *s;
@@ -179,17 +260,17 @@ static void dso__insert_symbol(struct dso *self, struct symbol *sym)
                        p = &(*p)->rb_right;
        }
        rb_link_node(&sym->rb_node, parent, p);
-       rb_insert_color(&sym->rb_node, &self->syms);
+       rb_insert_color(&sym->rb_node, self);
 }
 
-struct symbol *dso__find_symbol(struct dso *self, u64 ip)
+static struct symbol *symbols__find(struct rb_root *self, u64 ip)
 {
        struct rb_node *n;
 
        if (self == NULL)
                return NULL;
 
-       n = self->syms.rb_node;
+       n = self->rb_node;
 
        while (n) {
                struct symbol *s = rb_entry(n, struct symbol, rb_node);
@@ -205,10 +286,91 @@ struct symbol *dso__find_symbol(struct dso *self, u64 ip)
        return NULL;
 }
 
-int build_id__sprintf(u8 *self, int len, char *bf)
+struct symbol_name_rb_node {
+       struct rb_node  rb_node;
+       struct symbol   sym;
+};
+
+static void symbols__insert_by_name(struct rb_root *self, struct symbol *sym)
+{
+       struct rb_node **p = &self->rb_node;
+       struct rb_node *parent = NULL;
+       struct symbol_name_rb_node *symn, *s;
+
+       symn = container_of(sym, struct symbol_name_rb_node, sym);
+
+       while (*p != NULL) {
+               parent = *p;
+               s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
+               if (strcmp(sym->name, s->sym.name) < 0)
+                       p = &(*p)->rb_left;
+               else
+                       p = &(*p)->rb_right;
+       }
+       rb_link_node(&symn->rb_node, parent, p);
+       rb_insert_color(&symn->rb_node, self);
+}
+
+static void symbols__sort_by_name(struct rb_root *self, struct rb_root *source)
+{
+       struct rb_node *nd;
+
+       for (nd = rb_first(source); nd; nd = rb_next(nd)) {
+               struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+               symbols__insert_by_name(self, pos);
+       }
+}
+
+static struct symbol *symbols__find_by_name(struct rb_root *self, const char *name)
+{
+       struct rb_node *n;
+
+       if (self == NULL)
+               return NULL;
+
+       n = self->rb_node;
+
+       while (n) {
+               struct symbol_name_rb_node *s;
+               int cmp;
+
+               s = rb_entry(n, struct symbol_name_rb_node, rb_node);
+               cmp = strcmp(name, s->sym.name);
+
+               if (cmp < 0)
+                       n = n->rb_left;
+               else if (cmp > 0)
+                       n = n->rb_right;
+               else
+                       return &s->sym;
+       }
+
+       return NULL;
+}
+
+struct symbol *dso__find_symbol(struct dso *self,
+                               enum map_type type, u64 addr)
+{
+       return symbols__find(&self->symbols[type], addr);
+}
+
+struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
+                                       const char *name)
+{
+       return symbols__find_by_name(&self->symbol_names[type], name);
+}
+
+void dso__sort_by_name(struct dso *self, enum map_type type)
+{
+       dso__set_sorted_by_name(self, type);
+       return symbols__sort_by_name(&self->symbol_names[type],
+                                    &self->symbols[type]);
+}
+
+int build_id__sprintf(const u8 *self, int len, char *bf)
 {
        char *bid = bf;
-       u8 *raw = self;
+       const u8 *raw = self;
        int i;
 
        for (i = 0; i < len; ++i) {
@@ -228,15 +390,32 @@ size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
        return fprintf(fp, "%s", sbuild_id);
 }
 
-size_t dso__fprintf(struct dso *self, FILE *fp)
+size_t dso__fprintf_symbols_by_name(struct dso *self, enum map_type type, FILE *fp)
+{
+       size_t ret = 0;
+       struct rb_node *nd;
+       struct symbol_name_rb_node *pos;
+
+       for (nd = rb_first(&self->symbol_names[type]); nd; nd = rb_next(nd)) {
+               pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
+               fprintf(fp, "%s\n", pos->sym.name);
+       }
+
+       return ret;
+}
+
+size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
 {
        struct rb_node *nd;
        size_t ret = fprintf(fp, "dso: %s (", self->short_name);
 
+       if (self->short_name != self->long_name)
+               ret += fprintf(fp, "%s, ", self->long_name);
+       ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
+                      self->loaded ? "" : "NOT ");
        ret += dso__fprintf_buildid(self, fp);
        ret += fprintf(fp, ")\n");
-
-       for (nd = rb_first(&self->syms); nd; nd = rb_next(nd)) {
+       for (nd = rb_first(&self->symbols[type]); nd; nd = rb_next(nd)) {
                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
                ret += symbol__fprintf(pos, fp);
        }
@@ -244,34 +423,28 @@ size_t dso__fprintf(struct dso *self, FILE *fp)
        return ret;
 }
 
-/*
- * Loads the function entries in /proc/kallsyms into kernel_map->dso,
- * so that we can in the next step set the symbol ->end address and then
- * call kernel_maps__split_kallsyms.
- */
-static int kernel_maps__load_all_kallsyms(void)
+int kallsyms__parse(const char *filename, void *arg,
+                   int (*process_symbol)(void *arg, const char *name,
+                                                    char type, u64 start))
 {
        char *line = NULL;
        size_t n;
-       FILE *file = fopen("/proc/kallsyms", "r");
+       int err = 0;
+       FILE *file = fopen(filename, "r");
 
        if (file == NULL)
                goto out_failure;
 
        while (!feof(file)) {
                u64 start;
-               struct symbol *sym;
                int line_len, len;
                char symbol_type;
                char *symbol_name;
 
                line_len = getline(&line, &n, file);
-               if (line_len < 0)
+               if (line_len < 0 || !line)
                        break;
 
-               if (!line)
-                       goto out_failure;
-
                line[--line_len] = '\0'; /* \n */
 
                len = hex2u64(line, &start);
@@ -281,51 +454,87 @@ static int kernel_maps__load_all_kallsyms(void)
                        continue;
 
                symbol_type = toupper(line[len]);
-               /*
-                * We're interested only in code ('T'ext)
-                */
-               if (symbol_type != 'T' && symbol_type != 'W')
-                       continue;
-
                symbol_name = line + len + 2;
-               /*
-                * Will fix up the end later, when we have all symbols sorted.
-                */
-               sym = symbol__new(start, 0, symbol_name);
 
-               if (sym == NULL)
-                       goto out_delete_line;
-
-               /*
-                * We will pass the symbols to the filter later, in
-                * kernel_maps__split_kallsyms, when we have split the
-                * maps per module
-                */
-               dso__insert_symbol(kernel_map->dso, sym);
+               err = process_symbol(arg, symbol_name, symbol_type, start);
+               if (err)
+                       break;
        }
 
        free(line);
        fclose(file);
+       return err;
 
-       return 0;
-
-out_delete_line:
-       free(line);
 out_failure:
        return -1;
 }
 
+struct process_kallsyms_args {
+       struct map *map;
+       struct dso *dso;
+};
+
+static u8 kallsyms2elf_type(char type)
+{
+       if (type == 'W')
+               return STB_WEAK;
+
+       return isupper(type) ? STB_GLOBAL : STB_LOCAL;
+}
+
+static int map__process_kallsym_symbol(void *arg, const char *name,
+                                      char type, u64 start)
+{
+       struct symbol *sym;
+       struct process_kallsyms_args *a = arg;
+       struct rb_root *root = &a->dso->symbols[a->map->type];
+
+       if (!symbol_type__is_a(type, a->map->type))
+               return 0;
+
+       /*
+        * Will fix up the end later, when we have all symbols sorted.
+        */
+       sym = symbol__new(start, 0, kallsyms2elf_type(type), name);
+
+       if (sym == NULL)
+               return -ENOMEM;
+       /*
+        * We will pass the symbols to the filter later, in
+        * map__split_kallsyms, when we have split the maps per module
+        */
+       symbols__insert(root, sym);
+
+       return 0;
+}
+
+/*
+ * Loads the function entries in /proc/kallsyms into kernel_map->dso,
+ * so that we can in the next step set the symbol ->end address and then
+ * call kernel_maps__split_kallsyms.
+ */
+static int dso__load_all_kallsyms(struct dso *self, const char *filename,
+                                 struct map *map)
+{
+       struct process_kallsyms_args args = { .map = map, .dso = self, };
+       return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
+}
+
 /*
  * Split the symbols into maps, making sure there are no overlaps, i.e. the
  * kernel range is broken in several maps, named [kernel].N, as we don't have
  * the original ELF section names vmlinux have.
  */
-static int kernel_maps__split_kallsyms(symbol_filter_t filter)
+static int dso__split_kallsyms(struct dso *self, struct map *map,
+                              symbol_filter_t filter)
 {
-       struct map *map = kernel_map;
+       struct map_groups *kmaps = map__kmap(map)->kmaps;
+       struct machine *machine = kmaps->machine;
+       struct map *curr_map = map;
        struct symbol *pos;
        int count = 0;
-       struct rb_node *next = rb_first(&kernel_map->dso->syms);
+       struct rb_root *root = &self->symbols[map->type];
+       struct rb_node *next = rb_first(root);
        int kernel_range = 0;
 
        while (next) {
@@ -336,88 +545,111 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter)
 
                module = strchr(pos->name, '\t');
                if (module) {
+                       if (!symbol_conf.use_modules)
+                               goto discard_symbol;
+
                        *module++ = '\0';
 
-                       if (strcmp(map->dso->name, module)) {
-                               map = kernel_maps__find_by_dso_name(module);
-                               if (!map) {
-                                       pr_err("/proc/{kallsyms,modules} "
-                                              "inconsistency!\n");
-                                       return -1;
+                       if (strcmp(curr_map->dso->short_name, module)) {
+                               if (curr_map != map &&
+                                   self->kernel == DSO_TYPE_GUEST_KERNEL &&
+                                   machine__is_default_guest(machine)) {
+                                       /*
+                                        * We assume all symbols of a module are
+                                        * continuous in * kallsyms, so curr_map
+                                        * points to a module and all its
+                                        * symbols are in its kmap. Mark it as
+                                        * loaded.
+                                        */
+                                       dso__set_loaded(curr_map->dso,
+                                                       curr_map->type);
                                }
+
+                               curr_map = map_groups__find_by_name(kmaps,
+                                                       map->type, module);
+                               if (curr_map == NULL) {
+                                       pr_debug("%s/proc/{kallsyms,modules} "
+                                                "inconsistency while looking "
+                                                "for \"%s\" module!\n",
+                                                machine->root_dir, module);
+                                       curr_map = map;
+                                       goto discard_symbol;
+                               }
+
+                               if (curr_map->dso->loaded &&
+                                   !machine__is_default_guest(machine))
+                                       goto discard_symbol;
                        }
                        /*
                         * So that we look just like we get from .ko files,
                         * i.e. not prelinked, relative to map->start.
                         */
-                       pos->start = map->map_ip(map, pos->start);
-                       pos->end   = map->map_ip(map, pos->end);
-               } else if (map != kernel_map) {
+                       pos->start = curr_map->map_ip(curr_map, pos->start);
+                       pos->end   = curr_map->map_ip(curr_map, pos->end);
+               } else if (curr_map != map) {
                        char dso_name[PATH_MAX];
                        struct dso *dso;
 
-                       snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
-                                kernel_range++);
+                       if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+                               snprintf(dso_name, sizeof(dso_name),
+                                       "[guest.kernel].%d",
+                                       kernel_range++);
+                       else
+                               snprintf(dso_name, sizeof(dso_name),
+                                       "[kernel].%d",
+                                       kernel_range++);
 
                        dso = dso__new(dso_name);
                        if (dso == NULL)
                                return -1;
 
-                       map = map__new2(pos->start, dso);
-                       if (map == NULL) {
+                       dso->kernel = self->kernel;
+
+                       curr_map = map__new2(pos->start, dso, map->type);
+                       if (curr_map == NULL) {
                                dso__delete(dso);
                                return -1;
                        }
 
-                       map->map_ip = map->unmap_ip = identity__map_ip;
-                       kernel_maps__insert(map);
+                       curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
+                       map_groups__insert(kmaps, curr_map);
                        ++kernel_range;
                }
 
-               if (filter && filter(map, pos)) {
-                       rb_erase(&pos->rb_node, &kernel_map->dso->syms);
+               if (filter && filter(curr_map, pos)) {
+discard_symbol:                rb_erase(&pos->rb_node, root);
                        symbol__delete(pos);
                } else {
-                       if (map != kernel_map) {
-                               rb_erase(&pos->rb_node, &kernel_map->dso->syms);
-                               dso__insert_symbol(map->dso, pos);
+                       if (curr_map != map) {
+                               rb_erase(&pos->rb_node, root);
+                               symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
                        }
                        count++;
                }
        }
 
+       if (curr_map != map &&
+           self->kernel == DSO_TYPE_GUEST_KERNEL &&
+           machine__is_default_guest(kmaps->machine)) {
+               dso__set_loaded(curr_map->dso, curr_map->type);
+       }
+
        return count;
 }
 
-
-static int kernel_maps__load_kallsyms(symbol_filter_t filter)
+int dso__load_kallsyms(struct dso *self, const char *filename,
+                      struct map *map, symbol_filter_t filter)
 {
-       if (kernel_maps__load_all_kallsyms())
+       if (dso__load_all_kallsyms(self, filename, map) < 0)
                return -1;
 
-       dso__fixup_sym_end(kernel_map->dso);
-       kernel_map->dso->origin = DSO__ORIG_KERNEL;
-
-       return kernel_maps__split_kallsyms(filter);
-}
-
-size_t kernel_maps__fprintf(FILE *fp)
-{
-       size_t printed = fprintf(fp, "Kernel maps:\n");
-       struct rb_node *nd;
-
-       for (nd = rb_first(&kernel_maps); nd; nd = rb_next(nd)) {
-               struct map *pos = rb_entry(nd, struct map, rb_node);
+       symbols__fixup_end(&self->symbols[map->type]);
+       if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+               self->origin = DSO__ORIG_GUEST_KERNEL;
+       else
+               self->origin = DSO__ORIG_KERNEL;
 
-               printed += fprintf(fp, "Map:");
-               printed += map__fprintf(pos, fp);
-               if (verbose > 1) {
-                       printed += dso__fprintf(pos->dso, fp);
-                       printed += fprintf(fp, "--\n");
-               }
-       }
-
-       return printed + fprintf(fp, "END kernel maps\n");
+       return dso__split_kallsyms(self, map, filter);
 }
 
 static int dso__load_perf_map(struct dso *self, struct map *map,
@@ -458,7 +690,7 @@ static int dso__load_perf_map(struct dso *self, struct map *map,
                if (len + 2 >= line_len)
                        continue;
 
-               sym = symbol__new(start, size, line + len);
+               sym = symbol__new(start, size, STB_GLOBAL, line + len);
 
                if (sym == NULL)
                        goto out_delete_line;
@@ -466,7 +698,7 @@ static int dso__load_perf_map(struct dso *self, struct map *map,
                if (filter && filter(map, sym))
                        symbol__delete(sym);
                else {
-                       dso__insert_symbol(self, sym);
+                       symbols__insert(&self->symbols[map->type], sym);
                        nr_syms++;
                }
        }
@@ -506,6 +738,13 @@ static inline int elf_sym__is_function(const GElf_Sym *sym)
               sym->st_shndx != SHN_UNDEF;
 }
 
+static inline bool elf_sym__is_object(const GElf_Sym *sym)
+{
+       return elf_sym__type(sym) == STT_OBJECT &&
+               sym->st_name != 0 &&
+               sym->st_shndx != SHN_UNDEF;
+}
+
 static inline int elf_sym__is_label(const GElf_Sym *sym)
 {
        return elf_sym__type(sym) == STT_NOTYPE &&
@@ -526,6 +765,12 @@ static inline int elf_sec__is_text(const GElf_Shdr *shdr,
        return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 }
 
+static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
+                                   const Elf_Data *secstrs)
+{
+       return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
+}
+
 static inline const char *elf_sym__name(const GElf_Sym *sym,
                                        const Elf_Data *symstrs)
 {
@@ -657,14 +902,14 @@ static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
                                 "%s@plt", elf_sym__name(&sym, symstrs));
 
                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                       sympltname);
+                                       STB_GLOBAL, sympltname);
                        if (!f)
                                goto out_elf_end;
 
                        if (filter && filter(map, f))
                                symbol__delete(f);
                        else {
-                               dso__insert_symbol(self, f);
+                               symbols__insert(&self->symbols[map->type], f);
                                ++nr;
                        }
                }
@@ -679,14 +924,14 @@ static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
                                 "%s@plt", elf_sym__name(&sym, symstrs));
 
                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                       sympltname);
+                                       STB_GLOBAL, sympltname);
                        if (!f)
                                goto out_elf_end;
 
                        if (filter && filter(map, f))
                                symbol__delete(f);
                        else {
-                               dso__insert_symbol(self, f);
+                               symbols__insert(&self->symbols[map->type], f);
                                ++nr;
                        }
                }
@@ -701,48 +946,111 @@ out_close:
        if (err == 0)
                return nr;
 out:
-       pr_warning("%s: problems reading %s PLT info.\n",
-                  __func__, self->long_name);
+       pr_debug("%s: problems reading %s PLT info.\n",
+                __func__, self->long_name);
        return 0;
 }
 
+static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
+{
+       switch (type) {
+       case MAP__FUNCTION:
+               return elf_sym__is_function(self);
+       case MAP__VARIABLE:
+               return elf_sym__is_object(self);
+       default:
+               return false;
+       }
+}
+
+static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type)
+{
+       switch (type) {
+       case MAP__FUNCTION:
+               return elf_sec__is_text(self, secstrs);
+       case MAP__VARIABLE:
+               return elf_sec__is_data(self, secstrs);
+       default:
+               return false;
+       }
+}
+
+static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
+{
+       Elf_Scn *sec = NULL;
+       GElf_Shdr shdr;
+       size_t cnt = 1;
+
+       while ((sec = elf_nextscn(elf, sec)) != NULL) {
+               gelf_getshdr(sec, &shdr);
+
+               if ((addr >= shdr.sh_addr) &&
+                   (addr < (shdr.sh_addr + shdr.sh_size)))
+                       return cnt;
+
+               ++cnt;
+       }
+
+       return -1;
+}
+
 static int dso__load_sym(struct dso *self, struct map *map, const char *name,
-                        int fd, symbol_filter_t filter, int kernel,
-                        int kmodule)
+                        int fd, symbol_filter_t filter, int kmodule,
+                        int want_symtab)
 {
+       struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
        struct map *curr_map = map;
        struct dso *curr_dso = self;
-       size_t dso_name_len = strlen(self->short_name);
        Elf_Data *symstrs, *secstrs;
        uint32_t nr_syms;
        int err = -1;
        uint32_t idx;
        GElf_Ehdr ehdr;
-       GElf_Shdr shdr;
-       Elf_Data *syms;
+       GElf_Shdr shdr, opdshdr;
+       Elf_Data *syms, *opddata = NULL;
        GElf_Sym sym;
-       Elf_Scn *sec, *sec_strndx;
+       Elf_Scn *sec, *sec_strndx, *opdsec;
        Elf *elf;
        int nr = 0;
+       size_t opdidx = 0;
 
        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
        if (elf == NULL) {
-               pr_err("%s: cannot read %s ELF file.\n", __func__, name);
+               pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
                goto out_close;
        }
 
        if (gelf_getehdr(elf, &ehdr) == NULL) {
-               pr_err("%s: cannot get elf header.\n", __func__);
+               pr_debug("%s: cannot get elf header.\n", __func__);
                goto out_elf_end;
        }
 
+       /* Always reject images with a mismatched build-id: */
+       if (self->has_build_id) {
+               u8 build_id[BUILD_ID_SIZE];
+
+               if (elf_read_build_id(elf, build_id,
+                                     BUILD_ID_SIZE) != BUILD_ID_SIZE)
+                       goto out_elf_end;
+
+               if (!dso__build_id_equal(self, build_id))
+                       goto out_elf_end;
+       }
+
        sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
        if (sec == NULL) {
+               if (want_symtab)
+                       goto out_elf_end;
+
                sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
                if (sec == NULL)
                        goto out_elf_end;
        }
 
+       opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
+       if (opdsec)
+               opddata = elf_rawdata(opdsec, NULL);
+
        syms = elf_getdata(sec, NULL);
        if (syms == NULL)
                goto out_elf_end;
@@ -766,7 +1074,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
        nr_syms = shdr.sh_size / shdr.sh_entsize;
 
        memset(&sym, 0, sizeof(sym));
-       if (!kernel) {
+       if (self->kernel == DSO_TYPE_USER) {
                self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
                                elf_section_by_name(elf, &ehdr, &shdr,
                                                     ".gnu.prelink_undo",
@@ -775,31 +1083,52 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
 
        elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
                struct symbol *f;
-               const char *elf_name;
+               const char *elf_name = elf_sym__name(&sym, symstrs);
                char *demangled = NULL;
                int is_label = elf_sym__is_label(&sym);
                const char *section_name;
 
-               if (!is_label && !elf_sym__is_function(&sym))
+               if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
+                   strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
+                       kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
+
+               if (!is_label && !elf_sym__is_a(&sym, map->type))
                        continue;
 
+               /* Reject ARM ELF "mapping symbols": these aren't unique and
+                * don't identify functions, so will confuse the profile
+                * output: */
+               if (ehdr.e_machine == EM_ARM) {
+                       if (!strcmp(elf_name, "$a") ||
+                           !strcmp(elf_name, "$d") ||
+                           !strcmp(elf_name, "$t"))
+                               continue;
+               }
+
+               if (opdsec && sym.st_shndx == opdidx) {
+                       u32 offset = sym.st_value - opdshdr.sh_addr;
+                       u64 *opd = opddata->d_buf + offset;
+                       sym.st_value = *opd;
+                       sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
+               }
+
                sec = elf_getscn(elf, sym.st_shndx);
                if (!sec)
                        goto out_elf_end;
 
                gelf_getshdr(sec, &shdr);
 
-               if (is_label && !elf_sec__is_text(&shdr, secstrs))
+               if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
                        continue;
 
-               elf_name = elf_sym__name(&sym, symstrs);
                section_name = elf_sec__name(&shdr, secstrs);
 
-               if (kernel || kmodule) {
+               if (self->kernel != DSO_TYPE_USER || kmodule) {
                        char dso_name[PATH_MAX];
 
                        if (strcmp(section_name,
-                                  curr_dso->short_name + dso_name_len) == 0)
+                                  (curr_dso->short_name +
+                                   self->short_name_len)) == 0)
                                goto new_symbol;
 
                        if (strcmp(section_name, ".text") == 0) {
@@ -811,7 +1140,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                        snprintf(dso_name, sizeof(dso_name),
                                 "%s%s", self->short_name, section_name);
 
-                       curr_map = kernel_maps__find_by_dso_name(dso_name);
+                       curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
                        if (curr_map == NULL) {
                                u64 start = sym.st_value;
 
@@ -821,16 +1150,19 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                                curr_dso = dso__new(dso_name);
                                if (curr_dso == NULL)
                                        goto out_elf_end;
-                               curr_map = map__new2(start, curr_dso);
+                               curr_dso->kernel = self->kernel;
+                               curr_map = map__new2(start, curr_dso,
+                                                    map->type);
                                if (curr_map == NULL) {
                                        dso__delete(curr_dso);
                                        goto out_elf_end;
                                }
                                curr_map->map_ip = identity__map_ip;
                                curr_map->unmap_ip = identity__map_ip;
-                               curr_dso->origin = DSO__ORIG_KERNEL;
-                               kernel_maps__insert(curr_map);
-                               dsos__add(curr_dso);
+                               curr_dso->origin = self->origin;
+                               map_groups__insert(kmap->kmaps, curr_map);
+                               dsos__add(&self->node, curr_dso);
+                               dso__set_loaded(curr_dso, map->type);
                        } else
                                curr_dso = curr_map->dso;
 
@@ -838,9 +1170,10 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                }
 
                if (curr_dso->adjust_symbols) {
-                       pr_debug2("adjusting symbol: st_value: %Lx sh_addr: "
-                                 "%Lx sh_offset: %Lx\n", (u64)sym.st_value,
-                                 (u64)shdr.sh_addr, (u64)shdr.sh_offset);
+                       pr_debug4("%s: adjusting symbol: st_value: %#Lx "
+                                 "sh_addr: %#Lx sh_offset: %#Lx\n", __func__,
+                                 (u64)sym.st_value, (u64)shdr.sh_addr,
+                                 (u64)shdr.sh_offset);
                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
                }
                /*
@@ -852,7 +1185,8 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                if (demangled != NULL)
                        elf_name = demangled;
 new_symbol:
-               f = symbol__new(sym.st_value, sym.st_size, elf_name);
+               f = symbol__new(sym.st_value, sym.st_size,
+                               GELF_ST_BIND(sym.st_info), elf_name);
                free(demangled);
                if (!f)
                        goto out_elf_end;
@@ -860,7 +1194,7 @@ new_symbol:
                if (filter && filter(curr_map, f))
                        symbol__delete(f);
                else {
-                       dso__insert_symbol(curr_dso, f);
+                       symbols__insert(&curr_dso->symbols[curr_map->type], f);
                        nr++;
                }
        }
@@ -868,8 +1202,16 @@ new_symbol:
        /*
         * For misannotated, zeroed, ASM function sizes.
         */
-       if (nr > 0)
-               dso__fixup_sym_end(self);
+       if (nr > 0) {
+               symbols__fixup_end(&self->symbols[map->type]);
+               if (kmap) {
+                       /*
+                        * We need to fixup this here too because we create new
+                        * maps here, for things like vsyscall sections.
+                        */
+                       __map_groups__fixup_end(kmap->kmaps, map->type);
+               }
+       }
        err = nr;
 out_elf_end:
        elf_end(elf);
@@ -882,17 +1224,24 @@ static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
        return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
 }
 
-bool dsos__read_build_ids(void)
+bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 {
        bool have_build_id = false;
        struct dso *pos;
 
-       list_for_each_entry(pos, &dsos, node)
+       list_for_each_entry(pos, head, node) {
+               if (with_hits && !pos->hit)
+                       continue;
+               if (pos->has_build_id) {
+                       have_build_id = true;
+                       continue;
+               }
                if (filename__read_build_id(pos->long_name, pos->build_id,
                                            sizeof(pos->build_id)) > 0) {
                        have_build_id     = true;
                        pos->has_build_id = true;
                }
+       }
 
        return have_build_id;
 }
@@ -902,32 +1251,26 @@ bool dsos__read_build_ids(void)
  */
 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
 
-int filename__read_build_id(const char *filename, void *bf, size_t size)
+static int elf_read_build_id(Elf *elf, void *bf, size_t size)
 {
-       int fd, err = -1;
+       int err = -1;
        GElf_Ehdr ehdr;
        GElf_Shdr shdr;
        Elf_Data *data;
        Elf_Scn *sec;
+       Elf_Kind ek;
        void *ptr;
-       Elf *elf;
 
        if (size < BUILD_ID_SIZE)
                goto out;
 
-       fd = open(filename, O_RDONLY);
-       if (fd < 0)
+       ek = elf_kind(elf);
+       if (ek != ELF_K_ELF)
                goto out;
 
-       elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
-       if (elf == NULL) {
-               pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
-               goto out_close;
-       }
-
        if (gelf_getehdr(elf, &ehdr) == NULL) {
                pr_err("%s: cannot get elf header.\n", __func__);
-               goto out_elf_end;
+               goto out;
        }
 
        sec = elf_section_by_name(elf, &ehdr, &shdr,
@@ -936,12 +1279,12 @@ int filename__read_build_id(const char *filename, void *bf, size_t size)
                sec = elf_section_by_name(elf, &ehdr, &shdr,
                                          ".notes", NULL);
                if (sec == NULL)
-                       goto out_elf_end;
+                       goto out;
        }
 
        data = elf_getdata(sec, NULL);
        if (data == NULL)
-               goto out_elf_end;
+               goto out;
 
        ptr = data->d_buf;
        while (ptr < (data->d_buf + data->d_size)) {
@@ -963,7 +1306,31 @@ int filename__read_build_id(const char *filename, void *bf, size_t size)
                }
                ptr += descsz;
        }
-out_elf_end:
+
+out:
+       return err;
+}
+
+int filename__read_build_id(const char *filename, void *bf, size_t size)
+{
+       int fd, err = -1;
+       Elf *elf;
+
+       if (size < BUILD_ID_SIZE)
+               goto out;
+
+       fd = open(filename, O_RDONLY);
+       if (fd < 0)
+               goto out;
+
+       elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+       if (elf == NULL) {
+               pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
+               goto out_close;
+       }
+
+       err = elf_read_build_id(elf, bf, size);
+
        elf_end(elf);
 out_close:
        close(fd);
@@ -1020,11 +1387,14 @@ char dso__symtab_origin(const struct dso *self)
        static const char origin[] = {
                [DSO__ORIG_KERNEL] =   'k',
                [DSO__ORIG_JAVA_JIT] = 'j',
+               [DSO__ORIG_BUILD_ID_CACHE] = 'B',
                [DSO__ORIG_FEDORA] =   'f',
                [DSO__ORIG_UBUNTU] =   'u',
                [DSO__ORIG_BUILDID] =  'b',
                [DSO__ORIG_DSO] =      'd',
                [DSO__ORIG_KMODULE] =  'K',
+               [DSO__ORIG_GUEST_KERNEL] =  'g',
+               [DSO__ORIG_GUEST_KMODULE] =  'G',
        };
 
        if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
@@ -1036,14 +1406,23 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
 {
        int size = PATH_MAX;
        char *name;
-       u8 build_id[BUILD_ID_SIZE];
        int ret = -1;
        int fd;
+       struct machine *machine;
+       const char *root_dir;
+       int want_symtab;
 
-       self->loaded = 1;
+       dso__set_loaded(self, map->type);
 
-       if (self->kernel)
+       if (self->kernel == DSO_TYPE_KERNEL)
                return dso__load_kernel_sym(self, map, filter);
+       else if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+               return dso__load_guest_kernel_sym(self, map, filter);
+
+       if (map->groups && map->groups->machine)
+               machine = map->groups->machine;
+       else
+               machine = NULL;
 
        name = malloc(size);
        if (!name)
@@ -1058,12 +1437,18 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
                return ret;
        }
 
-       self->origin = DSO__ORIG_FEDORA - 1;
-
-more:
-       do {
-               self->origin++;
+       /* Iterate over candidate debug images.
+        * On the first pass, only load images if they have a full symtab.
+        * Failing that, do a second pass where we accept .dynsym also
+        */
+       for (self->origin = DSO__ORIG_BUILD_ID_CACHE, want_symtab = 1;
+            self->origin != DSO__ORIG_NOT_FOUND;
+            self->origin++) {
                switch (self->origin) {
+               case DSO__ORIG_BUILD_ID_CACHE:
+                       if (dso__build_id_filename(self, name, size) == NULL)
+                               continue;
+                       break;
                case DSO__ORIG_FEDORA:
                        snprintf(name, size, "/usr/lib/debug%s.debug",
                                 self->long_name);
@@ -1072,122 +1457,140 @@ more:
                        snprintf(name, size, "/usr/lib/debug%s",
                                 self->long_name);
                        break;
-               case DSO__ORIG_BUILDID:
-                       if (filename__read_build_id(self->long_name, build_id,
-                                                   sizeof(build_id))) {
-                               char build_id_hex[BUILD_ID_SIZE * 2 + 1];
-
-                               build_id__sprintf(build_id, sizeof(build_id),
-                                                 build_id_hex);
-                               snprintf(name, size,
-                                        "/usr/lib/debug/.build-id/%.2s/%s.debug",
-                                       build_id_hex, build_id_hex + 2);
-                               if (self->has_build_id)
-                                       goto compare_build_id;
-                               break;
+               case DSO__ORIG_BUILDID: {
+                       char build_id_hex[BUILD_ID_SIZE * 2 + 1];
+
+                       if (!self->has_build_id)
+                               continue;
+
+                       build_id__sprintf(self->build_id,
+                                         sizeof(self->build_id),
+                                         build_id_hex);
+                       snprintf(name, size,
+                                "/usr/lib/debug/.build-id/%.2s/%s.debug",
+                                build_id_hex, build_id_hex + 2);
                        }
-                       self->origin++;
-                       /* Fall thru */
+                       break;
                case DSO__ORIG_DSO:
                        snprintf(name, size, "%s", self->long_name);
                        break;
+               case DSO__ORIG_GUEST_KMODULE:
+                       if (map->groups && map->groups->machine)
+                               root_dir = map->groups->machine->root_dir;
+                       else
+                               root_dir = "";
+                       snprintf(name, size, "%s%s", root_dir, self->long_name);
+                       break;
 
                default:
-                       goto out;
-               }
-
-               if (self->has_build_id) {
-                       if (filename__read_build_id(name, build_id,
-                                                   sizeof(build_id)) < 0)
-                               goto more;
-compare_build_id:
-                       if (!dso__build_id_equal(self, build_id))
-                               goto more;
+                       /*
+                        * If we wanted a full symtab but no image had one,
+                        * relax our requirements and repeat the search.
+                        */
+                       if (want_symtab) {
+                               want_symtab = 0;
+                               self->origin = DSO__ORIG_BUILD_ID_CACHE;
+                       } else
+                               continue;
                }
 
+               /* Name is now the name of the next image to try */
                fd = open(name, O_RDONLY);
-       } while (fd < 0);
+               if (fd < 0)
+                       continue;
 
-       ret = dso__load_sym(self, map, name, fd, filter, 0, 0);
-       close(fd);
+               ret = dso__load_sym(self, map, name, fd, filter, 0,
+                                   want_symtab);
+               close(fd);
 
-       /*
-        * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
-        */
-       if (!ret)
-               goto more;
+               /*
+                * Some people seem to have debuginfo files _WITHOUT_ debug
+                * info!?!?
+                */
+               if (!ret)
+                       continue;
 
-       if (ret > 0) {
-               int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
-               if (nr_plt > 0)
-                       ret += nr_plt;
+               if (ret > 0) {
+                       int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
+                       if (nr_plt > 0)
+                               ret += nr_plt;
+                       break;
+               }
        }
-out:
+
        free(name);
        if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
                return 0;
        return ret;
 }
 
-struct map *kernel_map;
-
-static void kernel_maps__insert(struct map *map)
+struct map *map_groups__find_by_name(struct map_groups *self,
+                                    enum map_type type, const char *name)
 {
-       maps__insert(&kernel_maps, map);
-}
-
-struct symbol *kernel_maps__find_symbol(u64 ip, struct map **mapp,
-                                       symbol_filter_t filter)
-{
-       struct map *map = maps__find(&kernel_maps, ip);
+       struct rb_node *nd;
 
-       if (mapp)
-               *mapp = map;
+       for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+               struct map *map = rb_entry(nd, struct map, rb_node);
 
-       if (map) {
-               ip = map->map_ip(map, ip);
-               return map__find_symbol(map, ip, filter);
+               if (map->dso && strcmp(map->dso->short_name, name) == 0)
+                       return map;
        }
 
        return NULL;
 }
 
-struct map *kernel_maps__find_by_dso_name(const char *name)
+static int dso__kernel_module_get_build_id(struct dso *self,
+                               const char *root_dir)
 {
-       struct rb_node *nd;
+       char filename[PATH_MAX];
+       /*
+        * kernel module short names are of the form "[module]" and
+        * we need just "module" here.
+        */
+       const char *name = self->short_name + 1;
 
-       for (nd = rb_first(&kernel_maps); nd; nd = rb_next(nd)) {
-               struct map *map = rb_entry(nd, struct map, rb_node);
+       snprintf(filename, sizeof(filename),
+                "%s/sys/module/%.*s/notes/.note.gnu.build-id",
+                root_dir, (int)strlen(name) - 1, name);
 
-               if (map->dso && strcmp(map->dso->name, name) == 0)
-                       return map;
-       }
+       if (sysfs__read_build_id(filename, self->build_id,
+                                sizeof(self->build_id)) == 0)
+               self->has_build_id = true;
 
-       return NULL;
+       return 0;
 }
 
-static int dsos__set_modules_path_dir(char *dirname)
+static int map_groups__set_modules_path_dir(struct map_groups *self,
+                               const char *dir_name)
 {
        struct dirent *dent;
-       DIR *dir = opendir(dirname);
+       DIR *dir = opendir(dir_name);
+       int ret = 0;
 
        if (!dir) {
-               pr_err("%s: cannot open %s dir\n", __func__, dirname);
+               pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
                return -1;
        }
 
        while ((dent = readdir(dir)) != NULL) {
                char path[PATH_MAX];
+               struct stat st;
 
-               if (dent->d_type == DT_DIR) {
+               /*sshfs might return bad dent->d_type, so we have to stat*/
+               sprintf(path, "%s/%s", dir_name, dent->d_name);
+               if (stat(path, &st))
+                       continue;
+
+               if (S_ISDIR(st.st_mode)) {
                        if (!strcmp(dent->d_name, ".") ||
                            !strcmp(dent->d_name, ".."))
                                continue;
 
                        snprintf(path, sizeof(path), "%s/%s",
-                                dirname, dent->d_name);
-                       if (dsos__set_modules_path_dir(path) < 0)
-                               goto failure;
+                                dir_name, dent->d_name);
+                       ret = map_groups__set_modules_path_dir(self, path);
+                       if (ret < 0)
+                               goto out;
                } else {
                        char *dot = strrchr(dent->d_name, '.'),
                             dso_name[PATH_MAX];
@@ -1200,38 +1603,70 @@ static int dsos__set_modules_path_dir(char *dirname)
                                 (int)(dot - dent->d_name), dent->d_name);
 
                        strxfrchar(dso_name, '-', '_');
-                       map = kernel_maps__find_by_dso_name(dso_name);
+                       map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
                        if (map == NULL)
                                continue;
 
                        snprintf(path, sizeof(path), "%s/%s",
-                                dirname, dent->d_name);
+                                dir_name, dent->d_name);
 
                        long_name = strdup(path);
-                       if (long_name == NULL)
-                               goto failure;
+                       if (long_name == NULL) {
+                               ret = -1;
+                               goto out;
+                       }
                        dso__set_long_name(map->dso, long_name);
+                       map->dso->lname_alloc = 1;
+                       dso__kernel_module_get_build_id(map->dso, "");
                }
        }
 
-       return 0;
-failure:
+out:
        closedir(dir);
-       return -1;
+       return ret;
 }
 
-static int dsos__set_modules_path(void)
+static char *get_kernel_version(const char *root_dir)
 {
-       struct utsname uts;
+       char version[PATH_MAX];
+       FILE *file;
+       char *name, *tmp;
+       const char *prefix = "Linux version ";
+
+       sprintf(version, "%s/proc/version", root_dir);
+       file = fopen(version, "r");
+       if (!file)
+               return NULL;
+
+       version[0] = '\0';
+       tmp = fgets(version, sizeof(version), file);
+       fclose(file);
+
+       name = strstr(version, prefix);
+       if (!name)
+               return NULL;
+       name += strlen(prefix);
+       tmp = strchr(name, ' ');
+       if (tmp)
+               *tmp = '\0';
+
+       return strdup(name);
+}
+
+static int machine__set_modules_path(struct machine *self)
+{
+       char *version;
        char modules_path[PATH_MAX];
 
-       if (uname(&uts) < 0)
+       version = get_kernel_version(self->root_dir);
+       if (!version)
                return -1;
 
-       snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
-                uts.release);
+       snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
+                self->root_dir, version);
+       free(version);
 
-       return dsos__set_modules_path_dir(modules_path);
+       return map_groups__set_modules_path_dir(&self->kmaps, modules_path);
 }
 
 /*
@@ -1239,34 +1674,64 @@ static int dsos__set_modules_path(void)
  * they are loaded) and for vmlinux, where only after we load all the
  * symbols we'll know where it starts and ends.
  */
-static struct map *map__new2(u64 start, struct dso *dso)
+static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
 {
-       struct map *self = malloc(sizeof(*self));
-
+       struct map *self = calloc(1, (sizeof(*self) +
+                                     (dso->kernel ? sizeof(struct kmap) : 0)));
        if (self != NULL) {
                /*
                 * ->end will be filled after we load all the symbols
                 */
-               map__init(self, start, 0, 0, dso);
+               map__init(self, type, start, 0, 0, dso);
        }
 
        return self;
 }
 
-static int kernel_maps__create_module_maps(void)
+struct map *machine__new_module(struct machine *self, u64 start,
+                               const char *filename)
+{
+       struct map *map;
+       struct dso *dso = __dsos__findnew(&self->kernel_dsos, filename);
+
+       if (dso == NULL)
+               return NULL;
+
+       map = map__new2(start, dso, MAP__FUNCTION);
+       if (map == NULL)
+               return NULL;
+
+       if (machine__is_host(self))
+               dso->origin = DSO__ORIG_KMODULE;
+       else
+               dso->origin = DSO__ORIG_GUEST_KMODULE;
+       map_groups__insert(&self->kmaps, map);
+       return map;
+}
+
+static int machine__create_modules(struct machine *self)
 {
        char *line = NULL;
        size_t n;
-       FILE *file = fopen("/proc/modules", "r");
+       FILE *file;
        struct map *map;
+       const char *modules;
+       char path[PATH_MAX];
+
+       if (machine__is_default_guest(self))
+               modules = symbol_conf.default_guest_modules;
+       else {
+               sprintf(path, "%s/proc/modules", self->root_dir);
+               modules = path;
+       }
 
+       file = fopen(modules, "r");
        if (file == NULL)
                return -1;
 
        while (!feof(file)) {
                char name[PATH_MAX];
                u64 start;
-               struct dso *dso;
                char *sep;
                int line_len;
 
@@ -1292,38 +1757,16 @@ static int kernel_maps__create_module_maps(void)
                *sep = '\0';
 
                snprintf(name, sizeof(name), "[%s]", line);
-               dso = dso__new(name);
-
-               if (dso == NULL)
-                       goto out_delete_line;
-
-               map = map__new2(start, dso);
-               if (map == NULL) {
-                       dso__delete(dso);
+               map = machine__new_module(self, start, name);
+               if (map == NULL)
                        goto out_delete_line;
-               }
-
-               snprintf(name, sizeof(name),
-                        "/sys/module/%s/notes/.note.gnu.build-id", line);
-               if (sysfs__read_build_id(name, dso->build_id,
-                                        sizeof(dso->build_id)) == 0)
-                       dso->has_build_id = true;
-
-               dso->origin = DSO__ORIG_KMODULE;
-               kernel_maps__insert(map);
-               dsos__add(dso);
+               dso__kernel_module_get_build_id(map->dso, self->root_dir);
        }
 
        free(line);
        fclose(file);
 
-       /*
-        * Now that we have all sorted out, just set the ->end of all
-        * maps:
-        */
-       kernel_maps__fixup_end();
-
-       return dsos__set_modules_path();
+       return machine__set_modules_path(self);
 
 out_delete_line:
        free(line);
@@ -1336,51 +1779,200 @@ static int dso__load_vmlinux(struct dso *self, struct map *map,
 {
        int err = -1, fd;
 
+       fd = open(vmlinux, O_RDONLY);
+       if (fd < 0)
+               return -1;
+
+       dso__set_loaded(self, map->type);
+       err = dso__load_sym(self, map, vmlinux, fd, filter, 0, 0);
+       close(fd);
+
+       if (err > 0)
+               pr_debug("Using %s for symbols\n", vmlinux);
+
+       return err;
+}
+
+int dso__load_vmlinux_path(struct dso *self, struct map *map,
+                          symbol_filter_t filter)
+{
+       int i, err = 0;
+       char *filename;
+
+       pr_debug("Looking at the vmlinux_path (%d entries long)\n",
+                vmlinux_path__nr_entries + 1);
+
+       filename = dso__build_id_filename(self, NULL, 0);
+       if (filename != NULL) {
+               err = dso__load_vmlinux(self, map, filename, filter);
+               if (err > 0) {
+                       dso__set_long_name(self, filename);
+                       goto out;
+               }
+               free(filename);
+       }
+
+       for (i = 0; i < vmlinux_path__nr_entries; ++i) {
+               err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
+               if (err > 0) {
+                       dso__set_long_name(self, strdup(vmlinux_path[i]));
+                       break;
+               }
+       }
+out:
+       return err;
+}
+
+static int dso__load_kernel_sym(struct dso *self, struct map *map,
+                               symbol_filter_t filter)
+{
+       int err;
+       const char *kallsyms_filename = NULL;
+       char *kallsyms_allocated_filename = NULL;
+       /*
+        * Step 1: if the user specified a kallsyms or vmlinux filename, use
+        * it and only it, reporting errors to the user if it cannot be used.
+        *
+        * For instance, try to analyse an ARM perf.data file _without_ a
+        * build-id, or if the user specifies the wrong path to the right
+        * vmlinux file, obviously we can't fallback to another vmlinux (a
+        * x86_86 one, on the machine where analysis is being performed, say),
+        * or worse, /proc/kallsyms.
+        *
+        * If the specified file _has_ a build-id and there is a build-id
+        * section in the perf.data file, we will still do the expected
+        * validation in dso__load_vmlinux and will bail out if they don't
+        * match.
+        */
+       if (symbol_conf.kallsyms_name != NULL) {
+               kallsyms_filename = symbol_conf.kallsyms_name;
+               goto do_kallsyms;
+       }
+
+       if (symbol_conf.vmlinux_name != NULL) {
+               err = dso__load_vmlinux(self, map,
+                                       symbol_conf.vmlinux_name, filter);
+               if (err > 0) {
+                       dso__set_long_name(self,
+                                          strdup(symbol_conf.vmlinux_name));
+                       goto out_fixup;
+               }
+               return err;
+       }
+
+       if (vmlinux_path != NULL) {
+               err = dso__load_vmlinux_path(self, map, filter);
+               if (err > 0)
+                       goto out_fixup;
+       }
+
+       /*
+        * Say the kernel DSO was created when processing the build-id header table,
+        * we have a build-id, so check if it is the same as the running kernel,
+        * using it if it is.
+        */
        if (self->has_build_id) {
-               u8 build_id[BUILD_ID_SIZE];
+               u8 kallsyms_build_id[BUILD_ID_SIZE];
+               char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+               if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
+                                        sizeof(kallsyms_build_id)) == 0) {
+                       if (dso__build_id_equal(self, kallsyms_build_id)) {
+                               kallsyms_filename = "/proc/kallsyms";
+                               goto do_kallsyms;
+                       }
+               }
+               /*
+                * Now look if we have it on the build-id cache in
+                * $HOME/.debug/[kernel.kallsyms].
+                */
+               build_id__sprintf(self->build_id, sizeof(self->build_id),
+                                 sbuild_id);
 
-               if (filename__read_build_id(vmlinux, build_id,
-                                           sizeof(build_id)) < 0) {
-                       pr_debug("No build_id in %s, ignoring it\n", vmlinux);
+               if (asprintf(&kallsyms_allocated_filename,
+                            "%s/.debug/[kernel.kallsyms]/%s",
+                            getenv("HOME"), sbuild_id) == -1) {
+                       pr_err("Not enough memory for kallsyms file lookup\n");
                        return -1;
                }
-               if (!dso__build_id_equal(self, build_id)) {
-                       char expected_build_id[BUILD_ID_SIZE * 2 + 1],
-                            vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
 
-                       build_id__sprintf(self->build_id,
-                                         sizeof(self->build_id),
-                                         expected_build_id);
-                       build_id__sprintf(build_id, sizeof(build_id),
-                                         vmlinux_build_id);
-                       pr_debug("build_id in %s is %s while expected is %s, "
-                                "ignoring it\n", vmlinux, vmlinux_build_id,
-                                expected_build_id);
+               kallsyms_filename = kallsyms_allocated_filename;
+
+               if (access(kallsyms_filename, F_OK)) {
+                       pr_err("No kallsyms or vmlinux with build-id %s "
+                              "was found\n", sbuild_id);
+                       free(kallsyms_allocated_filename);
                        return -1;
                }
+       } else {
+               /*
+                * Last resort, if we don't have a build-id and couldn't find
+                * any vmlinux file, try the running kernel kallsyms table.
+                */
+               kallsyms_filename = "/proc/kallsyms";
        }
 
-       fd = open(vmlinux, O_RDONLY);
-       if (fd < 0)
-               return -1;
-
-       self->loaded = 1;
-       err = dso__load_sym(self, map, self->long_name, fd, filter, 1, 0);
+do_kallsyms:
+       err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
+       if (err > 0)
+               pr_debug("Using %s for symbols\n", kallsyms_filename);
+       free(kallsyms_allocated_filename);
 
-       close(fd);
+       if (err > 0) {
+out_fixup:
+               if (kallsyms_filename != NULL)
+                       dso__set_long_name(self, strdup("[kernel.kallsyms]"));
+               map__fixup_start(map);
+               map__fixup_end(map);
+       }
 
        return err;
 }
 
-static int dso__load_kernel_sym(struct dso *self, struct map *map,
+static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
                                symbol_filter_t filter)
 {
-       int err = dso__load_vmlinux(self, map, self->name, filter);
+       int err;
+       const char *kallsyms_filename = NULL;
+       struct machine *machine;
+       char path[PATH_MAX];
+
+       if (!map->groups) {
+               pr_debug("Guest kernel map hasn't the point to groups\n");
+               return -1;
+       }
+       machine = map->groups->machine;
+
+       if (machine__is_default_guest(machine)) {
+               /*
+                * if the user specified a vmlinux filename, use it and only
+                * it, reporting errors to the user if it cannot be used.
+                * Or use file guest_kallsyms inputted by user on commandline
+                */
+               if (symbol_conf.default_guest_vmlinux_name != NULL) {
+                       err = dso__load_vmlinux(self, map,
+                               symbol_conf.default_guest_vmlinux_name, filter);
+                       goto out_try_fixup;
+               }
+
+               kallsyms_filename = symbol_conf.default_guest_kallsyms;
+               if (!kallsyms_filename)
+                       return -1;
+       } else {
+               sprintf(path, "%s/proc/kallsyms", machine->root_dir);
+               kallsyms_filename = path;
+       }
 
-       if (err <= 0)
-               err = kernel_maps__load_kallsyms(filter);
+       err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
+       if (err > 0)
+               pr_debug("Using %s for symbols\n", kallsyms_filename);
 
+out_try_fixup:
        if (err > 0) {
+               if (kallsyms_filename != NULL) {
+                       machine__mmap_name(machine, path, sizeof(path));
+                       dso__set_long_name(self, strdup(path));
+               }
                map__fixup_start(map);
                map__fixup_end(map);
        }
@@ -1388,34 +1980,29 @@ static int dso__load_kernel_sym(struct dso *self, struct map *map,
        return err;
 }
 
-LIST_HEAD(dsos);
-struct dso     *vdso;
-
-const char     *vmlinux_name = "vmlinux";
-
-static void dsos__add(struct dso *dso)
+static void dsos__add(struct list_head *head, struct dso *dso)
 {
-       list_add_tail(&dso->node, &dsos);
+       list_add_tail(&dso->node, head);
 }
 
-static struct dso *dsos__find(const char *name)
+static struct dso *dsos__find(struct list_head *head, const char *name)
 {
        struct dso *pos;
 
-       list_for_each_entry(pos, &dsos, node)
-               if (strcmp(pos->name, name) == 0)
+       list_for_each_entry(pos, head, node)
+               if (strcmp(pos->long_name, name) == 0)
                        return pos;
        return NULL;
 }
 
-struct dso *dsos__findnew(const char *name)
+struct dso *__dsos__findnew(struct list_head *head, const char *name)
 {
-       struct dso *dso = dsos__find(name);
+       struct dso *dso = dsos__find(head, name);
 
        if (!dso) {
                dso = dso__new(name);
                if (dso != NULL) {
-                       dsos__add(dso);
+                       dsos__add(head, dso);
                        dso__set_basename(dso);
                }
        }
@@ -1423,77 +2010,471 @@ struct dso *dsos__findnew(const char *name)
        return dso;
 }
 
-void dsos__fprintf(FILE *fp)
+size_t __dsos__fprintf(struct list_head *head, FILE *fp)
 {
        struct dso *pos;
+       size_t ret = 0;
+
+       list_for_each_entry(pos, head, node) {
+               int i;
+               for (i = 0; i < MAP__NR_TYPES; ++i)
+                       ret += dso__fprintf(pos, i, fp);
+       }
 
-       list_for_each_entry(pos, &dsos, node)
-               dso__fprintf(pos, fp);
+       return ret;
 }
 
-size_t dsos__fprintf_buildid(FILE *fp)
+size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp)
+{
+       struct rb_node *nd;
+       size_t ret = 0;
+
+       for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+               struct machine *pos = rb_entry(nd, struct machine, rb_node);
+               ret += __dsos__fprintf(&pos->kernel_dsos, fp);
+               ret += __dsos__fprintf(&pos->user_dsos, fp);
+       }
+
+       return ret;
+}
+
+static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
+                                     bool with_hits)
 {
        struct dso *pos;
        size_t ret = 0;
 
-       list_for_each_entry(pos, &dsos, node) {
+       list_for_each_entry(pos, head, node) {
+               if (with_hits && !pos->hit)
+                       continue;
                ret += dso__fprintf_buildid(pos, fp);
                ret += fprintf(fp, " %s\n", pos->long_name);
        }
        return ret;
 }
 
-static int kernel_maps__create_kernel_map(void)
+size_t machine__fprintf_dsos_buildid(struct machine *self, FILE *fp, bool with_hits)
+{
+       return __dsos__fprintf_buildid(&self->kernel_dsos, fp, with_hits) +
+              __dsos__fprintf_buildid(&self->user_dsos, fp, with_hits);
+}
+
+size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits)
+{
+       struct rb_node *nd;
+       size_t ret = 0;
+
+       for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+               struct machine *pos = rb_entry(nd, struct machine, rb_node);
+               ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
+       }
+       return ret;
+}
+
+struct dso *dso__new_kernel(const char *name)
+{
+       struct dso *self = dso__new(name ?: "[kernel.kallsyms]");
+
+       if (self != NULL) {
+               dso__set_short_name(self, "[kernel]");
+               self->kernel = DSO_TYPE_KERNEL;
+       }
+
+       return self;
+}
+
+static struct dso *dso__new_guest_kernel(struct machine *machine,
+                                       const char *name)
+{
+       char bf[PATH_MAX];
+       struct dso *self = dso__new(name ?: machine__mmap_name(machine, bf, sizeof(bf)));
+
+       if (self != NULL) {
+               dso__set_short_name(self, "[guest.kernel]");
+               self->kernel = DSO_TYPE_GUEST_KERNEL;
+       }
+
+       return self;
+}
+
+void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine)
+{
+       char path[PATH_MAX];
+
+       if (machine__is_default_guest(machine))
+               return;
+       sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
+       if (sysfs__read_build_id(path, self->build_id,
+                                sizeof(self->build_id)) == 0)
+               self->has_build_id = true;
+}
+
+static struct dso *machine__create_kernel(struct machine *self)
+{
+       const char *vmlinux_name = NULL;
+       struct dso *kernel;
+
+       if (machine__is_host(self)) {
+               vmlinux_name = symbol_conf.vmlinux_name;
+               kernel = dso__new_kernel(vmlinux_name);
+       } else {
+               if (machine__is_default_guest(self))
+                       vmlinux_name = symbol_conf.default_guest_vmlinux_name;
+               kernel = dso__new_guest_kernel(self, vmlinux_name);
+       }
+
+       if (kernel != NULL) {
+               dso__read_running_kernel_build_id(kernel, self);
+               dsos__add(&self->kernel_dsos, kernel);
+       }
+       return kernel;
+}
+
+int __machine__create_kernel_maps(struct machine *self, struct dso *kernel)
+{
+       enum map_type type;
+
+       for (type = 0; type < MAP__NR_TYPES; ++type) {
+               struct kmap *kmap;
+
+               self->vmlinux_maps[type] = map__new2(0, kernel, type);
+               if (self->vmlinux_maps[type] == NULL)
+                       return -1;
+
+               self->vmlinux_maps[type]->map_ip =
+                       self->vmlinux_maps[type]->unmap_ip = identity__map_ip;
+
+               kmap = map__kmap(self->vmlinux_maps[type]);
+               kmap->kmaps = &self->kmaps;
+               map_groups__insert(&self->kmaps, self->vmlinux_maps[type]);
+       }
+
+       return 0;
+}
+
+void machine__destroy_kernel_maps(struct machine *self)
+{
+       enum map_type type;
+
+       for (type = 0; type < MAP__NR_TYPES; ++type) {
+               struct kmap *kmap;
+
+               if (self->vmlinux_maps[type] == NULL)
+                       continue;
+
+               kmap = map__kmap(self->vmlinux_maps[type]);
+               map_groups__remove(&self->kmaps, self->vmlinux_maps[type]);
+               if (kmap->ref_reloc_sym) {
+                       /*
+                        * ref_reloc_sym is shared among all maps, so free just
+                        * on one of them.
+                        */
+                       if (type == MAP__FUNCTION) {
+                               free((char *)kmap->ref_reloc_sym->name);
+                               kmap->ref_reloc_sym->name = NULL;
+                               free(kmap->ref_reloc_sym);
+                       }
+                       kmap->ref_reloc_sym = NULL;
+               }
+
+               map__delete(self->vmlinux_maps[type]);
+               self->vmlinux_maps[type] = NULL;
+       }
+}
+
+int machine__create_kernel_maps(struct machine *self)
 {
-       struct dso *kernel = dso__new(vmlinux_name);
+       struct dso *kernel = machine__create_kernel(self);
 
-       if (kernel == NULL)
+       if (kernel == NULL ||
+           __machine__create_kernel_maps(self, kernel) < 0)
                return -1;
 
-       kernel_map = map__new2(0, kernel);
-       if (kernel_map == NULL)
-               goto out_delete_kernel_dso;
+       if (symbol_conf.use_modules && machine__create_modules(self) < 0)
+               pr_debug("Problems creating module maps, continuing anyway...\n");
+       /*
+        * Now that we have all the maps created, just set the ->end of them:
+        */
+       map_groups__fixup_end(&self->kmaps);
+       return 0;
+}
+
+static void vmlinux_path__exit(void)
+{
+       while (--vmlinux_path__nr_entries >= 0) {
+               free(vmlinux_path[vmlinux_path__nr_entries]);
+               vmlinux_path[vmlinux_path__nr_entries] = NULL;
+       }
 
-       kernel_map->map_ip = kernel_map->unmap_ip = identity__map_ip;
+       free(vmlinux_path);
+       vmlinux_path = NULL;
+}
 
-       kernel->short_name = "[kernel]";
-       kernel->kernel = 1;
-       vdso = dso__new("[vdso]");
-       if (vdso == NULL)
-               goto out_delete_kernel_map;
+static int vmlinux_path__init(void)
+{
+       struct utsname uts;
+       char bf[PATH_MAX];
 
-       if (sysfs__read_build_id("/sys/kernel/notes", kernel->build_id,
-                                sizeof(kernel->build_id)) == 0)
-               kernel->has_build_id = true;
+       if (uname(&uts) < 0)
+               return -1;
 
-       kernel_maps__insert(kernel_map);
-       dsos__add(kernel);
-       dsos__add(vdso);
+       vmlinux_path = malloc(sizeof(char *) * 5);
+       if (vmlinux_path == NULL)
+               return -1;
+
+       vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
+       if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+               goto out_fail;
+       ++vmlinux_path__nr_entries;
+       vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
+       if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+               goto out_fail;
+       ++vmlinux_path__nr_entries;
+       snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
+       vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+       if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+               goto out_fail;
+       ++vmlinux_path__nr_entries;
+       snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
+       vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+       if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+               goto out_fail;
+       ++vmlinux_path__nr_entries;
+       snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
+                uts.release);
+       vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+       if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+               goto out_fail;
+       ++vmlinux_path__nr_entries;
 
        return 0;
 
-out_delete_kernel_map:
-       map__delete(kernel_map);
-       kernel_map = NULL;
-out_delete_kernel_dso:
-       dso__delete(kernel);
+out_fail:
+       vmlinux_path__exit();
        return -1;
 }
 
-int kernel_maps__init(bool use_modules)
+size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp)
 {
-       if (kernel_maps__create_kernel_map() < 0)
-               return -1;
+       int i;
+       size_t printed = 0;
+       struct dso *kdso = self->vmlinux_maps[MAP__FUNCTION]->dso;
+
+       if (kdso->has_build_id) {
+               char filename[PATH_MAX];
+               if (dso__build_id_filename(kdso, filename, sizeof(filename)))
+                       printed += fprintf(fp, "[0] %s\n", filename);
+       }
 
-       if (use_modules && kernel_maps__create_module_maps() < 0)
-               pr_warning("Failed to load list of modules in use, "
-                          "continuing...\n");
+       for (i = 0; i < vmlinux_path__nr_entries; ++i)
+               printed += fprintf(fp, "[%d] %s\n",
+                                  i + kdso->has_build_id, vmlinux_path[i]);
+
+       return printed;
+}
+
+static int setup_list(struct strlist **list, const char *list_str,
+                     const char *list_name)
+{
+       if (list_str == NULL)
+               return 0;
 
+       *list = strlist__new(true, list_str);
+       if (!*list) {
+               pr_err("problems parsing %s list\n", list_name);
+               return -1;
+       }
        return 0;
 }
 
-void symbol__init(unsigned int priv_size)
+int symbol__init(void)
 {
+       if (symbol_conf.initialized)
+               return 0;
+
        elf_version(EV_CURRENT);
-       symbol__priv_size = priv_size;
+       if (symbol_conf.sort_by_name)
+               symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
+                                         sizeof(struct symbol));
+
+       if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
+               return -1;
+
+       if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
+               pr_err("'.' is the only non valid --field-separator argument\n");
+               return -1;
+       }
+
+       if (setup_list(&symbol_conf.dso_list,
+                      symbol_conf.dso_list_str, "dso") < 0)
+               return -1;
+
+       if (setup_list(&symbol_conf.comm_list,
+                      symbol_conf.comm_list_str, "comm") < 0)
+               goto out_free_dso_list;
+
+       if (setup_list(&symbol_conf.sym_list,
+                      symbol_conf.sym_list_str, "symbol") < 0)
+               goto out_free_comm_list;
+
+       symbol_conf.initialized = true;
+       return 0;
+
+out_free_dso_list:
+       strlist__delete(symbol_conf.dso_list);
+out_free_comm_list:
+       strlist__delete(symbol_conf.comm_list);
+       return -1;
+}
+
+void symbol__exit(void)
+{
+       if (!symbol_conf.initialized)
+               return;
+       strlist__delete(symbol_conf.sym_list);
+       strlist__delete(symbol_conf.dso_list);
+       strlist__delete(symbol_conf.comm_list);
+       vmlinux_path__exit();
+       symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
+       symbol_conf.initialized = false;
+}
+
+int machines__create_kernel_maps(struct rb_root *self, pid_t pid)
+{
+       struct machine *machine = machines__findnew(self, pid);
+
+       if (machine == NULL)
+               return -1;
+
+       return machine__create_kernel_maps(machine);
+}
+
+static int hex(char ch)
+{
+       if ((ch >= '0') && (ch <= '9'))
+               return ch - '0';
+       if ((ch >= 'a') && (ch <= 'f'))
+               return ch - 'a' + 10;
+       if ((ch >= 'A') && (ch <= 'F'))
+               return ch - 'A' + 10;
+       return -1;
+}
+
+/*
+ * While we find nice hex chars, build a long_val.
+ * Return number of chars processed.
+ */
+int hex2u64(const char *ptr, u64 *long_val)
+{
+       const char *p = ptr;
+       *long_val = 0;
+
+       while (*p) {
+               const int hex_val = hex(*p);
+
+               if (hex_val < 0)
+                       break;
+
+               *long_val = (*long_val << 4) | hex_val;
+               p++;
+       }
+
+       return p - ptr;
+}
+
+char *strxfrchar(char *s, char from, char to)
+{
+       char *p = s;
+
+       while ((p = strchr(p, from)) != NULL)
+               *p++ = to;
+
+       return s;
+}
+
+int machines__create_guest_kernel_maps(struct rb_root *self)
+{
+       int ret = 0;
+       struct dirent **namelist = NULL;
+       int i, items = 0;
+       char path[PATH_MAX];
+       pid_t pid;
+
+       if (symbol_conf.default_guest_vmlinux_name ||
+           symbol_conf.default_guest_modules ||
+           symbol_conf.default_guest_kallsyms) {
+               machines__create_kernel_maps(self, DEFAULT_GUEST_KERNEL_ID);
+       }
+
+       if (symbol_conf.guestmount) {
+               items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
+               if (items <= 0)
+                       return -ENOENT;
+               for (i = 0; i < items; i++) {
+                       if (!isdigit(namelist[i]->d_name[0])) {
+                               /* Filter out . and .. */
+                               continue;
+                       }
+                       pid = atoi(namelist[i]->d_name);
+                       sprintf(path, "%s/%s/proc/kallsyms",
+                               symbol_conf.guestmount,
+                               namelist[i]->d_name);
+                       ret = access(path, R_OK);
+                       if (ret) {
+                               pr_debug("Can't access file %s\n", path);
+                               goto failure;
+                       }
+                       machines__create_kernel_maps(self, pid);
+               }
+failure:
+               free(namelist);
+       }
+
+       return ret;
+}
+
+void machines__destroy_guest_kernel_maps(struct rb_root *self)
+{
+       struct rb_node *next = rb_first(self);
+
+       while (next) {
+               struct machine *pos = rb_entry(next, struct machine, rb_node);
+
+               next = rb_next(&pos->rb_node);
+               rb_erase(&pos->rb_node, self);
+               machine__delete(pos);
+       }
+}
+
+int machine__load_kallsyms(struct machine *self, const char *filename,
+                          enum map_type type, symbol_filter_t filter)
+{
+       struct map *map = self->vmlinux_maps[type];
+       int ret = dso__load_kallsyms(map->dso, filename, map, filter);
+
+       if (ret > 0) {
+               dso__set_loaded(map->dso, type);
+               /*
+                * Since /proc/kallsyms will have multiple sessions for the
+                * kernel, with modules between them, fixup the end of all
+                * sections.
+                */
+               __map_groups__fixup_end(&self->kmaps, type);
+       }
+
+       return ret;
+}
+
+int machine__load_vmlinux_path(struct machine *self, enum map_type type,
+                              symbol_filter_t filter)
+{
+       struct map *map = self->vmlinux_maps[type];
+       int ret = dso__load_vmlinux_path(map->dso, map, filter);
+
+       if (ret > 0) {
+               dso__set_loaded(map->dso, type);
+               map__reloc_vmlinux(map);
+       }
+
+       return ret;
 }