symbol.c 43.5 KB
Newer Older
1 2
#include "util.h"
#include "../perf.h"
3
#include "sort.h"
4
#include "string.h"
5
#include "symbol.h"
6
#include "thread.h"
7

8 9
#include "debug.h"

10
#include <asm/bug.h>
11 12 13
#include <libelf.h>
#include <gelf.h>
#include <elf.h>
14
#include <limits.h>
15
#include <sys/utsname.h>
Peter Zijlstra's avatar
Peter Zijlstra committed
16

17 18 19 20
#ifndef NT_GNU_BUILD_ID
#define NT_GNU_BUILD_ID 3
#endif

21 22 23
enum dso_origin {
	DSO__ORIG_KERNEL = 0,
	DSO__ORIG_JAVA_JIT,
24
	DSO__ORIG_BUILD_ID_CACHE,
25 26 27 28
	DSO__ORIG_FEDORA,
	DSO__ORIG_UBUNTU,
	DSO__ORIG_BUILDID,
	DSO__ORIG_DSO,
29
	DSO__ORIG_KMODULE,
30 31 32
	DSO__ORIG_NOT_FOUND,
};

33
static void dsos__add(struct list_head *head, struct dso *dso);
34
static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
35
static int dso__load_kernel_sym(struct dso *self, struct map *map,
36
				symbol_filter_t filter);
37 38
static int vmlinux_path__nr_entries;
static char **vmlinux_path;
39

40
struct symbol_conf symbol_conf = {
41
	.exclude_other	  = true,
42 43 44 45
	.use_modules	  = true,
	.try_vmlinux_path = true,
};

46 47 48 49 50
bool dso__loaded(const struct dso *self, enum map_type type)
{
	return self->loaded & (1 << type);
}

51 52 53 54 55 56 57 58 59 60
bool dso__sorted_by_name(const struct dso *self, enum map_type type)
{
	return self->sorted_by_name & (1 << type);
}

static void dso__set_sorted_by_name(struct dso *self, enum map_type type)
{
	self->sorted_by_name |= (1 << type);
}

61
bool symbol_type__is_a(char symbol_type, enum map_type map_type)
62 63 64 65
{
	switch (map_type) {
	case MAP__FUNCTION:
		return symbol_type == 'T' || symbol_type == 'W';
66 67
	case MAP__VARIABLE:
		return symbol_type == 'D' || symbol_type == 'd';
68 69 70 71 72
	default:
		return false;
	}
}

73
static void symbols__fixup_end(struct rb_root *self)
74
{
75
	struct rb_node *nd, *prevnd = rb_first(self);
76
	struct symbol *curr, *prev;
77 78 79 80

	if (prevnd == NULL)
		return;

81 82
	curr = rb_entry(prevnd, struct symbol, rb_node);

83
	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
84 85
		prev = curr;
		curr = rb_entry(nd, struct symbol, rb_node);
86 87 88 89

		if (prev->end == prev->start)
			prev->end = curr->start - 1;
	}
90 91 92 93

	/* Last entry */
	if (curr->end == curr->start)
		curr->end = roundup(curr->start, 4096);
94 95
}

96
static void __map_groups__fixup_end(struct map_groups *self, enum map_type type)
97 98
{
	struct map *prev, *curr;
99
	struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
100 101 102 103 104 105 106 107 108 109

	if (prevnd == NULL)
		return;

	curr = rb_entry(prevnd, struct map, rb_node);

	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
		prev = curr;
		curr = rb_entry(nd, struct map, rb_node);
		prev->end = curr->start - 1;
110
	}
111 112 113 114 115 116

	/*
	 * We still haven't the actual symbols, so guess the
	 * last map final address.
	 */
	curr->end = ~0UL;
117 118
}

119
static void map_groups__fixup_end(struct map_groups *self)
120 121 122
{
	int i;
	for (i = 0; i < MAP__NR_TYPES; ++i)
123
		__map_groups__fixup_end(self, i);
124 125
}

126
static struct symbol *symbol__new(u64 start, u64 len, const char *name)
127
{
128
	size_t namelen = strlen(name) + 1;
129
	struct symbol *self = zalloc(symbol_conf.priv_size +
130 131
				     sizeof(*self) + namelen);
	if (self == NULL)
132 133
		return NULL;

134 135
	if (symbol_conf.priv_size)
		self = ((void *)self) + symbol_conf.priv_size;
136

137
	self->start = start;
138
	self->end   = len ? start + len - 1 : start;
139

140
	pr_debug3("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
141

142
	memcpy(self->name, name, namelen);
143 144 145 146

	return self;
}

147
static void symbol__delete(struct symbol *self)
148
{
149
	free(((void *)self) - symbol_conf.priv_size);
150 151 152 153
}

static size_t symbol__fprintf(struct symbol *self, FILE *fp)
{
154
	return fprintf(fp, " %llx-%llx %s\n",
155 156 157
		       self->start, self->end, self->name);
}

158
void dso__set_long_name(struct dso *self, char *name)
159
{
160 161
	if (name == NULL)
		return;
162 163 164 165 166 167 168 169 170
	self->long_name = name;
	self->long_name_len = strlen(name);
}

static void dso__set_basename(struct dso *self)
{
	self->short_name = basename(self->long_name);
}

171
struct dso *dso__new(const char *name)
172
{
173
	struct dso *self = zalloc(sizeof(*self) + strlen(name) + 1);
174 175

	if (self != NULL) {
176
		int i;
177
		strcpy(self->name, name);
178
		dso__set_long_name(self, self->name);
179
		self->short_name = self->name;
180
		for (i = 0; i < MAP__NR_TYPES; ++i)
181
			self->symbols[i] = self->symbol_names[i] = RB_ROOT;
182
		self->slen_calculated = 0;
183
		self->origin = DSO__ORIG_NOT_FOUND;
184
		self->loaded = 0;
185
		self->sorted_by_name = 0;
186
		self->has_build_id = 0;
187 188 189 190 191
	}

	return self;
}

192
static void symbols__delete(struct rb_root *self)
193 194
{
	struct symbol *pos;
195
	struct rb_node *next = rb_first(self);
196 197 198 199

	while (next) {
		pos = rb_entry(next, struct symbol, rb_node);
		next = rb_next(&pos->rb_node);
200
		rb_erase(&pos->rb_node, self);
201
		symbol__delete(pos);
202 203 204 205 206
	}
}

void dso__delete(struct dso *self)
{
207 208 209
	int i;
	for (i = 0; i < MAP__NR_TYPES; ++i)
		symbols__delete(&self->symbols[i]);
210 211
	if (self->long_name != self->name)
		free(self->long_name);
212 213 214
	free(self);
}

215 216 217 218 219 220
void dso__set_build_id(struct dso *self, void *build_id)
{
	memcpy(self->build_id, build_id, sizeof(self->build_id));
	self->has_build_id = 1;
}

221
static void symbols__insert(struct rb_root *self, struct symbol *sym)
222
{
223
	struct rb_node **p = &self->rb_node;
224
	struct rb_node *parent = NULL;
225
	const u64 ip = sym->start;
226 227 228 229 230 231 232 233 234 235 236
	struct symbol *s;

	while (*p != NULL) {
		parent = *p;
		s = rb_entry(parent, struct symbol, rb_node);
		if (ip < s->start)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}
	rb_link_node(&sym->rb_node, parent, p);
237
	rb_insert_color(&sym->rb_node, self);
238 239
}

240
static struct symbol *symbols__find(struct rb_root *self, u64 ip)
241 242 243 244 245 246
{
	struct rb_node *n;

	if (self == NULL)
		return NULL;

247
	n = self->rb_node;
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262

	while (n) {
		struct symbol *s = rb_entry(n, struct symbol, rb_node);

		if (ip < s->start)
			n = n->rb_left;
		else if (ip > s->end)
			n = n->rb_right;
		else
			return s;
	}

	return NULL;
}

263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
struct symbol_name_rb_node {
	struct rb_node	rb_node;
	struct symbol	sym;
};

static void symbols__insert_by_name(struct rb_root *self, struct symbol *sym)
{
	struct rb_node **p = &self->rb_node;
	struct rb_node *parent = NULL;
	struct symbol_name_rb_node *symn = ((void *)sym) - sizeof(*parent), *s;

	while (*p != NULL) {
		parent = *p;
		s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
		if (strcmp(sym->name, s->sym.name) < 0)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}
	rb_link_node(&symn->rb_node, parent, p);
	rb_insert_color(&symn->rb_node, self);
}

static void symbols__sort_by_name(struct rb_root *self, struct rb_root *source)
{
	struct rb_node *nd;

	for (nd = rb_first(source); nd; nd = rb_next(nd)) {
		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
		symbols__insert_by_name(self, pos);
	}
}

static struct symbol *symbols__find_by_name(struct rb_root *self, const char *name)
{
	struct rb_node *n;

	if (self == NULL)
		return NULL;

	n = self->rb_node;

	while (n) {
		struct symbol_name_rb_node *s;
		int cmp;

		s = rb_entry(n, struct symbol_name_rb_node, rb_node);
		cmp = strcmp(name, s->sym.name);

		if (cmp < 0)
			n = n->rb_left;
		else if (cmp > 0)
			n = n->rb_right;
		else
			return &s->sym;
	}

	return NULL;
}

struct symbol *dso__find_symbol(struct dso *self,
				enum map_type type, u64 addr)
325
{
326
	return symbols__find(&self->symbols[type], addr);
327 328
}

329 330 331 332 333 334 335 336 337 338 339 340 341
struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
					const char *name)
{
	return symbols__find_by_name(&self->symbol_names[type], name);
}

void dso__sort_by_name(struct dso *self, enum map_type type)
{
	dso__set_sorted_by_name(self, type);
	return symbols__sort_by_name(&self->symbol_names[type],
				     &self->symbols[type]);
}

342
int build_id__sprintf(const u8 *self, int len, char *bf)
343
{
344
	char *bid = bf;
345
	const u8 *raw = self;
346
	int i;
347

348 349 350 351 352 353 354 355 356
	for (i = 0; i < len; ++i) {
		sprintf(bid, "%02x", *raw);
		++raw;
		bid += 2;
	}

	return raw - self;
}

357
size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
358 359 360 361
{
	char sbuild_id[BUILD_ID_SIZE * 2 + 1];

	build_id__sprintf(self->build_id, sizeof(self->build_id), sbuild_id);
362 363 364
	return fprintf(fp, "%s", sbuild_id);
}

365
size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
366 367 368 369 370
{
	struct rb_node *nd;
	size_t ret = fprintf(fp, "dso: %s (", self->short_name);

	ret += dso__fprintf_buildid(self, fp);
371
	ret += fprintf(fp, ")\n");
372 373 374
	for (nd = rb_first(&self->symbols[type]); nd; nd = rb_next(nd)) {
		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
		ret += symbol__fprintf(pos, fp);
375 376 377 378 379
	}

	return ret;
}

380 381
int kallsyms__parse(const char *filename, void *arg,
		    int (*process_symbol)(void *arg, const char *name,
382
						     char type, u64 start))
383 384 385
{
	char *line = NULL;
	size_t n;
386
	int err = 0;
387
	FILE *file = fopen(filename, "r");
388 389 390 391 392

	if (file == NULL)
		goto out_failure;

	while (!feof(file)) {
393
		u64 start;
394 395
		int line_len, len;
		char symbol_type;
396
		char *symbol_name;
397 398 399 400 401 402 403 404 405 406

		line_len = getline(&line, &n, file);
		if (line_len < 0)
			break;

		if (!line)
			goto out_failure;

		line[--line_len] = '\0'; /* \n */

407
		len = hex2u64(line, &start);
408 409 410 411 412 413

		len++;
		if (len + 2 >= line_len)
			continue;

		symbol_type = toupper(line[len]);
414
		symbol_name = line + len + 2;
415 416 417 418

		err = process_symbol(arg, symbol_name, symbol_type, start);
		if (err)
			break;
419 420 421 422
	}

	free(line);
	fclose(file);
423
	return err;
424 425 426 427 428

out_failure:
	return -1;
}

429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
struct process_kallsyms_args {
	struct map *map;
	struct dso *dso;
};

static int map__process_kallsym_symbol(void *arg, const char *name,
				       char type, u64 start)
{
	struct symbol *sym;
	struct process_kallsyms_args *a = arg;
	struct rb_root *root = &a->dso->symbols[a->map->type];

	if (!symbol_type__is_a(type, a->map->type))
		return 0;

	/*
	 * Will fix up the end later, when we have all symbols sorted.
	 */
	sym = symbol__new(start, 0, name);

	if (sym == NULL)
		return -ENOMEM;
	/*
	 * We will pass the symbols to the filter later, in
	 * map__split_kallsyms, when we have split the maps per module
	 */
	symbols__insert(root, sym);
	return 0;
}

/*
 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
 * so that we can in the next step set the symbol ->end address and then
 * call kernel_maps__split_kallsyms.
 */
464 465
static int dso__load_all_kallsyms(struct dso *self, const char *filename,
				  struct map *map)
466 467
{
	struct process_kallsyms_args args = { .map = map, .dso = self, };
468
	return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
469 470
}

471 472 473 474 475
/*
 * Split the symbols into maps, making sure there are no overlaps, i.e. the
 * kernel range is broken in several maps, named [kernel].N, as we don't have
 * the original ELF section names vmlinux have.
 */
476
static int dso__split_kallsyms(struct dso *self, struct map *map,
477
			       symbol_filter_t filter)
478
{
479
	struct map_groups *kmaps = map__kmap(map)->kmaps;
480
	struct map *curr_map = map;
481 482
	struct symbol *pos;
	int count = 0;
483 484
	struct rb_root *root = &self->symbols[map->type];
	struct rb_node *next = rb_first(root);
485 486 487 488 489 490 491 492 493 494
	int kernel_range = 0;

	while (next) {
		char *module;

		pos = rb_entry(next, struct symbol, rb_node);
		next = rb_next(&pos->rb_node);

		module = strchr(pos->name, '\t');
		if (module) {
495
			if (!symbol_conf.use_modules)
496 497
				goto discard_symbol;

498 499
			*module++ = '\0';

500
			if (strcmp(curr_map->dso->short_name, module)) {
501
				curr_map = map_groups__find_by_name(kmaps, map->type, module);
502
				if (curr_map == NULL) {
503
					pr_debug("/proc/{kallsyms,modules} "
504 505
					         "inconsistency while looking "
						 "for \"%s\" module!\n", module);
506 507
					return -1;
				}
508 509 510

				if (curr_map->dso->loaded)
					goto discard_symbol;
511
			}
512 513 514 515
			/*
			 * So that we look just like we get from .ko files,
			 * i.e. not prelinked, relative to map->start.
			 */
516 517 518
			pos->start = curr_map->map_ip(curr_map, pos->start);
			pos->end   = curr_map->map_ip(curr_map, pos->end);
		} else if (curr_map != map) {
519 520 521 522 523 524
			char dso_name[PATH_MAX];
			struct dso *dso;

			snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
				 kernel_range++);

525
			dso = dso__new(dso_name);
526 527 528
			if (dso == NULL)
				return -1;

529
			curr_map = map__new2(pos->start, dso, map->type);
530 531 532 533
			if (map == NULL) {
				dso__delete(dso);
				return -1;
			}
534

535
			curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
536
			map_groups__insert(kmaps, curr_map);
537 538
			++kernel_range;
		}
539

540
		if (filter && filter(curr_map, pos)) {
541
discard_symbol:		rb_erase(&pos->rb_node, root);
542
			symbol__delete(pos);
543
		} else {
544 545 546
			if (curr_map != map) {
				rb_erase(&pos->rb_node, root);
				symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
547
			}
548 549
			count++;
		}
550 551
	}

552
	return count;
553
}
554

555 556
int dso__load_kallsyms(struct dso *self, const char *filename,
		       struct map *map, symbol_filter_t filter)
557
{
558
	if (dso__load_all_kallsyms(self, filename, map) < 0)
559 560
		return -1;

561 562
	symbols__fixup_end(&self->symbols[map->type]);
	self->origin = DSO__ORIG_KERNEL;
563

564
	return dso__split_kallsyms(self, map, filter);
565 566
}

567
static int dso__load_perf_map(struct dso *self, struct map *map,
568
			      symbol_filter_t filter)
569 570 571 572 573 574
{
	char *line = NULL;
	size_t n;
	FILE *file;
	int nr_syms = 0;

575
	file = fopen(self->long_name, "r");
576 577 578 579
	if (file == NULL)
		goto out_failure;

	while (!feof(file)) {
580
		u64 start, size;
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
		struct symbol *sym;
		int line_len, len;

		line_len = getline(&line, &n, file);
		if (line_len < 0)
			break;

		if (!line)
			goto out_failure;

		line[--line_len] = '\0'; /* \n */

		len = hex2u64(line, &start);

		len++;
		if (len + 2 >= line_len)
			continue;

		len += hex2u64(line + len, &size);

		len++;
		if (len + 2 >= line_len)
			continue;

605
		sym = symbol__new(start, size, line + len);
606 607 608 609

		if (sym == NULL)
			goto out_delete_line;

610
		if (filter && filter(map, sym))
611
			symbol__delete(sym);
612
		else {
613
			symbols__insert(&self->symbols[map->type], sym);
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
			nr_syms++;
		}
	}

	free(line);
	fclose(file);

	return nr_syms;

out_delete_line:
	free(line);
out_failure:
	return -1;
}

629 630 631 632
/**
 * elf_symtab__for_each_symbol - iterate thru all the symbols
 *
 * @self: struct elf_symtab instance to iterate
633
 * @idx: uint32_t idx
634 635
 * @sym: GElf_Sym iterator
 */
636 637 638 639
#define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
	for (idx = 0, gelf_getsym(syms, idx, &sym);\
	     idx < nr_syms; \
	     idx++, gelf_getsym(syms, idx, &sym))
640 641 642 643 644 645 646 647 648 649

static inline uint8_t elf_sym__type(const GElf_Sym *sym)
{
	return GELF_ST_TYPE(sym->st_info);
}

static inline int elf_sym__is_function(const GElf_Sym *sym)
{
	return elf_sym__type(sym) == STT_FUNC &&
	       sym->st_name != 0 &&
650
	       sym->st_shndx != SHN_UNDEF;
651 652
}

653 654 655 656 657 658 659
static inline bool elf_sym__is_object(const GElf_Sym *sym)
{
	return elf_sym__type(sym) == STT_OBJECT &&
		sym->st_name != 0 &&
		sym->st_shndx != SHN_UNDEF;
}

660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
static inline int elf_sym__is_label(const GElf_Sym *sym)
{
	return elf_sym__type(sym) == STT_NOTYPE &&
		sym->st_name != 0 &&
		sym->st_shndx != SHN_UNDEF &&
		sym->st_shndx != SHN_ABS;
}

static inline const char *elf_sec__name(const GElf_Shdr *shdr,
					const Elf_Data *secstrs)
{
	return secstrs->d_buf + shdr->sh_name;
}

static inline int elf_sec__is_text(const GElf_Shdr *shdr,
					const Elf_Data *secstrs)
{
	return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
}

680 681 682 683 684 685
static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
				    const Elf_Data *secstrs)
{
	return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
}

686 687 688 689 690 691 692 693
static inline const char *elf_sym__name(const GElf_Sym *sym,
					const Elf_Data *symstrs)
{
	return symstrs->d_buf + sym->st_name;
}

static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
				    GElf_Shdr *shp, const char *name,
694
				    size_t *idx)
695 696 697 698 699 700 701 702 703 704
{
	Elf_Scn *sec = NULL;
	size_t cnt = 1;

	while ((sec = elf_nextscn(elf, sec)) != NULL) {
		char *str;

		gelf_getshdr(sec, shp);
		str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
		if (!strcmp(name, str)) {
705 706
			if (idx)
				*idx = cnt;
707 708 709 710 711 712 713 714
			break;
		}
		++cnt;
	}

	return sec;
}

715 716 717 718 719 720 721 722 723 724
#define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
	for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
	     idx < nr_entries; \
	     ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))

#define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
	for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
	     idx < nr_entries; \
	     ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))

725 726 727 728 729 730 731
/*
 * We need to check if we have a .dynsym, so that we can handle the
 * .plt, synthesizing its symbols, that aren't on the symtabs (be it
 * .dynsym or .symtab).
 * And always look at the original dso, not at debuginfo packages, that
 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
 */
732 733
static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
				       symbol_filter_t filter)
734 735 736
{
	uint32_t nr_rel_entries, idx;
	GElf_Sym sym;
737
	u64 plt_offset;
738 739
	GElf_Shdr shdr_plt;
	struct symbol *f;
740
	GElf_Shdr shdr_rel_plt, shdr_dynsym;
741
	Elf_Data *reldata, *syms, *symstrs;
742 743 744
	Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
	size_t dynsym_idx;
	GElf_Ehdr ehdr;
745
	char sympltname[1024];
746 747 748
	Elf *elf;
	int nr = 0, symidx, fd, err = 0;

749
	fd = open(self->long_name, O_RDONLY);
750 751 752
	if (fd < 0)
		goto out;

753
	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
754 755 756 757 758 759 760 761 762 763
	if (elf == NULL)
		goto out_close;

	if (gelf_getehdr(elf, &ehdr) == NULL)
		goto out_elf_end;

	scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
					 ".dynsym", &dynsym_idx);
	if (scn_dynsym == NULL)
		goto out_elf_end;
764

765
	scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
766 767
					  ".rela.plt", NULL);
	if (scn_plt_rel == NULL) {
768
		scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
769 770
						  ".rel.plt", NULL);
		if (scn_plt_rel == NULL)
771
			goto out_elf_end;
772 773
	}

774 775
	err = -1;

776
	if (shdr_rel_plt.sh_link != dynsym_idx)
777
		goto out_elf_end;
778

779 780
	if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
		goto out_elf_end;
781 782

	/*
783
	 * Fetch the relocation section to find the idxes to the GOT
784 785 786 787
	 * and the symbols in the .dynsym they refer to.
	 */
	reldata = elf_getdata(scn_plt_rel, NULL);
	if (reldata == NULL)
788
		goto out_elf_end;
789 790 791

	syms = elf_getdata(scn_dynsym, NULL);
	if (syms == NULL)
792
		goto out_elf_end;
793

794
	scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
795
	if (scn_symstrs == NULL)
796
		goto out_elf_end;
797 798 799

	symstrs = elf_getdata(scn_symstrs, NULL);
	if (symstrs == NULL)
800
		goto out_elf_end;
801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816

	nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
	plt_offset = shdr_plt.sh_offset;

	if (shdr_rel_plt.sh_type == SHT_RELA) {
		GElf_Rela pos_mem, *pos;

		elf_section__for_each_rela(reldata, pos, pos_mem, idx,
					   nr_rel_entries) {
			symidx = GELF_R_SYM(pos->r_info);
			plt_offset += shdr_plt.sh_entsize;
			gelf_getsym(syms, symidx, &sym);
			snprintf(sympltname, sizeof(sympltname),
				 "%s@plt", elf_sym__name(&sym, symstrs));

			f = symbol__new(plt_offset, shdr_plt.sh_entsize,
817
					sympltname);
818
			if (!f)
819
				goto out_elf_end;
820

821 822 823
			if (filter && filter(map, f))
				symbol__delete(f);
			else {
824
				symbols__insert(&self->symbols[map->type], f);
825 826
				++nr;
			}
827 828 829 830 831 832 833 834 835 836 837 838
		}
	} else if (shdr_rel_plt.sh_type == SHT_REL) {
		GElf_Rel pos_mem, *pos;
		elf_section__for_each_rel(reldata, pos, pos_mem, idx,
					  nr_rel_entries) {
			symidx = GELF_R_SYM(pos->r_info);
			plt_offset += shdr_plt.sh_entsize;
			gelf_getsym(syms, symidx, &sym);
			snprintf(sympltname, sizeof(sympltname),
				 "%s@plt", elf_sym__name(&sym, symstrs));

			f = symbol__new(plt_offset, shdr_plt.sh_entsize,
839
					sympltname);
840
			if (!f)
841
				goto out_elf_end;
842

843 844 845
			if (filter && filter(map, f))
				symbol__delete(f);
			else {
846
				symbols__insert(&self->symbols[map->type], f);
847 848
				++nr;
			}
849 850 851
		}
	}

852 853 854 855 856 857 858 859 860
	err = 0;
out_elf_end:
	elf_end(elf);
out_close:
	close(fd);

	if (err == 0)
		return nr;
out:
861 862
	pr_warning("%s: problems reading %s PLT info.\n",
		   __func__, self->long_name);
863
	return 0;
864 865
}

866 867 868 869 870
static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
{
	switch (type) {
	case MAP__FUNCTION:
		return elf_sym__is_function(self);
871 872
	case MAP__VARIABLE:
		return elf_sym__is_object(self);
873 874 875 876 877 878 879 880 881 882
	default:
		return false;
	}
}

static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type)
{
	switch (type) {
	case MAP__FUNCTION:
		return elf_sec__is_text(self, secstrs);
883 884
	case MAP__VARIABLE:
		return elf_sec__is_data(self, secstrs);
885 886 887 888 889
	default:
		return false;
	}
}

890 891
static int dso__load_sym(struct dso *self, struct map *map, const char *name,
			 int fd, symbol_filter_t filter, int kmodule)
892
{
893
	struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
894 895 896
	struct map *curr_map = map;
	struct dso *curr_dso = self;
	size_t dso_name_len = strlen(self->short_name);
897
	Elf_Data *symstrs, *secstrs;
898 899
	uint32_t nr_syms;
	int err = -1;
900
	uint32_t idx;
901 902 903 904
	GElf_Ehdr ehdr;
	GElf_Shdr shdr;
	Elf_Data *syms;
	GElf_Sym sym;
905
	Elf_Scn *sec, *sec_strndx;
906
	Elf *elf;
907
	int nr = 0;
908

909
	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
910
	if (elf == NULL) {
911
		pr_err("%s: cannot read %s ELF file.\n", __func__, name);
912 913 914 915
		goto out_close;
	}

	if (gelf_getehdr(elf, &ehdr) == NULL) {
916
		pr_err("%s: cannot get elf header.\n", __func__);
917 918 919 920
		goto out_elf_end;
	}

	sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
921
	if (sec == NULL) {
922 923
		sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
		if (sec == NULL)
924 925
			goto out_elf_end;
	}
926 927 928 929 930 931 932 933 934 935 936 937 938

	syms = elf_getdata(sec, NULL);
	if (syms == NULL)
		goto out_elf_end;

	sec = elf_getscn(elf, shdr.sh_link);
	if (sec == NULL)
		goto out_elf_end;

	symstrs = elf_getdata(sec, NULL);
	if (symstrs == NULL)
		goto out_elf_end;

939 940 941 942 943
	sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
	if (sec_strndx == NULL)
		goto out_elf_end;

	secstrs = elf_getdata(sec_strndx, NULL);
944
	if (secstrs == NULL)
945 946
		goto out_elf_end;

947 948
	nr_syms = shdr.sh_size / shdr.sh_entsize;

949
	memset(&sym, 0, sizeof(sym));
950
	if (!self->kernel) {
951
		self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
952 953 954
				elf_section_by_name(elf, &ehdr, &shdr,
						     ".gnu.prelink_undo",
						     NULL) != NULL);
955 956
	} else self->adjust_symbols = 0;

957
	elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
958
		struct symbol *f;
959
		const char *elf_name = elf_sym__name(&sym, symstrs);
960
		char *demangled = NULL;
961 962
		int is_label = elf_sym__is_label(&sym);
		const char *section_name;
963

964 965 966
		if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
		    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
			kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
967

968
		if (!is_label && !elf_sym__is_a(&sym, map->type))
969 970 971 972 973 974 975
			continue;

		sec = elf_getscn(elf, sym.st_shndx);
		if (!sec)
			goto out_elf_end;

		gelf_getshdr(sec, &shdr);
976

977
		if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
978 979 980
			continue;

		section_name = elf_sec__name(&shdr, secstrs);
981

982
		if (self->kernel || kmodule) {
983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
			char dso_name[PATH_MAX];

			if (strcmp(section_name,
				   curr_dso->short_name + dso_name_len) == 0)
				goto new_symbol;

			if (strcmp(section_name, ".text") == 0) {
				curr_map = map;
				curr_dso = self;
				goto new_symbol;
			}

			snprintf(dso_name, sizeof(dso_name),
				 "%s%s", self->short_name, section_name);

998
			curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
999 1000 1001 1002 1003 1004
			if (curr_map == NULL) {
				u64 start = sym.st_value;

				if (kmodule)
					start += map->start + shdr.sh_offset;

1005
				curr_dso = dso__new(dso_name);
1006 1007
				if (curr_dso == NULL)
					goto out_elf_end;
1008
				curr_map = map__new2(start, curr_dso,
1009
						     map->type);
1010 1011 1012 1013
				if (curr_map == NULL) {
					dso__delete(curr_dso);
					goto out_elf_end;
				}
1014 1015
				curr_map->map_ip = identity__map_ip;
				curr_map->unmap_ip = identity__map_ip;
1016
				curr_dso->origin = DSO__ORIG_KERNEL;
1017
				map_groups__insert(kmap->kmaps, curr_map);
1018
				dsos__add(&dsos__kernel, curr_dso);
1019
				dso__set_loaded(curr_dso, map->type);
1020 1021 1022 1023
			} else
				curr_dso = curr_map->dso;

			goto new_symbol;
1024 1025
		}

1026
		if (curr_dso->adjust_symbols) {
1027 1028 1029
			pr_debug2("adjusting symbol: st_value: %Lx sh_addr: "
				  "%Lx sh_offset: %Lx\n", (u64)sym.st_value,
				  (u64)shdr.sh_addr, (u64)shdr.sh_offset);
1030
			sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1031
		}
1032 1033 1034 1035 1036
		/*
		 * We need to figure out if the object was created from C++ sources
		 * DWARF DW_compile_unit has this, but we don't always have access
		 * to it...
		 */
1037
		demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1038
		if (demangled != NULL)
1039
			elf_name = demangled;
1040
new_symbol:
1041
		f = symbol__new(sym.st_value, sym.st_size, elf_name);
1042
		free(demangled);
1043 1044 1045
		if (!f)
			goto out_elf_end;

1046
		if (filter && filter(curr_map, f))
1047
			symbol__delete(f);
1048
		else {
1049
			symbols__insert(&curr_dso->symbols[curr_map->type], f);
1050 1051
			nr++;
		}
1052 1053
	}

1054 1055 1056
	/*
	 * For misannotated, zeroed, ASM function sizes.
	 */
1057
	if (nr > 0) {
1058
		symbols__fixup_end(&self->symbols[map->type]);
1059 1060 1061 1062 1063 1064 1065 1066
		if (kmap) {
			/*
			 * We need to fixup this here too because we create new
			 * maps here, for things like vsyscall sections.
			 */
			__map_groups__fixup_end(kmap->kmaps, map->type);
		}
	}
1067 1068 1069 1070 1071 1072 1073
	err = nr;
out_elf_end:
	elf_end(elf);
out_close:
	return err;
}

1074 1075 1076 1077 1078
static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
{
	return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
}

1079
static bool __dsos__read_build_ids(struct list_head *head)
1080
{
1081
	bool have_build_id = false;
1082 1083
	struct dso *pos;

1084
	list_for_each_entry(pos, head, node)
1085 1086 1087 1088 1089
		if (filename__read_build_id(pos->long_name, pos->build_id,
					    sizeof(pos->build_id)) > 0) {
			have_build_id	  = true;
			pos->has_build_id = true;
		}
1090

1091
	return have_build_id;
1092 1093
}

1094 1095
bool dsos__read_build_ids(void)
{
1096 1097 1098
	bool kbuildids = __dsos__read_build_ids(&dsos__kernel),
	     ubuildids = __dsos__read_build_ids(&dsos__user);
	return kbuildids || ubuildids;
1099 1100
}

1101 1102 1103 1104 1105
/*
 * Align offset to 4 bytes as needed for note name and descriptor data.
 */
#define NOTE_ALIGN(n) (((n) + 3) & -4U)

1106
int filename__read_build_id(const char *filename, void *bf, size_t size)
1107
{
1108
	int fd, err = -1;
1109 1110
	GElf_Ehdr ehdr;
	GElf_Shdr shdr;
1111
	Elf_Data *data;
1112
	Elf_Scn *sec;
1113
	Elf_Kind ek;
1114
	void *ptr;
1115 1116
	Elf *elf;

1117 1118 1119 1120
	if (size < BUILD_ID_SIZE)
		goto out;

	fd = open(filename, O_RDONLY);
1121 1122 1123
	if (fd < 0)
		goto out;

1124
	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1125
	if (elf == NULL) {
1126
		pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1127 1128 1129
		goto out_close;
	}

1130 1131 1132 1133
	ek = elf_kind(elf);
	if (ek != ELF_K_ELF)
		goto out_elf_end;

1134
	if (gelf_getehdr(elf, &ehdr) == NULL) {
1135
		pr_err("%s: cannot get elf header.\n", __func__);
1136 1137 1138
		goto out_elf_end;
	}

1139 1140
	sec = elf_section_by_name(elf, &ehdr, &shdr,
				  ".note.gnu.build-id", NULL);
1141 1142 1143 1144 1145 1146
	if (sec == NULL) {
		sec = elf_section_by_name(elf, &ehdr, &shdr,
					  ".notes", NULL);
		if (sec == NULL)
			goto out_elf_end;
	}
1147

1148 1149
	data = elf_getdata(sec, NULL);
	if (data == NULL)
1150
		goto out_elf_end;
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171

	ptr = data->d_buf;
	while (ptr < (data->d_buf + data->d_size)) {
		GElf_Nhdr *nhdr = ptr;
		int namesz = NOTE_ALIGN(nhdr->n_namesz),
		    descsz = NOTE_ALIGN(nhdr->n_descsz);
		const char *name;

		ptr += sizeof(*nhdr);
		name = ptr;
		ptr += namesz;
		if (nhdr->n_type == NT_GNU_BUILD_ID &&
		    nhdr->n_namesz == sizeof("GNU")) {
			if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
				memcpy(bf, ptr, BUILD_ID_SIZE);
				err = BUILD_ID_SIZE;
				break;
			}
		}
		ptr += descsz;
	}
1172 1173 1174 1175 1176 1177 1178 1179
out_elf_end:
	elf_end(elf);
out_close:
	close(fd);
out:
	return err;
}

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
{
	int fd, err = -1;

	if (size < BUILD_ID_SIZE)
		goto out;

	fd = open(filename, O_RDONLY);
	if (fd < 0)
		goto out;

	while (1) {
		char bf[BUFSIZ];
		GElf_Nhdr nhdr;
		int namesz, descsz;

		if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
			break;

1199 1200
		namesz = NOTE_ALIGN(nhdr.n_namesz);
		descsz = NOTE_ALIGN(nhdr.n_descsz);
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
		if (nhdr.n_type == NT_GNU_BUILD_ID &&
		    nhdr.n_namesz == sizeof("GNU")) {
			if (read(fd, bf, namesz) != namesz)
				break;
			if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
				if (read(fd, build_id,
				    BUILD_ID_SIZE) == BUILD_ID_SIZE) {
					err = 0;
					break;
				}
			} else if (read(fd, bf, descsz) != descsz)
				break;
		} else {
			int n = namesz + descsz;
			if (read(fd, bf, n) != n)
				break;
		}
	}
	close(fd);
out:
	return err;
}

1224 1225 1226 1227 1228
char dso__symtab_origin(const struct dso *self)
{
	static const char origin[] = {
		[DSO__ORIG_KERNEL] =   'k',
		[DSO__ORIG_JAVA_JIT] = 'j',
1229
		[DSO__ORIG_BUILD_ID_CACHE] = 'B',
1230 1231 1232 1233
		[DSO__ORIG_FEDORA] =   'f',
		[DSO__ORIG_UBUNTU] =   'u',
		[DSO__ORIG_BUILDID] =  'b',
		[DSO__ORIG_DSO] =      'd',
1234
		[DSO__ORIG_KMODULE] =  'K',
1235 1236 1237 1238 1239 1240 1241
	};

	if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
		return '!';
	return origin[self->origin];
}

1242
int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1243
{
1244
	int size = PATH_MAX;
1245
	char *name;
1246
	u8 build_id[BUILD_ID_SIZE];
1247
	char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1248 1249 1250
	int ret = -1;
	int fd;

1251
	dso__set_loaded(self, map->type);
1252

1253
	if (self->kernel)
1254
		return dso__load_kernel_sym(self, map, filter);
1255 1256

	name = malloc(size);
1257 1258 1259
	if (!name)
		return -1;

1260
	self->adjust_symbols = 0;
1261

1262
	if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
1263
		ret = dso__load_perf_map(self, map, filter);
1264 1265 1266 1267 1268
		self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
					 DSO__ORIG_NOT_FOUND;
		return ret;
	}

1269
	self->origin = DSO__ORIG_BUILD_ID_CACHE;
1270

1271 1272 1273 1274 1275 1276 1277 1278
	if (self->has_build_id) {
		build_id__sprintf(self->build_id, sizeof(self->build_id),
				  build_id_hex);
		snprintf(name, size, "%s/%s/.build-id/%.2s/%s",
			 getenv("HOME"), DEBUG_CACHE_DIR,
			 build_id_hex, build_id_hex + 2);
		goto open_file;
	}
1279 1280
more:
	do {
1281 1282 1283
		self->origin++;
		switch (self->origin) {
		case DSO__ORIG_FEDORA:
1284 1285
			snprintf(name, size, "/usr/lib/debug%s.debug",
				 self->long_name);
1286
			break;
1287
		case DSO__ORIG_UBUNTU:
1288 1289
			snprintf(name, size, "/usr/lib/debug%s",
				 self->long_name);
1290
			break;
1291
		case DSO__ORIG_BUILDID:
1292 1293 1294 1295
			if (filename__read_build_id(self->long_name, build_id,
						    sizeof(build_id))) {
				build_id__sprintf(build_id, sizeof(build_id),
						  build_id_hex);
1296 1297
				snprintf(name, size,
					 "/usr/lib/debug/.build-id/%.2s/%s.debug",
1298 1299 1300 1301
					build_id_hex, build_id_hex + 2);
				if (self->has_build_id)
					goto compare_build_id;
				break;
1302
			}
1303
			self->origin++;
1304
			/* Fall thru */
1305
		case DSO__ORIG_DSO:
1306
			snprintf(name, size, "%s", self->long_name);
1307 1308 1309 1310 1311 1312
			break;

		default:
			goto out;
		}

1313
		if (self->has_build_id) {
1314 1315
			if (filename__read_build_id(name, build_id,
						    sizeof(build_id)) < 0)
1316 1317
				goto more;
compare_build_id:
1318
			if (!dso__build_id_equal(self, build_id))
1319 1320
				goto more;
		}
1321
open_file:
1322 1323 1324
		fd = open(name, O_RDONLY);
	} while (fd < 0);

1325
	ret = dso__load_sym(self, map, name, fd, filter, 0);
1326 1327 1328 1329 1330 1331 1332 1333
	close(fd);

	/*
	 * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
	 */
	if (!ret)
		goto more;

1334
	if (ret > 0) {
1335
		int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
1336 1337 1338
		if (nr_plt > 0)
			ret += nr_plt;
	}
1339 1340
out:
	free(name);
1341 1342
	if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
		return 0;
1343 1344 1345
	return ret;
}

1346 1347
struct map *map_groups__find_by_name(struct map_groups *self,
				     enum map_type type, const char *name)
1348 1349 1350
{
	struct rb_node *nd;

1351
	for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
1352 1353
		struct map *map = rb_entry(nd, struct map, rb_node);

1354
		if (map->dso && strcmp(map->dso->short_name, name) == 0)
1355 1356 1357 1358 1359 1360
			return map;
	}

	return NULL;
}

1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
static int dso__kernel_module_get_build_id(struct dso *self)
{
	char filename[PATH_MAX];
	/*
	 * kernel module short names are of the form "[module]" and
	 * we need just "module" here.
	 */
	const char *name = self->short_name + 1;

	snprintf(filename, sizeof(filename),
		 "/sys/module/%.*s/notes/.note.gnu.build-id",
		 (int)strlen(name - 1), name);

	if (sysfs__read_build_id(filename, self->build_id,
				 sizeof(self->build_id)) == 0)
		self->has_build_id = true;

	return 0;
}

1381
static int map_groups__set_modules_path_dir(struct map_groups *self, char *dirname)
1382
{
1383 1384
	struct dirent *dent;
	DIR *dir = opendir(dirname);
1385

1386
	if (!dir) {
1387
		pr_debug("%s: cannot open %s dir\n", __func__, dirname);
1388 1389
		return -1;
	}
1390

1391 1392 1393 1394 1395 1396 1397 1398 1399 1400
	while ((dent = readdir(dir)) != NULL) {
		char path[PATH_MAX];

		if (dent->d_type == DT_DIR) {
			if (!strcmp(dent->d_name, ".") ||
			    !strcmp(dent->d_name, ".."))
				continue;

			snprintf(path, sizeof(path), "%s/%s",
				 dirname, dent->d_name);
1401
			if (map_groups__set_modules_path_dir(self, path) < 0)
1402 1403 1404 1405 1406
				goto failure;
		} else {
			char *dot = strrchr(dent->d_name, '.'),
			     dso_name[PATH_MAX];
			struct map *map;
1407
			char *long_name;
1408 1409 1410 1411 1412 1413

			if (dot == NULL || strcmp(dot, ".ko"))
				continue;
			snprintf(dso_name, sizeof(dso_name), "[%.*s]",
				 (int)(dot - dent->d_name), dent->d_name);

1414
			strxfrchar(dso_name, '-', '_');
1415
			map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
1416 1417 1418 1419 1420 1421
			if (map == NULL)
				continue;

			snprintf(path, sizeof(path), "%s/%s",
				 dirname, dent->d_name);

1422 1423
			long_name = strdup(path);
			if (long_name == NULL)
1424
				goto failure;
1425
			dso__set_long_name(map->dso, long_name);
1426
			dso__kernel_module_get_build_id(map->dso);
1427 1428
		}
	}
1429

1430
	return 0;
1431 1432 1433 1434
failure:
	closedir(dir);
	return -1;
}
1435

1436
static int map_groups__set_modules_path(struct map_groups *self)
1437 1438 1439
{
	struct utsname uts;
	char modules_path[PATH_MAX];
1440

1441 1442
	if (uname(&uts) < 0)
		return -1;
1443

1444 1445
	snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
		 uts.release);
1446

1447
	return map_groups__set_modules_path_dir(self, modules_path);
1448 1449
}

1450 1451 1452 1453 1454
/*
 * Constructor variant for modules (where we know from /proc/modules where
 * they are loaded) and for vmlinux, where only after we load all the
 * symbols we'll know where it starts and ends.
 */
1455
static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1456
{
1457 1458
	struct map *self = zalloc(sizeof(*self) +
				  (dso->kernel ? sizeof(struct kmap) : 0));
1459 1460
	if (self != NULL) {
		/*
1461
		 * ->end will be filled after we load all the symbols
1462
		 */
1463
		map__init(self, type, start, 0, 0, dso);
1464
	}
1465

1466 1467 1468
	return self;
}

1469 1470
struct map *map_groups__new_module(struct map_groups *self, u64 start,
				   const char *filename)
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
{
	struct map *map;
	struct dso *dso = __dsos__findnew(&dsos__kernel, filename);

	if (dso == NULL)
		return NULL;

	map = map__new2(start, dso, MAP__FUNCTION);
	if (map == NULL)
		return NULL;

	dso->origin = DSO__ORIG_KMODULE;
1483
	map_groups__insert(self, map);
1484 1485 1486
	return map;
}

1487
static int map_groups__create_modules(struct map_groups *self)
1488 1489 1490 1491 1492
{
	char *line = NULL;
	size_t n;
	FILE *file = fopen("/proc/modules", "r");
	struct map *map;
1493

1494 1495
	if (file == NULL)
		return -1;
1496

1497 1498 1499 1500 1501
	while (!feof(file)) {
		char name[PATH_MAX];
		u64 start;
		char *sep;
		int line_len;
1502

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
		line_len = getline(&line, &n, file);
		if (line_len < 0)
			break;

		if (!line)
			goto out_failure;

		line[--line_len] = '\0'; /* \n */

		sep = strrchr(line, 'x');
		if (sep == NULL)
			continue;

		hex2u64(sep + 1, &start);

		sep = strchr(line, ' ');
		if (sep == NULL)
			continue;

		*sep = '\0';

		snprintf(name, sizeof(name), "[%s]", line);
1525
		map = map_groups__new_module(self, start, name);
1526
		if (map == NULL)
1527
			goto out_delete_line;
1528
		dso__kernel_module_get_build_id(map->dso);
1529
	}
1530 1531 1532 1533

	free(line);
	fclose(file);

1534
	return map_groups__set_modules_path(self);
1535 1536 1537 1538 1539

out_delete_line:
	free(line);
out_failure:
	return -1;
1540 1541
}

1542
static int dso__load_vmlinux(struct dso *self, struct map *map,
1543
			     const char *vmlinux, symbol_filter_t filter)
1544
{
1545
	int err = -1, fd;
1546

1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
	if (self->has_build_id) {
		u8 build_id[BUILD_ID_SIZE];

		if (filename__read_build_id(vmlinux, build_id,
					    sizeof(build_id)) < 0) {
			pr_debug("No build_id in %s, ignoring it\n", vmlinux);
			return -1;
		}
		if (!dso__build_id_equal(self, build_id)) {
			char expected_build_id[BUILD_ID_SIZE * 2 + 1],
			     vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];

			build_id__sprintf(self->build_id,
					  sizeof(self->build_id),
					  expected_build_id);
			build_id__sprintf(build_id, sizeof(build_id),
					  vmlinux_build_id);
			pr_debug("build_id in %s is %s while expected is %s, "
				 "ignoring it\n", vmlinux, vmlinux_build_id,
				 expected_build_id);
			return -1;
		}
	}
1570

1571
	fd = open(vmlinux, O_RDONLY);
1572 1573 1574
	if (fd < 0)
		return -1;

1575
	dso__set_loaded(self, map->type);
1576
	err = dso__load_sym(self, map, vmlinux, fd, filter, 0);
1577 1578 1579 1580 1581
	close(fd);

	return err;
}

1582
int dso__load_vmlinux_path(struct dso *self, struct map *map,
1583
			   symbol_filter_t filter)
1584 1585 1586 1587 1588 1589 1590
{
	int i, err = 0;

	pr_debug("Looking at the vmlinux_path (%d entries long)\n",
		 vmlinux_path__nr_entries);

	for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1591
		err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
		if (err > 0) {
			pr_debug("Using %s for symbols\n", vmlinux_path[i]);
			dso__set_long_name(self, strdup(vmlinux_path[i]));
			break;
		}
	}

	return err;
}

1602
static int dso__load_kernel_sym(struct dso *self, struct map *map,
1603
				symbol_filter_t filter)
1604
{
1605
	int err;
1606 1607
	const char *kallsyms_filename = NULL;
	char *kallsyms_allocated_filename = NULL;
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
	/*
	 * Step 1: if the user specified a vmlinux filename, use it and only
	 * it, reporting errors to the user if it cannot be used.
	 *
	 * For instance, try to analyse an ARM perf.data file _without_ a
	 * build-id, or if the user specifies the wrong path to the right
	 * vmlinux file, obviously we can't fallback to another vmlinux (a
	 * x86_86 one, on the machine where analysis is being performed, say),
	 * or worse, /proc/kallsyms.
	 *
	 * If the specified file _has_ a build-id and there is a build-id
	 * section in the perf.data file, we will still do the expected
	 * validation in dso__load_vmlinux and will bail out if they don't
	 * match.
	 */
	if (symbol_conf.vmlinux_name != NULL) {
1624
		err = dso__load_vmlinux(self, map,
1625 1626 1627
					symbol_conf.vmlinux_name, filter);
		goto out_try_fixup;
	}
1628 1629

	if (vmlinux_path != NULL) {
1630
		err = dso__load_vmlinux_path(self, map, filter);
1631 1632
		if (err > 0)
			goto out_fixup;
1633 1634
	}

1635 1636 1637 1638 1639 1640 1641
	/*
	 * Say the kernel DSO was created when processing the build-id header table,
	 * we have a build-id, so check if it is the same as the running kernel,
	 * using it if it is.
	 */
	if (self->has_build_id) {
		u8 kallsyms_build_id[BUILD_ID_SIZE];
1642
		char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1643 1644

		if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
1645
					 sizeof(kallsyms_build_id)) == 0) {
1646 1647
			if (dso__build_id_equal(self, kallsyms_build_id)) {
				kallsyms_filename = "/proc/kallsyms";
1648
				goto do_kallsyms;
1649
			}
1650
		}
1651 1652 1653 1654
		/*
		 * Now look if we have it on the build-id cache in
		 * $HOME/.debug/[kernel.kallsyms].
		 */
1655 1656 1657 1658 1659
		build_id__sprintf(self->build_id, sizeof(self->build_id),
				  sbuild_id);

		if (asprintf(&kallsyms_allocated_filename,
			     "%s/.debug/[kernel.kallsyms]/%s",
1660 1661 1662
			     getenv("HOME"), sbuild_id) == -1)
			return -1;

1663 1664
		kallsyms_filename = kallsyms_allocated_filename;

1665
		if (access(kallsyms_filename, F_OK)) {
1666
			free(kallsyms_allocated_filename);
1667
			return -1;
1668
		}
1669 1670 1671 1672 1673
	} else {
		/*
		 * Last resort, if we don't have a build-id and couldn't find
		 * any vmlinux file, try the running kernel kallsyms table.
		 */
1674 1675
		kallsyms_filename = "/proc/kallsyms";
	}
1676

1677
do_kallsyms:
1678
	err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1679
	free(kallsyms_allocated_filename);
1680

1681
out_try_fixup:
1682
	if (err > 0) {
1683
out_fixup:
1684
		if (kallsyms_filename != NULL)
1685
			dso__set_long_name(self, strdup("[kernel.kallsyms]"));
1686 1687
		map__fixup_start(map);
		map__fixup_end(map);
1688
	}
1689

1690 1691 1692
	return err;
}

1693 1694
LIST_HEAD(dsos__user);
LIST_HEAD(dsos__kernel);
1695

1696
static void dsos__add(struct list_head *head, struct dso *dso)
1697
{
1698
	list_add_tail(&dso->node, head);
1699 1700
}

1701
static struct dso *dsos__find(struct list_head *head, const char *name)
1702 1703 1704
{
	struct dso *pos;

1705
	list_for_each_entry(pos, head, node)
1706
		if (strcmp(pos->long_name, name) == 0)
1707 1708 1709 1710
			return pos;
	return NULL;
}

1711
struct dso *__dsos__findnew(struct list_head *head, const char *name)
1712
{
1713
	struct dso *dso = dsos__find(head, name);
1714

1715
	if (!dso) {
1716
		dso = dso__new(name);
1717
		if (dso != NULL) {
1718
			dsos__add(head, dso);
1719 1720
			dso__set_basename(dso);
		}
1721
	}
1722 1723 1724 1725

	return dso;
}

1726
static void __dsos__fprintf(struct list_head *head, FILE *fp)
1727 1728 1729
{
	struct dso *pos;

1730 1731 1732 1733 1734
	list_for_each_entry(pos, head, node) {
		int i;
		for (i = 0; i < MAP__NR_TYPES; ++i)
			dso__fprintf(pos, i, fp);
	}
1735 1736
}

1737 1738 1739 1740 1741 1742
void dsos__fprintf(FILE *fp)
{
	__dsos__fprintf(&dsos__kernel, fp);
	__dsos__fprintf(&dsos__user, fp);
}

1743 1744
static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
				      bool with_hits)
1745 1746 1747 1748
{
	struct dso *pos;
	size_t ret = 0;

1749
	list_for_each_entry(pos, head, node) {
1750 1751
		if (with_hits && !pos->hit)
			continue;
1752
		ret += dso__fprintf_buildid(pos, fp);
1753
		ret += fprintf(fp, " %s\n", pos->long_name);
1754 1755 1756 1757
	}
	return ret;
}

1758
size_t dsos__fprintf_buildid(FILE *fp, bool with_hits)
1759
{
1760 1761
	return (__dsos__fprintf_buildid(&dsos__kernel, fp, with_hits) +
		__dsos__fprintf_buildid(&dsos__user, fp, with_hits));
1762 1763
}

1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
struct dso *dso__new_kernel(const char *name)
{
	struct dso *self = dso__new(name ?: "[kernel.kallsyms]");

	if (self != NULL) {
		self->short_name = "[kernel]";
		self->kernel	 = 1;
	}

	return self;
}

void dso__read_running_kernel_build_id(struct dso *self)
{
	if (sysfs__read_build_id("/sys/kernel/notes", self->build_id,
				 sizeof(self->build_id)) == 0)
		self->has_build_id = true;
}

1783
static struct dso *dsos__create_kernel(const char *vmlinux)
1784
{
1785
	struct dso *kernel = dso__new_kernel(vmlinux);
1786

1787 1788 1789 1790
	if (kernel != NULL) {
		dso__read_running_kernel_build_id(kernel);
		dsos__add(&dsos__kernel, kernel);
	}
1791

1792 1793 1794
	return kernel;
}

1795 1796 1797
int __map_groups__create_kernel_maps(struct map_groups *self,
				     struct map *vmlinux_maps[MAP__NR_TYPES],
				     struct dso *kernel)
1798
{
1799
	enum map_type type;
1800

1801
	for (type = 0; type < MAP__NR_TYPES; ++type) {
1802 1803
		struct kmap *kmap;

1804 1805 1806
		vmlinux_maps[type] = map__new2(0, kernel, type);
		if (vmlinux_maps[type] == NULL)
			return -1;
1807

1808 1809
		vmlinux_maps[type]->map_ip =
			vmlinux_maps[type]->unmap_ip = identity__map_ip;
1810 1811 1812

		kmap = map__kmap(vmlinux_maps[type]);
		kmap->kmaps = self;
1813
		map_groups__insert(self, vmlinux_maps[type]);
1814 1815 1816
	}

	return 0;
1817 1818
}

1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
static void vmlinux_path__exit(void)
{
	while (--vmlinux_path__nr_entries >= 0) {
		free(vmlinux_path[vmlinux_path__nr_entries]);
		vmlinux_path[vmlinux_path__nr_entries] = NULL;
	}

	free(vmlinux_path);
	vmlinux_path = NULL;
}

static int vmlinux_path__init(void)
{
	struct utsname uts;
	char bf[PATH_MAX];

	if (uname(&uts) < 0)
		return -1;

	vmlinux_path = malloc(sizeof(char *) * 5);
	if (vmlinux_path == NULL)
		return -1;

	vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
		goto out_fail;
	++vmlinux_path__nr_entries;
	vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
		goto out_fail;
	++vmlinux_path__nr_entries;
	snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
		goto out_fail;
	++vmlinux_path__nr_entries;
	snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
		goto out_fail;
	++vmlinux_path__nr_entries;
	snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
		 uts.release);
	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
		goto out_fail;
	++vmlinux_path__nr_entries;

	return 0;

out_fail:
	vmlinux_path__exit();
	return -1;
}

1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887
static int setup_list(struct strlist **list, const char *list_str,
		      const char *list_name)
{
	if (list_str == NULL)
		return 0;

	*list = strlist__new(true, list_str);
	if (!*list) {
		pr_err("problems parsing %s list\n", list_name);
		return -1;
	}
	return 0;
}

1888
int symbol__init(void)
1889
{
1890
	elf_version(EV_CURRENT);
1891 1892 1893
	if (symbol_conf.sort_by_name)
		symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
					  sizeof(struct symbol));
1894

1895
	if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
1896 1897
		return -1;

1898 1899 1900 1901 1902
	if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
		pr_err("'.' is the only non valid --field-separator argument\n");
		return -1;
	}

1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914
	if (setup_list(&symbol_conf.dso_list,
		       symbol_conf.dso_list_str, "dso") < 0)
		return -1;

	if (setup_list(&symbol_conf.comm_list,
		       symbol_conf.comm_list_str, "comm") < 0)
		goto out_free_dso_list;

	if (setup_list(&symbol_conf.sym_list,
		       symbol_conf.sym_list_str, "symbol") < 0)
		goto out_free_comm_list;

1915
	return 0;
1916 1917 1918 1919 1920 1921

out_free_dso_list:
	strlist__delete(symbol_conf.dso_list);
out_free_comm_list:
	strlist__delete(symbol_conf.comm_list);
	return -1;
1922 1923
}

1924 1925
int map_groups__create_kernel_maps(struct map_groups *self,
				   struct map *vmlinux_maps[MAP__NR_TYPES])
1926
{
1927 1928 1929 1930 1931 1932
	struct dso *kernel = dsos__create_kernel(symbol_conf.vmlinux_name);

	if (kernel == NULL)
		return -1;

	if (__map_groups__create_kernel_maps(self, vmlinux_maps, kernel) < 0)
1933 1934
		return -1;

1935 1936
	if (symbol_conf.use_modules && map_groups__create_modules(self) < 0)
		return -1;
1937 1938 1939
	/*
	 * Now that we have all the maps created, just set the ->end of them:
	 */
1940
	map_groups__fixup_end(self);
1941
	return 0;
1942
}