1 files changed, 317 insertions, 65 deletions

diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index f3d4151e46a1..e782e7db16c5 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -28,6 +28,8 @@ 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);
+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;
 
@@ -186,6 +188,7 @@ struct dso *dso__new(const char *name)
                 self->loaded = 0;
                 self->sorted_by_name = 0;
                 self->has_build_id = 0;
+                self->kernel = DSO_TYPE_USER;
         }
 
         return self;
@@ -402,12 +405,9 @@ int kallsyms__parse(const char *filename, void *arg,
                 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);
@@ -459,6 +459,7 @@ static int map__process_kallsym_symbol(void *arg, const char *name,
          * map__split_kallsyms, when we have split the maps per module
          */
         symbols__insert(root, sym);
+
         return 0;
 }
 
@@ -483,6 +484,7 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
                                symbol_filter_t filter)
 {
         struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct kernel_info *kerninfo = kmaps->this_kerninfo;
         struct map *curr_map = map;
         struct symbol *pos;
         int count = 0;
@@ -504,15 +506,33 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
                         *module++ = '\0';
 
                         if (strcmp(curr_map->dso->short_name, module)) {
-                                curr_map = map_groups__find_by_name(kmaps, map->type, module);
+                                if (curr_map != map &&
+                                        self->kernel == DSO_TYPE_GUEST_KERNEL &&
+                                        is_default_guest(kerninfo)) {
+                                        /*
+                                         * 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("/proc/{kallsyms,modules} "
+                                        pr_err("%s/proc/{kallsyms,modules} "
                                                  "inconsistency while looking "
-                                                 "for \"%s\" module!\n", module);
-                                        return -1;
+                                                 "for \"%s\" module!\n",
+                                                 kerninfo->root_dir, module);
+                                        curr_map = map;
+                                        goto discard_symbol;
                                 }
 
-                                if (curr_map->dso->loaded)
+                                if (curr_map->dso->loaded &&
+                                        !is_default_guest(kmaps->this_kerninfo))
                                         goto discard_symbol;
                         }
                         /*
@@ -525,13 +545,21 @@ static int dso__split_kallsyms(struct dso *self, struct 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;
 
+                        dso->kernel = self->kernel;
+
                         curr_map = map__new2(pos->start, dso, map->type);
                         if (curr_map == NULL) {
                                 dso__delete(dso);
@@ -555,6 +583,12 @@ discard_symbol:		rb_erase(&pos->rb_node, root);
                 }
         }
 
+        if (curr_map != map &&
+            self->kernel == DSO_TYPE_GUEST_KERNEL &&
+            is_default_guest(kmaps->this_kerninfo)) {
+                dso__set_loaded(curr_map->dso, curr_map->type);
+        }
+
         return count;
 }
 
@@ -565,7 +599,10 @@ int dso__load_kallsyms(struct dso *self, const char *filename,
                 return -1;
 
         symbols__fixup_end(&self->symbols[map->type]);
-        self->origin = DSO__ORIG_KERNEL;
+        if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+                self->origin = DSO__ORIG_GUEST_KERNEL;
+        else
+                self->origin = DSO__ORIG_KERNEL;
 
         return dso__split_kallsyms(self, map, filter);
 }
@@ -952,7 +989,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 (!self->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",
@@ -984,7 +1021,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
 
                 section_name = elf_sec__name(&shdr, secstrs);
 
-                if (self->kernel || kmodule) {
+                if (self->kernel != DSO_TYPE_USER || kmodule) {
                         char dso_name[PATH_MAX];
 
                         if (strcmp(section_name,
@@ -1011,6 +1048,7 @@ 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_dso->kernel = self->kernel;
                                 curr_map = map__new2(start, curr_dso,
                                                      map->type);
                                 if (curr_map == NULL) {
@@ -1021,7 +1059,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                                 curr_map->unmap_ip = identity__map_ip;
                                 curr_dso->origin = self->origin;
                                 map_groups__insert(kmap->kmaps, curr_map);
-                                dsos__add(&dsos__kernel, curr_dso);
+                                dsos__add(&self->node, curr_dso);
                                 dso__set_loaded(curr_dso, map->type);
                         } else
                                 curr_dso = curr_map->dso;
@@ -1083,7 +1121,7 @@ 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;
 }
 
-static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
+bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 {
         bool have_build_id = false;
         struct dso *pos;
@@ -1101,13 +1139,6 @@ static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
         return have_build_id;
 }
 
-bool dsos__read_build_ids(bool with_hits)
-{
-        bool kbuildids = __dsos__read_build_ids(&dsos__kernel, with_hits),
-             ubuildids = __dsos__read_build_ids(&dsos__user, with_hits);
-        return kbuildids || ubuildids;
-}
-
 /*
  * Align offset to 4 bytes as needed for note name and descriptor data.
  */
@@ -1242,6 +1273,8 @@ char dso__symtab_origin(const struct dso *self)
                 [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)
@@ -1257,11 +1290,20 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
         int ret = -1;
         int fd;
+        struct kernel_info *kerninfo;
+        const char *root_dir;
 
         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->this_kerninfo)
+                kerninfo = map->groups->this_kerninfo;
+        else
+                kerninfo = NULL;
 
         name = malloc(size);
         if (!name)
@@ -1315,6 +1357,13 @@ more:
                 case DSO__ORIG_DSO:
                         snprintf(name, size, "%s", self->long_name);
                         break;
+                case DSO__ORIG_GUEST_KMODULE:
+                        if (map->groups && map->groups->this_kerninfo)
+                                root_dir = map->groups->this_kerninfo->root_dir;
+                        else
+                                root_dir = "";
+                        snprintf(name, size, "%s%s", root_dir, self->long_name);
+                        break;
 
                 default:
                         goto out;
@@ -1368,7 +1417,8 @@ struct map *map_groups__find_by_name(struct map_groups *self,
         return NULL;
 }
 
-static int dso__kernel_module_get_build_id(struct dso *self)
+static int dso__kernel_module_get_build_id(struct dso *self,
+                                const char *root_dir)
 {
         char filename[PATH_MAX];
         /*
@@ -1378,8 +1428,8 @@ static int dso__kernel_module_get_build_id(struct dso *self)
         const char *name = self->short_name + 1;
 
         snprintf(filename, sizeof(filename),
-                 "/sys/module/%.*s/notes/.note.gnu.build-id",
-                 (int)strlen(name - 1), name);
+                 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
+                 root_dir, (int)strlen(name) - 1, name);
 
         if (sysfs__read_build_id(filename, self->build_id,
                                  sizeof(self->build_id)) == 0)
@@ -1388,7 +1438,8 @@ static int dso__kernel_module_get_build_id(struct dso *self)
         return 0;
 }
 
-static int map_groups__set_modules_path_dir(struct map_groups *self, char *dir_name)
+static int map_groups__set_modules_path_dir(struct map_groups *self,
+                                const char *dir_name)
 {
         struct dirent *dent;
         DIR *dir = opendir(dir_name);
@@ -1400,8 +1451,14 @@ static int map_groups__set_modules_path_dir(struct map_groups *self, char *dir_n
 
         while ((dent = readdir(dir)) != NULL) {
                 char path[PATH_MAX];
+                struct stat st;
+
+                /*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 (dent->d_type == DT_DIR) {
+                if (S_ISDIR(st.st_mode)) {
                         if (!strcmp(dent->d_name, ".") ||
                             !strcmp(dent->d_name, ".."))
                                 continue;
@@ -1433,7 +1490,7 @@ static int map_groups__set_modules_path_dir(struct map_groups *self, char *dir_n
                         if (long_name == NULL)
                                 goto failure;
                         dso__set_long_name(map->dso, long_name);
-                        dso__kernel_module_get_build_id(map->dso);
+                        dso__kernel_module_get_build_id(map->dso, "");
                 }
         }
 
@@ -1443,16 +1500,46 @@ failure:
         return -1;
 }
 
-static int map_groups__set_modules_path(struct map_groups *self)
+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 map_groups__set_modules_path(struct map_groups *self,
+                                const char *root_dir)
+{
+        char *version;
         char modules_path[PATH_MAX];
 
-        if (uname(&uts) < 0)
+        version = get_kernel_version(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",
+                 root_dir, version);
+        free(version);
 
         return map_groups__set_modules_path_dir(self, modules_path);
 }
@@ -1477,11 +1564,13 @@ static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
 }
 
 struct map *map_groups__new_module(struct map_groups *self, u64 start,
-                                   const char *filename)
+                                const char *filename,
+                                struct kernel_info *kerninfo)
 {
         struct map *map;
-        struct dso *dso = __dsos__findnew(&dsos__kernel, filename);
+        struct dso *dso;
 
+        dso = __dsos__findnew(&kerninfo->dsos__kernel, filename);
         if (dso == NULL)
                 return NULL;
 
@@ -1489,21 +1578,37 @@ struct map *map_groups__new_module(struct map_groups *self, u64 start,
         if (map == NULL)
                 return NULL;
 
-        dso->origin = DSO__ORIG_KMODULE;
+        if (is_host_kernel(kerninfo))
+                dso->origin = DSO__ORIG_KMODULE;
+        else
+                dso->origin = DSO__ORIG_GUEST_KMODULE;
         map_groups__insert(self, map);
         return map;
 }
 
-static int map_groups__create_modules(struct map_groups *self)
+static int map_groups__create_modules(struct kernel_info *kerninfo)
 {
         char *line = NULL;
         size_t n;
-        FILE *file = fopen("/proc/modules", "r");
+        FILE *file;
         struct map *map;
+        const char *root_dir;
+        const char *modules;
+        char path[PATH_MAX];
+
+        if (is_default_guest(kerninfo))
+                modules = symbol_conf.default_guest_modules;
+        else {
+                sprintf(path, "%s/proc/modules", kerninfo->root_dir);
+                modules = path;
+        }
 
+        file = fopen(modules, "r");
         if (file == NULL)
                 return -1;
 
+        root_dir = kerninfo->root_dir;
+
         while (!feof(file)) {
                 char name[PATH_MAX];
                 u64 start;
@@ -1532,16 +1637,17 @@ static int map_groups__create_modules(struct map_groups *self)
                 *sep = '\0';
 
                 snprintf(name, sizeof(name), "[%s]", line);
-                map = map_groups__new_module(self, start, name);
+                map = map_groups__new_module(&kerninfo->kmaps,
+                                start, name, kerninfo);
                 if (map == NULL)
                         goto out_delete_line;
-                dso__kernel_module_get_build_id(map->dso);
+                dso__kernel_module_get_build_id(map->dso, root_dir);
         }
 
         free(line);
         fclose(file);
 
-        return map_groups__set_modules_path(self);
+        return map_groups__set_modules_path(&kerninfo->kmaps, root_dir);
 
 out_delete_line:
         free(line);
@@ -1708,8 +1814,57 @@ out_fixup:
         return err;
 }
 
-LIST_HEAD(dsos__user);
-LIST_HEAD(dsos__kernel);
+static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
+                                symbol_filter_t filter)
+{
+        int err;
+        const char *kallsyms_filename = NULL;
+        struct kernel_info *kerninfo;
+        char path[PATH_MAX];
+
+        if (!map->groups) {
+                pr_debug("Guest kernel map hasn't the point to groups\n");
+                return -1;
+        }
+        kerninfo = map->groups->this_kerninfo;
+
+        if (is_default_guest(kerninfo)) {
+                /*
+                 * 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", kerninfo->root_dir);
+                kallsyms_filename = path;
+        }
+
+        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) {
+                        kern_mmap_name(kerninfo, path);
+                        dso__set_long_name(self,
+                                strdup(path));
+                }
+                map__fixup_start(map);
+                map__fixup_end(map);
+        }
+
+        return err;
+}
 
 static void dsos__add(struct list_head *head, struct dso *dso)
 {
@@ -1752,10 +1907,16 @@ static void __dsos__fprintf(struct list_head *head, FILE *fp)
         }
 }
 
-void dsos__fprintf(FILE *fp)
+void dsos__fprintf(struct rb_root *kerninfo_root, FILE *fp)
 {
-        __dsos__fprintf(&dsos__kernel, fp);
-        __dsos__fprintf(&dsos__user, fp);
+        struct rb_node *nd;
+
+        for (nd = rb_first(kerninfo_root); nd; nd = rb_next(nd)) {
+                struct kernel_info *pos = rb_entry(nd, struct kernel_info,
+                                rb_node);
+                __dsos__fprintf(&pos->dsos__kernel, fp);
+                __dsos__fprintf(&pos->dsos__user, fp);
+        }
 }
 
 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
@@ -1773,10 +1934,21 @@ static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
         return ret;
 }
 
-size_t dsos__fprintf_buildid(FILE *fp, bool with_hits)
+size_t dsos__fprintf_buildid(struct rb_root *kerninfo_root,
+                FILE *fp, bool with_hits)
 {
-        return (__dsos__fprintf_buildid(&dsos__kernel, fp, with_hits) +
-                __dsos__fprintf_buildid(&dsos__user, fp, with_hits));
+        struct rb_node *nd;
+        size_t ret = 0;
+
+        for (nd = rb_first(kerninfo_root); nd; nd = rb_next(nd)) {
+                struct kernel_info *pos = rb_entry(nd, struct kernel_info,
+                                rb_node);
+                ret += __dsos__fprintf_buildid(&pos->dsos__kernel,
+                                        fp, with_hits);
+                ret += __dsos__fprintf_buildid(&pos->dsos__user,
+                                        fp, with_hits);
+        }
+        return ret;
 }
 
 struct dso *dso__new_kernel(const char *name)
@@ -1785,28 +1957,59 @@ struct dso *dso__new_kernel(const char *name)
 
         if (self != NULL) {
                 dso__set_short_name(self, "[kernel]");
-                self->kernel     = 1;
+                self->kernel = DSO_TYPE_KERNEL;
+        }
+
+        return self;
+}
+
+static struct dso *dso__new_guest_kernel(struct kernel_info *kerninfo,
+                                        const char *name)
+{
+        char buff[PATH_MAX];
+        struct dso *self;
+
+        kern_mmap_name(kerninfo, buff);
+        self = dso__new(name ?: buff);
+        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)
+void dso__read_running_kernel_build_id(struct dso *self,
+                        struct kernel_info *kerninfo)
 {
-        if (sysfs__read_build_id("/sys/kernel/notes", self->build_id,
+        char path[PATH_MAX];
+
+        if (is_default_guest(kerninfo))
+                return;
+        sprintf(path, "%s/sys/kernel/notes", kerninfo->root_dir);
+        if (sysfs__read_build_id(path, self->build_id,
                                  sizeof(self->build_id)) == 0)
                 self->has_build_id = true;
 }
 
-static struct dso *dsos__create_kernel(const char *vmlinux)
+static struct dso *dsos__create_kernel(struct kernel_info *kerninfo)
 {
-        struct dso *kernel = dso__new_kernel(vmlinux);
+        const char *vmlinux_name = NULL;
+        struct dso *kernel;
 
-        if (kernel != NULL) {
-                dso__read_running_kernel_build_id(kernel);
-                dsos__add(&dsos__kernel, kernel);
+        if (is_host_kernel(kerninfo)) {
+                vmlinux_name = symbol_conf.vmlinux_name;
+                kernel = dso__new_kernel(vmlinux_name);
+        } else {
+                if (is_default_guest(kerninfo))
+                        vmlinux_name = symbol_conf.default_guest_vmlinux_name;
+                kernel = dso__new_guest_kernel(kerninfo, vmlinux_name);
         }
 
+        if (kernel != NULL) {
+                dso__read_running_kernel_build_id(kernel, kerninfo);
+                dsos__add(&kerninfo->dsos__kernel, kernel);
+        }
         return kernel;
 }
 
@@ -1950,23 +2153,29 @@ out_free_comm_list:
         return -1;
 }
 
-int map_groups__create_kernel_maps(struct map_groups *self,
-                                   struct map *vmlinux_maps[MAP__NR_TYPES])
+int map_groups__create_kernel_maps(struct rb_root *kerninfo_root, pid_t pid)
 {
-        struct dso *kernel = dsos__create_kernel(symbol_conf.vmlinux_name);
+        struct kernel_info *kerninfo;
+        struct dso *kernel;
 
+        kerninfo = kerninfo__findnew(kerninfo_root, pid);
+        if (kerninfo == NULL)
+                return -1;
+        kernel = dsos__create_kernel(kerninfo);
         if (kernel == NULL)
                 return -1;
 
-        if (__map_groups__create_kernel_maps(self, vmlinux_maps, kernel) < 0)
+        if (__map_groups__create_kernel_maps(&kerninfo->kmaps,
+                        kerninfo->vmlinux_maps, kernel) < 0)
                 return -1;
 
-        if (symbol_conf.use_modules && map_groups__create_modules(self) < 0)
+        if (symbol_conf.use_modules &&
+                map_groups__create_modules(kerninfo) < 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);
+        map_groups__fixup_end(&kerninfo->kmaps);
         return 0;
 }
 
@@ -2012,3 +2221,46 @@ char *strxfrchar(char *s, char from, char to)
 
         return s;
 }
+
+int map_groups__create_guest_kernel_maps(struct rb_root *kerninfo_root)
+{
+        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) {
+                map_groups__create_kernel_maps(kerninfo_root,
+                                        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;
+                        }
+                        map_groups__create_kernel_maps(kerninfo_root,
+                                                        pid);
+                }
+failure:
+                free(namelist);
+        }
+
+        return ret;
+}