1#define _GNU_SOURCE
   2#include <ctype.h>
   3#include <dirent.h>
   4#include <errno.h>
   5#include <libgen.h>
   6#include <stdlib.h>
   7#include <stdio.h>
   8#include <string.h>
 
 
 
 
 
   9#include <sys/types.h>
  10#include <sys/stat.h>
  11#include <sys/param.h>
  12#include <fcntl.h>
  13#include <unistd.h>
  14#include <inttypes.h>
 
  15#include "build-id.h"
 
 
 
  16#include "debug.h"
 
 
 
  17#include "symbol.h"
 
 
 
  18#include "strlist.h"
 
 
 
 
 
 
  19
  20#include <libelf.h>
  21#include <gelf.h>
  22#include <elf.h>
  23#include <limits.h>
 
  24#include <sys/utsname.h>
  25
  26#ifndef KSYM_NAME_LEN
  27#define KSYM_NAME_LEN 128
  28#endif
  29
  30#ifndef NT_GNU_BUILD_ID
  31#define NT_GNU_BUILD_ID 3
  32#endif
  33
  34static bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
  35static int elf_read_build_id(Elf *elf, void *bf, size_t size);
  36static void dsos__add(struct list_head *head, struct dso *dso);
  37static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
  38static int dso__load_kernel_sym(struct dso *dso, struct map *map,
  39				symbol_filter_t filter);
  40static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
  41			symbol_filter_t filter);
  42static int vmlinux_path__nr_entries;
  43static char **vmlinux_path;
  44
  45struct symbol_conf symbol_conf = {
  46	.exclude_other	  = true,
  47	.use_modules	  = true,
  48	.try_vmlinux_path = true,
  49	.symfs            = "",
 
 
 
 
 
 
 
 
  50};
  51
  52int dso__name_len(const struct dso *dso)
  53{
  54	if (verbose)
  55		return dso->long_name_len;
  56
  57	return dso->short_name_len;
  58}
  59
  60bool dso__loaded(const struct dso *dso, enum map_type type)
  61{
  62	return dso->loaded & (1 << type);
  63}
  64
  65bool dso__sorted_by_name(const struct dso *dso, enum map_type type)
  66{
  67	return dso->sorted_by_name & (1 << type);
  68}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  69
  70static void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
  71{
  72	dso->sorted_by_name |= (1 << type);
  73}
  74
  75bool symbol_type__is_a(char symbol_type, enum map_type map_type)
  76{
  77	symbol_type = toupper(symbol_type);
  78
  79	switch (map_type) {
  80	case MAP__FUNCTION:
  81		return symbol_type == 'T' || symbol_type == 'W';
  82	case MAP__VARIABLE:
  83		return symbol_type == 'D';
  84	default:
  85		return false;
  86	}
  87}
  88
  89static int prefix_underscores_count(const char *str)
  90{
  91	const char *tail = str;
  92
  93	while (*tail == '_')
  94		tail++;
  95
  96	return tail - str;
  97}
  98
  99#define SYMBOL_A 0
 100#define SYMBOL_B 1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 101
 102static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
 103{
 104	s64 a;
 105	s64 b;
 
 106
 107	/* Prefer a symbol with non zero length */
 108	a = syma->end - syma->start;
 109	b = symb->end - symb->start;
 110	if ((b == 0) && (a > 0))
 111		return SYMBOL_A;
 112	else if ((a == 0) && (b > 0))
 113		return SYMBOL_B;
 114
 115	/* Prefer a non weak symbol over a weak one */
 116	a = syma->binding == STB_WEAK;
 117	b = symb->binding == STB_WEAK;
 118	if (b && !a)
 119		return SYMBOL_A;
 120	if (a && !b)
 121		return SYMBOL_B;
 122
 123	/* Prefer a global symbol over a non global one */
 124	a = syma->binding == STB_GLOBAL;
 125	b = symb->binding == STB_GLOBAL;
 126	if (a && !b)
 127		return SYMBOL_A;
 128	if (b && !a)
 129		return SYMBOL_B;
 130
 131	/* Prefer a symbol with less underscores */
 132	a = prefix_underscores_count(syma->name);
 133	b = prefix_underscores_count(symb->name);
 134	if (b > a)
 135		return SYMBOL_A;
 136	else if (a > b)
 137		return SYMBOL_B;
 138
 139	/* If all else fails, choose the symbol with the longest name */
 140	if (strlen(syma->name) >= strlen(symb->name))
 
 
 141		return SYMBOL_A;
 142	else
 143		return SYMBOL_B;
 
 
 144}
 145
 146static void symbols__fixup_duplicate(struct rb_root *symbols)
 147{
 148	struct rb_node *nd;
 149	struct symbol *curr, *next;
 150
 151	nd = rb_first(symbols);
 
 
 
 152
 153	while (nd) {
 154		curr = rb_entry(nd, struct symbol, rb_node);
 155again:
 156		nd = rb_next(&curr->rb_node);
 157		next = rb_entry(nd, struct symbol, rb_node);
 158
 159		if (!nd)
 160			break;
 161
 
 162		if (curr->start != next->start)
 163			continue;
 164
 165		if (choose_best_symbol(curr, next) == SYMBOL_A) {
 166			rb_erase(&next->rb_node, symbols);
 
 
 
 167			goto again;
 168		} else {
 
 
 169			nd = rb_next(&curr->rb_node);
 170			rb_erase(&curr->rb_node, symbols);
 
 171		}
 172	}
 173}
 174
 175static void symbols__fixup_end(struct rb_root *symbols)
 
 176{
 177	struct rb_node *nd, *prevnd = rb_first(symbols);
 178	struct symbol *curr, *prev;
 179
 180	if (prevnd == NULL)
 181		return;
 182
 183	curr = rb_entry(prevnd, struct symbol, rb_node);
 184
 185	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 186		prev = curr;
 187		curr = rb_entry(nd, struct symbol, rb_node);
 188
 189		if (prev->end == prev->start && prev->end != curr->start)
 190			prev->end = curr->start - 1;
 191	}
 192
 193	/* Last entry */
 194	if (curr->end == curr->start)
 195		curr->end = roundup(curr->start, 4096);
 196}
 
 
 
 
 
 
 
 
 
 
 
 197
 198static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 199{
 200	struct map *prev, *curr;
 201	struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
 202
 203	if (prevnd == NULL)
 204		return;
 205
 206	curr = rb_entry(prevnd, struct map, rb_node);
 
 
 
 
 
 
 
 207
 208	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 209		prev = curr;
 210		curr = rb_entry(nd, struct map, rb_node);
 211		prev->end = curr->start - 1;
 212	}
 213
 214	/*
 215	 * We still haven't the actual symbols, so guess the
 216	 * last map final address.
 217	 */
 218	curr->end = ~0ULL;
 219}
 220
 221static void map_groups__fixup_end(struct map_groups *mg)
 222{
 223	int i;
 224	for (i = 0; i < MAP__NR_TYPES; ++i)
 225		__map_groups__fixup_end(mg, i);
 226}
 227
 228static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
 229				  const char *name)
 230{
 231	size_t namelen = strlen(name) + 1;
 232	struct symbol *sym = calloc(1, (symbol_conf.priv_size +
 233					sizeof(*sym) + namelen));
 234	if (sym == NULL)
 235		return NULL;
 236
 237	if (symbol_conf.priv_size)
 
 
 
 
 238		sym = ((void *)sym) + symbol_conf.priv_size;
 
 239
 240	sym->start   = start;
 241	sym->end     = len ? start + len - 1 : start;
 
 242	sym->binding = binding;
 243	sym->namelen = namelen - 1;
 244
 245	pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
 246		  __func__, name, start, sym->end);
 247	memcpy(sym->name, name, namelen);
 248
 249	return sym;
 250}
 251
 252void symbol__delete(struct symbol *sym)
 253{
 254	free(((void *)sym) - symbol_conf.priv_size);
 255}
 256
 257static size_t symbol__fprintf(struct symbol *sym, FILE *fp)
 258{
 259	return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
 260		       sym->start, sym->end,
 261		       sym->binding == STB_GLOBAL ? 'g' :
 262		       sym->binding == STB_LOCAL  ? 'l' : 'w',
 263		       sym->name);
 264}
 265
 266void dso__set_long_name(struct dso *dso, char *name)
 267{
 268	if (name == NULL)
 269		return;
 270	dso->long_name = name;
 271	dso->long_name_len = strlen(name);
 272}
 273
 274static void dso__set_short_name(struct dso *dso, const char *name)
 275{
 276	if (name == NULL)
 277		return;
 278	dso->short_name = name;
 279	dso->short_name_len = strlen(name);
 280}
 281
 282static void dso__set_basename(struct dso *dso)
 283{
 284	dso__set_short_name(dso, basename(dso->long_name));
 285}
 286
 287struct dso *dso__new(const char *name)
 288{
 289	struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1);
 290
 291	if (dso != NULL) {
 292		int i;
 293		strcpy(dso->name, name);
 294		dso__set_long_name(dso, dso->name);
 295		dso__set_short_name(dso, dso->name);
 296		for (i = 0; i < MAP__NR_TYPES; ++i)
 297			dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
 298		dso->symtab_type = SYMTAB__NOT_FOUND;
 299		dso->loaded = 0;
 300		dso->sorted_by_name = 0;
 301		dso->has_build_id = 0;
 302		dso->kernel = DSO_TYPE_USER;
 303		INIT_LIST_HEAD(&dso->node);
 304	}
 305
 306	return dso;
 307}
 308
 309static void symbols__delete(struct rb_root *symbols)
 310{
 311	struct symbol *pos;
 312	struct rb_node *next = rb_first(symbols);
 313
 314	while (next) {
 315		pos = rb_entry(next, struct symbol, rb_node);
 316		next = rb_next(&pos->rb_node);
 317		rb_erase(&pos->rb_node, symbols);
 318		symbol__delete(pos);
 319	}
 320}
 321
 322void dso__delete(struct dso *dso)
 323{
 324	int i;
 325	for (i = 0; i < MAP__NR_TYPES; ++i)
 326		symbols__delete(&dso->symbols[i]);
 327	if (dso->sname_alloc)
 328		free((char *)dso->short_name);
 329	if (dso->lname_alloc)
 330		free(dso->long_name);
 331	free(dso);
 332}
 333
 334void dso__set_build_id(struct dso *dso, void *build_id)
 335{
 336	memcpy(dso->build_id, build_id, sizeof(dso->build_id));
 337	dso->has_build_id = 1;
 338}
 339
 340static void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 341{
 342	struct rb_node **p = &symbols->rb_node;
 343	struct rb_node *parent = NULL;
 344	const u64 ip = sym->start;
 345	struct symbol *s;
 
 
 
 
 
 
 
 
 
 
 
 
 346
 347	while (*p != NULL) {
 348		parent = *p;
 349		s = rb_entry(parent, struct symbol, rb_node);
 350		if (ip < s->start)
 351			p = &(*p)->rb_left;
 352		else
 353			p = &(*p)->rb_right;
 
 
 354	}
 355	rb_link_node(&sym->rb_node, parent, p);
 356	rb_insert_color(&sym->rb_node, symbols);
 357}
 358
 359static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 
 
 
 
 
 360{
 361	struct rb_node *n;
 362
 363	if (symbols == NULL)
 364		return NULL;
 365
 366	n = symbols->rb_node;
 367
 368	while (n) {
 369		struct symbol *s = rb_entry(n, struct symbol, rb_node);
 370
 371		if (ip < s->start)
 372			n = n->rb_left;
 373		else if (ip > s->end)
 374			n = n->rb_right;
 375		else
 376			return s;
 377	}
 378
 379	return NULL;
 380}
 381
 382struct symbol_name_rb_node {
 383	struct rb_node	rb_node;
 384	struct symbol	sym;
 385};
 
 
 
 
 
 386
 387static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
 388{
 389	struct rb_node **p = &symbols->rb_node;
 390	struct rb_node *parent = NULL;
 391	struct symbol_name_rb_node *symn, *s;
 392
 393	symn = container_of(sym, struct symbol_name_rb_node, sym);
 
 394
 395	while (*p != NULL) {
 396		parent = *p;
 397		s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 398		if (strcmp(sym->name, s->sym.name) < 0)
 399			p = &(*p)->rb_left;
 400		else
 401			p = &(*p)->rb_right;
 402	}
 403	rb_link_node(&symn->rb_node, parent, p);
 404	rb_insert_color(&symn->rb_node, symbols);
 
 
 
 
 
 
 
 
 
 405}
 406
 407static void symbols__sort_by_name(struct rb_root *symbols,
 408				  struct rb_root *source)
 409{
 410	struct rb_node *nd;
 
 
 411
 412	for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 
 
 
 
 
 
 
 413		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 414		symbols__insert_by_name(symbols, pos);
 
 415	}
 
 
 
 416}
 417
 418static struct symbol *symbols__find_by_name(struct rb_root *symbols,
 419					    const char *name)
 420{
 421	struct rb_node *n;
 422
 423	if (symbols == NULL)
 424		return NULL;
 
 425
 426	n = symbols->rb_node;
 
 427
 428	while (n) {
 429		struct symbol_name_rb_node *s;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 430		int cmp;
 431
 432		s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 433		cmp = strcmp(name, s->sym.name);
 434
 435		if (cmp < 0)
 436			n = n->rb_left;
 437		else if (cmp > 0)
 438			n = n->rb_right;
 439		else
 440			return &s->sym;
 
 
 
 
 441	}
 442
 443	return NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 444}
 445
 446struct symbol *dso__find_symbol(struct dso *dso,
 447				enum map_type type, u64 addr)
 448{
 449	return symbols__find(&dso->symbols[type], addr);
 
 450}
 451
 452struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 453					const char *name)
 454{
 455	return symbols__find_by_name(&dso->symbol_names[type], name);
 
 
 
 
 
 
 
 456}
 457
 458void dso__sort_by_name(struct dso *dso, enum map_type type)
 459{
 460	dso__set_sorted_by_name(dso, type);
 461	return symbols__sort_by_name(&dso->symbol_names[type],
 462				     &dso->symbols[type]);
 463}
 464
 465int build_id__sprintf(const u8 *build_id, int len, char *bf)
 466{
 467	char *bid = bf;
 468	const u8 *raw = build_id;
 469	int i;
 470
 471	for (i = 0; i < len; ++i) {
 472		sprintf(bid, "%02x", *raw);
 473		++raw;
 474		bid += 2;
 475	}
 476
 477	return raw - build_id;
 
 
 
 
 
 478}
 479
 480size_t dso__fprintf_buildid(struct dso *dso, FILE *fp)
 481{
 482	char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 
 483
 484	build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
 485	return fprintf(fp, "%s", sbuild_id);
 
 486}
 487
 488size_t dso__fprintf_symbols_by_name(struct dso *dso,
 489				    enum map_type type, FILE *fp)
 490{
 491	size_t ret = 0;
 492	struct rb_node *nd;
 493	struct symbol_name_rb_node *pos;
 494
 495	for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
 496		pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
 497		fprintf(fp, "%s\n", pos->sym.name);
 498	}
 499
 500	return ret;
 
 501}
 502
 503size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
 
 
 
 
 
 
 
 
 
 
 
 
 
 504{
 505	struct rb_node *nd;
 506	size_t ret = fprintf(fp, "dso: %s (", dso->short_name);
 
 507
 508	if (dso->short_name != dso->long_name)
 509		ret += fprintf(fp, "%s, ", dso->long_name);
 510	ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
 511		       dso->loaded ? "" : "NOT ");
 512	ret += dso__fprintf_buildid(dso, fp);
 513	ret += fprintf(fp, ")\n");
 514	for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
 515		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 516		ret += symbol__fprintf(pos, fp);
 517	}
 
 
 518
 519	return ret;
 
 
 
 
 
 
 
 
 
 
 520}
 521
 522int kallsyms__parse(const char *filename, void *arg,
 523		    int (*process_symbol)(void *arg, const char *name,
 524					  char type, u64 start, u64 end))
 
 525{
 526	char *line = NULL;
 527	size_t n;
 528	int err = -1;
 529	FILE *file = fopen(filename, "r");
 530
 
 531	if (file == NULL)
 532		goto out_failure;
 533
 534	err = 0;
 535
 536	while (!feof(file)) {
 537		u64 start;
 538		int line_len, len;
 539		char symbol_type;
 540		char *symbol_name;
 541
 542		line_len = getline(&line, &n, file);
 543		if (line_len < 0 || !line)
 544			break;
 
 
 
 
 
 
 
 
 
 545
 546		line[--line_len] = '\0'; /* \n */
 547
 548		len = hex2u64(line, &start);
 
 
 549
 550		len++;
 551		if (len + 2 >= line_len)
 
 
 552			continue;
 553
 554		symbol_type = line[len];
 555		len += 2;
 556		symbol_name = line + len;
 557		len = line_len - len;
 558
 559		if (len >= KSYM_NAME_LEN) {
 560			err = -1;
 561			break;
 562		}
 563
 564		/*
 565		 * module symbols are not sorted so we add all
 566		 * symbols with zero length and rely on
 567		 * symbols__fixup_end() to fix it up.
 568		 */
 569		err = process_symbol(arg, symbol_name,
 570				     symbol_type, start, start);
 571		if (err)
 572			break;
 573	}
 574
 575	free(line);
 576	fclose(file);
 577	return err;
 578
 579out_failure:
 580	return -1;
 581}
 582
 583struct process_kallsyms_args {
 584	struct map *map;
 585	struct dso *dso;
 586};
 587
 588static u8 kallsyms2elf_type(char type)
 589{
 590	if (type == 'W')
 591		return STB_WEAK;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 592
 593	return isupper(type) ? STB_GLOBAL : STB_LOCAL;
 
 
 
 594}
 595
 596static int map__process_kallsym_symbol(void *arg, const char *name,
 597				       char type, u64 start, u64 end)
 598{
 599	struct symbol *sym;
 600	struct process_kallsyms_args *a = arg;
 601	struct rb_root *root = &a->dso->symbols[a->map->type];
 
 
 
 602
 603	if (!symbol_type__is_a(type, a->map->type))
 
 604		return 0;
 605
 606	sym = symbol__new(start, end - start + 1,
 607			  kallsyms2elf_type(type), name);
 
 
 
 
 608	if (sym == NULL)
 609		return -ENOMEM;
 610	/*
 611	 * We will pass the symbols to the filter later, in
 612	 * map__split_kallsyms, when we have split the maps per module
 613	 */
 614	symbols__insert(root, sym);
 615
 616	return 0;
 617}
 618
 619/*
 620 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
 621 * so that we can in the next step set the symbol ->end address and then
 622 * call kernel_maps__split_kallsyms.
 623 */
 624static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 625				  struct map *map)
 
 
 
 
 626{
 627	struct process_kallsyms_args args = { .map = map, .dso = dso, };
 628	return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 629}
 630
 631/*
 632 * Split the symbols into maps, making sure there are no overlaps, i.e. the
 633 * kernel range is broken in several maps, named [kernel].N, as we don't have
 634 * the original ELF section names vmlinux have.
 635 */
 636static int dso__split_kallsyms(struct dso *dso, struct map *map,
 637			       symbol_filter_t filter)
 638{
 639	struct map_groups *kmaps = map__kmap(map)->kmaps;
 640	struct machine *machine = kmaps->machine;
 641	struct map *curr_map = map;
 642	struct symbol *pos;
 643	int count = 0, moved = 0;	
 644	struct rb_root *root = &dso->symbols[map->type];
 645	struct rb_node *next = rb_first(root);
 646	int kernel_range = 0;
 
 
 
 
 
 
 
 
 647
 648	while (next) {
 649		char *module;
 650
 651		pos = rb_entry(next, struct symbol, rb_node);
 652		next = rb_next(&pos->rb_node);
 653
 654		module = strchr(pos->name, '\t');
 655		if (module) {
 
 
 656			if (!symbol_conf.use_modules)
 657				goto discard_symbol;
 658
 659			*module++ = '\0';
 660
 661			if (strcmp(curr_map->dso->short_name, module)) {
 662				if (curr_map != map &&
 663				    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 664				    machine__is_default_guest(machine)) {
 665					/*
 666					 * We assume all symbols of a module are
 667					 * continuous in * kallsyms, so curr_map
 668					 * points to a module and all its
 669					 * symbols are in its kmap. Mark it as
 670					 * loaded.
 671					 */
 672					dso__set_loaded(curr_map->dso,
 673							curr_map->type);
 674				}
 675
 676				curr_map = map_groups__find_by_name(kmaps,
 677							map->type, module);
 678				if (curr_map == NULL) {
 679					pr_debug("%s/proc/{kallsyms,modules} "
 680					         "inconsistency while looking "
 681						 "for \"%s\" module!\n",
 682						 machine->root_dir, module);
 683					curr_map = map;
 684					goto discard_symbol;
 685				}
 686
 687				if (curr_map->dso->loaded &&
 688				    !machine__is_default_guest(machine))
 689					goto discard_symbol;
 690			}
 691			/*
 692			 * So that we look just like we get from .ko files,
 693			 * i.e. not prelinked, relative to map->start.
 
 
 
 
 
 
 
 
 
 
 
 694			 */
 695			pos->start = curr_map->map_ip(curr_map, pos->start);
 696			pos->end   = curr_map->map_ip(curr_map, pos->end);
 697		} else if (curr_map != map) {
 698			char dso_name[PATH_MAX];
 699			struct dso *ndso;
 700
 
 
 
 
 
 
 701			if (count == 0) {
 702				curr_map = map;
 703				goto filter_symbol;
 
 704			}
 705
 706			if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 707				snprintf(dso_name, sizeof(dso_name),
 708					"[guest.kernel].%d",
 709					kernel_range++);
 710			else
 711				snprintf(dso_name, sizeof(dso_name),
 712					"[kernel].%d",
 713					kernel_range++);
 714
 715			ndso = dso__new(dso_name);
 
 716			if (ndso == NULL)
 717				return -1;
 718
 719			ndso->kernel = dso->kernel;
 720
 721			curr_map = map__new2(pos->start, ndso, map->type);
 722			if (curr_map == NULL) {
 723				dso__delete(ndso);
 724				return -1;
 725			}
 726
 727			curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 728			map_groups__insert(kmaps, curr_map);
 
 
 
 
 729			++kernel_range;
 730		}
 731filter_symbol:
 732		if (filter && filter(curr_map, pos)) {
 733discard_symbol:		rb_erase(&pos->rb_node, root);
 734			symbol__delete(pos);
 735		} else {
 736			if (curr_map != map) {
 737				rb_erase(&pos->rb_node, root);
 738				symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 739				++moved;
 740			} else
 741				++count;
 742		}
 
 
 
 
 
 
 743	}
 744
 745	if (curr_map != map &&
 746	    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 747	    machine__is_default_guest(kmaps->machine)) {
 748		dso__set_loaded(curr_map->dso, curr_map->type);
 749	}
 750
 751	return count + moved;
 752}
 753
 754static bool symbol__restricted_filename(const char *filename,
 755					const char *restricted_filename)
 756{
 757	bool restricted = false;
 758
 759	if (symbol_conf.kptr_restrict) {
 760		char *r = realpath(filename, NULL);
 761
 762		if (r != NULL) {
 763			restricted = strcmp(r, restricted_filename) == 0;
 764			free(r);
 765			return restricted;
 766		}
 767	}
 768
 769	return restricted;
 770}
 771
 772int dso__load_kallsyms(struct dso *dso, const char *filename,
 773		       struct map *map, symbol_filter_t filter)
 774{
 775	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 776		return -1;
 777
 778	if (dso__load_all_kallsyms(dso, filename, map) < 0)
 779		return -1;
 
 
 
 780
 781	symbols__fixup_duplicate(&dso->symbols[map->type]);
 782	symbols__fixup_end(&dso->symbols[map->type]);
 
 
 
 
 
 
 
 
 
 783
 784	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 785		dso->symtab_type = SYMTAB__GUEST_KALLSYMS;
 786	else
 787		dso->symtab_type = SYMTAB__KALLSYMS;
 788
 789	return dso__split_kallsyms(dso, map, filter);
 
 
 
 
 
 
 790}
 791
 792static int dso__load_perf_map(struct dso *dso, struct map *map,
 793			      symbol_filter_t filter)
 794{
 795	char *line = NULL;
 796	size_t n;
 797	FILE *file;
 798	int nr_syms = 0;
 799
 800	file = fopen(dso->long_name, "r");
 801	if (file == NULL)
 802		goto out_failure;
 803
 804	while (!feof(file)) {
 805		u64 start, size;
 806		struct symbol *sym;
 807		int line_len, len;
 808
 809		line_len = getline(&line, &n, file);
 810		if (line_len < 0)
 811			break;
 
 
 
 
 
 
 812
 813		if (!line)
 814			goto out_failure;
 815
 816		line[--line_len] = '\0'; /* \n */
 
 
 
 
 817
 818		len = hex2u64(line, &start);
 
 
 819
 820		len++;
 821		if (len + 2 >= line_len)
 822			continue;
 823
 824		len += hex2u64(line + len, &size);
 
 
 
 825
 826		len++;
 827		if (len + 2 >= line_len)
 828			continue;
 829
 830		sym = symbol__new(start, size, STB_GLOBAL, line + len);
 
 831
 832		if (sym == NULL)
 833			goto out_delete_line;
 
 
 834
 835		if (filter && filter(map, sym))
 836			symbol__delete(sym);
 837		else {
 838			symbols__insert(&dso->symbols[map->type], sym);
 839			nr_syms++;
 840		}
 841	}
 842
 843	free(line);
 844	fclose(file);
 845
 846	return nr_syms;
 
 
 
 
 
 
 847
 848out_delete_line:
 849	free(line);
 850out_failure:
 851	return -1;
 852}
 853
 854/**
 855 * elf_symtab__for_each_symbol - iterate thru all the symbols
 856 *
 857 * @syms: struct elf_symtab instance to iterate
 858 * @idx: uint32_t idx
 859 * @sym: GElf_Sym iterator
 860 */
 861#define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
 862	for (idx = 0, gelf_getsym(syms, idx, &sym);\
 863	     idx < nr_syms; \
 864	     idx++, gelf_getsym(syms, idx, &sym))
 865
 866static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 867{
 868	return GELF_ST_TYPE(sym->st_info);
 869}
 
 870
 871static inline int elf_sym__is_function(const GElf_Sym *sym)
 872{
 873	return elf_sym__type(sym) == STT_FUNC &&
 874	       sym->st_name != 0 &&
 875	       sym->st_shndx != SHN_UNDEF;
 876}
 877
 878static inline bool elf_sym__is_object(const GElf_Sym *sym)
 879{
 880	return elf_sym__type(sym) == STT_OBJECT &&
 881		sym->st_name != 0 &&
 882		sym->st_shndx != SHN_UNDEF;
 883}
 884
 885static inline int elf_sym__is_label(const GElf_Sym *sym)
 886{
 887	return elf_sym__type(sym) == STT_NOTYPE &&
 888		sym->st_name != 0 &&
 889		sym->st_shndx != SHN_UNDEF &&
 890		sym->st_shndx != SHN_ABS;
 891}
 892
 893static inline const char *elf_sec__name(const GElf_Shdr *shdr,
 894					const Elf_Data *secstrs)
 895{
 896	return secstrs->d_buf + shdr->sh_name;
 897}
 898
 899static inline int elf_sec__is_text(const GElf_Shdr *shdr,
 900					const Elf_Data *secstrs)
 901{
 902	return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 903}
 904
 905static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
 906				    const Elf_Data *secstrs)
 907{
 908	return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
 909}
 910
 911static inline const char *elf_sym__name(const GElf_Sym *sym,
 912					const Elf_Data *symstrs)
 913{
 914	return symstrs->d_buf + sym->st_name;
 
 
 
 
 
 
 
 
 
 
 
 
 
 915}
 916
 917static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 918				    GElf_Shdr *shp, const char *name,
 919				    size_t *idx)
 920{
 921	Elf_Scn *sec = NULL;
 922	size_t cnt = 1;
 923
 924	while ((sec = elf_nextscn(elf, sec)) != NULL) {
 925		char *str;
 
 926
 927		gelf_getshdr(sec, shp);
 928		str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 929		if (!strcmp(name, str)) {
 930			if (idx)
 931				*idx = cnt;
 932			break;
 933		}
 934		++cnt;
 935	}
 936
 937	return sec;
 
 938}
 939
 940#define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
 941	for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
 942	     idx < nr_entries; \
 943	     ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
 944
 945#define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
 946	for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
 947	     idx < nr_entries; \
 948	     ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
 949
 950/*
 951 * We need to check if we have a .dynsym, so that we can handle the
 952 * .plt, synthesizing its symbols, that aren't on the symtabs (be it
 953 * .dynsym or .symtab).
 954 * And always look at the original dso, not at debuginfo packages, that
 955 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
 956 */
 957static int dso__synthesize_plt_symbols(struct  dso *dso, struct map *map,
 958				       symbol_filter_t filter)
 
 959{
 960	uint32_t nr_rel_entries, idx;
 961	GElf_Sym sym;
 962	u64 plt_offset;
 963	GElf_Shdr shdr_plt;
 964	struct symbol *f;
 965	GElf_Shdr shdr_rel_plt, shdr_dynsym;
 966	Elf_Data *reldata, *syms, *symstrs;
 967	Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 968	size_t dynsym_idx;
 969	GElf_Ehdr ehdr;
 970	char sympltname[1024];
 971	Elf *elf;
 972	int nr = 0, symidx, fd, err = 0;
 973	char name[PATH_MAX];
 974
 975	snprintf(name, sizeof(name), "%s%s",
 976		 symbol_conf.symfs, dso->long_name);
 977	fd = open(name, O_RDONLY);
 978	if (fd < 0)
 979		goto out;
 980
 981	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 982	if (elf == NULL)
 983		goto out_close;
 
 984
 985	if (gelf_getehdr(elf, &ehdr) == NULL)
 986		goto out_elf_end;
 987
 988	scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
 989					 ".dynsym", &dynsym_idx);
 990	if (scn_dynsym == NULL)
 991		goto out_elf_end;
 992
 993	scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 994					  ".rela.plt", NULL);
 995	if (scn_plt_rel == NULL) {
 996		scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 997						  ".rel.plt", NULL);
 998		if (scn_plt_rel == NULL)
 999			goto out_elf_end;
1000	}
1001
1002	err = -1;
 
1003
1004	if (shdr_rel_plt.sh_link != dynsym_idx)
1005		goto out_elf_end;
 
 
 
1006
1007	if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
1008		goto out_elf_end;
1009
1010	/*
1011	 * Fetch the relocation section to find the idxes to the GOT
1012	 * and the symbols in the .dynsym they refer to.
1013	 */
1014	reldata = elf_getdata(scn_plt_rel, NULL);
1015	if (reldata == NULL)
1016		goto out_elf_end;
1017
1018	syms = elf_getdata(scn_dynsym, NULL);
1019	if (syms == NULL)
1020		goto out_elf_end;
1021
1022	scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
1023	if (scn_symstrs == NULL)
1024		goto out_elf_end;
1025
1026	symstrs = elf_getdata(scn_symstrs, NULL);
1027	if (symstrs == NULL)
1028		goto out_elf_end;
1029
1030	nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
1031	plt_offset = shdr_plt.sh_offset;
1032
1033	if (shdr_rel_plt.sh_type == SHT_RELA) {
1034		GElf_Rela pos_mem, *pos;
1035
1036		elf_section__for_each_rela(reldata, pos, pos_mem, idx,
1037					   nr_rel_entries) {
1038			symidx = GELF_R_SYM(pos->r_info);
1039			plt_offset += shdr_plt.sh_entsize;
1040			gelf_getsym(syms, symidx, &sym);
1041			snprintf(sympltname, sizeof(sympltname),
1042				 "%s@plt", elf_sym__name(&sym, symstrs));
1043
1044			f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1045					STB_GLOBAL, sympltname);
1046			if (!f)
1047				goto out_elf_end;
1048
1049			if (filter && filter(map, f))
1050				symbol__delete(f);
1051			else {
1052				symbols__insert(&dso->symbols[map->type], f);
1053				++nr;
1054			}
1055		}
1056	} else if (shdr_rel_plt.sh_type == SHT_REL) {
1057		GElf_Rel pos_mem, *pos;
1058		elf_section__for_each_rel(reldata, pos, pos_mem, idx,
1059					  nr_rel_entries) {
1060			symidx = GELF_R_SYM(pos->r_info);
1061			plt_offset += shdr_plt.sh_entsize;
1062			gelf_getsym(syms, symidx, &sym);
1063			snprintf(sympltname, sizeof(sympltname),
1064				 "%s@plt", elf_sym__name(&sym, symstrs));
1065
1066			f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1067					STB_GLOBAL, sympltname);
1068			if (!f)
1069				goto out_elf_end;
1070
1071			if (filter && filter(map, f))
1072				symbol__delete(f);
1073			else {
1074				symbols__insert(&dso->symbols[map->type], f);
1075				++nr;
1076			}
1077		}
1078	}
1079
1080	err = 0;
1081out_elf_end:
1082	elf_end(elf);
1083out_close:
1084	close(fd);
1085
1086	if (err == 0)
1087		return nr;
1088out:
1089	pr_debug("%s: problems reading %s PLT info.\n",
1090		 __func__, dso->long_name);
1091	return 0;
1092}
1093
1094static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
1095{
1096	switch (type) {
1097	case MAP__FUNCTION:
1098		return elf_sym__is_function(sym);
1099	case MAP__VARIABLE:
1100		return elf_sym__is_object(sym);
1101	default:
1102		return false;
1103	}
1104}
1105
1106static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
1107			  enum map_type type)
1108{
1109	switch (type) {
1110	case MAP__FUNCTION:
1111		return elf_sec__is_text(shdr, secstrs);
1112	case MAP__VARIABLE:
1113		return elf_sec__is_data(shdr, secstrs);
1114	default:
1115		return false;
1116	}
1117}
1118
1119static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
1120{
1121	Elf_Scn *sec = NULL;
1122	GElf_Shdr shdr;
1123	size_t cnt = 1;
1124
1125	while ((sec = elf_nextscn(elf, sec)) != NULL) {
1126		gelf_getshdr(sec, &shdr);
1127
1128		if ((addr >= shdr.sh_addr) &&
1129		    (addr < (shdr.sh_addr + shdr.sh_size)))
1130			return cnt;
1131
1132		++cnt;
 
 
 
 
1133	}
1134
1135	return -1;
1136}
1137
1138static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
1139			 int fd, symbol_filter_t filter, int kmodule,
1140			 int want_symtab)
1141{
1142	struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
1143	struct map *curr_map = map;
1144	struct dso *curr_dso = dso;
1145	Elf_Data *symstrs, *secstrs;
1146	uint32_t nr_syms;
1147	int err = -1;
1148	uint32_t idx;
1149	GElf_Ehdr ehdr;
1150	GElf_Shdr shdr, opdshdr;
1151	Elf_Data *syms, *opddata = NULL;
1152	GElf_Sym sym;
1153	Elf_Scn *sec, *sec_strndx, *opdsec;
1154	Elf *elf;
1155	int nr = 0;
1156	size_t opdidx = 0;
1157
1158	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1159	if (elf == NULL) {
1160		pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1161		goto out_close;
1162	}
1163
1164	if (gelf_getehdr(elf, &ehdr) == NULL) {
1165		pr_debug("%s: cannot get elf header.\n", __func__);
1166		goto out_elf_end;
1167	}
1168
1169	/* Always reject images with a mismatched build-id: */
1170	if (dso->has_build_id) {
1171		u8 build_id[BUILD_ID_SIZE];
 
1172
1173		if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
1174			goto out_elf_end;
1175
1176		if (!dso__build_id_equal(dso, build_id))
1177			goto out_elf_end;
 
 
1178	}
1179
1180	sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
1181	if (sec == NULL) {
1182		if (want_symtab)
1183			goto out_elf_end;
1184
1185		sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
1186		if (sec == NULL)
1187			goto out_elf_end;
1188	}
1189
1190	opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
1191	if (opdshdr.sh_type != SHT_PROGBITS)
1192		opdsec = NULL;
1193	if (opdsec)
1194		opddata = elf_rawdata(opdsec, NULL);
1195
1196	syms = elf_getdata(sec, NULL);
1197	if (syms == NULL)
1198		goto out_elf_end;
1199
1200	sec = elf_getscn(elf, shdr.sh_link);
1201	if (sec == NULL)
1202		goto out_elf_end;
 
 
 
1203
1204	symstrs = elf_getdata(sec, NULL);
1205	if (symstrs == NULL)
1206		goto out_elf_end;
 
 
 
 
 
 
 
 
1207
1208	sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1209	if (sec_strndx == NULL)
1210		goto out_elf_end;
1211
1212	secstrs = elf_getdata(sec_strndx, NULL);
1213	if (secstrs == NULL)
1214		goto out_elf_end;
1215
1216	nr_syms = shdr.sh_size / shdr.sh_entsize;
 
 
1217
1218	memset(&sym, 0, sizeof(sym));
1219	if (dso->kernel == DSO_TYPE_USER) {
1220		dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
1221				elf_section_by_name(elf, &ehdr, &shdr,
1222						     ".gnu.prelink_undo",
1223						     NULL) != NULL);
1224	} else {
1225		dso->adjust_symbols = 0;
1226	}
1227	elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1228		struct symbol *f;
1229		const char *elf_name = elf_sym__name(&sym, symstrs);
1230		char *demangled = NULL;
1231		int is_label = elf_sym__is_label(&sym);
1232		const char *section_name;
1233
1234		if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1235		    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
1236			kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1237
1238		if (!is_label && !elf_sym__is_a(&sym, map->type))
1239			continue;
 
1240
1241		/* Reject ARM ELF "mapping symbols": these aren't unique and
1242		 * don't identify functions, so will confuse the profile
1243		 * output: */
1244		if (ehdr.e_machine == EM_ARM) {
1245			if (!strcmp(elf_name, "$a") ||
1246			    !strcmp(elf_name, "$d") ||
1247			    !strcmp(elf_name, "$t"))
1248				continue;
1249		}
1250
1251		if (opdsec && sym.st_shndx == opdidx) {
1252			u32 offset = sym.st_value - opdshdr.sh_addr;
1253			u64 *opd = opddata->d_buf + offset;
1254			sym.st_value = *opd;
1255			sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
1256		}
1257
1258		sec = elf_getscn(elf, sym.st_shndx);
1259		if (!sec)
1260			goto out_elf_end;
 
 
 
1261
1262		gelf_getshdr(sec, &shdr);
 
 
 
1263
1264		if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1265			continue;
 
1266
1267		section_name = elf_sec__name(&shdr, secstrs);
 
 
 
1268
1269		/* On ARM, symbols for thumb functions have 1 added to
1270		 * the symbol address as a flag - remove it */
1271		if ((ehdr.e_machine == EM_ARM) &&
1272		    (map->type == MAP__FUNCTION) &&
1273		    (sym.st_value & 1))
1274			--sym.st_value;
1275
1276		if (dso->kernel != DSO_TYPE_USER || kmodule) {
1277			char dso_name[PATH_MAX];
1278
1279			if (strcmp(section_name,
1280				   (curr_dso->short_name +
1281				    dso->short_name_len)) == 0)
1282				goto new_symbol;
1283
1284			if (strcmp(section_name, ".text") == 0) {
1285				curr_map = map;
1286				curr_dso = dso;
1287				goto new_symbol;
1288			}
 
 
1289
1290			snprintf(dso_name, sizeof(dso_name),
1291				 "%s%s", dso->short_name, section_name);
1292
1293			curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1294			if (curr_map == NULL) {
1295				u64 start = sym.st_value;
 
 
 
 
1296
1297				if (kmodule)
1298					start += map->start + shdr.sh_offset;
 
 
 
 
 
 
 
 
 
 
 
 
1299
1300				curr_dso = dso__new(dso_name);
1301				if (curr_dso == NULL)
1302					goto out_elf_end;
1303				curr_dso->kernel = dso->kernel;
1304				curr_dso->long_name = dso->long_name;
1305				curr_dso->long_name_len = dso->long_name_len;
1306				curr_map = map__new2(start, curr_dso,
1307						     map->type);
1308				if (curr_map == NULL) {
1309					dso__delete(curr_dso);
1310					goto out_elf_end;
1311				}
1312				curr_map->map_ip = identity__map_ip;
1313				curr_map->unmap_ip = identity__map_ip;
1314				curr_dso->symtab_type = dso->symtab_type;
1315				map_groups__insert(kmap->kmaps, curr_map);
1316				dsos__add(&dso->node, curr_dso);
1317				dso__set_loaded(curr_dso, map->type);
1318			} else
1319				curr_dso = curr_map->dso;
1320
1321			goto new_symbol;
 
 
 
 
 
 
 
 
 
 
1322		}
 
 
 
 
 
1323
1324		if (curr_dso->adjust_symbols) {
1325			pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1326				  "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
1327				  (u64)sym.st_value, (u64)shdr.sh_addr,
1328				  (u64)shdr.sh_offset);
1329			sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1330		}
1331		/*
1332		 * We need to figure out if the object was created from C++ sources
1333		 * DWARF DW_compile_unit has this, but we don't always have access
1334		 * to it...
1335		 */
1336		demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1337		if (demangled != NULL)
1338			elf_name = demangled;
1339new_symbol:
1340		f = symbol__new(sym.st_value, sym.st_size,
1341				GELF_ST_BIND(sym.st_info), elf_name);
1342		free(demangled);
1343		if (!f)
1344			goto out_elf_end;
1345
1346		if (filter && filter(curr_map, f))
1347			symbol__delete(f);
1348		else {
1349			symbols__insert(&curr_dso->symbols[curr_map->type], f);
1350			nr++;
1351		}
1352	}
1353
1354	/*
1355	 * For misannotated, zeroed, ASM function sizes.
 
1356	 */
1357	if (nr > 0) {
1358		symbols__fixup_duplicate(&dso->symbols[map->type]);
1359		symbols__fixup_end(&dso->symbols[map->type]);
1360		if (kmap) {
1361			/*
1362			 * We need to fixup this here too because we create new
1363			 * maps here, for things like vsyscall sections.
1364			 */
1365			__map_groups__fixup_end(kmap->kmaps, map->type);
1366		}
 
 
 
 
 
 
 
 
 
 
 
 
 
1367	}
1368	err = nr;
1369out_elf_end:
1370	elf_end(elf);
1371out_close:
1372	return err;
1373}
1374
1375static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
 
 
 
 
1376{
1377	return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
1378}
1379
1380bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1381{
1382	bool have_build_id = false;
1383	struct dso *pos;
1384
1385	list_for_each_entry(pos, head, node) {
1386		if (with_hits && !pos->hit)
1387			continue;
1388		if (pos->has_build_id) {
1389			have_build_id = true;
1390			continue;
1391		}
1392		if (filename__read_build_id(pos->long_name, pos->build_id,
1393					    sizeof(pos->build_id)) > 0) {
1394			have_build_id	  = true;
1395			pos->has_build_id = true;
1396		}
1397	}
1398
1399	return have_build_id;
 
1400}
1401
1402/*
1403 * Align offset to 4 bytes as needed for note name and descriptor data.
1404 */
1405#define NOTE_ALIGN(n) (((n) + 3) & -4U)
1406
1407static int elf_read_build_id(Elf *elf, void *bf, size_t size)
1408{
1409	int err = -1;
1410	GElf_Ehdr ehdr;
1411	GElf_Shdr shdr;
1412	Elf_Data *data;
1413	Elf_Scn *sec;
1414	Elf_Kind ek;
1415	void *ptr;
1416
1417	if (size < BUILD_ID_SIZE)
1418		goto out;
1419
1420	ek = elf_kind(elf);
1421	if (ek != ELF_K_ELF)
1422		goto out;
1423
1424	if (gelf_getehdr(elf, &ehdr) == NULL) {
1425		pr_err("%s: cannot get elf header.\n", __func__);
1426		goto out;
1427	}
1428
1429	sec = elf_section_by_name(elf, &ehdr, &shdr,
1430				  ".note.gnu.build-id", NULL);
1431	if (sec == NULL) {
1432		sec = elf_section_by_name(elf, &ehdr, &shdr,
1433					  ".notes", NULL);
1434		if (sec == NULL)
1435			goto out;
1436	}
1437
1438	data = elf_getdata(sec, NULL);
1439	if (data == NULL)
1440		goto out;
1441
1442	ptr = data->d_buf;
1443	while (ptr < (data->d_buf + data->d_size)) {
1444		GElf_Nhdr *nhdr = ptr;
1445		size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
1446		       descsz = NOTE_ALIGN(nhdr->n_descsz);
1447		const char *name;
1448
1449		ptr += sizeof(*nhdr);
1450		name = ptr;
1451		ptr += namesz;
1452		if (nhdr->n_type == NT_GNU_BUILD_ID &&
1453		    nhdr->n_namesz == sizeof("GNU")) {
1454			if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1455				size_t sz = min(size, descsz);
1456				memcpy(bf, ptr, sz);
1457				memset(bf + sz, 0, size - sz);
1458				err = descsz;
1459				break;
1460			}
1461		}
1462		ptr += descsz;
1463	}
1464
1465out:
1466	return err;
 
 
1467}
1468
1469int filename__read_build_id(const char *filename, void *bf, size_t size)
 
1470{
1471	int fd, err = -1;
1472	Elf *elf;
1473
1474	if (size < BUILD_ID_SIZE)
1475		goto out;
 
 
 
 
1476
1477	fd = open(filename, O_RDONLY);
1478	if (fd < 0)
1479		goto out;
1480
1481	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1482	if (elf == NULL) {
1483		pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1484		goto out_close;
1485	}
1486
1487	err = elf_read_build_id(elf, bf, size);
 
 
1488
1489	elf_end(elf);
1490out_close:
1491	close(fd);
1492out:
1493	return err;
1494}
1495
1496int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1497{
1498	int fd, err = -1;
1499
1500	if (size < BUILD_ID_SIZE)
1501		goto out;
1502
1503	fd = open(filename, O_RDONLY);
1504	if (fd < 0)
1505		goto out;
1506
1507	while (1) {
1508		char bf[BUFSIZ];
1509		GElf_Nhdr nhdr;
1510		size_t namesz, descsz;
1511
1512		if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1513			break;
 
1514
1515		namesz = NOTE_ALIGN(nhdr.n_namesz);
1516		descsz = NOTE_ALIGN(nhdr.n_descsz);
1517		if (nhdr.n_type == NT_GNU_BUILD_ID &&
1518		    nhdr.n_namesz == sizeof("GNU")) {
1519			if (read(fd, bf, namesz) != (ssize_t)namesz)
1520				break;
1521			if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1522				size_t sz = min(descsz, size);
1523				if (read(fd, build_id, sz) == (ssize_t)sz) {
1524					memset(build_id + sz, 0, size - sz);
1525					err = 0;
1526					break;
1527				}
1528			} else if (read(fd, bf, descsz) != (ssize_t)descsz)
1529				break;
1530		} else {
1531			int n = namesz + descsz;
1532			if (read(fd, bf, n) != n)
1533				break;
1534		}
1535	}
1536	close(fd);
1537out:
1538	return err;
 
 
 
 
 
 
 
1539}
1540
1541char dso__symtab_origin(const struct dso *dso)
 
 
 
 
1542{
1543	static const char origin[] = {
1544		[SYMTAB__KALLSYMS]	      = 'k',
1545		[SYMTAB__JAVA_JIT]	      = 'j',
1546		[SYMTAB__BUILD_ID_CACHE]      = 'B',
1547		[SYMTAB__FEDORA_DEBUGINFO]    = 'f',
1548		[SYMTAB__UBUNTU_DEBUGINFO]    = 'u',
1549		[SYMTAB__BUILDID_DEBUGINFO]   = 'b',
1550		[SYMTAB__SYSTEM_PATH_DSO]     = 'd',
1551		[SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
1552		[SYMTAB__GUEST_KALLSYMS]      =  'g',
1553		[SYMTAB__GUEST_KMODULE]	      =  'G',
1554	};
1555
1556	if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
1557		return '!';
1558	return origin[dso->symtab_type];
 
1559}
1560
1561int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1562{
1563	int size = PATH_MAX;
1564	char *name;
1565	int ret = -1;
1566	int fd;
1567	struct machine *machine;
1568	const char *root_dir;
1569	int want_symtab;
 
1570
1571	dso__set_loaded(dso, map->type);
 
 
 
 
 
 
 
 
1572
1573	if (dso->kernel == DSO_TYPE_KERNEL)
1574		return dso__load_kernel_sym(dso, map, filter);
1575	else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1576		return dso__load_guest_kernel_sym(dso, map, filter);
1577
1578	if (map->groups && map->groups->machine)
1579		machine = map->groups->machine;
1580	else
1581		machine = NULL;
 
1582
1583	name = malloc(size);
1584	if (!name)
1585		return -1;
1586
1587	dso->adjust_symbols = 0;
 
 
 
 
1588
1589	if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1590		struct stat st;
1591
1592		if (lstat(dso->name, &st) < 0)
1593			return -1;
 
1594
1595		if (st.st_uid && (st.st_uid != geteuid())) {
1596			pr_warning("File %s not owned by current user or root, "
1597				"ignoring it.\n", dso->name);
1598			return -1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1599		}
1600
1601		ret = dso__load_perf_map(dso, map, filter);
1602		dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
1603					      SYMTAB__NOT_FOUND;
1604		return ret;
1605	}
1606
1607	/* Iterate over candidate debug images.
1608	 * On the first pass, only load images if they have a full symtab.
1609	 * Failing that, do a second pass where we accept .dynsym also
1610	 */
1611	want_symtab = 1;
1612restart:
1613	for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
1614	     dso->symtab_type != SYMTAB__NOT_FOUND;
1615	     dso->symtab_type++) {
1616		switch (dso->symtab_type) {
1617		case SYMTAB__BUILD_ID_CACHE:
1618			/* skip the locally configured cache if a symfs is given */
1619			if (symbol_conf.symfs[0] ||
1620			    (dso__build_id_filename(dso, name, size) == NULL)) {
1621				continue;
1622			}
1623			break;
1624		case SYMTAB__FEDORA_DEBUGINFO:
1625			snprintf(name, size, "%s/usr/lib/debug%s.debug",
1626				 symbol_conf.symfs, dso->long_name);
1627			break;
1628		case SYMTAB__UBUNTU_DEBUGINFO:
1629			snprintf(name, size, "%s/usr/lib/debug%s",
1630				 symbol_conf.symfs, dso->long_name);
1631			break;
1632		case SYMTAB__BUILDID_DEBUGINFO: {
1633			char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1634
1635			if (!dso->has_build_id)
1636				continue;
 
 
 
 
 
 
1637
1638			build_id__sprintf(dso->build_id,
1639					  sizeof(dso->build_id),
1640					  build_id_hex);
1641			snprintf(name, size,
1642				 "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
1643				 symbol_conf.symfs, build_id_hex, build_id_hex + 2);
1644			}
1645			break;
1646		case SYMTAB__SYSTEM_PATH_DSO:
1647			snprintf(name, size, "%s%s",
1648			     symbol_conf.symfs, dso->long_name);
1649			break;
1650		case SYMTAB__GUEST_KMODULE:
1651			if (map->groups && machine)
1652				root_dir = machine->root_dir;
1653			else
1654				root_dir = "";
1655			snprintf(name, size, "%s%s%s", symbol_conf.symfs,
1656				 root_dir, dso->long_name);
1657			break;
1658
1659		case SYMTAB__SYSTEM_PATH_KMODULE:
1660			snprintf(name, size, "%s%s", symbol_conf.symfs,
1661				 dso->long_name);
1662			break;
1663		default:;
1664		}
1665
1666		/* Name is now the name of the next image to try */
1667		fd = open(name, O_RDONLY);
1668		if (fd < 0)
1669			continue;
 
1670
1671		ret = dso__load_sym(dso, map, name, fd, filter, 0,
1672				    want_symtab);
1673		close(fd);
1674
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1675		/*
1676		 * Some people seem to have debuginfo files _WITHOUT_ debug
1677		 * info!?!?
1678		 */
1679		if (!ret)
1680			continue;
1681
1682		if (ret > 0) {
1683			int nr_plt = dso__synthesize_plt_symbols(dso, map,
1684								 filter);
1685			if (nr_plt > 0)
1686				ret += nr_plt;
1687			break;
1688		}
1689	}
1690
1691	/*
1692	 * If we wanted a full symtab but no image had one,
1693	 * relax our requirements and repeat the search.
1694	 */
1695	if (ret <= 0 && want_symtab) {
1696		want_symtab = 0;
1697		goto restart;
1698	}
1699
1700	free(name);
1701	if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1702		return 0;
1703	return ret;
1704}
1705
1706struct map *map_groups__find_by_name(struct map_groups *mg,
1707				     enum map_type type, const char *name)
 
 
 
 
 
 
1708{
1709	struct rb_node *nd;
 
 
 
1710
1711	for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
1712		struct map *map = rb_entry(nd, struct map, rb_node);
1713
1714		if (map->dso && strcmp(map->dso->short_name, name) == 0)
1715			return map;
 
 
 
 
 
1716	}
1717
1718	return NULL;
 
 
 
 
 
 
 
 
 
 
1719}
1720
1721static int dso__kernel_module_get_build_id(struct dso *dso,
1722					   const char *root_dir)
1723{
1724	char filename[PATH_MAX];
1725	/*
1726	 * kernel module short names are of the form "[module]" and
1727	 * we need just "module" here.
1728	 */
1729	const char *name = dso->short_name + 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1730
1731	snprintf(filename, sizeof(filename),
1732		 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1733		 root_dir, (int)strlen(name) - 1, name);
1734
1735	if (sysfs__read_build_id(filename, dso->build_id,
1736				 sizeof(dso->build_id)) == 0)
1737		dso->has_build_id = true;
1738
1739	return 0;
1740}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1741
1742static int map_groups__set_modules_path_dir(struct map_groups *mg,
1743				const char *dir_name)
1744{
1745	struct dirent *dent;
1746	DIR *dir = opendir(dir_name);
1747	int ret = 0;
1748
1749	if (!dir) {
1750		pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1751		return -1;
 
 
1752	}
1753
1754	while ((dent = readdir(dir)) != NULL) {
1755		char path[PATH_MAX];
1756		struct stat st;
1757
1758		/*sshfs might return bad dent->d_type, so we have to stat*/
1759		sprintf(path, "%s/%s", dir_name, dent->d_name);
1760		if (stat(path, &st))
1761			continue;
1762
1763		if (S_ISDIR(st.st_mode)) {
1764			if (!strcmp(dent->d_name, ".") ||
1765			    !strcmp(dent->d_name, ".."))
1766				continue;
 
 
 
 
 
 
1767
1768			snprintf(path, sizeof(path), "%s/%s",
1769				 dir_name, dent->d_name);
1770			ret = map_groups__set_modules_path_dir(mg, path);
1771			if (ret < 0)
1772				goto out;
1773		} else {
1774			char *dot = strrchr(dent->d_name, '.'),
1775			     dso_name[PATH_MAX];
1776			struct map *map;
1777			char *long_name;
 
 
1778
1779			if (dot == NULL || strcmp(dot, ".ko"))
1780				continue;
1781			snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1782				 (int)(dot - dent->d_name), dent->d_name);
1783
1784			strxfrchar(dso_name, '-', '_');
1785			map = map_groups__find_by_name(mg, MAP__FUNCTION,
1786						       dso_name);
1787			if (map == NULL)
1788				continue;
1789
1790			snprintf(path, sizeof(path), "%s/%s",
1791				 dir_name, dent->d_name);
 
 
 
 
1792
1793			long_name = strdup(path);
1794			if (long_name == NULL) {
1795				ret = -1;
1796				goto out;
 
 
 
 
 
 
1797			}
1798			dso__set_long_name(map->dso, long_name);
1799			map->dso->lname_alloc = 1;
1800			dso__kernel_module_get_build_id(map->dso, "");
1801		}
1802	}
1803
1804out:
1805	closedir(dir);
1806	return ret;
1807}
 
 
1808
1809static char *get_kernel_version(const char *root_dir)
1810{
1811	char version[PATH_MAX];
1812	FILE *file;
1813	char *name, *tmp;
1814	const char *prefix = "Linux version ";
1815
1816	sprintf(version, "%s/proc/version", root_dir);
1817	file = fopen(version, "r");
1818	if (!file)
1819		return NULL;
1820
1821	version[0] = '\0';
1822	tmp = fgets(version, sizeof(version), file);
1823	fclose(file);
1824
1825	name = strstr(version, prefix);
1826	if (!name)
1827		return NULL;
1828	name += strlen(prefix);
1829	tmp = strchr(name, ' ');
1830	if (tmp)
1831		*tmp = '\0';
1832
1833	return strdup(name);
1834}
 
 
1835
1836static int machine__set_modules_path(struct machine *machine)
1837{
1838	char *version;
1839	char modules_path[PATH_MAX];
1840
1841	version = get_kernel_version(machine->root_dir);
1842	if (!version)
1843		return -1;
 
 
1844
1845	snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1846		 machine->root_dir, version);
1847	free(version);
1848
1849	return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
1850}
1851
1852/*
1853 * Constructor variant for modules (where we know from /proc/modules where
1854 * they are loaded) and for vmlinux, where only after we load all the
1855 * symbols we'll know where it starts and ends.
1856 */
1857static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1858{
1859	struct map *map = calloc(1, (sizeof(*map) +
1860				     (dso->kernel ? sizeof(struct kmap) : 0)));
1861	if (map != NULL) {
1862		/*
1863		 * ->end will be filled after we load all the symbols
1864		 */
1865		map__init(map, type, start, 0, 0, dso);
1866	}
1867
1868	return map;
1869}
 
1870
1871struct map *machine__new_module(struct machine *machine, u64 start,
1872				const char *filename)
1873{
1874	struct map *map;
1875	struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
1876
1877	if (dso == NULL)
1878		return NULL;
1879
1880	map = map__new2(start, dso, MAP__FUNCTION);
1881	if (map == NULL)
1882		return NULL;
 
1883
1884	if (machine__is_host(machine))
1885		dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE;
1886	else
1887		dso->symtab_type = SYMTAB__GUEST_KMODULE;
1888	map_groups__insert(&machine->kmaps, map);
1889	return map;
 
 
 
 
 
 
1890}
1891
1892static int machine__create_modules(struct machine *machine)
 
 
 
 
 
1893{
1894	char *line = NULL;
1895	size_t n;
1896	FILE *file;
1897	struct map *map;
1898	const char *modules;
1899	char path[PATH_MAX];
1900
1901	if (machine__is_default_guest(machine))
1902		modules = symbol_conf.default_guest_modules;
1903	else {
1904		sprintf(path, "%s/proc/modules", machine->root_dir);
1905		modules = path;
1906	}
1907
1908	if (symbol__restricted_filename(path, "/proc/modules"))
1909		return -1;
 
 
1910
1911	file = fopen(modules, "r");
1912	if (file == NULL)
 
1913		return -1;
 
1914
1915	while (!feof(file)) {
1916		char name[PATH_MAX];
1917		u64 start;
1918		char *sep;
1919		int line_len;
1920
1921		line_len = getline(&line, &n, file);
1922		if (line_len < 0)
1923			break;
1924
1925		if (!line)
1926			goto out_failure;
1927
1928		line[--line_len] = '\0'; /* \n */
 
1929
1930		sep = strrchr(line, 'x');
1931		if (sep == NULL)
1932			continue;
 
1933
1934		hex2u64(sep + 1, &start);
 
1935
1936		sep = strchr(line, ' ');
1937		if (sep == NULL)
1938			continue;
 
1939
1940		*sep = '\0';
 
1941
1942		snprintf(name, sizeof(name), "[%s]", line);
1943		map = machine__new_module(machine, start, name);
1944		if (map == NULL)
1945			goto out_delete_line;
1946		dso__kernel_module_get_build_id(map->dso, machine->root_dir);
1947	}
1948
1949	free(line);
1950	fclose(file);
1951
1952	return machine__set_modules_path(machine);
 
 
 
 
 
 
1953
1954out_delete_line:
1955	free(line);
1956out_failure:
1957	return -1;
 
1958}
1959
1960int dso__load_vmlinux(struct dso *dso, struct map *map,
1961		      const char *vmlinux, symbol_filter_t filter)
1962{
1963	int err = -1, fd;
1964	char symfs_vmlinux[PATH_MAX];
 
 
1965
1966	snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
1967		 symbol_conf.symfs, vmlinux);
1968	fd = open(symfs_vmlinux, O_RDONLY);
1969	if (fd < 0)
1970		return -1;
1971
1972	dso__set_long_name(dso, (char *)vmlinux);
1973	dso__set_loaded(dso, map->type);
1974	err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
1975	close(fd);
 
 
 
 
 
1976
1977	if (err > 0)
1978		pr_debug("Using %s for symbols\n", symfs_vmlinux);
1979
1980	return err;
1981}
1982
1983int dso__load_vmlinux_path(struct dso *dso, struct map *map,
1984			   symbol_filter_t filter)
 
 
 
 
1985{
1986	int i, err = 0;
1987	char *filename;
 
 
 
 
1988
1989	pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1990		 vmlinux_path__nr_entries + 1);
 
 
 
 
1991
1992	filename = dso__build_id_filename(dso, NULL, 0);
1993	if (filename != NULL) {
1994		err = dso__load_vmlinux(dso, map, filename, filter);
1995		if (err > 0) {
1996			dso__set_long_name(dso, filename);
1997			goto out;
1998		}
1999		free(filename);
2000	}
2001
2002	for (i = 0; i < vmlinux_path__nr_entries; ++i) {
2003		err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
2004		if (err > 0) {
2005			dso__set_long_name(dso, strdup(vmlinux_path[i]));
2006			break;
2007		}
 
 
 
 
 
 
 
 
 
2008	}
2009out:
2010	return err;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2011}
2012
2013static int dso__load_kernel_sym(struct dso *dso, struct map *map,
2014				symbol_filter_t filter)
2015{
2016	int err;
2017	const char *kallsyms_filename = NULL;
2018	char *kallsyms_allocated_filename = NULL;
 
 
2019	/*
2020	 * Step 1: if the user specified a kallsyms or vmlinux filename, use
2021	 * it and only it, reporting errors to the user if it cannot be used.
2022	 *
2023	 * For instance, try to analyse an ARM perf.data file _without_ a
2024	 * build-id, or if the user specifies the wrong path to the right
2025	 * vmlinux file, obviously we can't fallback to another vmlinux (a
2026	 * x86_86 one, on the machine where analysis is being performed, say),
2027	 * or worse, /proc/kallsyms.
2028	 *
2029	 * If the specified file _has_ a build-id and there is a build-id
2030	 * section in the perf.data file, we will still do the expected
2031	 * validation in dso__load_vmlinux and will bail out if they don't
2032	 * match.
2033	 */
2034	if (symbol_conf.kallsyms_name != NULL) {
2035		kallsyms_filename = symbol_conf.kallsyms_name;
2036		goto do_kallsyms;
2037	}
2038
2039	if (symbol_conf.vmlinux_name != NULL) {
2040		err = dso__load_vmlinux(dso, map,
2041					symbol_conf.vmlinux_name, filter);
2042		if (err > 0) {
2043			dso__set_long_name(dso,
2044					   strdup(symbol_conf.vmlinux_name));
2045			goto out_fixup;
2046		}
2047		return err;
 
 
 
 
 
 
2048	}
2049
2050	if (vmlinux_path != NULL) {
2051		err = dso__load_vmlinux_path(dso, map, filter);
2052		if (err > 0)
2053			goto out_fixup;
2054	}
2055
2056	/* do not try local files if a symfs was given */
2057	if (symbol_conf.symfs[0] != 0)
2058		return -1;
2059
2060	/*
2061	 * Say the kernel DSO was created when processing the build-id header table,
2062	 * we have a build-id, so check if it is the same as the running kernel,
2063	 * using it if it is.
2064	 */
2065	if (dso->has_build_id) {
2066		u8 kallsyms_build_id[BUILD_ID_SIZE];
2067		char sbuild_id[BUILD_ID_SIZE * 2 + 1];
2068
2069		if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
2070					 sizeof(kallsyms_build_id)) == 0) {
2071			if (dso__build_id_equal(dso, kallsyms_build_id)) {
2072				kallsyms_filename = "/proc/kallsyms";
2073				goto do_kallsyms;
2074			}
2075		}
2076		/*
2077		 * Now look if we have it on the build-id cache in
2078		 * $HOME/.debug/[kernel.kallsyms].
2079		 */
2080		build_id__sprintf(dso->build_id, sizeof(dso->build_id),
2081				  sbuild_id);
2082
2083		if (asprintf(&kallsyms_allocated_filename,
2084			     "%s/.debug/[kernel.kallsyms]/%s",
2085			     getenv("HOME"), sbuild_id) == -1) {
2086			pr_err("Not enough memory for kallsyms file lookup\n");
2087			return -1;
2088		}
2089
2090		kallsyms_filename = kallsyms_allocated_filename;
2091
2092		if (access(kallsyms_filename, F_OK)) {
2093			pr_err("No kallsyms or vmlinux with build-id %s "
2094			       "was found\n", sbuild_id);
2095			free(kallsyms_allocated_filename);
2096			return -1;
2097		}
2098	} else {
2099		/*
2100		 * Last resort, if we don't have a build-id and couldn't find
2101		 * any vmlinux file, try the running kernel kallsyms table.
2102		 */
2103		kallsyms_filename = "/proc/kallsyms";
2104	}
2105
2106do_kallsyms:
2107	err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2108	if (err > 0)
2109		pr_debug("Using %s for symbols\n", kallsyms_filename);
2110	free(kallsyms_allocated_filename);
2111
2112	if (err > 0) {
2113out_fixup:
2114		if (kallsyms_filename != NULL)
2115			dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
2116		map__fixup_start(map);
2117		map__fixup_end(map);
2118	}
2119
2120	return err;
2121}
2122
2123static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
2124				      symbol_filter_t filter)
2125{
2126	int err;
2127	const char *kallsyms_filename = NULL;
2128	struct machine *machine;
2129	char path[PATH_MAX];
2130
2131	if (!map->groups) {
2132		pr_debug("Guest kernel map hasn't the point to groups\n");
2133		return -1;
2134	}
2135	machine = map->groups->machine;
2136
2137	if (machine__is_default_guest(machine)) {
2138		/*
2139		 * if the user specified a vmlinux filename, use it and only
2140		 * it, reporting errors to the user if it cannot be used.
2141		 * Or use file guest_kallsyms inputted by user on commandline
2142		 */
2143		if (symbol_conf.default_guest_vmlinux_name != NULL) {
2144			err = dso__load_vmlinux(dso, map,
2145				symbol_conf.default_guest_vmlinux_name, filter);
2146			goto out_try_fixup;
 
2147		}
2148
2149		kallsyms_filename = symbol_conf.default_guest_kallsyms;
2150		if (!kallsyms_filename)
2151			return -1;
2152	} else {
2153		sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2154		kallsyms_filename = path;
2155	}
2156
2157	err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2158	if (err > 0)
2159		pr_debug("Using %s for symbols\n", kallsyms_filename);
2160
2161out_try_fixup:
2162	if (err > 0) {
2163		if (kallsyms_filename != NULL) {
2164			machine__mmap_name(machine, path, sizeof(path));
2165			dso__set_long_name(dso, strdup(path));
2166		}
2167		map__fixup_start(map);
2168		map__fixup_end(map);
2169	}
2170
2171	return err;
2172}
2173
2174static void dsos__add(struct list_head *head, struct dso *dso)
2175{
2176	list_add_tail(&dso->node, head);
2177}
2178
2179static struct dso *dsos__find(struct list_head *head, const char *name)
2180{
2181	struct dso *pos;
2182
2183	list_for_each_entry(pos, head, node)
2184		if (strcmp(pos->long_name, name) == 0)
2185			return pos;
2186	return NULL;
2187}
2188
2189struct dso *__dsos__findnew(struct list_head *head, const char *name)
2190{
2191	struct dso *dso = dsos__find(head, name);
2192
2193	if (!dso) {
2194		dso = dso__new(name);
2195		if (dso != NULL) {
2196			dsos__add(head, dso);
2197			dso__set_basename(dso);
2198		}
2199	}
2200
2201	return dso;
2202}
2203
2204size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2205{
2206	struct dso *pos;
2207	size_t ret = 0;
2208
2209	list_for_each_entry(pos, head, node) {
2210		int i;
2211		for (i = 0; i < MAP__NR_TYPES; ++i)
2212			ret += dso__fprintf(pos, i, fp);
2213	}
2214
2215	return ret;
2216}
2217
2218size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
2219{
2220	struct rb_node *nd;
2221	size_t ret = 0;
2222
2223	for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2224		struct machine *pos = rb_entry(nd, struct machine, rb_node);
2225		ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2226		ret += __dsos__fprintf(&pos->user_dsos, fp);
2227	}
2228
2229	return ret;
2230}
2231
2232static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2233				      bool with_hits)
2234{
2235	struct dso *pos;
2236	size_t ret = 0;
2237
2238	list_for_each_entry(pos, head, node) {
2239		if (with_hits && !pos->hit)
2240			continue;
2241		ret += dso__fprintf_buildid(pos, fp);
2242		ret += fprintf(fp, " %s\n", pos->long_name);
2243	}
2244	return ret;
2245}
2246
2247size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
2248				     bool with_hits)
2249{
2250	return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
2251	       __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
2252}
2253
2254size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
2255				      FILE *fp, bool with_hits)
2256{
2257	struct rb_node *nd;
2258	size_t ret = 0;
2259
2260	for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2261		struct machine *pos = rb_entry(nd, struct machine, rb_node);
2262		ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2263	}
2264	return ret;
2265}
 
2266
2267static struct dso*
2268dso__kernel_findnew(struct machine *machine, const char *name,
2269		    const char *short_name, int dso_type)
2270{
2271	/*
2272	 * The kernel dso could be created by build_id processing.
2273	 */
2274	struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
2275
2276	/*
2277	 * We need to run this in all cases, since during the build_id
2278	 * processing we had no idea this was the kernel dso.
2279	 */
2280	if (dso != NULL) {
2281		dso__set_short_name(dso, short_name);
2282		dso->kernel = dso_type;
2283	}
2284
2285	return dso;
2286}
2287
2288void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
2289{
2290	char path[PATH_MAX];
 
 
 
2291
2292	if (machine__is_default_guest(machine))
2293		return;
2294	sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2295	if (sysfs__read_build_id(path, dso->build_id,
2296				 sizeof(dso->build_id)) == 0)
2297		dso->has_build_id = true;
2298}
2299
2300static struct dso *machine__get_kernel(struct machine *machine)
2301{
2302	const char *vmlinux_name = NULL;
2303	struct dso *kernel;
2304
2305	if (machine__is_host(machine)) {
2306		vmlinux_name = symbol_conf.vmlinux_name;
2307		if (!vmlinux_name)
2308			vmlinux_name = "[kernel.kallsyms]";
2309
2310		kernel = dso__kernel_findnew(machine, vmlinux_name,
2311					     "[kernel]",
2312					     DSO_TYPE_KERNEL);
2313	} else {
2314		char bf[PATH_MAX];
 
2315
2316		if (machine__is_default_guest(machine))
2317			vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2318		if (!vmlinux_name)
2319			vmlinux_name = machine__mmap_name(machine, bf,
2320							  sizeof(bf));
2321
2322		kernel = dso__kernel_findnew(machine, vmlinux_name,
2323					     "[guest.kernel]",
2324					     DSO_TYPE_GUEST_KERNEL);
 
2325	}
2326
2327	if (kernel != NULL && (!kernel->has_build_id))
2328		dso__read_running_kernel_build_id(kernel, machine);
2329
2330	return kernel;
 
 
2331}
2332
2333struct process_args {
2334	u64 start;
2335};
2336
2337static int symbol__in_kernel(void *arg, const char *name,
2338			     char type __used, u64 start, u64 end __used)
2339{
2340	struct process_args *args = arg;
2341
2342	if (strchr(name, '['))
2343		return 0;
2344
2345	args->start = start;
2346	return 1;
2347}
2348
2349/* Figure out the start address of kernel map from /proc/kallsyms */
2350static u64 machine__get_kernel_start_addr(struct machine *machine)
2351{
2352	const char *filename;
2353	char path[PATH_MAX];
2354	struct process_args args;
2355
2356	if (machine__is_host(machine)) {
2357		filename = "/proc/kallsyms";
2358	} else {
2359		if (machine__is_default_guest(machine))
2360			filename = (char *)symbol_conf.default_guest_kallsyms;
2361		else {
2362			sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2363			filename = path;
2364		}
2365	}
2366
2367	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
2368		return 0;
2369
2370	if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
2371		return 0;
2372
2373	return args.start;
2374}
2375
2376int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
 
2377{
2378	enum map_type type;
2379	u64 start = machine__get_kernel_start_addr(machine);
2380
2381	for (type = 0; type < MAP__NR_TYPES; ++type) {
2382		struct kmap *kmap;
2383
2384		machine->vmlinux_maps[type] = map__new2(start, kernel, type);
2385		if (machine->vmlinux_maps[type] == NULL)
2386			return -1;
2387
2388		machine->vmlinux_maps[type]->map_ip =
2389			machine->vmlinux_maps[type]->unmap_ip =
2390				identity__map_ip;
2391		kmap = map__kmap(machine->vmlinux_maps[type]);
2392		kmap->kmaps = &machine->kmaps;
2393		map_groups__insert(&machine->kmaps,
2394				   machine->vmlinux_maps[type]);
2395	}
2396
2397	return 0;
2398}
2399
2400void machine__destroy_kernel_maps(struct machine *machine)
2401{
2402	enum map_type type;
 
 
 
 
2403
2404	for (type = 0; type < MAP__NR_TYPES; ++type) {
2405		struct kmap *kmap;
 
2406
2407		if (machine->vmlinux_maps[type] == NULL)
 
 
 
2408			continue;
2409
2410		kmap = map__kmap(machine->vmlinux_maps[type]);
2411		map_groups__remove(&machine->kmaps,
2412				   machine->vmlinux_maps[type]);
2413		if (kmap->ref_reloc_sym) {
2414			/*
2415			 * ref_reloc_sym is shared among all maps, so free just
2416			 * on one of them.
2417			 */
2418			if (type == MAP__FUNCTION) {
2419				free((char *)kmap->ref_reloc_sym->name);
2420				kmap->ref_reloc_sym->name = NULL;
2421				free(kmap->ref_reloc_sym);
2422			}
2423			kmap->ref_reloc_sym = NULL;
2424		}
2425
2426		map__delete(machine->vmlinux_maps[type]);
2427		machine->vmlinux_maps[type] = NULL;
2428	}
2429}
2430
2431int machine__create_kernel_maps(struct machine *machine)
2432{
2433	struct dso *kernel = machine__get_kernel(machine);
2434
2435	if (kernel == NULL ||
2436	    __machine__create_kernel_maps(machine, kernel) < 0)
2437		return -1;
2438
2439	if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
2440		pr_debug("Problems creating module maps, continuing anyway...\n");
2441	/*
2442	 * Now that we have all the maps created, just set the ->end of them:
2443	 */
2444	map_groups__fixup_end(&machine->kmaps);
2445	return 0;
2446}
2447
2448static void vmlinux_path__exit(void)
2449{
2450	while (--vmlinux_path__nr_entries >= 0) {
2451		free(vmlinux_path[vmlinux_path__nr_entries]);
2452		vmlinux_path[vmlinux_path__nr_entries] = NULL;
2453	}
2454
2455	free(vmlinux_path);
2456	vmlinux_path = NULL;
2457}
2458
2459static int vmlinux_path__init(void)
2460{
2461	struct utsname uts;
2462	char bf[PATH_MAX];
2463
2464	vmlinux_path = malloc(sizeof(char *) * 5);
2465	if (vmlinux_path == NULL)
2466		return -1;
2467
2468	vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2469	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2470		goto out_fail;
2471	++vmlinux_path__nr_entries;
2472	vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2473	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2474		goto out_fail;
2475	++vmlinux_path__nr_entries;
2476
2477	/* only try running kernel version if no symfs was given */
2478	if (symbol_conf.symfs[0] != 0)
2479		return 0;
2480
2481	if (uname(&uts) < 0)
2482		return -1;
2483
2484	snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2485	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2486	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2487		goto out_fail;
2488	++vmlinux_path__nr_entries;
2489	snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2490	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2491	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2492		goto out_fail;
2493	++vmlinux_path__nr_entries;
2494	snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2495		 uts.release);
2496	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2497	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2498		goto out_fail;
2499	++vmlinux_path__nr_entries;
2500
2501	return 0;
2502
2503out_fail:
2504	vmlinux_path__exit();
2505	return -1;
2506}
2507
2508size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
2509{
2510	int i;
2511	size_t printed = 0;
2512	struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
2513
2514	if (kdso->has_build_id) {
2515		char filename[PATH_MAX];
2516		if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2517			printed += fprintf(fp, "[0] %s\n", filename);
2518	}
2519
2520	for (i = 0; i < vmlinux_path__nr_entries; ++i)
2521		printed += fprintf(fp, "[%d] %s\n",
2522				   i + kdso->has_build_id, vmlinux_path[i]);
 
 
2523
2524	return printed;
2525}
2526
2527static int setup_list(struct strlist **list, const char *list_str,
2528		      const char *list_name)
2529{
2530	if (list_str == NULL)
2531		return 0;
2532
2533	*list = strlist__new(true, list_str);
2534	if (!*list) {
2535		pr_err("problems parsing %s list\n", list_name);
2536		return -1;
2537	}
2538	return 0;
2539}
2540
2541static bool symbol__read_kptr_restrict(void)
2542{
2543	bool value = false;
2544
2545	if (geteuid() != 0) {
2546		FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2547		if (fp != NULL) {
2548			char line[8];
2549
2550			if (fgets(line, sizeof(line), fp) != NULL)
2551				value = atoi(line) != 0;
2552
2553			fclose(fp);
2554		}
2555	}
2556
2557	return value;
2558}
2559
2560int symbol__init(void)
2561{
2562	const char *symfs;
2563
2564	if (symbol_conf.initialized)
2565		return 0;
2566
2567	symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
2568
2569	elf_version(EV_CURRENT);
2570	if (symbol_conf.sort_by_name)
2571		symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2572					  sizeof(struct symbol));
2573
2574	if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2575		return -1;
2576
2577	if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2578		pr_err("'.' is the only non valid --field-separator argument\n");
2579		return -1;
2580	}
2581
2582	if (setup_list(&symbol_conf.dso_list,
2583		       symbol_conf.dso_list_str, "dso") < 0)
2584		return -1;
2585
2586	if (setup_list(&symbol_conf.comm_list,
2587		       symbol_conf.comm_list_str, "comm") < 0)
2588		goto out_free_dso_list;
2589
 
 
 
 
 
 
 
 
2590	if (setup_list(&symbol_conf.sym_list,
2591		       symbol_conf.sym_list_str, "symbol") < 0)
2592		goto out_free_comm_list;
 
 
 
 
 
 
 
 
2593
2594	/*
2595	 * A path to symbols of "/" is identical to ""
2596	 * reset here for simplicity.
2597	 */
2598	symfs = realpath(symbol_conf.symfs, NULL);
2599	if (symfs == NULL)
2600		symfs = symbol_conf.symfs;
2601	if (strcmp(symfs, "/") == 0)
2602		symbol_conf.symfs = "";
2603	if (symfs != symbol_conf.symfs)
2604		free((void *)symfs);
2605
2606	symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2607
2608	symbol_conf.initialized = true;
2609	return 0;
2610
2611out_free_dso_list:
2612	strlist__delete(symbol_conf.dso_list);
 
 
 
 
 
2613out_free_comm_list:
2614	strlist__delete(symbol_conf.comm_list);
 
 
2615	return -1;
2616}
2617
2618void symbol__exit(void)
2619{
2620	if (!symbol_conf.initialized)
2621		return;
 
2622	strlist__delete(symbol_conf.sym_list);
2623	strlist__delete(symbol_conf.dso_list);
2624	strlist__delete(symbol_conf.comm_list);
 
 
 
2625	vmlinux_path__exit();
2626	symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
 
2627	symbol_conf.initialized = false;
2628}
2629
2630int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
2631{
2632	struct machine *machine = machines__findnew(machines, pid);
2633
2634	if (machine == NULL)
2635		return -1;
2636
2637	return machine__create_kernel_maps(machine);
2638}
2639
2640static int hex(char ch)
2641{
2642	if ((ch >= '0') && (ch <= '9'))
2643		return ch - '0';
2644	if ((ch >= 'a') && (ch <= 'f'))
2645		return ch - 'a' + 10;
2646	if ((ch >= 'A') && (ch <= 'F'))
2647		return ch - 'A' + 10;
2648	return -1;
2649}
2650
2651/*
2652 * While we find nice hex chars, build a long_val.
2653 * Return number of chars processed.
2654 */
2655int hex2u64(const char *ptr, u64 *long_val)
2656{
2657	const char *p = ptr;
2658	*long_val = 0;
2659
2660	while (*p) {
2661		const int hex_val = hex(*p);
2662
2663		if (hex_val < 0)
2664			break;
2665
2666		*long_val = (*long_val << 4) | hex_val;
2667		p++;
2668	}
2669
2670	return p - ptr;
2671}
2672
2673char *strxfrchar(char *s, char from, char to)
2674{
2675	char *p = s;
 
 
 
2676
2677	while ((p = strchr(p, from)) != NULL)
2678		*p++ = to;
2679
2680	return s;
 
2681}
2682
2683int machines__create_guest_kernel_maps(struct rb_root *machines)
2684{
2685	int ret = 0;
2686	struct dirent **namelist = NULL;
2687	int i, items = 0;
2688	char path[PATH_MAX];
2689	pid_t pid;
2690
2691	if (symbol_conf.default_guest_vmlinux_name ||
2692	    symbol_conf.default_guest_modules ||
2693	    symbol_conf.default_guest_kallsyms) {
2694		machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
2695	}
2696
2697	if (symbol_conf.guestmount) {
2698		items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2699		if (items <= 0)
2700			return -ENOENT;
2701		for (i = 0; i < items; i++) {
2702			if (!isdigit(namelist[i]->d_name[0])) {
2703				/* Filter out . and .. */
2704				continue;
2705			}
2706			pid = atoi(namelist[i]->d_name);
2707			sprintf(path, "%s/%s/proc/kallsyms",
2708				symbol_conf.guestmount,
2709				namelist[i]->d_name);
2710			ret = access(path, R_OK);
2711			if (ret) {
2712				pr_debug("Can't access file %s\n", path);
2713				goto failure;
2714			}
2715			machines__create_kernel_maps(machines, pid);
2716		}
2717failure:
2718		free(namelist);
2719	}
2720
2721	return ret;
2722}
2723
2724void machines__destroy_guest_kernel_maps(struct rb_root *machines)
2725{
2726	struct rb_node *next = rb_first(machines);
2727
2728	while (next) {
2729		struct machine *pos = rb_entry(next, struct machine, rb_node);
2730
2731		next = rb_next(&pos->rb_node);
2732		rb_erase(&pos->rb_node, machines);
2733		machine__delete(pos);
2734	}
2735}
2736
2737int machine__load_kallsyms(struct machine *machine, const char *filename,
2738			   enum map_type type, symbol_filter_t filter)
2739{
2740	struct map *map = machine->vmlinux_maps[type];
2741	int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2742
2743	if (ret > 0) {
2744		dso__set_loaded(map->dso, type);
2745		/*
2746		 * Since /proc/kallsyms will have multiple sessions for the
2747		 * kernel, with modules between them, fixup the end of all
2748		 * sections.
2749		 */
2750		__map_groups__fixup_end(&machine->kmaps, type);
2751	}
2752
2753	return ret;
 
 
2754}
2755
2756int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
2757			       symbol_filter_t filter)
 
 
 
 
 
 
2758{
2759	struct map *map = machine->vmlinux_maps[type];
2760	int ret = dso__load_vmlinux_path(map->dso, map, filter);
2761
2762	if (ret > 0) {
2763		dso__set_loaded(map->dso, type);
2764		map__reloc_vmlinux(map);
 
 
 
2765	}
2766
2767	return ret;
2768}