Commit 4e06255f authored by Arnaldo Carvalho de Melo's avatar Arnaldo Carvalho de Melo Committed by Ingo Molnar
Browse files

perf symbols: Make the kallsyms loading routines part of the dso class 



So that the kallsyms loading routines are the direct counterpart
of the vmlinux loading ones, i.e. dso__load_kallsyms is the
counterpart of dso__load_vmlinux.

In the process make them also use the symbols rb tree indexed by
map->type, paving the way for supporting other types of symtabs,
such as the next one to be supported: variables.

This also allowed removal of yet another global variable:
kernel_map__functions.

Signed-off-by: default avatarArnaldo 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: <1259346563-12568-7-git-send-email-acme@infradead.org>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent 6a4694a4

tools/perf/util/symbol.c

+38 −39
Original line number Original line Diff line number Diff line
@@ -37,7 +37,6 @@ static int dso__load_kernel_sym(struct dso *self, struct map *map, 
unsigned int symbol__priv_size;

unsigned int symbol__priv_size;

static int vmlinux_path__nr_entries;

static int vmlinux_path__nr_entries;

static char **vmlinux_path;

static char **vmlinux_path;

static struct map *kernel_map__functions;





static struct symbol_conf symbol_conf__defaults = {

static struct symbol_conf symbol_conf__defaults = {

	.use_modules	  = true,

	.use_modules	  = true,
@@ -296,10 +295,11 @@ size_t dso__fprintf(struct dso *self, FILE *fp) 
 * so that we can in the next step set the symbol ->end address and then

 * so that we can in the next step set the symbol ->end address and then

 * call kernel_maps__split_kallsyms.

 * call kernel_maps__split_kallsyms.

 */

 */

static int kernel_maps__load_all_kallsyms(void)

static int dso__load_all_kallsyms(struct dso *self, struct map *map)

{

{

	char *line = NULL;

	char *line = NULL;

	size_t n;

	size_t n;

	struct rb_root *root = &self->symbols[map->type];

	FILE *file = fopen("/proc/kallsyms", "r");

	FILE *file = fopen("/proc/kallsyms", "r");





	if (file == NULL)

	if (file == NULL)
@@ -342,13 +342,11 @@ static int kernel_maps__load_all_kallsyms(void) 




		if (sym == NULL)

		if (sym == NULL)

			goto out_delete_line;

			goto out_delete_line;



		/*

		/*

		 * We will pass the symbols to the filter later, in

		 * We will pass the symbols to the filter later, in

		 * kernel_maps__split_kallsyms, when we have split the

		 * map__split_kallsyms, when we have split the maps per module

		 * maps per module

		 */

		 */

		symbols__insert(&kernel_map__functions->dso->symbols[MAP__FUNCTION], sym);

		symbols__insert(root, sym);

	}

	}





	free(line);

	free(line);
@@ -367,12 +365,14 @@ static int kernel_maps__load_all_kallsyms(void) 
 * kernel range is broken in several maps, named [kernel].N, as we don't have

 * kernel range is broken in several maps, named [kernel].N, as we don't have

 * the original ELF section names vmlinux 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__functions;

	struct map *curr_map = map;

	struct symbol *pos;

	struct symbol *pos;

	int count = 0;

	int count = 0;

	struct rb_node *next = rb_first(&kernel_map__functions->dso->symbols[map->type]);

	struct rb_root *root = &self->symbols[map->type];

	struct rb_node *next = rb_first(root);

	int kernel_range = 0;

	int kernel_range = 0;





	while (next) {

	while (next) {
@@ -385,9 +385,9 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter) 
		if (module) {

		if (module) {

			*module++ = '\0';

			*module++ = '\0';





			if (strcmp(map->dso->name, module)) {

			if (strcmp(self->name, module)) {

				map = kernel_maps__find_by_dso_name(module);

				curr_map = kernel_maps__find_by_dso_name(module);

				if (!map) {

				if (curr_map == NULL) {

					pr_err("/proc/{kallsyms,modules} "

					pr_err("/proc/{kallsyms,modules} "

					       "inconsistency!\n");

					       "inconsistency!\n");

					return -1;

					return -1;
@@ -397,9 +397,9 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter) 
			 * So that we look just like we get from .ko files,

			 * So that we look just like we get from .ko files,

			 * i.e. not prelinked, relative to map->start.

			 * i.e. not prelinked, relative to map->start.

			 */

			 */

			pos->start = map->map_ip(map, pos->start);

			pos->start = curr_map->map_ip(curr_map, pos->start);

			pos->end   = map->map_ip(map, pos->end);

			pos->end   = curr_map->map_ip(curr_map, pos->end);

		} else if (map != kernel_map__functions) {

		} else if (curr_map != map) {

			char dso_name[PATH_MAX];

			char dso_name[PATH_MAX];

			struct dso *dso;

			struct dso *dso;
@@ -410,25 +410,24 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter) 
			if (dso == NULL)

			if (dso == NULL)

				return -1;

				return -1;





			map = map__new2(pos->start, dso, MAP__FUNCTION);

			curr_map = map__new2(pos->start, dso, map->type);

			if (map == NULL) {

			if (map == NULL) {

				dso__delete(dso);

				dso__delete(dso);

				return -1;

				return -1;

			}

			}





			map->map_ip = map->unmap_ip = identity__map_ip;

			curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;

			kernel_maps__insert(map);

			kernel_maps__insert(curr_map);

			++kernel_range;

			++kernel_range;

		}

		}





		if (filter && filter(map, pos)) {

		if (filter && filter(curr_map, pos)) {

			rb_erase(&pos->rb_node, &kernel_map__functions->dso->symbols[map->type]);

			rb_erase(&pos->rb_node, root);

			symbol__delete(pos);

			symbol__delete(pos);

		} else {

		} else {

			if (map != kernel_map__functions) {

			if (curr_map != map) {

				rb_erase(&pos->rb_node,

				rb_erase(&pos->rb_node, root);

					 &kernel_map__functions->dso->symbols[map->type]);

				symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);

				symbols__insert(&map->dso->symbols[map->type], pos);

			}

			}

			count++;

			count++;

		}

		}
@@ -438,15 +437,16 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter) 
}

}









static int kernel_maps__load_kallsyms(symbol_filter_t filter)

static int dso__load_kallsyms(struct dso *self, struct map *map,

			      symbol_filter_t filter)

{

{

	if (kernel_maps__load_all_kallsyms())

	if (dso__load_all_kallsyms(self, map) < 0)

		return -1;

		return -1;





	symbols__fixup_end(&kernel_map__functions->dso->symbols[MAP__FUNCTION]);

	symbols__fixup_end(&self->symbols[map->type]);

	kernel_map__functions->dso->origin = DSO__ORIG_KERNEL;

	self->origin = DSO__ORIG_KERNEL;





	return kernel_maps__split_kallsyms(filter);

	return dso__split_kallsyms(self, map, filter);

}

}





size_t kernel_maps__fprintf(FILE *fp)

size_t kernel_maps__fprintf(FILE *fp)
@@ -1457,9 +1457,8 @@ static int dso__load_kernel_sym(struct dso *self, struct map *map, 
	if (err <= 0) {

	if (err <= 0) {

		pr_info("The file %s cannot be used, "

		pr_info("The file %s cannot be used, "

			"trying to use /proc/kallsyms...", self->long_name);

			"trying to use /proc/kallsyms...", self->long_name);

		sleep(2);

do_kallsyms:

do_kallsyms:

		err = kernel_maps__load_kallsyms(filter);

		err = dso__load_kallsyms(self, map, filter);

		if (err > 0 && !is_kallsyms)

		if (err > 0 && !is_kallsyms)

                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));

                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));

	}

	}
@@ -1541,16 +1540,17 @@ size_t dsos__fprintf_buildid(FILE *fp) 




static int kernel_maps__create_kernel_map(const struct symbol_conf *conf)

static int kernel_maps__create_kernel_map(const struct symbol_conf *conf)

{

{

	struct map *kmap;

	struct dso *kernel = dso__new(conf->vmlinux_name ?: "[kernel.kallsyms]");

	struct dso *kernel = dso__new(conf->vmlinux_name ?: "[kernel.kallsyms]");





	if (kernel == NULL)

	if (kernel == NULL)

		return -1;

		return -1;





	kernel_map__functions = map__new2(0, kernel, MAP__FUNCTION);

	kmap = map__new2(0, kernel, MAP__FUNCTION);

	if (kernel_map__functions == NULL)

	if (kmap == NULL)

		goto out_delete_kernel_dso;

		goto out_delete_kernel_dso;





	kernel_map__functions->map_ip	 = kernel_map__functions->unmap_ip = identity__map_ip;

	kmap->map_ip	   = kmap->unmap_ip = identity__map_ip;

	kernel->short_name = "[kernel]";

	kernel->short_name = "[kernel]";

	kernel->kernel	   = 1;

	kernel->kernel	   = 1;
@@ -1563,15 +1563,14 @@ static int kernel_maps__create_kernel_map(const struct symbol_conf *conf) 
				 sizeof(kernel->build_id)) == 0)

				 sizeof(kernel->build_id)) == 0)

		kernel->has_build_id = true;

		kernel->has_build_id = true;





	kernel_maps__insert(kernel_map__functions);

	kernel_maps__insert(kmap);

	dsos__add(&dsos__kernel, kernel);

	dsos__add(&dsos__kernel, kernel);

	dsos__add(&dsos__user, vdso);

	dsos__add(&dsos__user, vdso);





	return 0;

	return 0;





out_delete_kernel_map:

out_delete_kernel_map:

	map__delete(kernel_map__functions);

	map__delete(kmap);

	kernel_map__functions = NULL;

out_delete_kernel_dso:

out_delete_kernel_dso:

	dso__delete(kernel);

	dso__delete(kernel);

	return -1;

	return -1;