1 files changed, 313 insertions, 192 deletions

diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 5cc96c86861b..44d81d5ae8cf 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -9,8 +9,13 @@
 #include <libelf.h>
 #include <gelf.h>
 #include <elf.h>
+#include <limits.h>
 #include <sys/utsname.h>
 
+#ifndef NT_GNU_BUILD_ID
+#define NT_GNU_BUILD_ID 3
+#endif
+
 enum dso_origin {
         DSO__ORIG_KERNEL = 0,
         DSO__ORIG_JAVA_JIT,
@@ -26,7 +31,11 @@ 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 int dso__load_kernel_sym(struct dso *self, struct map *map,
+                                symbol_filter_t filter);
 unsigned int symbol__priv_size;
+static int vmlinux_path__nr_entries;
+static char **vmlinux_path;
 
 static struct rb_root kernel_maps;
 
@@ -69,11 +78,11 @@ static void kernel_maps__fixup_end(void)
                 prev->end = curr->start - 1;
         }
 
-        nd = rb_last(&curr->dso->syms);
-        if (nd) {
-                struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
-                curr->end = sym->end;
-        }
+        /*
+         * We still haven't the actual symbols, so guess the
+         * last map final address.
+         */
+        curr->end = ~0UL;
 }
 
 static struct symbol *symbol__new(u64 start, u64 len, const char *name)
@@ -111,6 +120,8 @@ static size_t symbol__fprintf(struct symbol *self, FILE *fp)
 
 static void dso__set_long_name(struct dso *self, char *name)
 {
+        if (name == NULL)
+                return;
         self->long_name = name;
         self->long_name_len = strlen(name);
 }
@@ -323,7 +334,7 @@ out_failure:
  * 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, int use_modules)
+static int kernel_maps__split_kallsyms(symbol_filter_t filter)
 {
         struct map *map = kernel_map;
         struct symbol *pos;
@@ -339,9 +350,6 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter, int use_modules)
 
                 module = strchr(pos->name, '\t');
                 if (module) {
-                        if (!use_modules)
-                                goto delete_symbol;
-
                         *module++ = '\0';
 
                         if (strcmp(map->dso->name, module)) {
@@ -381,7 +389,6 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter, int use_modules)
                 }
 
                 if (filter && filter(map, pos)) {
-delete_symbol:
                         rb_erase(&pos->rb_node, &kernel_map->dso->syms);
                         symbol__delete(pos);
                 } else {
@@ -397,17 +404,18 @@ delete_symbol:
 }
 
 
-static int kernel_maps__load_kallsyms(symbol_filter_t filter, int use_modules)
+static int kernel_maps__load_kallsyms(symbol_filter_t filter)
 {
         if (kernel_maps__load_all_kallsyms())
                 return -1;
 
         dso__fixup_sym_end(kernel_map->dso);
+        kernel_map->dso->origin = DSO__ORIG_KERNEL;
 
-        return kernel_maps__split_kallsyms(filter, use_modules);
+        return kernel_maps__split_kallsyms(filter);
 }
 
-static size_t kernel_maps__fprintf(FILE *fp)
+size_t kernel_maps__fprintf(FILE *fp)
 {
         size_t printed = fprintf(fp, "Kernel maps:\n");
         struct rb_node *nd;
@@ -883,47 +891,40 @@ out_close:
         return err;
 }
 
-bool fetch_build_id_table(struct list_head *head)
+static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
 {
-        bool have_buildid = false;
-        struct dso *pos;
-
-        list_for_each_entry(pos, &dsos, node) {
-                struct build_id_list *new;
-                struct build_id_event b;
-                size_t len;
-
-                if (filename__read_build_id(pos->long_name,
-                                            &b.build_id,
-                                            sizeof(b.build_id)) < 0)
-                        continue;
-                have_buildid = true;
-                memset(&b.header, 0, sizeof(b.header));
-                len = pos->long_name_len + 1;
-                len = ALIGN(len, 64);
-                b.header.size = sizeof(b) + len;
-
-                new = malloc(sizeof(*new));
-                if (!new)
-                        die("No memory\n");
+        return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
+}
 
-                memcpy(&new->event, &b, sizeof(b));
-                new->dso_name = pos->long_name;
-                new->len = len;
+bool dsos__read_build_ids(void)
+{
+        bool have_build_id = false;
+        struct dso *pos;
 
-                list_add_tail(&new->list, head);
-        }
+        list_for_each_entry(pos, &dsos, node)
+                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_buildid;
+        return have_build_id;
 }
 
+/*
+ * Align offset to 4 bytes as needed for note name and descriptor data.
+ */
+#define NOTE_ALIGN(n) (((n) + 3) & -4U)
+
 int filename__read_build_id(const char *filename, void *bf, size_t size)
 {
         int fd, err = -1;
         GElf_Ehdr ehdr;
         GElf_Shdr shdr;
-        Elf_Data *build_id_data;
+        Elf_Data *data;
         Elf_Scn *sec;
+        Elf_Kind ek;
+        void *ptr;
         Elf *elf;
 
         if (size < BUILD_ID_SIZE)
@@ -939,6 +940,10 @@ int filename__read_build_id(const char *filename, void *bf, size_t size)
                 goto out_close;
         }
 
+        ek = elf_kind(elf);
+        if (ek != ELF_K_ELF)
+                goto out_elf_end;
+
         if (gelf_getehdr(elf, &ehdr) == NULL) {
                 pr_err("%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
@@ -946,14 +951,37 @@ int filename__read_build_id(const char *filename, void *bf, size_t size)
 
         sec = elf_section_by_name(elf, &ehdr, &shdr,
                                   ".note.gnu.build-id", NULL);
-        if (sec == NULL)
-                goto out_elf_end;
+        if (sec == NULL) {
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".notes", NULL);
+                if (sec == NULL)
+                        goto out_elf_end;
+        }
 
-        build_id_data = elf_getdata(sec, NULL);
-        if (build_id_data == NULL)
+        data = elf_getdata(sec, NULL);
+        if (data == NULL)
                 goto out_elf_end;
-        memcpy(bf, build_id_data->d_buf + 16, BUILD_ID_SIZE);
-        err = BUILD_ID_SIZE;
+
+        ptr = data->d_buf;
+        while (ptr < (data->d_buf + data->d_size)) {
+                GElf_Nhdr *nhdr = ptr;
+                int namesz = NOTE_ALIGN(nhdr->n_namesz),
+                    descsz = NOTE_ALIGN(nhdr->n_descsz);
+                const char *name;
+
+                ptr += sizeof(*nhdr);
+                name = ptr;
+                ptr += namesz;
+                if (nhdr->n_type == NT_GNU_BUILD_ID &&
+                    nhdr->n_namesz == sizeof("GNU")) {
+                        if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
+                                memcpy(bf, ptr, BUILD_ID_SIZE);
+                                err = BUILD_ID_SIZE;
+                                break;
+                        }
+                }
+                ptr += descsz;
+        }
 out_elf_end:
         elf_end(elf);
 out_close:
@@ -962,23 +990,48 @@ out:
         return err;
 }
 
-static char *dso__read_build_id(struct dso *self)
+int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
 {
-        int len;
-        char *build_id = NULL;
-        unsigned char rawbf[BUILD_ID_SIZE];
+        int fd, err = -1;
 
-        len = filename__read_build_id(self->long_name, rawbf, sizeof(rawbf));
-        if (len < 0)
+        if (size < BUILD_ID_SIZE)
                 goto out;
 
-        build_id = malloc(len * 2 + 1);
-        if (build_id == NULL)
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
                 goto out;
 
-        build_id__sprintf(rawbf, len, build_id);
+        while (1) {
+                char bf[BUFSIZ];
+                GElf_Nhdr nhdr;
+                int namesz, descsz;
+
+                if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
+                        break;
+
+                namesz = NOTE_ALIGN(nhdr.n_namesz);
+                descsz = NOTE_ALIGN(nhdr.n_descsz);
+                if (nhdr.n_type == NT_GNU_BUILD_ID &&
+                    nhdr.n_namesz == sizeof("GNU")) {
+                        if (read(fd, bf, namesz) != namesz)
+                                break;
+                        if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
+                                if (read(fd, build_id,
+                                    BUILD_ID_SIZE) == BUILD_ID_SIZE) {
+                                        err = 0;
+                                        break;
+                                }
+                        } else if (read(fd, bf, descsz) != descsz)
+                                break;
+                } else {
+                        int n = namesz + descsz;
+                        if (read(fd, bf, n) != n)
+                                break;
+                }
+        }
+        close(fd);
 out:
-        return build_id;
+        return err;
 }
 
 char dso__symtab_origin(const struct dso *self)
@@ -1001,12 +1054,17 @@ char dso__symtab_origin(const struct dso *self)
 int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
 {
         int size = PATH_MAX;
-        char *name = malloc(size), *build_id = NULL;
+        char *name;
+        u8 build_id[BUILD_ID_SIZE];
         int ret = -1;
         int fd;
 
         self->loaded = 1;
 
+        if (self->kernel)
+                return dso__load_kernel_sym(self, map, filter);
+
+        name = malloc(size);
         if (!name)
                 return -1;
 
@@ -1023,8 +1081,6 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
 
 more:
         do {
-                int berr = 0;
-
                 self->origin++;
                 switch (self->origin) {
                 case DSO__ORIG_FEDORA:
@@ -1036,12 +1092,18 @@ more:
                                  self->long_name);
                         break;
                 case DSO__ORIG_BUILDID:
-                        build_id = dso__read_build_id(self);
-                        if (build_id != NULL) {
+                        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, build_id + 2);
-                                goto compare_build_id;
+                                        build_id_hex, build_id_hex + 2);
+                                if (self->has_build_id)
+                                        goto compare_build_id;
+                                break;
                         }
                         self->origin++;
                         /* Fall thru */
@@ -1054,18 +1116,11 @@ more:
                 }
 
                 if (self->has_build_id) {
-                        bool match;
-                        build_id = malloc(BUILD_ID_SIZE);
-                        if (build_id == NULL)
+                        if (filename__read_build_id(name, build_id,
+                                                    sizeof(build_id)) < 0)
                                 goto more;
-                        berr = filename__read_build_id(name, build_id,
-                                                       BUILD_ID_SIZE);
 compare_build_id:
-                        match = berr > 0 && memcmp(build_id, self->build_id,
-                                                   sizeof(self->build_id)) == 0;
-                        free(build_id);
-                        build_id = NULL;
-                        if (!match)
+                        if (!dso__build_id_equal(self, build_id))
                                 goto more;
                 }
 
@@ -1100,7 +1155,8 @@ static void kernel_maps__insert(struct map *map)
         maps__insert(&kernel_maps, map);
 }
 
-struct symbol *kernel_maps__find_symbol(u64 ip, struct map **mapp)
+struct symbol *kernel_maps__find_symbol(u64 ip, struct map **mapp,
+                                        symbol_filter_t filter)
 {
         struct map *map = maps__find(&kernel_maps, ip);
 
@@ -1109,7 +1165,7 @@ struct symbol *kernel_maps__find_symbol(u64 ip, struct map **mapp)
 
         if (map) {
                 ip = map->map_ip(map, ip);
-                return map->dso->find_symbol(map->dso, ip);
+                return map__find_symbol(map, ip, filter);
         }
 
         return NULL;
@@ -1129,32 +1185,13 @@ struct map *kernel_maps__find_by_dso_name(const char *name)
         return NULL;
 }
 
-static int dso__load_module_sym(struct dso *self, struct map *map,
-                                symbol_filter_t filter)
-{
-        int err = 0, fd = open(self->long_name, O_RDONLY);
-
-        self->loaded = 1;
-
-        if (fd < 0) {
-                pr_err("%s: cannot open %s\n", __func__, self->long_name);
-                return err;
-        }
-
-        err = dso__load_sym(self, map, self->long_name, fd, filter, 0, 1);
-        close(fd);
-
-        return err;
-}
-
-static int dsos__load_modules_sym_dir(char *dirname, symbol_filter_t filter)
+static int dsos__set_modules_path_dir(char *dirname)
 {
         struct dirent *dent;
-        int nr_symbols = 0, err;
         DIR *dir = opendir(dirname);
 
         if (!dir) {
-                pr_err("%s: cannot open %s dir\n", __func__, dirname);
+                pr_debug("%s: cannot open %s dir\n", __func__, dirname);
                 return -1;
         }
 
@@ -1168,14 +1205,12 @@ static int dsos__load_modules_sym_dir(char *dirname, symbol_filter_t filter)
 
                         snprintf(path, sizeof(path), "%s/%s",
                                  dirname, dent->d_name);
-                        err = dsos__load_modules_sym_dir(path, filter);
-                        if (err < 0)
+                        if (dsos__set_modules_path_dir(path) < 0)
                                 goto failure;
                 } else {
                         char *dot = strrchr(dent->d_name, '.'),
                              dso_name[PATH_MAX];
                         struct map *map;
-                        struct rb_node *last;
                         char *long_name;
 
                         if (dot == NULL || strcmp(dot, ".ko"))
@@ -1195,36 +1230,16 @@ static int dsos__load_modules_sym_dir(char *dirname, symbol_filter_t filter)
                         if (long_name == NULL)
                                 goto failure;
                         dso__set_long_name(map->dso, long_name);
-                        dso__set_basename(map->dso);
-
-                        err = dso__load_module_sym(map->dso, map, filter);
-                        if (err < 0)
-                                goto failure;
-                        last = rb_last(&map->dso->syms);
-                        if (last) {
-                                struct symbol *sym;
-                                /*
-                                 * We do this here as well, even having the
-                                 * symbol size found in the symtab because
-                                 * misannotated ASM symbols may have the size
-                                 * set to zero.
-                                 */
-                                dso__fixup_sym_end(map->dso);
-
-                                sym = rb_entry(last, struct symbol, rb_node);
-                                map->end = map->start + sym->end;
-                        }
                 }
-                nr_symbols += err;
         }
 
-        return nr_symbols;
+        return 0;
 failure:
         closedir(dir);
         return -1;
 }
 
-static int dsos__load_modules_sym(symbol_filter_t filter)
+static int dsos__set_modules_path(void)
 {
         struct utsname uts;
         char modules_path[PATH_MAX];
@@ -1235,7 +1250,7 @@ static int dsos__load_modules_sym(symbol_filter_t filter)
         snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
                  uts.release);
 
-        return dsos__load_modules_sym_dir(modules_path, filter);
+        return dsos__set_modules_path_dir(modules_path);
 }
 
 /*
@@ -1257,7 +1272,7 @@ static struct map *map__new2(u64 start, struct dso *dso)
         return self;
 }
 
-static int dsos__load_modules(void)
+static int kernel_maps__create_module_maps(void)
 {
         char *line = NULL;
         size_t n;
@@ -1307,6 +1322,12 @@ static int dsos__load_modules(void)
                         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);
@@ -1315,7 +1336,7 @@ static int dsos__load_modules(void)
         free(line);
         fclose(file);
 
-        return 0;
+        return dsos__set_modules_path();
 
 out_delete_line:
         free(line);
@@ -1326,13 +1347,37 @@ out_failure:
 static int dso__load_vmlinux(struct dso *self, struct map *map,
                              const char *vmlinux, symbol_filter_t filter)
 {
-        int err, fd = open(vmlinux, O_RDONLY);
+        int err = -1, fd;
 
-        self->loaded = 1;
+        if (self->has_build_id) {
+                u8 build_id[BUILD_ID_SIZE];
+
+                if (filename__read_build_id(vmlinux, build_id,
+                                            sizeof(build_id)) < 0) {
+                        pr_debug("No build_id in %s, ignoring it\n", vmlinux);
+                        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);
+                        return -1;
+                }
+        }
 
+        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);
 
         close(fd);
@@ -1340,78 +1385,55 @@ static int dso__load_vmlinux(struct dso *self, struct map *map,
         return err;
 }
 
-int dsos__load_kernel(const char *vmlinux, symbol_filter_t filter,
-                      int use_modules)
+static int dso__load_kernel_sym(struct dso *self, struct map *map,
+                                symbol_filter_t filter)
 {
-        int err = -1;
-        struct dso *dso = dso__new(vmlinux);
-
-        if (dso == NULL)
-                return -1;
-
-        dso->short_name = "[kernel]";
-        kernel_map = map__new2(0, dso);
-        if (kernel_map == NULL)
-                goto out_delete_dso;
-
-        kernel_map->map_ip = kernel_map->unmap_ip = identity__map_ip;
-
-        if (use_modules && dsos__load_modules() < 0) {
-                pr_warning("Failed to load list of modules in use! "
-                           "Continuing...\n");
-                use_modules = 0;
-        }
-
-        if (vmlinux) {
-                err = dso__load_vmlinux(dso, kernel_map, vmlinux, filter);
-                if (err > 0 && use_modules) {
-                        int syms = dsos__load_modules_sym(filter);
-
-                        if (syms < 0)
-                                pr_warning("Failed to read module symbols!"
-                                           " Continuing...\n");
-                        else
-                                err += syms;
+        int err;
+        bool is_kallsyms;
+
+        if (vmlinux_path != NULL) {
+                int i;
+                pr_debug("Looking at the vmlinux_path (%d entries long)\n",
+                         vmlinux_path__nr_entries);
+                for (i = 0; i < vmlinux_path__nr_entries; ++i) {
+                        err = dso__load_vmlinux(self, map, vmlinux_path[i],
+                                                filter);
+                        if (err > 0) {
+                                pr_debug("Using %s for symbols\n",
+                                         vmlinux_path[i]);
+                                dso__set_long_name(self,
+                                                   strdup(vmlinux_path[i]));
+                                goto out_fixup;
+                        }
                 }
         }
 
-        if (err <= 0)
-                err = kernel_maps__load_kallsyms(filter, use_modules);
+        is_kallsyms = self->long_name[0] == '[';
+        if (is_kallsyms)
+                goto do_kallsyms;
+
+        err = dso__load_vmlinux(self, map, self->long_name, filter);
+        if (err <= 0) {
+                pr_info("The file %s cannot be used, "
+                        "trying to use /proc/kallsyms...", self->long_name);
+                sleep(2);
+do_kallsyms:
+                err = kernel_maps__load_kallsyms(filter);
+                if (err > 0 && !is_kallsyms)
+                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));
+        }
 
         if (err > 0) {
-                struct rb_node *node = rb_first(&dso->syms);
-                struct symbol *sym = rb_entry(node, struct symbol, rb_node);
-
-                kernel_map->start = sym->start;
-                node = rb_last(&dso->syms);
-                sym = rb_entry(node, struct symbol, rb_node);
-                kernel_map->end = sym->end;
-
-                dso->origin = DSO__ORIG_KERNEL;
-                kernel_maps__insert(kernel_map);
-                /*
-                 * Now that we have all sorted out, just set the ->end of all
-                 * maps:
-                 */
-                kernel_maps__fixup_end();
-                dsos__add(dso);
-
-                if (verbose)
-                        kernel_maps__fprintf(stderr);
+out_fixup:
+                map__fixup_start(map);
+                map__fixup_end(map);
         }
 
         return err;
-
-out_delete_dso:
-        dso__delete(dso);
-        return -1;
 }
 
 LIST_HEAD(dsos);
-struct dso      *vdso;
-
-const char      *vmlinux_name = "vmlinux";
-int             modules;
+struct dso *vdso;
 
 static void dsos__add(struct dso *dso)
 {
@@ -1463,18 +1485,117 @@ size_t dsos__fprintf_buildid(FILE *fp)
         return ret;
 }
 
-int load_kernel(symbol_filter_t filter)
+static int kernel_maps__create_kernel_map(const char *vmlinux_name)
 {
-        if (dsos__load_kernel(vmlinux_name, filter, modules) <= 0)
+        struct dso *kernel = dso__new(vmlinux_name ?: "[kernel.kallsyms]");
+
+        if (kernel == NULL)
                 return -1;
 
+        kernel_map = map__new2(0, kernel);
+        if (kernel_map == NULL)
+                goto out_delete_kernel_dso;
+
+        kernel_map->map_ip       = kernel_map->unmap_ip = identity__map_ip;
+        kernel->short_name       = "[kernel]";
+        kernel->kernel           = 1;
+
         vdso = dso__new("[vdso]");
-        if (!vdso)
-                return -1;
+        if (vdso == NULL)
+                goto out_delete_kernel_map;
+
+        if (sysfs__read_build_id("/sys/kernel/notes", kernel->build_id,
+                                 sizeof(kernel->build_id)) == 0)
+                kernel->has_build_id = true;
 
+        kernel_maps__insert(kernel_map);
+        dsos__add(kernel);
         dsos__add(vdso);
 
         return 0;
+
+out_delete_kernel_map:
+        map__delete(kernel_map);
+        kernel_map = NULL;
+out_delete_kernel_dso:
+        dso__delete(kernel);
+        return -1;
+}
+
+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;
+        }
+
+        free(vmlinux_path);
+        vmlinux_path = NULL;
+}
+
+static int vmlinux_path__init(void)
+{
+        struct utsname uts;
+        char bf[PATH_MAX];
+
+        if (uname(&uts) < 0)
+                return -1;
+
+        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_fail:
+        vmlinux_path__exit();
+        return -1;
+}
+
+int kernel_maps__init(const char *vmlinux_name, bool try_vmlinux_path,
+                      bool use_modules)
+{
+        if (try_vmlinux_path && vmlinux_path__init() < 0)
+                return -1;
+
+        if (kernel_maps__create_kernel_map(vmlinux_name) < 0) {
+                vmlinux_path__exit();
+                return -1;
+        }
+
+        if (use_modules && kernel_maps__create_module_maps() < 0)
+                pr_debug("Failed to load list of modules in use, "
+                         "continuing...\n");
+        /*
+         * Now that we have all the maps created, just set the ->end of them:
+         */
+        kernel_maps__fixup_end();
+        return 0;
 }
 
 void symbol__init(unsigned int priv_size)