1// SPDX-License-Identifier: GPL-2.0
   2#include <dirent.h>
   3#include <errno.h>
   4#include <stdlib.h>
   5#include <stdio.h>
   6#include <string.h>
   7#include <linux/capability.h>
   8#include <linux/kernel.h>
   9#include <linux/mman.h>
  10#include <linux/string.h>
  11#include <linux/time64.h>
  12#include <sys/types.h>
  13#include <sys/stat.h>
  14#include <sys/param.h>
  15#include <fcntl.h>
  16#include <unistd.h>
  17#include <inttypes.h>
  18#include "annotate.h"
  19#include "build-id.h"
  20#include "cap.h"
  21#include "dso.h"
  22#include "util.h" // lsdir()
  23#include "debug.h"
  24#include "event.h"
  25#include "machine.h"
  26#include "map.h"
  27#include "symbol.h"
  28#include "map_symbol.h"
  29#include "mem-events.h"
  30#include "mem-info.h"
  31#include "symsrc.h"
  32#include "strlist.h"
  33#include "intlist.h"
  34#include "namespaces.h"
  35#include "header.h"
  36#include "path.h"
  37#include <linux/ctype.h>
  38#include <linux/zalloc.h>
  39
  40#include <elf.h>
  41#include <limits.h>
  42#include <symbol/kallsyms.h>
  43#include <sys/utsname.h>
  44
  45static int dso__load_kernel_sym(struct dso *dso, struct map *map);
  46static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map);
  47static bool symbol__is_idle(const char *name);
  48
  49int vmlinux_path__nr_entries;
  50char **vmlinux_path;
  51
  52struct symbol_conf symbol_conf = {
  53	.nanosecs		= false,
  54	.use_modules		= true,
  55	.try_vmlinux_path	= true,
  56	.demangle		= true,
  57	.demangle_kernel	= false,
  58	.cumulate_callchain	= true,
  59	.time_quantum		= 100 * NSEC_PER_MSEC, /* 100ms */
  60	.show_hist_headers	= true,
  61	.symfs			= "",
  62	.event_group		= true,
  63	.inline_name		= true,
  64	.res_sample		= 0,
  65};
  66
  67struct map_list_node {
  68	struct list_head node;
  69	struct map *map;
  70};
  71
  72static struct map_list_node *map_list_node__new(void)
  73{
  74	return malloc(sizeof(struct map_list_node));
  75}
  76
  77static enum dso_binary_type binary_type_symtab[] = {
  78	DSO_BINARY_TYPE__KALLSYMS,
  79	DSO_BINARY_TYPE__GUEST_KALLSYMS,
  80	DSO_BINARY_TYPE__JAVA_JIT,
  81	DSO_BINARY_TYPE__DEBUGLINK,
  82	DSO_BINARY_TYPE__BUILD_ID_CACHE,
  83	DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO,
  84	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
  85	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
  86	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
  87	DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
  88	DSO_BINARY_TYPE__GUEST_KMODULE,
  89	DSO_BINARY_TYPE__GUEST_KMODULE_COMP,
  90	DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
  91	DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP,
  92	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
  93	DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO,
  94	DSO_BINARY_TYPE__NOT_FOUND,
  95};
  96
  97#define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
  98
  99static bool symbol_type__filter(char symbol_type)
 100{
 101	symbol_type = toupper(symbol_type);
 102	return symbol_type == 'T' || symbol_type == 'W' || symbol_type == 'D' || symbol_type == 'B';
 103}
 104
 105static int prefix_underscores_count(const char *str)
 106{
 107	const char *tail = str;
 108
 109	while (*tail == '_')
 110		tail++;
 111
 112	return tail - str;
 113}
 114
 
 
 
 
 
 115const char * __weak arch__normalize_symbol_name(const char *name)
 116{
 117	return name;
 118}
 119
 120int __weak arch__compare_symbol_names(const char *namea, const char *nameb)
 121{
 122	return strcmp(namea, nameb);
 123}
 124
 125int __weak arch__compare_symbol_names_n(const char *namea, const char *nameb,
 126					unsigned int n)
 127{
 128	return strncmp(namea, nameb, n);
 129}
 130
 131int __weak arch__choose_best_symbol(struct symbol *syma,
 132				    struct symbol *symb __maybe_unused)
 133{
 134	/* Avoid "SyS" kernel syscall aliases */
 135	if (strlen(syma->name) >= 3 && !strncmp(syma->name, "SyS", 3))
 136		return SYMBOL_B;
 137	if (strlen(syma->name) >= 10 && !strncmp(syma->name, "compat_SyS", 10))
 138		return SYMBOL_B;
 139
 140	return SYMBOL_A;
 141}
 142
 143static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
 144{
 145	s64 a;
 146	s64 b;
 147	size_t na, nb;
 148
 149	/* Prefer a symbol with non zero length */
 150	a = syma->end - syma->start;
 151	b = symb->end - symb->start;
 152	if ((b == 0) && (a > 0))
 153		return SYMBOL_A;
 154	else if ((a == 0) && (b > 0))
 155		return SYMBOL_B;
 156
 157	if (syma->type != symb->type) {
 158		if (syma->type == STT_NOTYPE)
 159			return SYMBOL_B;
 160		if (symb->type == STT_NOTYPE)
 161			return SYMBOL_A;
 162	}
 163
 164	/* Prefer a non weak symbol over a weak one */
 165	a = syma->binding == STB_WEAK;
 166	b = symb->binding == STB_WEAK;
 167	if (b && !a)
 168		return SYMBOL_A;
 169	if (a && !b)
 170		return SYMBOL_B;
 171
 172	/* Prefer a global symbol over a non global one */
 173	a = syma->binding == STB_GLOBAL;
 174	b = symb->binding == STB_GLOBAL;
 175	if (a && !b)
 176		return SYMBOL_A;
 177	if (b && !a)
 178		return SYMBOL_B;
 179
 180	/* Prefer a symbol with less underscores */
 181	a = prefix_underscores_count(syma->name);
 182	b = prefix_underscores_count(symb->name);
 183	if (b > a)
 184		return SYMBOL_A;
 185	else if (a > b)
 186		return SYMBOL_B;
 187
 188	/* Choose the symbol with the longest name */
 189	na = strlen(syma->name);
 190	nb = strlen(symb->name);
 191	if (na > nb)
 192		return SYMBOL_A;
 193	else if (na < nb)
 194		return SYMBOL_B;
 195
 196	return arch__choose_best_symbol(syma, symb);
 197}
 198
 199void symbols__fixup_duplicate(struct rb_root_cached *symbols)
 200{
 201	struct rb_node *nd;
 202	struct symbol *curr, *next;
 203
 204	if (symbol_conf.allow_aliases)
 205		return;
 206
 207	nd = rb_first_cached(symbols);
 208
 209	while (nd) {
 210		curr = rb_entry(nd, struct symbol, rb_node);
 211again:
 212		nd = rb_next(&curr->rb_node);
 
 
 213		if (!nd)
 214			break;
 215
 216		next = rb_entry(nd, struct symbol, rb_node);
 217		if (curr->start != next->start)
 218			continue;
 219
 220		if (choose_best_symbol(curr, next) == SYMBOL_A) {
 221			if (next->type == STT_GNU_IFUNC)
 222				curr->ifunc_alias = true;
 223			rb_erase_cached(&next->rb_node, symbols);
 224			symbol__delete(next);
 225			goto again;
 226		} else {
 227			if (curr->type == STT_GNU_IFUNC)
 228				next->ifunc_alias = true;
 229			nd = rb_next(&curr->rb_node);
 230			rb_erase_cached(&curr->rb_node, symbols);
 231			symbol__delete(curr);
 232		}
 233	}
 234}
 235
 236/* Update zero-sized symbols using the address of the next symbol */
 237void symbols__fixup_end(struct rb_root_cached *symbols, bool is_kallsyms)
 238{
 239	struct rb_node *nd, *prevnd = rb_first_cached(symbols);
 240	struct symbol *curr, *prev;
 241
 242	if (prevnd == NULL)
 243		return;
 244
 245	curr = rb_entry(prevnd, struct symbol, rb_node);
 246
 247	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 248		prev = curr;
 249		curr = rb_entry(nd, struct symbol, rb_node);
 250
 251		/*
 252		 * On some architecture kernel text segment start is located at
 253		 * some low memory address, while modules are located at high
 254		 * memory addresses (or vice versa).  The gap between end of
 255		 * kernel text segment and beginning of first module's text
 256		 * segment is very big.  Therefore do not fill this gap and do
 257		 * not assign it to the kernel dso map (kallsyms).
 258		 *
 259		 * Also BPF code can be allocated separately from text segments
 260		 * and modules.  So the last entry in a module should not fill
 261		 * the gap too.
 262		 *
 263		 * In kallsyms, it determines module symbols using '[' character
 264		 * like in:
 265		 *   ffffffffc1937000 T hdmi_driver_init  [snd_hda_codec_hdmi]
 266		 */
 267		if (prev->end == prev->start) {
 268			const char *prev_mod;
 269			const char *curr_mod;
 270
 271			if (!is_kallsyms) {
 272				prev->end = curr->start;
 273				continue;
 274			}
 275
 276			prev_mod = strchr(prev->name, '[');
 277			curr_mod = strchr(curr->name, '[');
 278
 279			/* Last kernel/module symbol mapped to end of page */
 280			if (!prev_mod != !curr_mod)
 281				prev->end = roundup(prev->end + 4096, 4096);
 282			/* Last symbol in the previous module */
 283			else if (prev_mod && strcmp(prev_mod, curr_mod))
 284				prev->end = roundup(prev->end + 4096, 4096);
 285			else
 286				prev->end = curr->start;
 287
 288			pr_debug4("%s sym:%s end:%#" PRIx64 "\n",
 289				  __func__, prev->name, prev->end);
 290		}
 291	}
 292
 293	/* Last entry */
 294	if (curr->end == curr->start)
 295		curr->end = roundup(curr->start, 4096) + 4096;
 296}
 297
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 298struct symbol *symbol__new(u64 start, u64 len, u8 binding, u8 type, const char *name)
 299{
 300	size_t namelen = strlen(name) + 1;
 301	struct symbol *sym = calloc(1, (symbol_conf.priv_size +
 302					sizeof(*sym) + namelen));
 303	if (sym == NULL)
 304		return NULL;
 305
 306	if (symbol_conf.priv_size) {
 307		if (symbol_conf.init_annotation) {
 308			struct annotation *notes = (void *)sym;
 309			annotation__init(notes);
 310		}
 311		sym = ((void *)sym) + symbol_conf.priv_size;
 312	}
 313
 314	sym->start   = start;
 315	sym->end     = len ? start + len : start;
 316	sym->type    = type;
 317	sym->binding = binding;
 318	sym->namelen = namelen - 1;
 319
 320	pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
 321		  __func__, name, start, sym->end);
 322	memcpy(sym->name, name, namelen);
 323
 324	return sym;
 325}
 326
 327void symbol__delete(struct symbol *sym)
 328{
 329	if (symbol_conf.priv_size) {
 330		if (symbol_conf.init_annotation) {
 331			struct annotation *notes = symbol__annotation(sym);
 332
 333			annotation__exit(notes);
 334		}
 335	}
 336	free(((void *)sym) - symbol_conf.priv_size);
 337}
 338
 339void symbols__delete(struct rb_root_cached *symbols)
 340{
 341	struct symbol *pos;
 342	struct rb_node *next = rb_first_cached(symbols);
 343
 344	while (next) {
 345		pos = rb_entry(next, struct symbol, rb_node);
 346		next = rb_next(&pos->rb_node);
 347		rb_erase_cached(&pos->rb_node, symbols);
 348		symbol__delete(pos);
 349	}
 350}
 351
 352void __symbols__insert(struct rb_root_cached *symbols,
 353		       struct symbol *sym, bool kernel)
 354{
 355	struct rb_node **p = &symbols->rb_root.rb_node;
 356	struct rb_node *parent = NULL;
 357	const u64 ip = sym->start;
 358	struct symbol *s;
 359	bool leftmost = true;
 360
 361	if (kernel) {
 362		const char *name = sym->name;
 363		/*
 364		 * ppc64 uses function descriptors and appends a '.' to the
 365		 * start of every instruction address. Remove it.
 366		 */
 367		if (name[0] == '.')
 368			name++;
 369		sym->idle = symbol__is_idle(name);
 370	}
 371
 372	while (*p != NULL) {
 373		parent = *p;
 374		s = rb_entry(parent, struct symbol, rb_node);
 375		if (ip < s->start)
 376			p = &(*p)->rb_left;
 377		else {
 378			p = &(*p)->rb_right;
 379			leftmost = false;
 380		}
 381	}
 382	rb_link_node(&sym->rb_node, parent, p);
 383	rb_insert_color_cached(&sym->rb_node, symbols, leftmost);
 384}
 385
 386void symbols__insert(struct rb_root_cached *symbols, struct symbol *sym)
 387{
 388	__symbols__insert(symbols, sym, false);
 389}
 390
 391static struct symbol *symbols__find(struct rb_root_cached *symbols, u64 ip)
 392{
 393	struct rb_node *n;
 394
 395	if (symbols == NULL)
 396		return NULL;
 397
 398	n = symbols->rb_root.rb_node;
 399
 400	while (n) {
 401		struct symbol *s = rb_entry(n, struct symbol, rb_node);
 402
 403		if (ip < s->start)
 404			n = n->rb_left;
 405		else if (ip > s->end || (ip == s->end && ip != s->start))
 406			n = n->rb_right;
 407		else
 408			return s;
 409	}
 410
 411	return NULL;
 412}
 413
 414static struct symbol *symbols__first(struct rb_root_cached *symbols)
 415{
 416	struct rb_node *n = rb_first_cached(symbols);
 417
 418	if (n)
 419		return rb_entry(n, struct symbol, rb_node);
 420
 421	return NULL;
 422}
 423
 424static struct symbol *symbols__last(struct rb_root_cached *symbols)
 425{
 426	struct rb_node *n = rb_last(&symbols->rb_root);
 427
 428	if (n)
 429		return rb_entry(n, struct symbol, rb_node);
 430
 431	return NULL;
 432}
 433
 434static struct symbol *symbols__next(struct symbol *sym)
 435{
 436	struct rb_node *n = rb_next(&sym->rb_node);
 437
 438	if (n)
 439		return rb_entry(n, struct symbol, rb_node);
 440
 441	return NULL;
 442}
 443
 444static int symbols__sort_name_cmp(const void *vlhs, const void *vrhs)
 445{
 446	const struct symbol *lhs = *((const struct symbol **)vlhs);
 447	const struct symbol *rhs = *((const struct symbol **)vrhs);
 
 
 
 
 448
 449	return strcmp(lhs->name, rhs->name);
 
 
 
 
 
 
 
 
 
 
 
 450}
 451
 452static struct symbol **symbols__sort_by_name(struct rb_root_cached *source, size_t *len)
 
 453{
 454	struct rb_node *nd;
 455	struct symbol **result;
 456	size_t i = 0, size = 0;
 457
 458	for (nd = rb_first_cached(source); nd; nd = rb_next(nd))
 459		size++;
 460
 461	result = malloc(sizeof(*result) * size);
 462	if (!result)
 463		return NULL;
 464
 465	for (nd = rb_first_cached(source); nd; nd = rb_next(nd)) {
 466		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 467
 468		result[i++] = pos;
 469	}
 470	qsort(result, size, sizeof(*result), symbols__sort_name_cmp);
 471	*len = size;
 472	return result;
 473}
 474
 475int symbol__match_symbol_name(const char *name, const char *str,
 476			      enum symbol_tag_include includes)
 477{
 478	const char *versioning;
 479
 480	if (includes == SYMBOL_TAG_INCLUDE__DEFAULT_ONLY &&
 481	    (versioning = strstr(name, "@@"))) {
 482		int len = strlen(str);
 483
 484		if (len < versioning - name)
 485			len = versioning - name;
 486
 487		return arch__compare_symbol_names_n(name, str, len);
 488	} else
 489		return arch__compare_symbol_names(name, str);
 490}
 491
 492static struct symbol *symbols__find_by_name(struct symbol *symbols[],
 493					    size_t symbols_len,
 494					    const char *name,
 495					    enum symbol_tag_include includes,
 496					    size_t *found_idx)
 497{
 498	size_t i, lower = 0, upper = symbols_len;
 499	struct symbol *s = NULL;
 500
 501	if (found_idx)
 502		*found_idx = SIZE_MAX;
 503
 504	if (!symbols_len)
 505		return NULL;
 506
 507	while (lower < upper) {
 
 
 508		int cmp;
 509
 510		i = (lower + upper) / 2;
 511		cmp = symbol__match_symbol_name(symbols[i]->name, name, includes);
 512
 513		if (cmp > 0)
 514			upper = i;
 515		else if (cmp < 0)
 516			lower = i + 1;
 517		else {
 518			if (found_idx)
 519				*found_idx = i;
 520			s = symbols[i];
 521			break;
 522		}
 523	}
 524	if (s && includes != SYMBOL_TAG_INCLUDE__DEFAULT_ONLY) {
 
 
 
 
 525		/* return first symbol that has same name (if any) */
 526		for (; i > 0; i--) {
 527			struct symbol *tmp = symbols[i - 1];
 528
 529			if (!arch__compare_symbol_names(tmp->name, s->name)) {
 530				if (found_idx)
 531					*found_idx = i - 1;
 532				s = tmp;
 533			} else
 534				break;
 
 
 535		}
 536	}
 537	assert(!found_idx || !s || s == symbols[*found_idx]);
 538	return s;
 539}
 540
 541void dso__reset_find_symbol_cache(struct dso *dso)
 542{
 543	dso__set_last_find_result_addr(dso, 0);
 544	dso__set_last_find_result_symbol(dso, NULL);
 545}
 546
 547void dso__insert_symbol(struct dso *dso, struct symbol *sym)
 548{
 549	__symbols__insert(dso__symbols(dso), sym, dso__kernel(dso));
 550
 551	/* update the symbol cache if necessary */
 552	if (dso__last_find_result_addr(dso) >= sym->start &&
 553	    (dso__last_find_result_addr(dso) < sym->end ||
 554	    sym->start == sym->end)) {
 555		dso__set_last_find_result_symbol(dso, sym);
 556	}
 557}
 558
 559void dso__delete_symbol(struct dso *dso, struct symbol *sym)
 560{
 561	rb_erase_cached(&sym->rb_node, dso__symbols(dso));
 562	symbol__delete(sym);
 563	dso__reset_find_symbol_cache(dso);
 564}
 565
 566struct symbol *dso__find_symbol(struct dso *dso, u64 addr)
 567{
 568	if (dso__last_find_result_addr(dso) != addr || dso__last_find_result_symbol(dso) == NULL) {
 569		dso__set_last_find_result_addr(dso, addr);
 570		dso__set_last_find_result_symbol(dso, symbols__find(dso__symbols(dso), addr));
 571	}
 572
 573	return dso__last_find_result_symbol(dso);
 574}
 575
 576struct symbol *dso__find_symbol_nocache(struct dso *dso, u64 addr)
 577{
 578	return symbols__find(dso__symbols(dso), addr);
 579}
 580
 581struct symbol *dso__first_symbol(struct dso *dso)
 582{
 583	return symbols__first(dso__symbols(dso));
 584}
 585
 586struct symbol *dso__last_symbol(struct dso *dso)
 587{
 588	return symbols__last(dso__symbols(dso));
 589}
 590
 591struct symbol *dso__next_symbol(struct symbol *sym)
 592{
 593	return symbols__next(sym);
 594}
 595
 596struct symbol *dso__next_symbol_by_name(struct dso *dso, size_t *idx)
 597{
 598	if (*idx + 1 >= dso__symbol_names_len(dso))
 599		return NULL;
 600
 601	++*idx;
 602	return dso__symbol_names(dso)[*idx];
 603}
 604
 605 /*
 606  * Returns first symbol that matched with @name.
 607  */
 608struct symbol *dso__find_symbol_by_name(struct dso *dso, const char *name, size_t *idx)
 609{
 610	struct symbol *s = symbols__find_by_name(dso__symbol_names(dso),
 611						 dso__symbol_names_len(dso),
 612						 name, SYMBOL_TAG_INCLUDE__NONE, idx);
 613	if (!s) {
 614		s = symbols__find_by_name(dso__symbol_names(dso), dso__symbol_names_len(dso),
 615					  name, SYMBOL_TAG_INCLUDE__DEFAULT_ONLY, idx);
 616	}
 617	return s;
 618}
 619
 620void dso__sort_by_name(struct dso *dso)
 621{
 622	mutex_lock(dso__lock(dso));
 623	if (!dso__sorted_by_name(dso)) {
 624		size_t len;
 625
 626		dso__set_symbol_names(dso, symbols__sort_by_name(dso__symbols(dso), &len));
 627		if (dso__symbol_names(dso)) {
 628			dso__set_symbol_names_len(dso, len);
 629			dso__set_sorted_by_name(dso);
 630		}
 631	}
 632	mutex_unlock(dso__lock(dso));
 633}
 634
 635/*
 636 * While we find nice hex chars, build a long_val.
 637 * Return number of chars processed.
 638 */
 639static int hex2u64(const char *ptr, u64 *long_val)
 640{
 641	char *p;
 642
 643	*long_val = strtoull(ptr, &p, 16);
 644
 645	return p - ptr;
 646}
 647
 648
 649int modules__parse(const char *filename, void *arg,
 650		   int (*process_module)(void *arg, const char *name,
 651					 u64 start, u64 size))
 652{
 653	char *line = NULL;
 654	size_t n;
 655	FILE *file;
 656	int err = 0;
 657
 658	file = fopen(filename, "r");
 659	if (file == NULL)
 660		return -1;
 661
 662	while (1) {
 663		char name[PATH_MAX];
 664		u64 start, size;
 665		char *sep, *endptr;
 666		ssize_t line_len;
 667
 668		line_len = getline(&line, &n, file);
 669		if (line_len < 0) {
 670			if (feof(file))
 671				break;
 672			err = -1;
 673			goto out;
 674		}
 675
 676		if (!line) {
 677			err = -1;
 678			goto out;
 679		}
 680
 681		line[--line_len] = '\0'; /* \n */
 682
 683		sep = strrchr(line, 'x');
 684		if (sep == NULL)
 685			continue;
 686
 687		hex2u64(sep + 1, &start);
 688
 689		sep = strchr(line, ' ');
 690		if (sep == NULL)
 691			continue;
 692
 693		*sep = '\0';
 694
 695		scnprintf(name, sizeof(name), "[%s]", line);
 696
 697		size = strtoul(sep + 1, &endptr, 0);
 698		if (*endptr != ' ' && *endptr != '\t')
 699			continue;
 700
 701		err = process_module(arg, name, start, size);
 702		if (err)
 703			break;
 704	}
 705out:
 706	free(line);
 707	fclose(file);
 708	return err;
 709}
 710
 711/*
 712 * These are symbols in the kernel image, so make sure that
 713 * sym is from a kernel DSO.
 714 */
 715static bool symbol__is_idle(const char *name)
 716{
 717	const char * const idle_symbols[] = {
 718		"acpi_idle_do_entry",
 719		"acpi_processor_ffh_cstate_enter",
 720		"arch_cpu_idle",
 721		"cpu_idle",
 722		"cpu_startup_entry",
 723		"idle_cpu",
 724		"intel_idle",
 725		"intel_idle_ibrs",
 726		"default_idle",
 727		"native_safe_halt",
 728		"enter_idle",
 729		"exit_idle",
 730		"mwait_idle",
 731		"mwait_idle_with_hints",
 732		"mwait_idle_with_hints.constprop.0",
 733		"poll_idle",
 734		"ppc64_runlatch_off",
 735		"pseries_dedicated_idle_sleep",
 736		"psw_idle",
 737		"psw_idle_exit",
 738		NULL
 739	};
 740	int i;
 741	static struct strlist *idle_symbols_list;
 742
 743	if (idle_symbols_list)
 744		return strlist__has_entry(idle_symbols_list, name);
 745
 746	idle_symbols_list = strlist__new(NULL, NULL);
 747
 748	for (i = 0; idle_symbols[i]; i++)
 749		strlist__add(idle_symbols_list, idle_symbols[i]);
 750
 751	return strlist__has_entry(idle_symbols_list, name);
 752}
 753
 754static int map__process_kallsym_symbol(void *arg, const char *name,
 755				       char type, u64 start)
 756{
 757	struct symbol *sym;
 758	struct dso *dso = arg;
 759	struct rb_root_cached *root = dso__symbols(dso);
 760
 761	if (!symbol_type__filter(type))
 762		return 0;
 763
 764	/* Ignore local symbols for ARM modules */
 765	if (name[0] == '$')
 766		return 0;
 767
 768	/*
 769	 * module symbols are not sorted so we add all
 770	 * symbols, setting length to 0, and rely on
 771	 * symbols__fixup_end() to fix it up.
 772	 */
 773	sym = symbol__new(start, 0, kallsyms2elf_binding(type), kallsyms2elf_type(type), name);
 774	if (sym == NULL)
 775		return -ENOMEM;
 776	/*
 777	 * We will pass the symbols to the filter later, in
 778	 * map__split_kallsyms, when we have split the maps per module
 779	 */
 780	__symbols__insert(root, sym, !strchr(name, '['));
 781
 782	return 0;
 783}
 784
 785/*
 786 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
 787 * so that we can in the next step set the symbol ->end address and then
 788 * call kernel_maps__split_kallsyms.
 789 */
 790static int dso__load_all_kallsyms(struct dso *dso, const char *filename)
 791{
 792	return kallsyms__parse(filename, dso, map__process_kallsym_symbol);
 793}
 794
 795static int maps__split_kallsyms_for_kcore(struct maps *kmaps, struct dso *dso)
 796{
 
 797	struct symbol *pos;
 798	int count = 0;
 799	struct rb_root_cached *root = dso__symbols(dso);
 800	struct rb_root_cached old_root = *root;
 801	struct rb_node *next = rb_first_cached(root);
 802
 803	if (!kmaps)
 804		return -1;
 805
 806	*root = RB_ROOT_CACHED;
 807
 808	while (next) {
 809		struct map *curr_map;
 810		struct dso *curr_map_dso;
 811		char *module;
 812
 813		pos = rb_entry(next, struct symbol, rb_node);
 814		next = rb_next(&pos->rb_node);
 815
 816		rb_erase_cached(&pos->rb_node, &old_root);
 817		RB_CLEAR_NODE(&pos->rb_node);
 818		module = strchr(pos->name, '\t');
 819		if (module)
 820			*module = '\0';
 821
 822		curr_map = maps__find(kmaps, pos->start);
 823
 824		if (!curr_map) {
 825			symbol__delete(pos);
 826			continue;
 827		}
 828		curr_map_dso = map__dso(curr_map);
 829		pos->start -= map__start(curr_map) - map__pgoff(curr_map);
 830		if (pos->end > map__end(curr_map))
 831			pos->end = map__end(curr_map);
 832		if (pos->end)
 833			pos->end -= map__start(curr_map) - map__pgoff(curr_map);
 834		symbols__insert(dso__symbols(curr_map_dso), pos);
 835		++count;
 836		map__put(curr_map);
 837	}
 838
 839	/* Symbols have been adjusted */
 840	dso__set_adjust_symbols(dso, true);
 841
 842	return count;
 843}
 844
 845/*
 846 * Split the symbols into maps, making sure there are no overlaps, i.e. the
 847 * kernel range is broken in several maps, named [kernel].N, as we don't have
 848 * the original ELF section names vmlinux have.
 849 */
 850static int maps__split_kallsyms(struct maps *kmaps, struct dso *dso, u64 delta,
 851				struct map *initial_map)
 852{
 853	struct machine *machine;
 854	struct map *curr_map = map__get(initial_map);
 855	struct symbol *pos;
 856	int count = 0, moved = 0;
 857	struct rb_root_cached *root = dso__symbols(dso);
 858	struct rb_node *next = rb_first_cached(root);
 859	int kernel_range = 0;
 860	bool x86_64;
 861
 862	if (!kmaps)
 863		return -1;
 864
 865	machine = maps__machine(kmaps);
 866
 867	x86_64 = machine__is(machine, "x86_64");
 868
 869	while (next) {
 870		char *module;
 871
 872		pos = rb_entry(next, struct symbol, rb_node);
 873		next = rb_next(&pos->rb_node);
 874
 875		module = strchr(pos->name, '\t');
 876		if (module) {
 877			struct dso *curr_map_dso;
 878
 879			if (!symbol_conf.use_modules)
 880				goto discard_symbol;
 881
 882			*module++ = '\0';
 883			curr_map_dso = map__dso(curr_map);
 884			if (strcmp(dso__short_name(curr_map_dso), module)) {
 885				if (!RC_CHK_EQUAL(curr_map, initial_map) &&
 886				    dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST &&
 887				    machine__is_default_guest(machine)) {
 888					/*
 889					 * We assume all symbols of a module are
 890					 * continuous in * kallsyms, so curr_map
 891					 * points to a module and all its
 892					 * symbols are in its kmap. Mark it as
 893					 * loaded.
 894					 */
 895					dso__set_loaded(curr_map_dso);
 896				}
 897
 898				map__zput(curr_map);
 899				curr_map = maps__find_by_name(kmaps, module);
 900				if (curr_map == NULL) {
 901					pr_debug("%s/proc/{kallsyms,modules} "
 902					         "inconsistency while looking "
 903						 "for \"%s\" module!\n",
 904						 machine->root_dir, module);
 905					curr_map = map__get(initial_map);
 906					goto discard_symbol;
 907				}
 908				curr_map_dso = map__dso(curr_map);
 909				if (dso__loaded(curr_map_dso) &&
 910				    !machine__is_default_guest(machine))
 911					goto discard_symbol;
 912			}
 913			/*
 914			 * So that we look just like we get from .ko files,
 915			 * i.e. not prelinked, relative to initial_map->start.
 916			 */
 917			pos->start = map__map_ip(curr_map, pos->start);
 918			pos->end   = map__map_ip(curr_map, pos->end);
 919		} else if (x86_64 && is_entry_trampoline(pos->name)) {
 920			/*
 921			 * These symbols are not needed anymore since the
 922			 * trampoline maps refer to the text section and it's
 923			 * symbols instead. Avoid having to deal with
 924			 * relocations, and the assumption that the first symbol
 925			 * is the start of kernel text, by simply removing the
 926			 * symbols at this point.
 927			 */
 928			goto discard_symbol;
 929		} else if (!RC_CHK_EQUAL(curr_map, initial_map)) {
 930			char dso_name[PATH_MAX];
 931			struct dso *ndso;
 932
 933			if (delta) {
 934				/* Kernel was relocated at boot time */
 935				pos->start -= delta;
 936				pos->end -= delta;
 937			}
 938
 939			if (count == 0) {
 940				map__zput(curr_map);
 941				curr_map = map__get(initial_map);
 942				goto add_symbol;
 943			}
 944
 945			if (dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST)
 946				snprintf(dso_name, sizeof(dso_name),
 947					"[guest.kernel].%d",
 948					kernel_range++);
 949			else
 950				snprintf(dso_name, sizeof(dso_name),
 951					"[kernel].%d",
 952					kernel_range++);
 953
 954			ndso = dso__new(dso_name);
 955			map__zput(curr_map);
 956			if (ndso == NULL)
 957				return -1;
 958
 959			dso__set_kernel(ndso, dso__kernel(dso));
 960
 961			curr_map = map__new2(pos->start, ndso);
 962			if (curr_map == NULL) {
 963				dso__put(ndso);
 964				return -1;
 965			}
 966
 967			map__set_mapping_type(curr_map, MAPPING_TYPE__IDENTITY);
 968			if (maps__insert(kmaps, curr_map)) {
 969				map__zput(curr_map);
 970				dso__put(ndso);
 971				return -1;
 972			}
 973			++kernel_range;
 974		} else if (delta) {
 975			/* Kernel was relocated at boot time */
 976			pos->start -= delta;
 977			pos->end -= delta;
 978		}
 979add_symbol:
 980		if (!RC_CHK_EQUAL(curr_map, initial_map)) {
 981			struct dso *curr_map_dso = map__dso(curr_map);
 982
 983			rb_erase_cached(&pos->rb_node, root);
 984			symbols__insert(dso__symbols(curr_map_dso), pos);
 985			++moved;
 986		} else
 987			++count;
 988
 989		continue;
 990discard_symbol:
 991		rb_erase_cached(&pos->rb_node, root);
 992		symbol__delete(pos);
 993	}
 994
 995	if (!RC_CHK_EQUAL(curr_map, initial_map) &&
 996	    dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST &&
 997	    machine__is_default_guest(maps__machine(kmaps))) {
 998		dso__set_loaded(map__dso(curr_map));
 999	}
1000	map__put(curr_map);
1001	return count + moved;
1002}
1003
1004bool symbol__restricted_filename(const char *filename,
1005				 const char *restricted_filename)
1006{
1007	bool restricted = false;
1008
1009	if (symbol_conf.kptr_restrict) {
1010		char *r = realpath(filename, NULL);
1011
1012		if (r != NULL) {
1013			restricted = strcmp(r, restricted_filename) == 0;
1014			free(r);
1015			return restricted;
1016		}
1017	}
1018
1019	return restricted;
1020}
1021
1022struct module_info {
1023	struct rb_node rb_node;
1024	char *name;
1025	u64 start;
1026};
1027
1028static void add_module(struct module_info *mi, struct rb_root *modules)
1029{
1030	struct rb_node **p = &modules->rb_node;
1031	struct rb_node *parent = NULL;
1032	struct module_info *m;
1033
1034	while (*p != NULL) {
1035		parent = *p;
1036		m = rb_entry(parent, struct module_info, rb_node);
1037		if (strcmp(mi->name, m->name) < 0)
1038			p = &(*p)->rb_left;
1039		else
1040			p = &(*p)->rb_right;
1041	}
1042	rb_link_node(&mi->rb_node, parent, p);
1043	rb_insert_color(&mi->rb_node, modules);
1044}
1045
1046static void delete_modules(struct rb_root *modules)
1047{
1048	struct module_info *mi;
1049	struct rb_node *next = rb_first(modules);
1050
1051	while (next) {
1052		mi = rb_entry(next, struct module_info, rb_node);
1053		next = rb_next(&mi->rb_node);
1054		rb_erase(&mi->rb_node, modules);
1055		zfree(&mi->name);
1056		free(mi);
1057	}
1058}
1059
1060static struct module_info *find_module(const char *name,
1061				       struct rb_root *modules)
1062{
1063	struct rb_node *n = modules->rb_node;
1064
1065	while (n) {
1066		struct module_info *m;
1067		int cmp;
1068
1069		m = rb_entry(n, struct module_info, rb_node);
1070		cmp = strcmp(name, m->name);
1071		if (cmp < 0)
1072			n = n->rb_left;
1073		else if (cmp > 0)
1074			n = n->rb_right;
1075		else
1076			return m;
1077	}
1078
1079	return NULL;
1080}
1081
1082static int __read_proc_modules(void *arg, const char *name, u64 start,
1083			       u64 size __maybe_unused)
1084{
1085	struct rb_root *modules = arg;
1086	struct module_info *mi;
1087
1088	mi = zalloc(sizeof(struct module_info));
1089	if (!mi)
1090		return -ENOMEM;
1091
1092	mi->name = strdup(name);
1093	mi->start = start;
1094
1095	if (!mi->name) {
1096		free(mi);
1097		return -ENOMEM;
1098	}
1099
1100	add_module(mi, modules);
1101
1102	return 0;
1103}
1104
1105static int read_proc_modules(const char *filename, struct rb_root *modules)
1106{
1107	if (symbol__restricted_filename(filename, "/proc/modules"))
1108		return -1;
1109
1110	if (modules__parse(filename, modules, __read_proc_modules)) {
1111		delete_modules(modules);
1112		return -1;
1113	}
1114
1115	return 0;
1116}
1117
1118int compare_proc_modules(const char *from, const char *to)
1119{
1120	struct rb_root from_modules = RB_ROOT;
1121	struct rb_root to_modules = RB_ROOT;
1122	struct rb_node *from_node, *to_node;
1123	struct module_info *from_m, *to_m;
1124	int ret = -1;
1125
1126	if (read_proc_modules(from, &from_modules))
1127		return -1;
1128
1129	if (read_proc_modules(to, &to_modules))
1130		goto out_delete_from;
1131
1132	from_node = rb_first(&from_modules);
1133	to_node = rb_first(&to_modules);
1134	while (from_node) {
1135		if (!to_node)
1136			break;
1137
1138		from_m = rb_entry(from_node, struct module_info, rb_node);
1139		to_m = rb_entry(to_node, struct module_info, rb_node);
1140
1141		if (from_m->start != to_m->start ||
1142		    strcmp(from_m->name, to_m->name))
1143			break;
1144
1145		from_node = rb_next(from_node);
1146		to_node = rb_next(to_node);
1147	}
1148
1149	if (!from_node && !to_node)
1150		ret = 0;
1151
1152	delete_modules(&to_modules);
1153out_delete_from:
1154	delete_modules(&from_modules);
1155
1156	return ret;
1157}
1158
1159static int do_validate_kcore_modules_cb(struct map *old_map, void *data)
1160{
1161	struct rb_root *modules = data;
1162	struct module_info *mi;
1163	struct dso *dso;
1164
1165	if (!__map__is_kmodule(old_map))
1166		return 0;
1167
1168	dso = map__dso(old_map);
1169	/* Module must be in memory at the same address */
1170	mi = find_module(dso__short_name(dso), modules);
1171	if (!mi || mi->start != map__start(old_map))
1172		return -EINVAL;
1173
1174	return 0;
1175}
1176
1177static int do_validate_kcore_modules(const char *filename, struct maps *kmaps)
1178{
1179	struct rb_root modules = RB_ROOT;
 
1180	int err;
1181
1182	err = read_proc_modules(filename, &modules);
1183	if (err)
1184		return err;
1185
1186	err = maps__for_each_map(kmaps, do_validate_kcore_modules_cb, &modules);
 
1187
 
 
 
 
 
 
 
 
 
 
 
 
1188	delete_modules(&modules);
1189	return err;
1190}
1191
1192/*
1193 * If kallsyms is referenced by name then we look for filename in the same
1194 * directory.
1195 */
1196static bool filename_from_kallsyms_filename(char *filename,
1197					    const char *base_name,
1198					    const char *kallsyms_filename)
1199{
1200	char *name;
1201
1202	strcpy(filename, kallsyms_filename);
1203	name = strrchr(filename, '/');
1204	if (!name)
1205		return false;
1206
1207	name += 1;
1208
1209	if (!strcmp(name, "kallsyms")) {
1210		strcpy(name, base_name);
1211		return true;
1212	}
1213
1214	return false;
1215}
1216
1217static int validate_kcore_modules(const char *kallsyms_filename,
1218				  struct map *map)
1219{
1220	struct maps *kmaps = map__kmaps(map);
1221	char modules_filename[PATH_MAX];
1222
1223	if (!kmaps)
1224		return -EINVAL;
1225
1226	if (!filename_from_kallsyms_filename(modules_filename, "modules",
1227					     kallsyms_filename))
1228		return -EINVAL;
1229
1230	if (do_validate_kcore_modules(modules_filename, kmaps))
1231		return -EINVAL;
1232
1233	return 0;
1234}
1235
1236static int validate_kcore_addresses(const char *kallsyms_filename,
1237				    struct map *map)
1238{
1239	struct kmap *kmap = map__kmap(map);
1240
1241	if (!kmap)
1242		return -EINVAL;
1243
1244	if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) {
1245		u64 start;
1246
1247		if (kallsyms__get_function_start(kallsyms_filename,
1248						 kmap->ref_reloc_sym->name, &start))
1249			return -ENOENT;
1250		if (start != kmap->ref_reloc_sym->addr)
1251			return -EINVAL;
1252	}
1253
1254	return validate_kcore_modules(kallsyms_filename, map);
1255}
1256
1257struct kcore_mapfn_data {
1258	struct dso *dso;
1259	struct list_head maps;
1260};
1261
1262static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data)
1263{
1264	struct kcore_mapfn_data *md = data;
1265	struct map_list_node *list_node = map_list_node__new();
1266
1267	if (!list_node)
1268		return -ENOMEM;
1269
1270	list_node->map = map__new2(start, md->dso);
1271	if (!list_node->map) {
1272		free(list_node);
1273		return -ENOMEM;
1274	}
1275
1276	map__set_end(list_node->map, map__start(list_node->map) + len);
1277	map__set_pgoff(list_node->map, pgoff);
1278
1279	list_add(&list_node->node, &md->maps);
1280
1281	return 0;
1282}
1283
1284static bool remove_old_maps(struct map *map, void *data)
 
 
 
 
1285{
1286	const struct map *map_to_save = data;
 
1287
1288	/*
1289	 * We need to preserve eBPF maps even if they are covered by kcore,
1290	 * because we need to access eBPF dso for source data.
1291	 */
1292	return !RC_CHK_EQUAL(map, map_to_save) && !__map__is_bpf_prog(map);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1293}
1294
1295static int dso__load_kcore(struct dso *dso, struct map *map,
1296			   const char *kallsyms_filename)
1297{
1298	struct maps *kmaps = map__kmaps(map);
1299	struct kcore_mapfn_data md;
1300	struct map *map_ref, *replacement_map = NULL;
1301	struct machine *machine;
1302	bool is_64_bit;
1303	int err, fd;
1304	char kcore_filename[PATH_MAX];
1305	u64 stext;
1306
1307	if (!kmaps)
1308		return -EINVAL;
1309
1310	machine = maps__machine(kmaps);
1311
1312	/* This function requires that the map is the kernel map */
1313	if (!__map__is_kernel(map))
1314		return -EINVAL;
1315
1316	if (!filename_from_kallsyms_filename(kcore_filename, "kcore",
1317					     kallsyms_filename))
1318		return -EINVAL;
1319
1320	/* Modules and kernel must be present at their original addresses */
1321	if (validate_kcore_addresses(kallsyms_filename, map))
1322		return -EINVAL;
1323
1324	md.dso = dso;
1325	INIT_LIST_HEAD(&md.maps);
1326
1327	fd = open(kcore_filename, O_RDONLY);
1328	if (fd < 0) {
1329		pr_debug("Failed to open %s. Note /proc/kcore requires CAP_SYS_RAWIO capability to access.\n",
1330			 kcore_filename);
1331		return -EINVAL;
1332	}
1333
1334	/* Read new maps into temporary lists */
1335	err = file__read_maps(fd, map__prot(map) & PROT_EXEC, kcore_mapfn, &md,
1336			      &is_64_bit);
1337	if (err)
1338		goto out_err;
1339	dso__set_is_64_bit(dso, is_64_bit);
1340
1341	if (list_empty(&md.maps)) {
1342		err = -EINVAL;
1343		goto out_err;
1344	}
1345
1346	/* Remove old maps */
1347	maps__remove_maps(kmaps, remove_old_maps, map);
 
 
 
 
 
 
 
 
1348	machine->trampolines_mapped = false;
1349
1350	/* Find the kernel map using the '_stext' symbol */
1351	if (!kallsyms__get_function_start(kallsyms_filename, "_stext", &stext)) {
1352		u64 replacement_size = 0;
1353		struct map_list_node *new_node;
1354
1355		list_for_each_entry(new_node, &md.maps, node) {
1356			struct map *new_map = new_node->map;
1357			u64 new_size = map__size(new_map);
1358
1359			if (!(stext >= map__start(new_map) && stext < map__end(new_map)))
1360				continue;
1361
1362			/*
1363			 * On some architectures, ARM64 for example, the kernel
1364			 * text can get allocated inside of the vmalloc segment.
1365			 * Select the smallest matching segment, in case stext
1366			 * falls within more than one in the list.
1367			 */
1368			if (!replacement_map || new_size < replacement_size) {
1369				replacement_map = new_map;
1370				replacement_size = new_size;
1371			}
1372		}
1373	}
1374
1375	if (!replacement_map)
1376		replacement_map = list_entry(md.maps.next, struct map_list_node, node)->map;
1377
1378	/*
1379	 * Update addresses of vmlinux map. Re-insert it to ensure maps are
1380	 * correctly ordered. Do this before using maps__merge_in() for the
1381	 * remaining maps so vmlinux gets split if necessary.
1382	 */
1383	map_ref = map__get(map);
1384	maps__remove(kmaps, map_ref);
1385
1386	map__set_start(map_ref, map__start(replacement_map));
1387	map__set_end(map_ref, map__end(replacement_map));
1388	map__set_pgoff(map_ref, map__pgoff(replacement_map));
1389	map__set_mapping_type(map_ref, map__mapping_type(replacement_map));
1390
1391	err = maps__insert(kmaps, map_ref);
1392	map__put(map_ref);
1393	if (err)
1394		goto out_err;
1395
1396	/* Add new maps */
1397	while (!list_empty(&md.maps)) {
1398		struct map_list_node *new_node = list_entry(md.maps.next, struct map_list_node, node);
1399		struct map *new_map = new_node->map;
1400
1401		list_del_init(&new_node->node);
1402
1403		/* skip if replacement_map, already inserted above */
1404		if (!RC_CHK_EQUAL(new_map, replacement_map)) {
 
 
 
 
 
 
 
 
1405			/*
1406			 * Merge kcore map into existing maps,
1407			 * and ensure that current maps (eBPF)
1408			 * stay intact.
1409			 */
1410			if (maps__merge_in(kmaps, new_map)) {
1411				err = -EINVAL;
1412				goto out_err;
1413			}
1414		}
1415		free(new_node);
1416	}
1417
1418	if (machine__is(machine, "x86_64")) {
1419		u64 addr;
1420
1421		/*
1422		 * If one of the corresponding symbols is there, assume the
1423		 * entry trampoline maps are too.
1424		 */
1425		if (!kallsyms__get_function_start(kallsyms_filename,
1426						  ENTRY_TRAMPOLINE_NAME,
1427						  &addr))
1428			machine->trampolines_mapped = true;
1429	}
1430
1431	/*
1432	 * Set the data type and long name so that kcore can be read via
1433	 * dso__data_read_addr().
1434	 */
1435	if (dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST)
1436		dso__set_binary_type(dso, DSO_BINARY_TYPE__GUEST_KCORE);
1437	else
1438		dso__set_binary_type(dso, DSO_BINARY_TYPE__KCORE);
1439	dso__set_long_name(dso, strdup(kcore_filename), true);
1440
1441	close(fd);
1442
1443	if (map__prot(map) & PROT_EXEC)
1444		pr_debug("Using %s for kernel object code\n", kcore_filename);
1445	else
1446		pr_debug("Using %s for kernel data\n", kcore_filename);
1447
1448	return 0;
1449
1450out_err:
1451	while (!list_empty(&md.maps)) {
1452		struct map_list_node *list_node;
1453
1454		list_node = list_entry(md.maps.next, struct map_list_node, node);
1455		list_del_init(&list_node->node);
1456		map__zput(list_node->map);
1457		free(list_node);
1458	}
1459	close(fd);
1460	return err;
1461}
1462
1463/*
1464 * If the kernel is relocated at boot time, kallsyms won't match.  Compute the
1465 * delta based on the relocation reference symbol.
1466 */
1467static int kallsyms__delta(struct kmap *kmap, const char *filename, u64 *delta)
1468{
1469	u64 addr;
1470
1471	if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name)
1472		return 0;
1473
1474	if (kallsyms__get_function_start(filename, kmap->ref_reloc_sym->name, &addr))
1475		return -1;
1476
1477	*delta = addr - kmap->ref_reloc_sym->addr;
1478	return 0;
1479}
1480
1481int __dso__load_kallsyms(struct dso *dso, const char *filename,
1482			 struct map *map, bool no_kcore)
1483{
1484	struct kmap *kmap = map__kmap(map);
1485	u64 delta = 0;
1486
1487	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
1488		return -1;
1489
1490	if (!kmap || !kmap->kmaps)
1491		return -1;
1492
1493	if (dso__load_all_kallsyms(dso, filename) < 0)
1494		return -1;
1495
1496	if (kallsyms__delta(kmap, filename, &delta))
1497		return -1;
1498
1499	symbols__fixup_end(dso__symbols(dso), true);
1500	symbols__fixup_duplicate(dso__symbols(dso));
1501
1502	if (dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST)
1503		dso__set_symtab_type(dso, DSO_BINARY_TYPE__GUEST_KALLSYMS);
1504	else
1505		dso__set_symtab_type(dso, DSO_BINARY_TYPE__KALLSYMS);
1506
1507	if (!no_kcore && !dso__load_kcore(dso, map, filename))
1508		return maps__split_kallsyms_for_kcore(kmap->kmaps, dso);
1509	else
1510		return maps__split_kallsyms(kmap->kmaps, dso, delta, map);
1511}
1512
1513int dso__load_kallsyms(struct dso *dso, const char *filename,
1514		       struct map *map)
1515{
1516	return __dso__load_kallsyms(dso, filename, map, false);
1517}
1518
1519static int dso__load_perf_map(const char *map_path, struct dso *dso)
1520{
1521	char *line = NULL;
1522	size_t n;
1523	FILE *file;
1524	int nr_syms = 0;
1525
1526	file = fopen(map_path, "r");
1527	if (file == NULL)
1528		goto out_failure;
1529
1530	while (!feof(file)) {
1531		u64 start, size;
1532		struct symbol *sym;
1533		int line_len, len;
1534
1535		line_len = getline(&line, &n, file);
1536		if (line_len < 0)
1537			break;
1538
1539		if (!line)
1540			goto out_failure;
1541
1542		line[--line_len] = '\0'; /* \n */
1543
1544		len = hex2u64(line, &start);
1545
1546		len++;
1547		if (len + 2 >= line_len)
1548			continue;
1549
1550		len += hex2u64(line + len, &size);
1551
1552		len++;
1553		if (len + 2 >= line_len)
1554			continue;
1555
1556		sym = symbol__new(start, size, STB_GLOBAL, STT_FUNC, line + len);
1557
1558		if (sym == NULL)
1559			goto out_delete_line;
1560
1561		symbols__insert(dso__symbols(dso), sym);
1562		nr_syms++;
1563	}
1564
1565	free(line);
1566	fclose(file);
1567
1568	return nr_syms;
1569
1570out_delete_line:
1571	free(line);
1572out_failure:
1573	return -1;
1574}
1575
1576#ifdef HAVE_LIBBFD_SUPPORT
1577#define PACKAGE 'perf'
1578#include <bfd.h>
1579
1580static int bfd_symbols__cmpvalue(const void *a, const void *b)
1581{
1582	const asymbol *as = *(const asymbol **)a, *bs = *(const asymbol **)b;
1583
1584	if (bfd_asymbol_value(as) != bfd_asymbol_value(bs))
1585		return bfd_asymbol_value(as) - bfd_asymbol_value(bs);
1586
1587	return bfd_asymbol_name(as)[0] - bfd_asymbol_name(bs)[0];
1588}
1589
1590static int bfd2elf_binding(asymbol *symbol)
1591{
1592	if (symbol->flags & BSF_WEAK)
1593		return STB_WEAK;
1594	if (symbol->flags & BSF_GLOBAL)
1595		return STB_GLOBAL;
1596	if (symbol->flags & BSF_LOCAL)
1597		return STB_LOCAL;
1598	return -1;
1599}
1600
1601int dso__load_bfd_symbols(struct dso *dso, const char *debugfile)
1602{
1603	int err = -1;
1604	long symbols_size, symbols_count, i;
1605	asection *section;
1606	asymbol **symbols, *sym;
1607	struct symbol *symbol;
1608	bfd *abfd;
1609	u64 start, len;
1610
1611	abfd = bfd_openr(debugfile, NULL);
1612	if (!abfd)
1613		return -1;
1614
1615	if (!bfd_check_format(abfd, bfd_object)) {
1616		pr_debug2("%s: cannot read %s bfd file.\n", __func__,
1617			  dso__long_name(dso));
1618		goto out_close;
1619	}
1620
1621	if (bfd_get_flavour(abfd) == bfd_target_elf_flavour)
1622		goto out_close;
1623
1624	symbols_size = bfd_get_symtab_upper_bound(abfd);
1625	if (symbols_size == 0) {
1626		bfd_close(abfd);
1627		return 0;
1628	}
1629
1630	if (symbols_size < 0)
1631		goto out_close;
1632
1633	symbols = malloc(symbols_size);
1634	if (!symbols)
1635		goto out_close;
1636
1637	symbols_count = bfd_canonicalize_symtab(abfd, symbols);
1638	if (symbols_count < 0)
1639		goto out_free;
1640
1641	section = bfd_get_section_by_name(abfd, ".text");
1642	if (section) {
1643		for (i = 0; i < symbols_count; ++i) {
1644			if (!strcmp(bfd_asymbol_name(symbols[i]), "__ImageBase") ||
1645			    !strcmp(bfd_asymbol_name(symbols[i]), "__image_base__"))
1646				break;
1647		}
1648		if (i < symbols_count) {
1649			/* PE symbols can only have 4 bytes, so use .text high bits */
1650			u64 text_offset = (section->vma - (u32)section->vma)
1651				+ (u32)bfd_asymbol_value(symbols[i]);
1652			dso__set_text_offset(dso, text_offset);
1653			dso__set_text_end(dso, (section->vma - text_offset) + section->size);
1654		} else {
1655			dso__set_text_offset(dso, section->vma - section->filepos);
1656			dso__set_text_end(dso, section->filepos + section->size);
1657		}
1658	}
1659
1660	qsort(symbols, symbols_count, sizeof(asymbol *), bfd_symbols__cmpvalue);
1661
1662#ifdef bfd_get_section
1663#define bfd_asymbol_section bfd_get_section
1664#endif
1665	for (i = 0; i < symbols_count; ++i) {
1666		sym = symbols[i];
1667		section = bfd_asymbol_section(sym);
1668		if (bfd2elf_binding(sym) < 0)
1669			continue;
1670
1671		while (i + 1 < symbols_count &&
1672		       bfd_asymbol_section(symbols[i + 1]) == section &&
1673		       bfd2elf_binding(symbols[i + 1]) < 0)
1674			i++;
1675
1676		if (i + 1 < symbols_count &&
1677		    bfd_asymbol_section(symbols[i + 1]) == section)
1678			len = symbols[i + 1]->value - sym->value;
1679		else
1680			len = section->size - sym->value;
1681
1682		start = bfd_asymbol_value(sym) - dso__text_offset(dso);
1683		symbol = symbol__new(start, len, bfd2elf_binding(sym), STT_FUNC,
1684				     bfd_asymbol_name(sym));
1685		if (!symbol)
1686			goto out_free;
1687
1688		symbols__insert(dso__symbols(dso), symbol);
1689	}
1690#ifdef bfd_get_section
1691#undef bfd_asymbol_section
1692#endif
1693
1694	symbols__fixup_end(dso__symbols(dso), false);
1695	symbols__fixup_duplicate(dso__symbols(dso));
1696	dso__set_adjust_symbols(dso, true);
1697
1698	err = 0;
1699out_free:
1700	free(symbols);
1701out_close:
1702	bfd_close(abfd);
1703	return err;
1704}
1705#endif
1706
1707static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod,
1708					   enum dso_binary_type type)
1709{
1710	switch (type) {
1711	case DSO_BINARY_TYPE__JAVA_JIT:
1712	case DSO_BINARY_TYPE__DEBUGLINK:
1713	case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
1714	case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
1715	case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
1716	case DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO:
1717	case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
1718	case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO:
1719		return !kmod && dso__kernel(dso) == DSO_SPACE__USER;
1720
1721	case DSO_BINARY_TYPE__KALLSYMS:
1722	case DSO_BINARY_TYPE__VMLINUX:
1723	case DSO_BINARY_TYPE__KCORE:
1724		return dso__kernel(dso) == DSO_SPACE__KERNEL;
1725
1726	case DSO_BINARY_TYPE__GUEST_KALLSYMS:
1727	case DSO_BINARY_TYPE__GUEST_VMLINUX:
1728	case DSO_BINARY_TYPE__GUEST_KCORE:
1729		return dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST;
1730
1731	case DSO_BINARY_TYPE__GUEST_KMODULE:
1732	case DSO_BINARY_TYPE__GUEST_KMODULE_COMP:
1733	case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
1734	case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP:
1735		/*
1736		 * kernel modules know their symtab type - it's set when
1737		 * creating a module dso in machine__addnew_module_map().
1738		 */
1739		return kmod && dso__symtab_type(dso) == type;
1740
1741	case DSO_BINARY_TYPE__BUILD_ID_CACHE:
1742	case DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO:
1743		return true;
1744
1745	case DSO_BINARY_TYPE__BPF_PROG_INFO:
1746	case DSO_BINARY_TYPE__BPF_IMAGE:
1747	case DSO_BINARY_TYPE__OOL:
1748	case DSO_BINARY_TYPE__NOT_FOUND:
1749	default:
1750		return false;
1751	}
1752}
1753
1754/* Checks for the existence of the perf-<pid>.map file in two different
1755 * locations.  First, if the process is a separate mount namespace, check in
1756 * that namespace using the pid of the innermost pid namespace.  If's not in a
1757 * namespace, or the file can't be found there, try in the mount namespace of
1758 * the tracing process using our view of its pid.
1759 */
1760static int dso__find_perf_map(char *filebuf, size_t bufsz,
1761			      struct nsinfo **nsip)
1762{
1763	struct nscookie nsc;
1764	struct nsinfo *nsi;
1765	struct nsinfo *nnsi;
1766	int rc = -1;
1767
1768	nsi = *nsip;
1769
1770	if (nsinfo__need_setns(nsi)) {
1771		snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nsinfo__nstgid(nsi));
1772		nsinfo__mountns_enter(nsi, &nsc);
1773		rc = access(filebuf, R_OK);
1774		nsinfo__mountns_exit(&nsc);
1775		if (rc == 0)
1776			return rc;
1777	}
1778
1779	nnsi = nsinfo__copy(nsi);
1780	if (nnsi) {
1781		nsinfo__put(nsi);
1782
1783		nsinfo__clear_need_setns(nnsi);
1784		snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nsinfo__tgid(nnsi));
1785		*nsip = nnsi;
1786		rc = 0;
1787	}
1788
1789	return rc;
1790}
1791
1792int dso__load(struct dso *dso, struct map *map)
1793{
1794	char *name;
1795	int ret = -1;
1796	u_int i;
1797	struct machine *machine = NULL;
1798	char *root_dir = (char *) "";
1799	int ss_pos = 0;
1800	struct symsrc ss_[2];
1801	struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
1802	bool kmod;
1803	bool perfmap;
1804	struct build_id bid;
1805	struct nscookie nsc;
1806	char newmapname[PATH_MAX];
1807	const char *map_path = dso__long_name(dso);
1808
1809	mutex_lock(dso__lock(dso));
1810	perfmap = is_perf_pid_map_name(map_path);
1811
 
1812	if (perfmap) {
1813		if (dso__nsinfo(dso) &&
1814		    (dso__find_perf_map(newmapname, sizeof(newmapname),
1815					dso__nsinfo_ptr(dso)) == 0)) {
1816			map_path = newmapname;
1817		}
1818	}
1819
1820	nsinfo__mountns_enter(dso__nsinfo(dso), &nsc);
 
1821
1822	/* check again under the dso->lock */
1823	if (dso__loaded(dso)) {
1824		ret = 1;
1825		goto out;
1826	}
1827
1828	kmod = dso__is_kmod(dso);
 
 
 
1829
1830	if (dso__kernel(dso) && !kmod) {
1831		if (dso__kernel(dso) == DSO_SPACE__KERNEL)
1832			ret = dso__load_kernel_sym(dso, map);
1833		else if (dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST)
1834			ret = dso__load_guest_kernel_sym(dso, map);
1835
1836		machine = maps__machine(map__kmaps(map));
1837		if (machine__is(machine, "x86_64"))
1838			machine__map_x86_64_entry_trampolines(machine, dso);
1839		goto out;
1840	}
1841
1842	dso__set_adjust_symbols(dso, false);
1843
1844	if (perfmap) {
1845		ret = dso__load_perf_map(map_path, dso);
1846		dso__set_symtab_type(dso, ret > 0
1847				? DSO_BINARY_TYPE__JAVA_JIT
1848				: DSO_BINARY_TYPE__NOT_FOUND);
1849		goto out;
1850	}
1851
1852	if (machine)
1853		root_dir = machine->root_dir;
1854
1855	name = malloc(PATH_MAX);
1856	if (!name)
1857		goto out;
1858
1859	/*
1860	 * Read the build id if possible. This is required for
1861	 * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work
1862	 */
1863	if (!dso__has_build_id(dso) &&
1864	    is_regular_file(dso__long_name(dso))) {
1865		__symbol__join_symfs(name, PATH_MAX, dso__long_name(dso));
1866		if (filename__read_build_id(name, &bid) > 0)
1867			dso__set_build_id(dso, &bid);
1868	}
1869
1870	/*
1871	 * Iterate over candidate debug images.
1872	 * Keep track of "interesting" ones (those which have a symtab, dynsym,
1873	 * and/or opd section) for processing.
1874	 */
1875	for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
1876		struct symsrc *ss = &ss_[ss_pos];
1877		bool next_slot = false;
1878		bool is_reg;
1879		bool nsexit;
1880		int bfdrc = -1;
1881		int sirc = -1;
1882
1883		enum dso_binary_type symtab_type = binary_type_symtab[i];
1884
1885		nsexit = (symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE ||
1886		    symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO);
1887
1888		if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type))
1889			continue;
1890
1891		if (dso__read_binary_type_filename(dso, symtab_type,
1892						   root_dir, name, PATH_MAX))
1893			continue;
1894
1895		if (nsexit)
1896			nsinfo__mountns_exit(&nsc);
1897
1898		is_reg = is_regular_file(name);
1899		if (!is_reg && errno == ENOENT && dso__nsinfo(dso)) {
1900			char *new_name = dso__filename_with_chroot(dso, name);
1901			if (new_name) {
1902				is_reg = is_regular_file(new_name);
1903				strlcpy(name, new_name, PATH_MAX);
1904				free(new_name);
1905			}
1906		}
1907
1908#ifdef HAVE_LIBBFD_SUPPORT
1909		if (is_reg)
1910			bfdrc = dso__load_bfd_symbols(dso, name);
1911#endif
1912		if (is_reg && bfdrc < 0)
1913			sirc = symsrc__init(ss, dso, name, symtab_type);
1914
1915		if (nsexit)
1916			nsinfo__mountns_enter(dso__nsinfo(dso), &nsc);
1917
1918		if (bfdrc == 0) {
1919			ret = 0;
1920			break;
1921		}
1922
1923		if (!is_reg || sirc < 0)
1924			continue;
1925
1926		if (!syms_ss && symsrc__has_symtab(ss)) {
1927			syms_ss = ss;
1928			next_slot = true;
1929			if (!dso__symsrc_filename(dso))
1930				dso__set_symsrc_filename(dso, strdup(name));
1931		}
1932
1933		if (!runtime_ss && symsrc__possibly_runtime(ss)) {
1934			runtime_ss = ss;
1935			next_slot = true;
1936		}
1937
1938		if (next_slot) {
1939			ss_pos++;
1940
1941			if (dso__binary_type(dso) == DSO_BINARY_TYPE__NOT_FOUND)
1942				dso__set_binary_type(dso, symtab_type);
1943
1944			if (syms_ss && runtime_ss)
1945				break;
1946		} else {
1947			symsrc__destroy(ss);
1948		}
1949
1950	}
1951
1952	if (!runtime_ss && !syms_ss)
1953		goto out_free;
1954
1955	if (runtime_ss && !syms_ss) {
1956		syms_ss = runtime_ss;
1957	}
1958
1959	/* We'll have to hope for the best */
1960	if (!runtime_ss && syms_ss)
1961		runtime_ss = syms_ss;
1962
1963	if (syms_ss)
1964		ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod);
1965	else
1966		ret = -1;
1967
1968	if (ret > 0) {
1969		int nr_plt;
1970
1971		nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss);
1972		if (nr_plt > 0)
1973			ret += nr_plt;
1974	}
1975
1976	for (; ss_pos > 0; ss_pos--)
1977		symsrc__destroy(&ss_[ss_pos - 1]);
1978out_free:
1979	free(name);
1980	if (ret < 0 && strstr(dso__name(dso), " (deleted)") != NULL)
1981		ret = 0;
1982out:
1983	dso__set_loaded(dso);
1984	mutex_unlock(dso__lock(dso));
1985	nsinfo__mountns_exit(&nsc);
1986
1987	return ret;
1988}
1989
1990/*
1991 * Always takes ownership of vmlinux when vmlinux_allocated == true, even if
1992 * it returns an error.
1993 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1994int dso__load_vmlinux(struct dso *dso, struct map *map,
1995		      const char *vmlinux, bool vmlinux_allocated)
1996{
1997	int err = -1;
1998	struct symsrc ss;
1999	char symfs_vmlinux[PATH_MAX];
2000	enum dso_binary_type symtab_type;
2001
2002	if (vmlinux[0] == '/')
2003		snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux);
2004	else
2005		symbol__join_symfs(symfs_vmlinux, vmlinux);
2006
2007	if (dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST)
2008		symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
2009	else
2010		symtab_type = DSO_BINARY_TYPE__VMLINUX;
2011
2012	if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type)) {
2013		if (vmlinux_allocated)
2014			free((char *) vmlinux);
2015		return -1;
2016	}
2017
2018	/*
2019	 * dso__load_sym() may copy 'dso' which will result in the copies having
2020	 * an incorrect long name unless we set it here first.
2021	 */
2022	dso__set_long_name(dso, vmlinux, vmlinux_allocated);
2023	if (dso__kernel(dso) == DSO_SPACE__KERNEL_GUEST)
2024		dso__set_binary_type(dso, DSO_BINARY_TYPE__GUEST_VMLINUX);
2025	else
2026		dso__set_binary_type(dso, DSO_BINARY_TYPE__VMLINUX);
2027
2028	err = dso__load_sym(dso, map, &ss, &ss, 0);
2029	symsrc__destroy(&ss);
2030
2031	if (err > 0) {
 
 
 
 
 
2032		dso__set_loaded(dso);
2033		pr_debug("Using %s for symbols\n", symfs_vmlinux);
2034	}
2035
2036	return err;
2037}
2038
2039int dso__load_vmlinux_path(struct dso *dso, struct map *map)
2040{
2041	int i, err = 0;
2042	char *filename = NULL;
2043
2044	pr_debug("Looking at the vmlinux_path (%d entries long)\n",
2045		 vmlinux_path__nr_entries + 1);
2046
2047	for (i = 0; i < vmlinux_path__nr_entries; ++i) {
2048		err = dso__load_vmlinux(dso, map, vmlinux_path[i], false);
2049		if (err > 0)
2050			goto out;
2051	}
2052
2053	if (!symbol_conf.ignore_vmlinux_buildid)
2054		filename = dso__build_id_filename(dso, NULL, 0, false);
2055	if (filename != NULL) {
2056		err = dso__load_vmlinux(dso, map, filename, true);
2057		if (err > 0)
2058			goto out;
 
2059	}
2060out:
2061	return err;
2062}
2063
2064static bool visible_dir_filter(const char *name, struct dirent *d)
2065{
2066	if (d->d_type != DT_DIR)
2067		return false;
2068	return lsdir_no_dot_filter(name, d);
2069}
2070
2071static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz)
2072{
2073	char kallsyms_filename[PATH_MAX];
2074	int ret = -1;
2075	struct strlist *dirs;
2076	struct str_node *nd;
2077
2078	dirs = lsdir(dir, visible_dir_filter);
2079	if (!dirs)
2080		return -1;
2081
2082	strlist__for_each_entry(nd, dirs) {
2083		scnprintf(kallsyms_filename, sizeof(kallsyms_filename),
2084			  "%s/%s/kallsyms", dir, nd->s);
2085		if (!validate_kcore_addresses(kallsyms_filename, map)) {
2086			strlcpy(dir, kallsyms_filename, dir_sz);
2087			ret = 0;
2088			break;
2089		}
2090	}
2091
2092	strlist__delete(dirs);
2093
2094	return ret;
2095}
2096
2097/*
2098 * Use open(O_RDONLY) to check readability directly instead of access(R_OK)
2099 * since access(R_OK) only checks with real UID/GID but open() use effective
2100 * UID/GID and actual capabilities (e.g. /proc/kcore requires CAP_SYS_RAWIO).
2101 */
2102static bool filename__readable(const char *file)
2103{
2104	int fd = open(file, O_RDONLY);
2105	if (fd < 0)
2106		return false;
2107	close(fd);
2108	return true;
2109}
2110
2111static char *dso__find_kallsyms(struct dso *dso, struct map *map)
2112{
2113	struct build_id bid;
2114	char sbuild_id[SBUILD_ID_SIZE];
2115	bool is_host = false;
2116	char path[PATH_MAX];
2117
2118	if (!dso__has_build_id(dso)) {
2119		/*
2120		 * Last resort, if we don't have a build-id and couldn't find
2121		 * any vmlinux file, try the running kernel kallsyms table.
2122		 */
2123		goto proc_kallsyms;
2124	}
2125
2126	if (sysfs__read_build_id("/sys/kernel/notes", &bid) == 0)
2127		is_host = dso__build_id_equal(dso, &bid);
 
2128
2129	/* Try a fast path for /proc/kallsyms if possible */
2130	if (is_host) {
2131		/*
2132		 * Do not check the build-id cache, unless we know we cannot use
2133		 * /proc/kcore or module maps don't match to /proc/kallsyms.
2134		 * To check readability of /proc/kcore, do not use access(R_OK)
2135		 * since /proc/kcore requires CAP_SYS_RAWIO to read and access
2136		 * can't check it.
2137		 */
2138		if (filename__readable("/proc/kcore") &&
2139		    !validate_kcore_addresses("/proc/kallsyms", map))
2140			goto proc_kallsyms;
2141	}
2142
2143	build_id__sprintf(dso__bid(dso), sbuild_id);
2144
2145	/* Find kallsyms in build-id cache with kcore */
2146	scnprintf(path, sizeof(path), "%s/%s/%s",
2147		  buildid_dir, DSO__NAME_KCORE, sbuild_id);
2148
2149	if (!find_matching_kcore(map, path, sizeof(path)))
2150		return strdup(path);
2151
2152	/* Use current /proc/kallsyms if possible */
2153	if (is_host) {
2154proc_kallsyms:
2155		return strdup("/proc/kallsyms");
2156	}
2157
2158	/* Finally, find a cache of kallsyms */
2159	if (!build_id_cache__kallsyms_path(sbuild_id, path, sizeof(path))) {
2160		pr_err("No kallsyms or vmlinux with build-id %s was found\n",
2161		       sbuild_id);
2162		return NULL;
2163	}
2164
2165	return strdup(path);
2166}
2167
2168static int dso__load_kernel_sym(struct dso *dso, struct map *map)
2169{
2170	int err;
2171	const char *kallsyms_filename = NULL;
2172	char *kallsyms_allocated_filename = NULL;
2173	char *filename = NULL;
2174
2175	/*
2176	 * Step 1: if the user specified a kallsyms or vmlinux filename, use
2177	 * it and only it, reporting errors to the user if it cannot be used.
2178	 *
2179	 * For instance, try to analyse an ARM perf.data file _without_ a
2180	 * build-id, or if the user specifies the wrong path to the right
2181	 * vmlinux file, obviously we can't fallback to another vmlinux (a
2182	 * x86_86 one, on the machine where analysis is being performed, say),
2183	 * or worse, /proc/kallsyms.
2184	 *
2185	 * If the specified file _has_ a build-id and there is a build-id
2186	 * section in the perf.data file, we will still do the expected
2187	 * validation in dso__load_vmlinux and will bail out if they don't
2188	 * match.
2189	 */
2190	if (symbol_conf.kallsyms_name != NULL) {
2191		kallsyms_filename = symbol_conf.kallsyms_name;
2192		goto do_kallsyms;
2193	}
2194
2195	if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) {
2196		return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name, false);
2197	}
2198
2199	/*
2200	 * Before checking on common vmlinux locations, check if it's
2201	 * stored as standard build id binary (not kallsyms) under
2202	 * .debug cache.
2203	 */
2204	if (!symbol_conf.ignore_vmlinux_buildid)
2205		filename = __dso__build_id_filename(dso, NULL, 0, false, false);
2206	if (filename != NULL) {
2207		err = dso__load_vmlinux(dso, map, filename, true);
2208		if (err > 0)
2209			return err;
2210	}
2211
2212	if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) {
2213		err = dso__load_vmlinux_path(dso, map);
2214		if (err > 0)
2215			return err;
2216	}
2217
2218	/* do not try local files if a symfs was given */
2219	if (symbol_conf.symfs[0] != 0)
2220		return -1;
2221
2222	kallsyms_allocated_filename = dso__find_kallsyms(dso, map);
2223	if (!kallsyms_allocated_filename)
2224		return -1;
2225
2226	kallsyms_filename = kallsyms_allocated_filename;
2227
2228do_kallsyms:
2229	err = dso__load_kallsyms(dso, kallsyms_filename, map);
2230	if (err > 0)
2231		pr_debug("Using %s for symbols\n", kallsyms_filename);
2232	free(kallsyms_allocated_filename);
2233
2234	if (err > 0 && !dso__is_kcore(dso)) {
2235		dso__set_binary_type(dso, DSO_BINARY_TYPE__KALLSYMS);
2236		dso__set_long_name(dso, DSO__NAME_KALLSYMS, false);
2237		map__fixup_start(map);
2238		map__fixup_end(map);
2239	}
2240
2241	return err;
2242}
2243
2244static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map)
2245{
2246	int err;
2247	const char *kallsyms_filename;
2248	struct machine *machine = maps__machine(map__kmaps(map));
2249	char path[PATH_MAX];
2250
2251	if (machine->kallsyms_filename) {
2252		kallsyms_filename = machine->kallsyms_filename;
2253	} else if (machine__is_default_guest(machine)) {
2254		/*
2255		 * if the user specified a vmlinux filename, use it and only
2256		 * it, reporting errors to the user if it cannot be used.
2257		 * Or use file guest_kallsyms inputted by user on commandline
2258		 */
2259		if (symbol_conf.default_guest_vmlinux_name != NULL) {
2260			err = dso__load_vmlinux(dso, map,
2261						symbol_conf.default_guest_vmlinux_name,
2262						false);
2263			return err;
2264		}
2265
2266		kallsyms_filename = symbol_conf.default_guest_kallsyms;
2267		if (!kallsyms_filename)
2268			return -1;
2269	} else {
2270		sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2271		kallsyms_filename = path;
2272	}
2273
2274	err = dso__load_kallsyms(dso, kallsyms_filename, map);
2275	if (err > 0)
2276		pr_debug("Using %s for symbols\n", kallsyms_filename);
2277	if (err > 0 && !dso__is_kcore(dso)) {
2278		dso__set_binary_type(dso, DSO_BINARY_TYPE__GUEST_KALLSYMS);
2279		dso__set_long_name(dso, machine->mmap_name, false);
2280		map__fixup_start(map);
2281		map__fixup_end(map);
2282	}
2283
2284	return err;
2285}
2286
2287static void vmlinux_path__exit(void)
2288{
2289	while (--vmlinux_path__nr_entries >= 0)
2290		zfree(&vmlinux_path[vmlinux_path__nr_entries]);
2291	vmlinux_path__nr_entries = 0;
2292
2293	zfree(&vmlinux_path);
2294}
2295
2296static const char * const vmlinux_paths[] = {
2297	"vmlinux",
2298	"/boot/vmlinux"
2299};
2300
2301static const char * const vmlinux_paths_upd[] = {
2302	"/boot/vmlinux-%s",
2303	"/usr/lib/debug/boot/vmlinux-%s",
2304	"/lib/modules/%s/build/vmlinux",
2305	"/usr/lib/debug/lib/modules/%s/vmlinux",
2306	"/usr/lib/debug/boot/vmlinux-%s.debug"
2307};
2308
2309static int vmlinux_path__add(const char *new_entry)
2310{
2311	vmlinux_path[vmlinux_path__nr_entries] = strdup(new_entry);
2312	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2313		return -1;
2314	++vmlinux_path__nr_entries;
2315
2316	return 0;
2317}
2318
2319static int vmlinux_path__init(struct perf_env *env)
2320{
2321	struct utsname uts;
2322	char bf[PATH_MAX];
2323	char *kernel_version;
2324	unsigned int i;
2325
2326	vmlinux_path = malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) +
2327			      ARRAY_SIZE(vmlinux_paths_upd)));
2328	if (vmlinux_path == NULL)
2329		return -1;
2330
2331	for (i = 0; i < ARRAY_SIZE(vmlinux_paths); i++)
2332		if (vmlinux_path__add(vmlinux_paths[i]) < 0)
2333			goto out_fail;
2334
2335	/* only try kernel version if no symfs was given */
2336	if (symbol_conf.symfs[0] != 0)
2337		return 0;
2338
2339	if (env) {
2340		kernel_version = env->os_release;
2341	} else {
2342		if (uname(&uts) < 0)
2343			goto out_fail;
2344
2345		kernel_version = uts.release;
2346	}
2347
2348	for (i = 0; i < ARRAY_SIZE(vmlinux_paths_upd); i++) {
2349		snprintf(bf, sizeof(bf), vmlinux_paths_upd[i], kernel_version);
2350		if (vmlinux_path__add(bf) < 0)
2351			goto out_fail;
2352	}
2353
2354	return 0;
2355
2356out_fail:
2357	vmlinux_path__exit();
2358	return -1;
2359}
2360
2361int setup_list(struct strlist **list, const char *list_str,
2362		      const char *list_name)
2363{
2364	if (list_str == NULL)
2365		return 0;
2366
2367	*list = strlist__new(list_str, NULL);
2368	if (!*list) {
2369		pr_err("problems parsing %s list\n", list_name);
2370		return -1;
2371	}
2372
2373	symbol_conf.has_filter = true;
2374	return 0;
2375}
2376
2377int setup_intlist(struct intlist **list, const char *list_str,
2378		  const char *list_name)
2379{
2380	if (list_str == NULL)
2381		return 0;
2382
2383	*list = intlist__new(list_str);
2384	if (!*list) {
2385		pr_err("problems parsing %s list\n", list_name);
2386		return -1;
2387	}
2388	return 0;
2389}
2390
2391static int setup_addrlist(struct intlist **addr_list, struct strlist *sym_list)
2392{
2393	struct str_node *pos, *tmp;
2394	unsigned long val;
2395	char *sep;
2396	const char *end;
2397	int i = 0, err;
2398
2399	*addr_list = intlist__new(NULL);
2400	if (!*addr_list)
2401		return -1;
2402
2403	strlist__for_each_entry_safe(pos, tmp, sym_list) {
2404		errno = 0;
2405		val = strtoul(pos->s, &sep, 16);
2406		if (errno || (sep == pos->s))
2407			continue;
2408
2409		if (*sep != '\0') {
2410			end = pos->s + strlen(pos->s) - 1;
2411			while (end >= sep && isspace(*end))
2412				end--;
2413
2414			if (end >= sep)
2415				continue;
2416		}
2417
2418		err = intlist__add(*addr_list, val);
2419		if (err)
2420			break;
2421
2422		strlist__remove(sym_list, pos);
2423		i++;
2424	}
2425
2426	if (i == 0) {
2427		intlist__delete(*addr_list);
2428		*addr_list = NULL;
2429	}
2430
2431	return 0;
2432}
2433
2434static bool symbol__read_kptr_restrict(void)
2435{
2436	bool value = false;
2437	FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2438	bool used_root;
2439	bool cap_syslog = perf_cap__capable(CAP_SYSLOG, &used_root);
2440
2441	if (fp != NULL) {
2442		char line[8];
2443
2444		if (fgets(line, sizeof(line), fp) != NULL)
2445			value = cap_syslog ? (atoi(line) >= 2) : (atoi(line) != 0);
 
 
2446
2447		fclose(fp);
2448	}
2449
2450	/* Per kernel/kallsyms.c:
2451	 * we also restrict when perf_event_paranoid > 1 w/o CAP_SYSLOG
2452	 */
2453	if (perf_event_paranoid() > 1 && !cap_syslog)
2454		value = true;
2455
2456	return value;
2457}
2458
2459int symbol__annotation_init(void)
2460{
2461	if (symbol_conf.init_annotation)
2462		return 0;
2463
2464	if (symbol_conf.initialized) {
2465		pr_err("Annotation needs to be init before symbol__init()\n");
2466		return -1;
2467	}
2468
2469	symbol_conf.priv_size += sizeof(struct annotation);
2470	symbol_conf.init_annotation = true;
2471	return 0;
2472}
2473
2474int symbol__init(struct perf_env *env)
2475{
2476	const char *symfs;
2477
2478	if (symbol_conf.initialized)
2479		return 0;
2480
2481	symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
2482
2483	symbol__elf_init();
2484
 
 
 
 
2485	if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0)
2486		return -1;
2487
2488	if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2489		pr_err("'.' is the only non valid --field-separator argument\n");
2490		return -1;
2491	}
2492
2493	if (setup_list(&symbol_conf.dso_list,
2494		       symbol_conf.dso_list_str, "dso") < 0)
2495		return -1;
2496
2497	if (setup_list(&symbol_conf.comm_list,
2498		       symbol_conf.comm_list_str, "comm") < 0)
2499		goto out_free_dso_list;
2500
2501	if (setup_intlist(&symbol_conf.pid_list,
2502		       symbol_conf.pid_list_str, "pid") < 0)
2503		goto out_free_comm_list;
2504
2505	if (setup_intlist(&symbol_conf.tid_list,
2506		       symbol_conf.tid_list_str, "tid") < 0)
2507		goto out_free_pid_list;
2508
2509	if (setup_list(&symbol_conf.sym_list,
2510		       symbol_conf.sym_list_str, "symbol") < 0)
2511		goto out_free_tid_list;
2512
2513	if (symbol_conf.sym_list &&
2514	    setup_addrlist(&symbol_conf.addr_list, symbol_conf.sym_list) < 0)
2515		goto out_free_sym_list;
2516
2517	if (setup_list(&symbol_conf.bt_stop_list,
2518		       symbol_conf.bt_stop_list_str, "symbol") < 0)
2519		goto out_free_sym_list;
2520
2521	/*
2522	 * A path to symbols of "/" is identical to ""
2523	 * reset here for simplicity.
2524	 */
2525	symfs = realpath(symbol_conf.symfs, NULL);
2526	if (symfs == NULL)
2527		symfs = symbol_conf.symfs;
2528	if (strcmp(symfs, "/") == 0)
2529		symbol_conf.symfs = "";
2530	if (symfs != symbol_conf.symfs)
2531		free((void *)symfs);
2532
2533	symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2534
2535	symbol_conf.initialized = true;
2536	return 0;
2537
2538out_free_sym_list:
2539	strlist__delete(symbol_conf.sym_list);
2540	intlist__delete(symbol_conf.addr_list);
2541out_free_tid_list:
2542	intlist__delete(symbol_conf.tid_list);
2543out_free_pid_list:
2544	intlist__delete(symbol_conf.pid_list);
2545out_free_comm_list:
2546	strlist__delete(symbol_conf.comm_list);
2547out_free_dso_list:
2548	strlist__delete(symbol_conf.dso_list);
2549	return -1;
2550}
2551
2552void symbol__exit(void)
2553{
2554	if (!symbol_conf.initialized)
2555		return;
2556	strlist__delete(symbol_conf.bt_stop_list);
2557	strlist__delete(symbol_conf.sym_list);
2558	strlist__delete(symbol_conf.dso_list);
2559	strlist__delete(symbol_conf.comm_list);
2560	intlist__delete(symbol_conf.tid_list);
2561	intlist__delete(symbol_conf.pid_list);
2562	intlist__delete(symbol_conf.addr_list);
2563	vmlinux_path__exit();
2564	symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2565	symbol_conf.bt_stop_list = NULL;
2566	symbol_conf.initialized = false;
2567}
2568
2569int symbol__config_symfs(const struct option *opt __maybe_unused,
2570			 const char *dir, int unset __maybe_unused)
2571{
2572	char *bf = NULL;
2573	int ret;
2574
2575	symbol_conf.symfs = strdup(dir);
2576	if (symbol_conf.symfs == NULL)
2577		return -ENOMEM;
2578
2579	/* skip the locally configured cache if a symfs is given, and
2580	 * config buildid dir to symfs/.debug
2581	 */
2582	ret = asprintf(&bf, "%s/%s", dir, ".debug");
2583	if (ret < 0)
2584		return -ENOMEM;
2585
2586	set_buildid_dir(bf);
2587
2588	free(bf);
2589	return 0;
2590}
2591
2592/*
2593 * Checks that user supplied symbol kernel files are accessible because
2594 * the default mechanism for accessing elf files fails silently. i.e. if
2595 * debug syms for a build ID aren't found perf carries on normally. When
2596 * they are user supplied we should assume that the user doesn't want to
2597 * silently fail.
2598 */
2599int symbol__validate_sym_arguments(void)
2600{
2601	if (symbol_conf.vmlinux_name &&
2602	    access(symbol_conf.vmlinux_name, R_OK)) {
2603		pr_err("Invalid file: %s\n", symbol_conf.vmlinux_name);
2604		return -EINVAL;
2605	}
2606	if (symbol_conf.kallsyms_name &&
2607	    access(symbol_conf.kallsyms_name, R_OK)) {
2608		pr_err("Invalid file: %s\n", symbol_conf.kallsyms_name);
2609		return -EINVAL;
2610	}
2611	return 0;
 
 
 
 
 
 
 
2612}