xiaomi-sm8450/android_kernel_xiaomi_sm8450
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf symbols: Do lazy symtab loading for the kernel & modules too

Browse Source 
Just like we do with the other DSOs. This also simplifies the
kernel_maps setup process, now all that the tools need to do is
to call kernel_maps__init and the maps for the modules and
kernel will be created, then, later, when
kernel_maps__find_symbol() is used, it will also call
maps__find_symbol that already checks if the symtab was loaded,
loading it if needed.

Now if one does 'perf top --hide_kernel_symbols' we won't pay
the price of loading the (many) symbols in /proc/kallsyms or
vmlinux.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1258757489-5978-4-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Arnaldo Carvalho de Melo
2009-11-20 20:51:27 -02:00
committed by Ingo Molnar
parent 78075caad9
commit c338aee853
10 changed files with 109 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
tools/perf/util/symbol.c
View File

@@ -27,6 +27,8 @@ 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 struct rb_root kernel_maps;
@@ -69,12 +71,6 @@ static void kernel_maps__fixup_end(void)
curr = rb_entry(nd, struct map, rb_node);
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;
}
}
static struct symbol *symbol__new(u64 start, u64 len, const char *name)
@@ -324,7 +320,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;
@@ -340,9 +336,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)) {
@@ -382,7 +375,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 {
@@ -398,17 +390,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;
@@ -1042,13 +1035,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);
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;
@@ -1139,7 +1136,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);
@@ -1148,7 +1146,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;
@@ -1168,28 +1166,9 @@ 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) {
@@ -1207,14 +1186,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"))
@@ -1234,36 +1211,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;
}
int dsos__load_modules_sym(symbol_filter_t filter)
static int dsos__set_modules_path(void)
{
struct utsname uts;
char modules_path[PATH_MAX];
@@ -1274,7 +1231,7 @@ 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);
}
/*
@@ -1296,7 +1253,7 @@ static struct map *map__new2(u64 start, struct dso *dso)
return self;
}
int dsos__load_modules(void)
static int kernel_maps__create_module_maps(void)
{
char *line = NULL;
size_t n;
@@ -1360,7 +1317,13 @@ int dsos__load_modules(void)
free(line);
fclose(file);
return 0;
/*
* Now that we have all sorted out, just set the ->end of all
* maps:
*/
kernel_maps__fixup_end();
return dsos__set_modules_path();
out_delete_line:
free(line);
@@ -1385,40 +1348,17 @@ static int dso__load_vmlinux(struct dso *self, struct map *map,
return err;
}
int dso__load_kernel_sym(struct dso *self, 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;
int err = dso__load_vmlinux(self, map, self->name, filter);
kernel_map = map__new2(0, self);
if (kernel_map == NULL)
return -1;
kernel_map->map_ip = kernel_map->unmap_ip = identity__map_ip;
err = dso__load_vmlinux(self, kernel_map, self->name, filter);
if (err <= 0)
err = kernel_maps__load_kallsyms(filter, use_modules);
err = kernel_maps__load_kallsyms(filter);
if (err > 0) {
struct rb_node *node = rb_first(&self->syms);
struct symbol *sym = rb_entry(node, struct symbol, rb_node);
kernel_map->start = sym->start;
node = rb_last(&self->syms);
sym = rb_entry(node, struct symbol, rb_node);
kernel_map->end = sym->end;
self->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();
if (verbose)
kernel_maps__fprintf(stderr);
map__fixup_start(map);
map__fixup_end(map);
}
return err;
@@ -1479,46 +1419,51 @@ size_t dsos__fprintf_buildid(FILE *fp)
return ret;
}
struct dso *dsos__load_kernel(void)
static int kernel_maps__create_kernel_map(void)
{
struct dso *kernel = dso__new(vmlinux_name);
if (kernel == NULL)
return 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 NULL;
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 kernel;
return 0;
out_delete_kernel_map:
map__delete(kernel_map);
kernel_map = NULL;
out_delete_kernel_dso:
dso__delete(kernel);
return -1;
}
int load_kernel(symbol_filter_t filter, bool use_modules)
int kernel_maps__init(bool use_modules)
{
struct dso *kernel = dsos__load_kernel();
if (kernel == NULL)
if (kernel_maps__create_kernel_map() < 0)
return -1;
if (use_modules) {
if (dsos__load_modules() < 0)
pr_warning("Failed to load list of modules in use, "
"continuing...\n");
else if (dsos__load_modules_sym(filter) < 0)
pr_warning("Failed to read module symbols, "
"continuing...\n");
}
if (dso__load_kernel_sym(kernel, filter, use_modules) < 0)
pr_warning("Failed to read kernel symbols, continuing...\n");
if (use_modules && kernel_maps__create_module_maps() < 0)
pr_warning("Failed to load list of modules in use, "
"continuing...\n");
return 0;
}