symbol.c 59.0 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
#define _GNU_SOURCE
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <libgen.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <fcntl.h>
#include <unistd.h>
14
#include "build-id.h"
15
#include "debug.h"
16
#include "symbol.h"
17
#include "strlist.h"
18 19 20 21

#include <libelf.h>
#include <gelf.h>
#include <elf.h>
22
#include <limits.h>
23
#include <sys/utsname.h>
P
Peter Zijlstra 已提交
24

25 26 27 28
#ifndef KSYM_NAME_LEN
#define KSYM_NAME_LEN 128
#endif

29 30 31 32
#ifndef NT_GNU_BUILD_ID
#define NT_GNU_BUILD_ID 3
#endif

33 34
static bool dso__build_id_equal(const struct dso *self, u8 *build_id);
static int elf_read_build_id(Elf *elf, void *bf, size_t size);
35
static void dsos__add(struct list_head *head, struct dso *dso);
36
static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
37
static int dso__load_kernel_sym(struct dso *self, struct map *map,
38
				symbol_filter_t filter);
39 40
static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
			symbol_filter_t filter);
41 42
static int vmlinux_path__nr_entries;
static char **vmlinux_path;
43

44
struct symbol_conf symbol_conf = {
45
	.exclude_other	  = true,
46 47
	.use_modules	  = true,
	.try_vmlinux_path = true,
48
	.symfs            = "",
49 50
};

51 52 53 54 55 56 57 58
int dso__name_len(const struct dso *self)
{
	if (verbose)
		return self->long_name_len;

	return self->short_name_len;
}

59 60 61 62 63
bool dso__loaded(const struct dso *self, enum map_type type)
{
	return self->loaded & (1 << type);
}

64 65 66 67 68 69 70 71 72 73
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);
}

74
bool symbol_type__is_a(char symbol_type, enum map_type map_type)
75 76 77 78
{
	switch (map_type) {
	case MAP__FUNCTION:
		return symbol_type == 'T' || symbol_type == 'W';
79 80
	case MAP__VARIABLE:
		return symbol_type == 'D' || symbol_type == 'd';
81 82 83 84 85
	default:
		return false;
	}
}

86
static void symbols__fixup_end(struct rb_root *self)
87
{
88
	struct rb_node *nd, *prevnd = rb_first(self);
89
	struct symbol *curr, *prev;
90 91 92 93

	if (prevnd == NULL)
		return;

94 95
	curr = rb_entry(prevnd, struct symbol, rb_node);

96
	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
97 98
		prev = curr;
		curr = rb_entry(nd, struct symbol, rb_node);
99

100
		if (prev->end == prev->start && prev->end != curr->start)
101 102
			prev->end = curr->start - 1;
	}
103 104 105 106

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

109
static void __map_groups__fixup_end(struct map_groups *self, enum map_type type)
110 111
{
	struct map *prev, *curr;
112
	struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
113 114 115 116 117 118 119 120 121 122

	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;
123
	}
124 125 126 127 128

	/*
	 * We still haven't the actual symbols, so guess the
	 * last map final address.
	 */
129
	curr->end = ~0ULL;
130 131
}

132
static void map_groups__fixup_end(struct map_groups *self)
133 134 135
{
	int i;
	for (i = 0; i < MAP__NR_TYPES; ++i)
136
		__map_groups__fixup_end(self, i);
137 138
}

139 140
static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
				  const char *name)
141
{
142
	size_t namelen = strlen(name) + 1;
143 144
	struct symbol *self = calloc(1, (symbol_conf.priv_size +
					 sizeof(*self) + namelen));
145
	if (self == NULL)
146 147
		return NULL;

148 149
	if (symbol_conf.priv_size)
		self = ((void *)self) + symbol_conf.priv_size;
150

151 152
	self->start   = start;
	self->end     = len ? start + len - 1 : start;
153
	self->binding = binding;
154
	self->namelen = namelen - 1;
155

156
	pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
157

158
	memcpy(self->name, name, namelen);
159 160 161 162

	return self;
}

163
void symbol__delete(struct symbol *self)
164
{
165
	free(((void *)self) - symbol_conf.priv_size);
166 167 168 169
}

static size_t symbol__fprintf(struct symbol *self, FILE *fp)
{
170 171 172 173 174
	return fprintf(fp, " %llx-%llx %c %s\n",
		       self->start, self->end,
		       self->binding == STB_GLOBAL ? 'g' :
		       self->binding == STB_LOCAL  ? 'l' : 'w',
		       self->name);
175 176
}

177
void dso__set_long_name(struct dso *self, char *name)
178
{
179 180
	if (name == NULL)
		return;
181 182 183 184
	self->long_name = name;
	self->long_name_len = strlen(name);
}

185 186 187 188 189 190 191 192
static void dso__set_short_name(struct dso *self, const char *name)
{
	if (name == NULL)
		return;
	self->short_name = name;
	self->short_name_len = strlen(name);
}

193 194
static void dso__set_basename(struct dso *self)
{
195
	dso__set_short_name(self, basename(self->long_name));
196 197
}

198
struct dso *dso__new(const char *name)
199
{
200
	struct dso *self = calloc(1, sizeof(*self) + strlen(name) + 1);
201 202

	if (self != NULL) {
203
		int i;
204
		strcpy(self->name, name);
205
		dso__set_long_name(self, self->name);
206
		dso__set_short_name(self, self->name);
207
		for (i = 0; i < MAP__NR_TYPES; ++i)
208
			self->symbols[i] = self->symbol_names[i] = RB_ROOT;
209
		self->slen_calculated = 0;
210
		self->origin = DSO__ORIG_NOT_FOUND;
211
		self->loaded = 0;
212
		self->sorted_by_name = 0;
213
		self->has_build_id = 0;
214
		self->kernel = DSO_TYPE_USER;
215
		INIT_LIST_HEAD(&self->node);
216 217 218 219 220
	}

	return self;
}

221
static void symbols__delete(struct rb_root *self)
222 223
{
	struct symbol *pos;
224
	struct rb_node *next = rb_first(self);
225 226 227 228

	while (next) {
		pos = rb_entry(next, struct symbol, rb_node);
		next = rb_next(&pos->rb_node);
229
		rb_erase(&pos->rb_node, self);
230
		symbol__delete(pos);
231 232 233 234 235
	}
}

void dso__delete(struct dso *self)
{
236 237 238
	int i;
	for (i = 0; i < MAP__NR_TYPES; ++i)
		symbols__delete(&self->symbols[i]);
239 240 241
	if (self->sname_alloc)
		free((char *)self->short_name);
	if (self->lname_alloc)
242
		free(self->long_name);
243 244 245
	free(self);
}

246 247 248 249 250 251
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;
}

252
static void symbols__insert(struct rb_root *self, struct symbol *sym)
253
{
254
	struct rb_node **p = &self->rb_node;
255
	struct rb_node *parent = NULL;
256
	const u64 ip = sym->start;
257 258 259 260 261 262 263 264 265 266 267
	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);
268
	rb_insert_color(&sym->rb_node, self);
269 270
}

271
static struct symbol *symbols__find(struct rb_root *self, u64 ip)
272 273 274 275 276 277
{
	struct rb_node *n;

	if (self == NULL)
		return NULL;

278
	n = self->rb_node;
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293

	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;
}

294 295 296 297 298 299 300 301 302
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;
303 304 305
	struct symbol_name_rb_node *symn, *s;

	symn = container_of(sym, struct symbol_name_rb_node, sym);
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357

	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)
358
{
359
	return symbols__find(&self->symbols[type], addr);
360 361
}

362 363 364 365 366 367 368 369 370 371 372 373 374
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]);
}

375
int build_id__sprintf(const u8 *self, int len, char *bf)
376
{
377
	char *bid = bf;
378
	const u8 *raw = self;
379
	int i;
380

381 382 383 384 385 386 387 388 389
	for (i = 0; i < len; ++i) {
		sprintf(bid, "%02x", *raw);
		++raw;
		bid += 2;
	}

	return raw - self;
}

390
size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
391 392 393 394
{
	char sbuild_id[BUILD_ID_SIZE * 2 + 1];

	build_id__sprintf(self->build_id, sizeof(self->build_id), sbuild_id);
395 396 397
	return fprintf(fp, "%s", sbuild_id);
}

398 399 400 401 402 403 404 405 406 407 408 409 410 411
size_t dso__fprintf_symbols_by_name(struct dso *self, enum map_type type, FILE *fp)
{
	size_t ret = 0;
	struct rb_node *nd;
	struct symbol_name_rb_node *pos;

	for (nd = rb_first(&self->symbol_names[type]); nd; nd = rb_next(nd)) {
		pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
		fprintf(fp, "%s\n", pos->sym.name);
	}

	return ret;
}

412
size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
413 414 415 416
{
	struct rb_node *nd;
	size_t ret = fprintf(fp, "dso: %s (", self->short_name);

417 418 419 420
	if (self->short_name != self->long_name)
		ret += fprintf(fp, "%s, ", self->long_name);
	ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
		       self->loaded ? "" : "NOT ");
421
	ret += dso__fprintf_buildid(self, fp);
422
	ret += fprintf(fp, ")\n");
423 424 425
	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);
426 427 428 429 430
	}

	return ret;
}

431 432
int kallsyms__parse(const char *filename, void *arg,
		    int (*process_symbol)(void *arg, const char *name,
433
					  char type, u64 start, u64 end))
434 435 436
{
	char *line = NULL;
	size_t n;
437 438 439 440
	int err = -1;
	u64 prev_start = 0;
	char prev_symbol_type = 0;
	char *prev_symbol_name;
441
	FILE *file = fopen(filename, "r");
442 443 444 445

	if (file == NULL)
		goto out_failure;

446 447 448 449 450 451
	prev_symbol_name = malloc(KSYM_NAME_LEN);
	if (prev_symbol_name == NULL)
		goto out_close;

	err = 0;

452
	while (!feof(file)) {
453
		u64 start;
454 455
		int line_len, len;
		char symbol_type;
456
		char *symbol_name;
457 458

		line_len = getline(&line, &n, file);
459
		if (line_len < 0 || !line)
460 461 462 463
			break;

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

464
		len = hex2u64(line, &start);
465 466 467 468 469 470

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

		symbol_type = toupper(line[len]);
471 472 473
		len += 2;
		symbol_name = line + len;
		len = line_len - len;
474

475 476
		if (len >= KSYM_NAME_LEN) {
			err = -1;
477
			break;
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
		}

		if (prev_symbol_type) {
			u64 end = start;
			if (end != prev_start)
				--end;
			err = process_symbol(arg, prev_symbol_name,
					     prev_symbol_type, prev_start, end);
			if (err)
				break;
		}

		memcpy(prev_symbol_name, symbol_name, len + 1);
		prev_symbol_type = symbol_type;
		prev_start = start;
493 494
	}

495
	free(prev_symbol_name);
496
	free(line);
497
out_close:
498
	fclose(file);
499
	return err;
500 501 502 503 504

out_failure:
	return -1;
}

505 506 507 508 509
struct process_kallsyms_args {
	struct map *map;
	struct dso *dso;
};

510 511 512 513 514 515 516 517
static u8 kallsyms2elf_type(char type)
{
	if (type == 'W')
		return STB_WEAK;

	return isupper(type) ? STB_GLOBAL : STB_LOCAL;
}

518
static int map__process_kallsym_symbol(void *arg, const char *name,
519
				       char type, u64 start, u64 end)
520 521 522 523 524 525 526 527
{
	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;

528 529
	sym = symbol__new(start, end - start + 1,
			  kallsyms2elf_type(type), name);
530 531 532 533 534 535 536
	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);
537

538 539 540 541 542 543 544 545
	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.
 */
546 547
static int dso__load_all_kallsyms(struct dso *self, const char *filename,
				  struct map *map)
548 549
{
	struct process_kallsyms_args args = { .map = map, .dso = self, };
550
	return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
551 552
}

553 554 555 556 557
/*
 * 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.
 */
558
static int dso__split_kallsyms(struct dso *self, struct map *map,
559
			       symbol_filter_t filter)
560
{
561
	struct map_groups *kmaps = map__kmap(map)->kmaps;
562
	struct machine *machine = kmaps->machine;
563
	struct map *curr_map = map;
564
	struct symbol *pos;
565
	int count = 0, moved = 0;	
566 567
	struct rb_root *root = &self->symbols[map->type];
	struct rb_node *next = rb_first(root);
568 569 570 571 572 573 574 575 576 577
	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) {
578
			if (!symbol_conf.use_modules)
579 580
				goto discard_symbol;

581 582
			*module++ = '\0';

583
			if (strcmp(curr_map->dso->short_name, module)) {
584
				if (curr_map != map &&
585 586
				    self->kernel == DSO_TYPE_GUEST_KERNEL &&
				    machine__is_default_guest(machine)) {
587 588 589 590 591 592 593 594 595 596 597 598 599
					/*
					 * We assume all symbols of a module are
					 * continuous in * kallsyms, so curr_map
					 * points to a module and all its
					 * symbols are in its kmap. Mark it as
					 * loaded.
					 */
					dso__set_loaded(curr_map->dso,
							curr_map->type);
				}

				curr_map = map_groups__find_by_name(kmaps,
							map->type, module);
600
				if (curr_map == NULL) {
601
					pr_debug("%s/proc/{kallsyms,modules} "
602
					         "inconsistency while looking "
603
						 "for \"%s\" module!\n",
604
						 machine->root_dir, module);
605 606
					curr_map = map;
					goto discard_symbol;
607
				}
608

609
				if (curr_map->dso->loaded &&
610
				    !machine__is_default_guest(machine))
611
					goto discard_symbol;
612
			}
613 614 615 616
			/*
			 * So that we look just like we get from .ko files,
			 * i.e. not prelinked, relative to map->start.
			 */
617 618 619
			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) {
620 621 622
			char dso_name[PATH_MAX];
			struct dso *dso;

623 624 625 626 627
			if (count == 0) {
				curr_map = map;
				goto filter_symbol;
			}

628 629 630 631 632 633 634 635
			if (self->kernel == DSO_TYPE_GUEST_KERNEL)
				snprintf(dso_name, sizeof(dso_name),
					"[guest.kernel].%d",
					kernel_range++);
			else
				snprintf(dso_name, sizeof(dso_name),
					"[kernel].%d",
					kernel_range++);
636

637
			dso = dso__new(dso_name);
638 639 640
			if (dso == NULL)
				return -1;

641 642
			dso->kernel = self->kernel;

643
			curr_map = map__new2(pos->start, dso, map->type);
644
			if (curr_map == NULL) {
645 646 647
				dso__delete(dso);
				return -1;
			}
648

649
			curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
650
			map_groups__insert(kmaps, curr_map);
651 652
			++kernel_range;
		}
653
filter_symbol:
654
		if (filter && filter(curr_map, pos)) {
655
discard_symbol:		rb_erase(&pos->rb_node, root);
656
			symbol__delete(pos);
657
		} else {
658 659 660
			if (curr_map != map) {
				rb_erase(&pos->rb_node, root);
				symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
661 662 663
				++moved;
			} else
				++count;
664
		}
665 666
	}

667 668
	if (curr_map != map &&
	    self->kernel == DSO_TYPE_GUEST_KERNEL &&
669
	    machine__is_default_guest(kmaps->machine)) {
670 671 672
		dso__set_loaded(curr_map->dso, curr_map->type);
	}

673
	return count + moved;
674
}
675

676 677
int dso__load_kallsyms(struct dso *self, const char *filename,
		       struct map *map, symbol_filter_t filter)
678
{
679
	if (dso__load_all_kallsyms(self, filename, map) < 0)
680 681
		return -1;

682 683 684 685
	if (self->kernel == DSO_TYPE_GUEST_KERNEL)
		self->origin = DSO__ORIG_GUEST_KERNEL;
	else
		self->origin = DSO__ORIG_KERNEL;
686

687
	return dso__split_kallsyms(self, map, filter);
688 689
}

690
static int dso__load_perf_map(struct dso *self, struct map *map,
691
			      symbol_filter_t filter)
692 693 694 695 696 697
{
	char *line = NULL;
	size_t n;
	FILE *file;
	int nr_syms = 0;

698
	file = fopen(self->long_name, "r");
699 700 701 702
	if (file == NULL)
		goto out_failure;

	while (!feof(file)) {
703
		u64 start, size;
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
		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;

728
		sym = symbol__new(start, size, STB_GLOBAL, line + len);
729 730 731 732

		if (sym == NULL)
			goto out_delete_line;

733
		if (filter && filter(map, sym))
734
			symbol__delete(sym);
735
		else {
736
			symbols__insert(&self->symbols[map->type], sym);
737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
			nr_syms++;
		}
	}

	free(line);
	fclose(file);

	return nr_syms;

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

752 753 754 755
/**
 * elf_symtab__for_each_symbol - iterate thru all the symbols
 *
 * @self: struct elf_symtab instance to iterate
756
 * @idx: uint32_t idx
757 758
 * @sym: GElf_Sym iterator
 */
759 760 761 762
#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))
763 764 765 766 767 768 769 770 771 772

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 &&
773
	       sym->st_shndx != SHN_UNDEF;
774 775
}

776 777 778 779 780 781 782
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;
}

783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
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;
}

803 804 805 806 807 808
static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
				    const Elf_Data *secstrs)
{
	return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
}

809 810 811 812 813 814 815 816
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,
817
				    size_t *idx)
818 819 820 821 822 823 824 825 826 827
{
	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)) {
828 829
			if (idx)
				*idx = cnt;
830 831 832 833 834 835 836 837
			break;
		}
		++cnt;
	}

	return sec;
}

838 839 840 841 842 843 844 845 846 847
#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))

848 849 850 851 852 853 854
/*
 * 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).
 */
855 856
static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
				       symbol_filter_t filter)
857 858 859
{
	uint32_t nr_rel_entries, idx;
	GElf_Sym sym;
860
	u64 plt_offset;
861 862
	GElf_Shdr shdr_plt;
	struct symbol *f;
863
	GElf_Shdr shdr_rel_plt, shdr_dynsym;
864
	Elf_Data *reldata, *syms, *symstrs;
865 866 867
	Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
	size_t dynsym_idx;
	GElf_Ehdr ehdr;
868
	char sympltname[1024];
869 870
	Elf *elf;
	int nr = 0, symidx, fd, err = 0;
871
	char name[PATH_MAX];
872

873 874 875
	snprintf(name, sizeof(name), "%s%s",
		 symbol_conf.symfs, self->long_name);
	fd = open(name, O_RDONLY);
876 877 878
	if (fd < 0)
		goto out;

879
	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
880 881 882 883 884 885 886 887 888 889
	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;
890

891
	scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
892 893
					  ".rela.plt", NULL);
	if (scn_plt_rel == NULL) {
894
		scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
895 896
						  ".rel.plt", NULL);
		if (scn_plt_rel == NULL)
897
			goto out_elf_end;
898 899
	}

900 901
	err = -1;

902
	if (shdr_rel_plt.sh_link != dynsym_idx)
903
		goto out_elf_end;
904

905 906
	if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
		goto out_elf_end;
907 908

	/*
909
	 * Fetch the relocation section to find the idxes to the GOT
910 911 912 913
	 * and the symbols in the .dynsym they refer to.
	 */
	reldata = elf_getdata(scn_plt_rel, NULL);
	if (reldata == NULL)
914
		goto out_elf_end;
915 916 917

	syms = elf_getdata(scn_dynsym, NULL);
	if (syms == NULL)
918
		goto out_elf_end;
919

920
	scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
921
	if (scn_symstrs == NULL)
922
		goto out_elf_end;
923 924 925

	symstrs = elf_getdata(scn_symstrs, NULL);
	if (symstrs == NULL)
926
		goto out_elf_end;
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942

	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,
943
					STB_GLOBAL, sympltname);
944
			if (!f)
945
				goto out_elf_end;
946

947 948 949
			if (filter && filter(map, f))
				symbol__delete(f);
			else {
950
				symbols__insert(&self->symbols[map->type], f);
951 952
				++nr;
			}
953 954 955 956 957 958 959 960 961 962 963 964
		}
	} 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,
965
					STB_GLOBAL, sympltname);
966
			if (!f)
967
				goto out_elf_end;
968

969 970 971
			if (filter && filter(map, f))
				symbol__delete(f);
			else {
972
				symbols__insert(&self->symbols[map->type], f);
973 974
				++nr;
			}
975 976 977
		}
	}

978 979 980 981 982 983 984 985 986
	err = 0;
out_elf_end:
	elf_end(elf);
out_close:
	close(fd);

	if (err == 0)
		return nr;
out:
987 988
	pr_debug("%s: problems reading %s PLT info.\n",
		 __func__, self->long_name);
989
	return 0;
990 991
}

992 993 994 995 996
static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
{
	switch (type) {
	case MAP__FUNCTION:
		return elf_sym__is_function(self);
997 998
	case MAP__VARIABLE:
		return elf_sym__is_object(self);
999 1000 1001 1002 1003 1004 1005 1006 1007 1008
	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);
1009 1010
	case MAP__VARIABLE:
		return elf_sec__is_data(self, secstrs);
1011 1012 1013 1014 1015
	default:
		return false;
	}
}

1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
{
	Elf_Scn *sec = NULL;
	GElf_Shdr shdr;
	size_t cnt = 1;

	while ((sec = elf_nextscn(elf, sec)) != NULL) {
		gelf_getshdr(sec, &shdr);

		if ((addr >= shdr.sh_addr) &&
		    (addr < (shdr.sh_addr + shdr.sh_size)))
			return cnt;

		++cnt;
	}

	return -1;
}

1035
static int dso__load_sym(struct dso *self, struct map *map, const char *name,
1036 1037
			 int fd, symbol_filter_t filter, int kmodule,
			 int want_symtab)
1038
{
1039
	struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
1040 1041
	struct map *curr_map = map;
	struct dso *curr_dso = self;
1042
	Elf_Data *symstrs, *secstrs;
1043 1044
	uint32_t nr_syms;
	int err = -1;
1045
	uint32_t idx;
1046
	GElf_Ehdr ehdr;
1047 1048
	GElf_Shdr shdr, opdshdr;
	Elf_Data *syms, *opddata = NULL;
1049
	GElf_Sym sym;
1050
	Elf_Scn *sec, *sec_strndx, *opdsec;
1051
	Elf *elf;
1052
	int nr = 0;
1053
	size_t opdidx = 0;
1054

1055
	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1056
	if (elf == NULL) {
1057
		pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1058 1059 1060 1061
		goto out_close;
	}

	if (gelf_getehdr(elf, &ehdr) == NULL) {
1062
		pr_debug("%s: cannot get elf header.\n", __func__);
1063 1064 1065
		goto out_elf_end;
	}

1066
	/* Always reject images with a mismatched build-id: */
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
	if (self->has_build_id) {
		u8 build_id[BUILD_ID_SIZE];

		if (elf_read_build_id(elf, build_id,
				      BUILD_ID_SIZE) != BUILD_ID_SIZE)
			goto out_elf_end;

		if (!dso__build_id_equal(self, build_id))
			goto out_elf_end;
	}

1078
	sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
1079
	if (sec == NULL) {
1080 1081 1082
		if (want_symtab)
			goto out_elf_end;

1083 1084
		sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
		if (sec == NULL)
1085 1086
			goto out_elf_end;
	}
1087

1088 1089 1090 1091
	opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
	if (opdsec)
		opddata = elf_rawdata(opdsec, NULL);

1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
	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;

1104 1105 1106 1107 1108
	sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
	if (sec_strndx == NULL)
		goto out_elf_end;

	secstrs = elf_getdata(sec_strndx, NULL);
S
Stoyan Gaydarov 已提交
1109
	if (secstrs == NULL)
1110 1111
		goto out_elf_end;

1112 1113
	nr_syms = shdr.sh_size / shdr.sh_entsize;

1114
	memset(&sym, 0, sizeof(sym));
1115
	if (self->kernel == DSO_TYPE_USER) {
1116
		self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
1117 1118 1119
				elf_section_by_name(elf, &ehdr, &shdr,
						     ".gnu.prelink_undo",
						     NULL) != NULL);
1120 1121
	} else self->adjust_symbols = 0;

1122
	elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1123
		struct symbol *f;
1124
		const char *elf_name = elf_sym__name(&sym, symstrs);
1125
		char *demangled = NULL;
1126 1127
		int is_label = elf_sym__is_label(&sym);
		const char *section_name;
1128

1129 1130 1131
		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;
1132

1133
		if (!is_label && !elf_sym__is_a(&sym, map->type))
1134 1135
			continue;

1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
		/* Reject ARM ELF "mapping symbols": these aren't unique and
		 * don't identify functions, so will confuse the profile
		 * output: */
		if (ehdr.e_machine == EM_ARM) {
			if (!strcmp(elf_name, "$a") ||
			    !strcmp(elf_name, "$d") ||
			    !strcmp(elf_name, "$t"))
				continue;
		}

1146 1147 1148 1149 1150 1151 1152
		if (opdsec && sym.st_shndx == opdidx) {
			u32 offset = sym.st_value - opdshdr.sh_addr;
			u64 *opd = opddata->d_buf + offset;
			sym.st_value = *opd;
			sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
		}

1153 1154 1155 1156 1157
		sec = elf_getscn(elf, sym.st_shndx);
		if (!sec)
			goto out_elf_end;

		gelf_getshdr(sec, &shdr);
1158

1159
		if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1160 1161 1162
			continue;

		section_name = elf_sec__name(&shdr, secstrs);
1163

1164 1165 1166 1167 1168 1169 1170
		/* On ARM, symbols for thumb functions have 1 added to
		 * the symbol address as a flag - remove it */
		if ((ehdr.e_machine == EM_ARM) &&
		    (map->type == MAP__FUNCTION) &&
		    (sym.st_value & 1))
			--sym.st_value;

1171
		if (self->kernel != DSO_TYPE_USER || kmodule) {
1172 1173 1174
			char dso_name[PATH_MAX];

			if (strcmp(section_name,
1175 1176
				   (curr_dso->short_name +
				    self->short_name_len)) == 0)
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
				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);

1188
			curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1189 1190 1191 1192 1193 1194
			if (curr_map == NULL) {
				u64 start = sym.st_value;

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

1195
				curr_dso = dso__new(dso_name);
1196 1197
				if (curr_dso == NULL)
					goto out_elf_end;
1198
				curr_dso->kernel = self->kernel;
1199
				curr_map = map__new2(start, curr_dso,
1200
						     map->type);
1201 1202 1203 1204
				if (curr_map == NULL) {
					dso__delete(curr_dso);
					goto out_elf_end;
				}
1205 1206
				curr_map->map_ip = identity__map_ip;
				curr_map->unmap_ip = identity__map_ip;
1207
				curr_dso->origin = self->origin;
1208
				map_groups__insert(kmap->kmaps, curr_map);
1209
				dsos__add(&self->node, curr_dso);
1210
				dso__set_loaded(curr_dso, map->type);
1211 1212 1213 1214
			} else
				curr_dso = curr_map->dso;

			goto new_symbol;
1215 1216
		}

1217
		if (curr_dso->adjust_symbols) {
1218 1219 1220 1221
			pr_debug4("%s: adjusting symbol: st_value: %#Lx "
				  "sh_addr: %#Lx sh_offset: %#Lx\n", __func__,
				  (u64)sym.st_value, (u64)shdr.sh_addr,
				  (u64)shdr.sh_offset);
1222
			sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1223
		}
1224 1225 1226 1227 1228
		/*
		 * 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...
		 */
1229
		demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1230
		if (demangled != NULL)
1231
			elf_name = demangled;
1232
new_symbol:
1233 1234
		f = symbol__new(sym.st_value, sym.st_size,
				GELF_ST_BIND(sym.st_info), elf_name);
1235
		free(demangled);
1236 1237 1238
		if (!f)
			goto out_elf_end;

1239
		if (filter && filter(curr_map, f))
1240
			symbol__delete(f);
1241
		else {
1242
			symbols__insert(&curr_dso->symbols[curr_map->type], f);
1243 1244
			nr++;
		}
1245 1246
	}

1247 1248 1249
	/*
	 * For misannotated, zeroed, ASM function sizes.
	 */
1250
	if (nr > 0) {
1251
		symbols__fixup_end(&self->symbols[map->type]);
1252 1253 1254 1255 1256 1257 1258 1259
		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);
		}
	}
1260 1261 1262 1263 1264 1265 1266
	err = nr;
out_elf_end:
	elf_end(elf);
out_close:
	return err;
}

1267 1268 1269 1270 1271
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;
}

1272
bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1273
{
1274
	bool have_build_id = false;
1275 1276
	struct dso *pos;

1277 1278 1279
	list_for_each_entry(pos, head, node) {
		if (with_hits && !pos->hit)
			continue;
1280 1281 1282 1283
		if (pos->has_build_id) {
			have_build_id = true;
			continue;
		}
1284 1285 1286 1287 1288
		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;
		}
1289
	}
1290

1291
	return have_build_id;
1292 1293
}

1294 1295 1296 1297 1298
/*
 * Align offset to 4 bytes as needed for note name and descriptor data.
 */
#define NOTE_ALIGN(n) (((n) + 3) & -4U)

1299
static int elf_read_build_id(Elf *elf, void *bf, size_t size)
1300
{
1301
	int err = -1;
1302 1303
	GElf_Ehdr ehdr;
	GElf_Shdr shdr;
1304
	Elf_Data *data;
1305
	Elf_Scn *sec;
1306
	Elf_Kind ek;
1307
	void *ptr;
1308

1309 1310 1311
	if (size < BUILD_ID_SIZE)
		goto out;

1312 1313
	ek = elf_kind(elf);
	if (ek != ELF_K_ELF)
1314
		goto out;
1315

1316
	if (gelf_getehdr(elf, &ehdr) == NULL) {
1317
		pr_err("%s: cannot get elf header.\n", __func__);
1318
		goto out;
1319 1320
	}

1321 1322
	sec = elf_section_by_name(elf, &ehdr, &shdr,
				  ".note.gnu.build-id", NULL);
1323 1324 1325 1326
	if (sec == NULL) {
		sec = elf_section_by_name(elf, &ehdr, &shdr,
					  ".notes", NULL);
		if (sec == NULL)
1327
			goto out;
1328
	}
1329

1330 1331
	data = elf_getdata(sec, NULL);
	if (data == NULL)
1332
		goto out;
1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353

	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;
	}
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378

out:
	return err;
}

int filename__read_build_id(const char *filename, void *bf, size_t size)
{
	int fd, err = -1;
	Elf *elf;

	if (size < BUILD_ID_SIZE)
		goto out;

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

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

	err = elf_read_build_id(elf, bf, size);

1379 1380 1381 1382 1383 1384 1385
	elf_end(elf);
out_close:
	close(fd);
out:
	return err;
}

1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
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;

1405 1406
		namesz = NOTE_ALIGN(nhdr.n_namesz);
		descsz = NOTE_ALIGN(nhdr.n_descsz);
1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
		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;
}

1430 1431 1432 1433 1434
char dso__symtab_origin(const struct dso *self)
{
	static const char origin[] = {
		[DSO__ORIG_KERNEL] =   'k',
		[DSO__ORIG_JAVA_JIT] = 'j',
1435
		[DSO__ORIG_BUILD_ID_CACHE] = 'B',
1436 1437 1438 1439
		[DSO__ORIG_FEDORA] =   'f',
		[DSO__ORIG_UBUNTU] =   'u',
		[DSO__ORIG_BUILDID] =  'b',
		[DSO__ORIG_DSO] =      'd',
1440
		[DSO__ORIG_KMODULE] =  'K',
1441 1442
		[DSO__ORIG_GUEST_KERNEL] =  'g',
		[DSO__ORIG_GUEST_KMODULE] =  'G',
1443 1444 1445 1446 1447 1448 1449
	};

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

1450
int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1451
{
1452
	int size = PATH_MAX;
1453
	char *name;
1454 1455
	int ret = -1;
	int fd;
1456
	struct machine *machine;
1457
	const char *root_dir;
1458
	int want_symtab;
1459

1460
	dso__set_loaded(self, map->type);
1461

1462
	if (self->kernel == DSO_TYPE_KERNEL)
1463
		return dso__load_kernel_sym(self, map, filter);
1464 1465 1466
	else if (self->kernel == DSO_TYPE_GUEST_KERNEL)
		return dso__load_guest_kernel_sym(self, map, filter);

1467 1468
	if (map->groups && map->groups->machine)
		machine = map->groups->machine;
1469
	else
1470
		machine = NULL;
1471 1472

	name = malloc(size);
1473 1474 1475
	if (!name)
		return -1;

1476
	self->adjust_symbols = 0;
1477

1478
	if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
1479
		ret = dso__load_perf_map(self, map, filter);
1480 1481 1482 1483 1484
		self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
					 DSO__ORIG_NOT_FOUND;
		return ret;
	}

1485 1486 1487 1488 1489 1490 1491
	/* Iterate over candidate debug images.
	 * On the first pass, only load images if they have a full symtab.
	 * Failing that, do a second pass where we accept .dynsym also
	 */
	for (self->origin = DSO__ORIG_BUILD_ID_CACHE, want_symtab = 1;
	     self->origin != DSO__ORIG_NOT_FOUND;
	     self->origin++) {
1492
		switch (self->origin) {
1493
		case DSO__ORIG_BUILD_ID_CACHE:
1494 1495 1496
			/* skip the locally configured cache if a symfs is given */
			if (symbol_conf.symfs[0] ||
			    (dso__build_id_filename(self, name, size) == NULL)) {
1497
				continue;
1498
			}
1499
			break;
1500
		case DSO__ORIG_FEDORA:
1501 1502
			snprintf(name, size, "%s/usr/lib/debug%s.debug",
				 symbol_conf.symfs, self->long_name);
1503
			break;
1504
		case DSO__ORIG_UBUNTU:
1505 1506
			snprintf(name, size, "%s/usr/lib/debug%s",
				 symbol_conf.symfs, self->long_name);
1507
			break;
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
		case DSO__ORIG_BUILDID: {
			char build_id_hex[BUILD_ID_SIZE * 2 + 1];

			if (!self->has_build_id)
				continue;

			build_id__sprintf(self->build_id,
					  sizeof(self->build_id),
					  build_id_hex);
			snprintf(name, size,
1518 1519
				 "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
				 symbol_conf.symfs, build_id_hex, build_id_hex + 2);
1520
			}
1521
			break;
1522
		case DSO__ORIG_DSO:
1523 1524
			snprintf(name, size, "%s%s",
			     symbol_conf.symfs, self->long_name);
1525
			break;
1526
		case DSO__ORIG_GUEST_KMODULE:
1527 1528
			if (map->groups && map->groups->machine)
				root_dir = map->groups->machine->root_dir;
1529 1530
			else
				root_dir = "";
1531 1532 1533 1534 1535 1536 1537
			snprintf(name, size, "%s%s%s", symbol_conf.symfs,
				 root_dir, self->long_name);
			break;

		case DSO__ORIG_KMODULE:
			snprintf(name, size, "%s%s", symbol_conf.symfs,
				 self->long_name);
1538
			break;
1539 1540

		default:
1541 1542 1543 1544 1545 1546 1547 1548 1549
			/*
			 * If we wanted a full symtab but no image had one,
			 * relax our requirements and repeat the search.
			 */
			if (want_symtab) {
				want_symtab = 0;
				self->origin = DSO__ORIG_BUILD_ID_CACHE;
			} else
				continue;
1550
		}
1551 1552

		/* Name is now the name of the next image to try */
1553
		fd = open(name, O_RDONLY);
1554 1555
		if (fd < 0)
			continue;
1556

1557 1558 1559
		ret = dso__load_sym(self, map, name, fd, filter, 0,
				    want_symtab);
		close(fd);
1560

1561 1562 1563 1564 1565 1566
		/*
		 * Some people seem to have debuginfo files _WITHOUT_ debug
		 * info!?!?
		 */
		if (!ret)
			continue;
1567

1568 1569 1570 1571 1572 1573
		if (ret > 0) {
			int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
			if (nr_plt > 0)
				ret += nr_plt;
			break;
		}
1574
	}
1575

1576
	free(name);
1577 1578
	if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
		return 0;
1579 1580 1581
	return ret;
}

1582 1583
struct map *map_groups__find_by_name(struct map_groups *self,
				     enum map_type type, const char *name)
1584 1585 1586
{
	struct rb_node *nd;

1587
	for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
1588 1589
		struct map *map = rb_entry(nd, struct map, rb_node);

1590
		if (map->dso && strcmp(map->dso->short_name, name) == 0)
1591 1592 1593 1594 1595 1596
			return map;
	}

	return NULL;
}

1597 1598
static int dso__kernel_module_get_build_id(struct dso *self,
				const char *root_dir)
1599 1600 1601 1602 1603 1604 1605 1606 1607
{
	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),
1608 1609
		 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
		 root_dir, (int)strlen(name) - 1, name);
1610 1611 1612 1613 1614 1615 1616 1617

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

	return 0;
}

1618 1619
static int map_groups__set_modules_path_dir(struct map_groups *self,
				const char *dir_name)
1620
{
1621
	struct dirent *dent;
1622
	DIR *dir = opendir(dir_name);
1623
	int ret = 0;
1624

1625
	if (!dir) {
1626
		pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1627 1628
		return -1;
	}
1629

1630 1631
	while ((dent = readdir(dir)) != NULL) {
		char path[PATH_MAX];
1632 1633 1634 1635 1636 1637
		struct stat st;

		/*sshfs might return bad dent->d_type, so we have to stat*/
		sprintf(path, "%s/%s", dir_name, dent->d_name);
		if (stat(path, &st))
			continue;
1638

1639
		if (S_ISDIR(st.st_mode)) {
1640 1641 1642 1643 1644
			if (!strcmp(dent->d_name, ".") ||
			    !strcmp(dent->d_name, ".."))
				continue;

			snprintf(path, sizeof(path), "%s/%s",
1645
				 dir_name, dent->d_name);
1646 1647 1648
			ret = map_groups__set_modules_path_dir(self, path);
			if (ret < 0)
				goto out;
1649 1650 1651 1652
		} else {
			char *dot = strrchr(dent->d_name, '.'),
			     dso_name[PATH_MAX];
			struct map *map;
1653
			char *long_name;
1654 1655 1656 1657 1658 1659

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

1660
			strxfrchar(dso_name, '-', '_');
1661
			map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
1662 1663 1664 1665
			if (map == NULL)
				continue;

			snprintf(path, sizeof(path), "%s/%s",
1666
				 dir_name, dent->d_name);
1667

1668
			long_name = strdup(path);
1669 1670 1671 1672
			if (long_name == NULL) {
				ret = -1;
				goto out;
			}
1673
			dso__set_long_name(map->dso, long_name);
1674
			map->dso->lname_alloc = 1;
1675
			dso__kernel_module_get_build_id(map->dso, "");
1676 1677
		}
	}
1678

1679
out:
1680
	closedir(dir);
1681
	return ret;
1682
}
1683

1684
static char *get_kernel_version(const char *root_dir)
1685
{
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710
	char version[PATH_MAX];
	FILE *file;
	char *name, *tmp;
	const char *prefix = "Linux version ";

	sprintf(version, "%s/proc/version", root_dir);
	file = fopen(version, "r");
	if (!file)
		return NULL;

	version[0] = '\0';
	tmp = fgets(version, sizeof(version), file);
	fclose(file);

	name = strstr(version, prefix);
	if (!name)
		return NULL;
	name += strlen(prefix);
	tmp = strchr(name, ' ');
	if (tmp)
		*tmp = '\0';

	return strdup(name);
}

1711
static int machine__set_modules_path(struct machine *self)
1712 1713
{
	char *version;
1714
	char modules_path[PATH_MAX];
1715

1716
	version = get_kernel_version(self->root_dir);
1717
	if (!version)
1718
		return -1;
1719

1720
	snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1721
		 self->root_dir, version);
1722
	free(version);
1723

1724
	return map_groups__set_modules_path_dir(&self->kmaps, modules_path);
1725 1726
}

1727 1728 1729 1730 1731
/*
 * 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.
 */
1732
static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1733
{
1734 1735
	struct map *self = calloc(1, (sizeof(*self) +
				      (dso->kernel ? sizeof(struct kmap) : 0)));
1736 1737
	if (self != NULL) {
		/*
1738
		 * ->end will be filled after we load all the symbols
1739
		 */
1740
		map__init(self, type, start, 0, 0, dso);
1741
	}
1742

1743 1744 1745
	return self;
}

1746 1747
struct map *machine__new_module(struct machine *self, u64 start,
				const char *filename)
1748 1749
{
	struct map *map;
1750
	struct dso *dso = __dsos__findnew(&self->kernel_dsos, filename);
1751 1752 1753 1754 1755 1756 1757 1758

	if (dso == NULL)
		return NULL;

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

1759
	if (machine__is_host(self))
1760 1761 1762
		dso->origin = DSO__ORIG_KMODULE;
	else
		dso->origin = DSO__ORIG_GUEST_KMODULE;
1763
	map_groups__insert(&self->kmaps, map);
1764 1765 1766
	return map;
}

1767
static int machine__create_modules(struct machine *self)
1768 1769 1770
{
	char *line = NULL;
	size_t n;
1771
	FILE *file;
1772
	struct map *map;
1773 1774 1775
	const char *modules;
	char path[PATH_MAX];

1776
	if (machine__is_default_guest(self))
1777 1778
		modules = symbol_conf.default_guest_modules;
	else {
1779
		sprintf(path, "%s/proc/modules", self->root_dir);
1780 1781
		modules = path;
	}
1782

1783
	file = fopen(modules, "r");
1784 1785
	if (file == NULL)
		return -1;
1786

1787 1788 1789 1790 1791
	while (!feof(file)) {
		char name[PATH_MAX];
		u64 start;
		char *sep;
		int line_len;
1792

1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
		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);
1815
		map = machine__new_module(self, start, name);
1816
		if (map == NULL)
1817
			goto out_delete_line;
1818
		dso__kernel_module_get_build_id(map->dso, self->root_dir);
1819
	}
1820 1821 1822 1823

	free(line);
	fclose(file);

1824
	return machine__set_modules_path(self);
1825 1826 1827 1828 1829

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

1832 1833
int dso__load_vmlinux(struct dso *self, struct map *map,
		      const char *vmlinux, symbol_filter_t filter)
1834
{
1835
	int err = -1, fd;
1836
	char symfs_vmlinux[PATH_MAX];
1837

1838 1839 1840
	snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s/%s",
		 symbol_conf.symfs, vmlinux);
	fd = open(symfs_vmlinux, O_RDONLY);
1841 1842 1843
	if (fd < 0)
		return -1;

1844
	dso__set_loaded(self, map->type);
1845
	err = dso__load_sym(self, map, symfs_vmlinux, fd, filter, 0, 0);
1846 1847
	close(fd);

1848
	if (err > 0)
1849
		pr_debug("Using %s for symbols\n", symfs_vmlinux);
1850

1851 1852 1853
	return err;
}

1854
int dso__load_vmlinux_path(struct dso *self, struct map *map,
1855
			   symbol_filter_t filter)
1856 1857
{
	int i, err = 0;
1858
	char *filename;
1859 1860

	pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
		 vmlinux_path__nr_entries + 1);

	filename = dso__build_id_filename(self, NULL, 0);
	if (filename != NULL) {
		err = dso__load_vmlinux(self, map, filename, filter);
		if (err > 0) {
			dso__set_long_name(self, filename);
			goto out;
		}
		free(filename);
	}
1872 1873

	for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1874
		err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
1875 1876 1877 1878 1879
		if (err > 0) {
			dso__set_long_name(self, strdup(vmlinux_path[i]));
			break;
		}
	}
1880
out:
1881 1882 1883
	return err;
}

1884
static int dso__load_kernel_sym(struct dso *self, struct map *map,
1885
				symbol_filter_t filter)
1886
{
1887
	int err;
1888 1889
	const char *kallsyms_filename = NULL;
	char *kallsyms_allocated_filename = NULL;
1890
	/*
1891 1892
	 * Step 1: if the user specified a kallsyms or vmlinux filename, use
	 * it and only it, reporting errors to the user if it cannot be used.
1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904
	 *
	 * 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.
	 */
1905 1906 1907 1908 1909
	if (symbol_conf.kallsyms_name != NULL) {
		kallsyms_filename = symbol_conf.kallsyms_name;
		goto do_kallsyms;
	}

1910
	if (symbol_conf.vmlinux_name != NULL) {
1911
		err = dso__load_vmlinux(self, map,
1912
					symbol_conf.vmlinux_name, filter);
1913 1914 1915 1916 1917 1918
		if (err > 0) {
			dso__set_long_name(self,
					   strdup(symbol_conf.vmlinux_name));
			goto out_fixup;
		}
		return err;
1919
	}
1920 1921

	if (vmlinux_path != NULL) {
1922
		err = dso__load_vmlinux_path(self, map, filter);
1923 1924
		if (err > 0)
			goto out_fixup;
1925 1926
	}

1927 1928 1929 1930
	/* do not try local files if a symfs was given */
	if (symbol_conf.symfs[0] != 0)
		return -1;

1931 1932 1933 1934 1935 1936 1937
	/*
	 * 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];
1938
		char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1939 1940

		if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
1941
					 sizeof(kallsyms_build_id)) == 0) {
1942 1943
			if (dso__build_id_equal(self, kallsyms_build_id)) {
				kallsyms_filename = "/proc/kallsyms";
1944
				goto do_kallsyms;
1945
			}
1946
		}
1947 1948 1949 1950
		/*
		 * Now look if we have it on the build-id cache in
		 * $HOME/.debug/[kernel.kallsyms].
		 */
1951 1952 1953 1954 1955
		build_id__sprintf(self->build_id, sizeof(self->build_id),
				  sbuild_id);

		if (asprintf(&kallsyms_allocated_filename,
			     "%s/.debug/[kernel.kallsyms]/%s",
1956 1957
			     getenv("HOME"), sbuild_id) == -1) {
			pr_err("Not enough memory for kallsyms file lookup\n");
1958
			return -1;
1959
		}
1960

1961 1962
		kallsyms_filename = kallsyms_allocated_filename;

1963
		if (access(kallsyms_filename, F_OK)) {
1964 1965
			pr_err("No kallsyms or vmlinux with build-id %s "
			       "was found\n", sbuild_id);
1966
			free(kallsyms_allocated_filename);
1967
			return -1;
1968
		}
1969 1970 1971 1972 1973
	} else {
		/*
		 * Last resort, if we don't have a build-id and couldn't find
		 * any vmlinux file, try the running kernel kallsyms table.
		 */
1974 1975
		kallsyms_filename = "/proc/kallsyms";
	}
1976

1977
do_kallsyms:
1978
	err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1979 1980
	if (err > 0)
		pr_debug("Using %s for symbols\n", kallsyms_filename);
1981
	free(kallsyms_allocated_filename);
1982 1983

	if (err > 0) {
1984
out_fixup:
1985
		if (kallsyms_filename != NULL)
1986
			dso__set_long_name(self, strdup("[kernel.kallsyms]"));
1987 1988
		map__fixup_start(map);
		map__fixup_end(map);
1989
	}
1990

1991 1992 1993
	return err;
}

1994 1995 1996 1997 1998
static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
				symbol_filter_t filter)
{
	int err;
	const char *kallsyms_filename = NULL;
1999
	struct machine *machine;
2000 2001 2002 2003 2004 2005
	char path[PATH_MAX];

	if (!map->groups) {
		pr_debug("Guest kernel map hasn't the point to groups\n");
		return -1;
	}
2006
	machine = map->groups->machine;
2007

2008
	if (machine__is_default_guest(machine)) {
2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023
		/*
		 * if the user specified a vmlinux filename, use it and only
		 * it, reporting errors to the user if it cannot be used.
		 * Or use file guest_kallsyms inputted by user on commandline
		 */
		if (symbol_conf.default_guest_vmlinux_name != NULL) {
			err = dso__load_vmlinux(self, map,
				symbol_conf.default_guest_vmlinux_name, filter);
			goto out_try_fixup;
		}

		kallsyms_filename = symbol_conf.default_guest_kallsyms;
		if (!kallsyms_filename)
			return -1;
	} else {
2024
		sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
		kallsyms_filename = path;
	}

	err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
	if (err > 0)
		pr_debug("Using %s for symbols\n", kallsyms_filename);

out_try_fixup:
	if (err > 0) {
		if (kallsyms_filename != NULL) {
2035
			machine__mmap_name(machine, path, sizeof(path));
2036
			dso__set_long_name(self, strdup(path));
2037 2038 2039 2040 2041 2042 2043
		}
		map__fixup_start(map);
		map__fixup_end(map);
	}

	return err;
}
2044

2045
static void dsos__add(struct list_head *head, struct dso *dso)
2046
{
2047
	list_add_tail(&dso->node, head);
2048 2049
}

2050
static struct dso *dsos__find(struct list_head *head, const char *name)
2051 2052 2053
{
	struct dso *pos;

2054
	list_for_each_entry(pos, head, node)
2055
		if (strcmp(pos->long_name, name) == 0)
2056 2057 2058 2059
			return pos;
	return NULL;
}

2060
struct dso *__dsos__findnew(struct list_head *head, const char *name)
2061
{
2062
	struct dso *dso = dsos__find(head, name);
2063

2064
	if (!dso) {
2065
		dso = dso__new(name);
2066
		if (dso != NULL) {
2067
			dsos__add(head, dso);
2068 2069
			dso__set_basename(dso);
		}
2070
	}
2071 2072 2073 2074

	return dso;
}

2075
size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2076 2077
{
	struct dso *pos;
2078
	size_t ret = 0;
2079

2080 2081 2082
	list_for_each_entry(pos, head, node) {
		int i;
		for (i = 0; i < MAP__NR_TYPES; ++i)
2083
			ret += dso__fprintf(pos, i, fp);
2084
	}
2085 2086

	return ret;
2087 2088
}

2089
size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp)
2090
{
2091
	struct rb_node *nd;
2092
	size_t ret = 0;
2093

2094
	for (nd = rb_first(self); nd; nd = rb_next(nd)) {
2095
		struct machine *pos = rb_entry(nd, struct machine, rb_node);
2096 2097
		ret += __dsos__fprintf(&pos->kernel_dsos, fp);
		ret += __dsos__fprintf(&pos->user_dsos, fp);
2098
	}
2099 2100

	return ret;
2101 2102
}

2103 2104
static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
				      bool with_hits)
2105 2106 2107 2108
{
	struct dso *pos;
	size_t ret = 0;

2109
	list_for_each_entry(pos, head, node) {
2110 2111
		if (with_hits && !pos->hit)
			continue;
2112
		ret += dso__fprintf_buildid(pos, fp);
2113
		ret += fprintf(fp, " %s\n", pos->long_name);
2114 2115 2116 2117
	}
	return ret;
}

2118 2119 2120 2121 2122 2123
size_t machine__fprintf_dsos_buildid(struct machine *self, FILE *fp, bool with_hits)
{
	return __dsos__fprintf_buildid(&self->kernel_dsos, fp, with_hits) +
	       __dsos__fprintf_buildid(&self->user_dsos, fp, with_hits);
}

2124
size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits)
2125
{
2126 2127 2128
	struct rb_node *nd;
	size_t ret = 0;

2129
	for (nd = rb_first(self); nd; nd = rb_next(nd)) {
2130
		struct machine *pos = rb_entry(nd, struct machine, rb_node);
2131
		ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2132 2133
	}
	return ret;
2134 2135
}

2136 2137 2138 2139 2140
struct dso *dso__new_kernel(const char *name)
{
	struct dso *self = dso__new(name ?: "[kernel.kallsyms]");

	if (self != NULL) {
2141
		dso__set_short_name(self, "[kernel]");
2142 2143 2144 2145 2146 2147
		self->kernel = DSO_TYPE_KERNEL;
	}

	return self;
}

2148
static struct dso *dso__new_guest_kernel(struct machine *machine,
2149 2150
					const char *name)
{
2151 2152
	char bf[PATH_MAX];
	struct dso *self = dso__new(name ?: machine__mmap_name(machine, bf, sizeof(bf)));
2153 2154 2155 2156

	if (self != NULL) {
		dso__set_short_name(self, "[guest.kernel]");
		self->kernel = DSO_TYPE_GUEST_KERNEL;
2157 2158 2159 2160 2161
	}

	return self;
}

2162
void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine)
2163
{
2164 2165
	char path[PATH_MAX];

2166
	if (machine__is_default_guest(machine))
2167
		return;
2168
	sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2169
	if (sysfs__read_build_id(path, self->build_id,
2170 2171 2172 2173
				 sizeof(self->build_id)) == 0)
		self->has_build_id = true;
}

2174
static struct dso *machine__create_kernel(struct machine *self)
2175
{
2176 2177
	const char *vmlinux_name = NULL;
	struct dso *kernel;
2178

2179
	if (machine__is_host(self)) {
2180 2181 2182
		vmlinux_name = symbol_conf.vmlinux_name;
		kernel = dso__new_kernel(vmlinux_name);
	} else {
2183
		if (machine__is_default_guest(self))
2184
			vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2185
		kernel = dso__new_guest_kernel(self, vmlinux_name);
2186
	}
2187

2188
	if (kernel != NULL) {
2189 2190
		dso__read_running_kernel_build_id(kernel, self);
		dsos__add(&self->kernel_dsos, kernel);
2191
	}
2192 2193 2194
	return kernel;
}

2195 2196 2197 2198 2199
struct process_args {
	u64 start;
};

static int symbol__in_kernel(void *arg, const char *name,
2200
			     char type __used, u64 start, u64 end __used)
2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234
{
	struct process_args *args = arg;

	if (strchr(name, '['))
		return 0;

	args->start = start;
	return 1;
}

/* Figure out the start address of kernel map from /proc/kallsyms */
static u64 machine__get_kernel_start_addr(struct machine *machine)
{
	const char *filename;
	char path[PATH_MAX];
	struct process_args args;

	if (machine__is_host(machine)) {
		filename = "/proc/kallsyms";
	} else {
		if (machine__is_default_guest(machine))
			filename = (char *)symbol_conf.default_guest_kallsyms;
		else {
			sprintf(path, "%s/proc/kallsyms", machine->root_dir);
			filename = path;
		}
	}

	if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
		return 0;

	return args.start;
}

2235
int __machine__create_kernel_maps(struct machine *self, struct dso *kernel)
2236
{
2237
	enum map_type type;
2238
	u64 start = machine__get_kernel_start_addr(self);
2239

2240
	for (type = 0; type < MAP__NR_TYPES; ++type) {
2241 2242
		struct kmap *kmap;

2243
		self->vmlinux_maps[type] = map__new2(start, kernel, type);
2244
		if (self->vmlinux_maps[type] == NULL)
2245
			return -1;
2246

2247 2248
		self->vmlinux_maps[type]->map_ip =
			self->vmlinux_maps[type]->unmap_ip = identity__map_ip;
2249

2250 2251 2252
		kmap = map__kmap(self->vmlinux_maps[type]);
		kmap->kmaps = &self->kmaps;
		map_groups__insert(&self->kmaps, self->vmlinux_maps[type]);
2253 2254 2255
	}

	return 0;
2256 2257
}

2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287
void machine__destroy_kernel_maps(struct machine *self)
{
	enum map_type type;

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

		if (self->vmlinux_maps[type] == NULL)
			continue;

		kmap = map__kmap(self->vmlinux_maps[type]);
		map_groups__remove(&self->kmaps, self->vmlinux_maps[type]);
		if (kmap->ref_reloc_sym) {
			/*
			 * ref_reloc_sym is shared among all maps, so free just
			 * on one of them.
			 */
			if (type == MAP__FUNCTION) {
				free((char *)kmap->ref_reloc_sym->name);
				kmap->ref_reloc_sym->name = NULL;
				free(kmap->ref_reloc_sym);
			}
			kmap->ref_reloc_sym = NULL;
		}

		map__delete(self->vmlinux_maps[type]);
		self->vmlinux_maps[type] = NULL;
	}
}

2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304
int machine__create_kernel_maps(struct machine *self)
{
	struct dso *kernel = machine__create_kernel(self);

	if (kernel == NULL ||
	    __machine__create_kernel_maps(self, kernel) < 0)
		return -1;

	if (symbol_conf.use_modules && machine__create_modules(self) < 0)
		pr_debug("Problems creating module maps, continuing anyway...\n");
	/*
	 * Now that we have all the maps created, just set the ->end of them:
	 */
	map_groups__fixup_end(&self->kmaps);
	return 0;
}

2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
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];

	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;
2333 2334 2335 2336 2337 2338 2339 2340

	/* only try running kernel version if no symfs was given */
	if (symbol_conf.symfs[0] != 0)
		return 0;

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

2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
	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;
}

2365
size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp)
2366 2367 2368
{
	int i;
	size_t printed = 0;
2369 2370 2371 2372 2373 2374 2375
	struct dso *kdso = self->vmlinux_maps[MAP__FUNCTION]->dso;

	if (kdso->has_build_id) {
		char filename[PATH_MAX];
		if (dso__build_id_filename(kdso, filename, sizeof(filename)))
			printed += fprintf(fp, "[0] %s\n", filename);
	}
2376 2377

	for (i = 0; i < vmlinux_path__nr_entries; ++i)
2378 2379
		printed += fprintf(fp, "[%d] %s\n",
				   i + kdso->has_build_id, vmlinux_path[i]);
2380 2381 2382 2383

	return printed;
}

2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397
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;
}

2398
int symbol__init(void)
2399
{
2400 2401
	const char *symfs;

2402 2403 2404
	if (symbol_conf.initialized)
		return 0;

2405
	elf_version(EV_CURRENT);
2406 2407 2408
	if (symbol_conf.sort_by_name)
		symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
					  sizeof(struct symbol));
2409

2410
	if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2411 2412
		return -1;

2413 2414 2415 2416 2417
	if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
		pr_err("'.' is the only non valid --field-separator argument\n");
		return -1;
	}

2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
	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;

2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441
	/*
	 * A path to symbols of "/" is identical to ""
	 * reset here for simplicity.
	 */
	symfs = realpath(symbol_conf.symfs, NULL);
	if (symfs == NULL)
		symfs = symbol_conf.symfs;
	if (strcmp(symfs, "/") == 0)
		symbol_conf.symfs = "";
	if (symfs != symbol_conf.symfs)
		free((void *)symfs);

2442
	symbol_conf.initialized = true;
2443
	return 0;
2444 2445 2446 2447 2448 2449

out_free_dso_list:
	strlist__delete(symbol_conf.dso_list);
out_free_comm_list:
	strlist__delete(symbol_conf.comm_list);
	return -1;
2450 2451
}

2452 2453
void symbol__exit(void)
{
2454 2455
	if (!symbol_conf.initialized)
		return;
2456 2457 2458 2459 2460
	strlist__delete(symbol_conf.sym_list);
	strlist__delete(symbol_conf.dso_list);
	strlist__delete(symbol_conf.comm_list);
	vmlinux_path__exit();
	symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2461
	symbol_conf.initialized = false;
2462 2463
}

2464
int machines__create_kernel_maps(struct rb_root *self, pid_t pid)
2465
{
2466
	struct machine *machine = machines__findnew(self, pid);
2467

2468
	if (machine == NULL)
2469
		return -1;
2470

2471
	return machine__create_kernel_maps(machine);
2472
}
2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515

static int hex(char ch)
{
	if ((ch >= '0') && (ch <= '9'))
		return ch - '0';
	if ((ch >= 'a') && (ch <= 'f'))
		return ch - 'a' + 10;
	if ((ch >= 'A') && (ch <= 'F'))
		return ch - 'A' + 10;
	return -1;
}

/*
 * While we find nice hex chars, build a long_val.
 * Return number of chars processed.
 */
int hex2u64(const char *ptr, u64 *long_val)
{
	const char *p = ptr;
	*long_val = 0;

	while (*p) {
		const int hex_val = hex(*p);

		if (hex_val < 0)
			break;

		*long_val = (*long_val << 4) | hex_val;
		p++;
	}

	return p - ptr;
}

char *strxfrchar(char *s, char from, char to)
{
	char *p = s;

	while ((p = strchr(p, from)) != NULL)
		*p++ = to;

	return s;
}
2516

2517
int machines__create_guest_kernel_maps(struct rb_root *self)
2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
{
	int ret = 0;
	struct dirent **namelist = NULL;
	int i, items = 0;
	char path[PATH_MAX];
	pid_t pid;

	if (symbol_conf.default_guest_vmlinux_name ||
	    symbol_conf.default_guest_modules ||
	    symbol_conf.default_guest_kallsyms) {
2528
		machines__create_kernel_maps(self, DEFAULT_GUEST_KERNEL_ID);
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548
	}

	if (symbol_conf.guestmount) {
		items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
		if (items <= 0)
			return -ENOENT;
		for (i = 0; i < items; i++) {
			if (!isdigit(namelist[i]->d_name[0])) {
				/* Filter out . and .. */
				continue;
			}
			pid = atoi(namelist[i]->d_name);
			sprintf(path, "%s/%s/proc/kallsyms",
				symbol_conf.guestmount,
				namelist[i]->d_name);
			ret = access(path, R_OK);
			if (ret) {
				pr_debug("Can't access file %s\n", path);
				goto failure;
			}
2549
			machines__create_kernel_maps(self, pid);
2550 2551 2552 2553 2554 2555 2556
		}
failure:
		free(namelist);
	}

	return ret;
}
2557

2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
void machines__destroy_guest_kernel_maps(struct rb_root *self)
{
	struct rb_node *next = rb_first(self);

	while (next) {
		struct machine *pos = rb_entry(next, struct machine, rb_node);

		next = rb_next(&pos->rb_node);
		rb_erase(&pos->rb_node, self);
		machine__delete(pos);
	}
}

2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602
int machine__load_kallsyms(struct machine *self, const char *filename,
			   enum map_type type, symbol_filter_t filter)
{
	struct map *map = self->vmlinux_maps[type];
	int ret = dso__load_kallsyms(map->dso, filename, map, filter);

	if (ret > 0) {
		dso__set_loaded(map->dso, type);
		/*
		 * Since /proc/kallsyms will have multiple sessions for the
		 * kernel, with modules between them, fixup the end of all
		 * sections.
		 */
		__map_groups__fixup_end(&self->kmaps, type);
	}

	return ret;
}

int machine__load_vmlinux_path(struct machine *self, enum map_type type,
			       symbol_filter_t filter)
{
	struct map *map = self->vmlinux_maps[type];
	int ret = dso__load_vmlinux_path(map->dso, map, filter);

	if (ret > 0) {
		dso__set_loaded(map->dso, type);
		map__reloc_vmlinux(map);
	}

	return ret;
}