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