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