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/kernel.h>
   8#include <sys/types.h>
   9#include <sys/stat.h>
  10#include <sys/param.h>
  11#include <fcntl.h>
  12#include <unistd.h>
  13#include <inttypes.h>
  14#include "annotate.h"
  15#include "build-id.h"
  16#include "util.h"
  17#include "debug.h"
  18#include "machine.h"
  19#include "symbol.h"
  20#include "strlist.h"
  21#include "intlist.h"
  22#include "namespaces.h"
  23#include "header.h"
  24#include "path.h"
  25#include "sane_ctype.h"
  26
 
 
  27#include <elf.h>
  28#include <limits.h>
  29#include <symbol/kallsyms.h>
  30#include <sys/utsname.h>
  31
  32static int dso__load_kernel_sym(struct dso *dso, struct map *map);
  33static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map);
  34static bool symbol__is_idle(const char *name);
  35
  36int vmlinux_path__nr_entries;
  37char **vmlinux_path;
 
 
 
 
 
 
 
 
 
 
 
 
  38
  39struct symbol_conf symbol_conf = {
  40	.use_modules		= true,
  41	.try_vmlinux_path	= true,
  42	.annotate_src		= true,
  43	.demangle		= true,
  44	.demangle_kernel	= false,
  45	.cumulate_callchain	= true,
  46	.show_hist_headers	= true,
  47	.symfs			= "",
  48	.event_group		= true,
  49	.inline_name		= true,
  50};
  51
  52static enum dso_binary_type binary_type_symtab[] = {
  53	DSO_BINARY_TYPE__KALLSYMS,
  54	DSO_BINARY_TYPE__GUEST_KALLSYMS,
  55	DSO_BINARY_TYPE__JAVA_JIT,
  56	DSO_BINARY_TYPE__DEBUGLINK,
  57	DSO_BINARY_TYPE__BUILD_ID_CACHE,
  58	DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO,
  59	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
  60	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
  61	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
  62	DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
  63	DSO_BINARY_TYPE__GUEST_KMODULE,
  64	DSO_BINARY_TYPE__GUEST_KMODULE_COMP,
  65	DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
  66	DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP,
  67	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
  68	DSO_BINARY_TYPE__NOT_FOUND,
  69};
  70
  71#define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  72
  73bool symbol_type__is_a(char symbol_type, enum map_type map_type)
  74{
  75	symbol_type = toupper(symbol_type);
  76
  77	switch (map_type) {
  78	case MAP__FUNCTION:
  79		return symbol_type == 'T' || symbol_type == 'W';
  80	case MAP__VARIABLE:
  81		return symbol_type == 'D';
  82	default:
  83		return false;
  84	}
  85}
  86
  87static int prefix_underscores_count(const char *str)
  88{
  89	const char *tail = str;
  90
  91	while (*tail == '_')
  92		tail++;
  93
  94	return tail - str;
  95}
  96
  97const char * __weak arch__normalize_symbol_name(const char *name)
  98{
  99	return name;
 100}
 101
 102int __weak arch__compare_symbol_names(const char *namea, const char *nameb)
 103{
 104	return strcmp(namea, nameb);
 105}
 106
 107int __weak arch__compare_symbol_names_n(const char *namea, const char *nameb,
 108					unsigned int n)
 109{
 110	return strncmp(namea, nameb, n);
 111}
 112
 113int __weak arch__choose_best_symbol(struct symbol *syma,
 114				    struct symbol *symb __maybe_unused)
 115{
 116	/* Avoid "SyS" kernel syscall aliases */
 117	if (strlen(syma->name) >= 3 && !strncmp(syma->name, "SyS", 3))
 118		return SYMBOL_B;
 119	if (strlen(syma->name) >= 10 && !strncmp(syma->name, "compat_SyS", 10))
 120		return SYMBOL_B;
 121
 122	return SYMBOL_A;
 123}
 124
 125static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
 126{
 127	s64 a;
 128	s64 b;
 129	size_t na, nb;
 130
 131	/* Prefer a symbol with non zero length */
 132	a = syma->end - syma->start;
 133	b = symb->end - symb->start;
 134	if ((b == 0) && (a > 0))
 135		return SYMBOL_A;
 136	else if ((a == 0) && (b > 0))
 137		return SYMBOL_B;
 138
 139	/* Prefer a non weak symbol over a weak one */
 140	a = syma->binding == STB_WEAK;
 141	b = symb->binding == STB_WEAK;
 142	if (b && !a)
 143		return SYMBOL_A;
 144	if (a && !b)
 145		return SYMBOL_B;
 146
 147	/* Prefer a global symbol over a non global one */
 148	a = syma->binding == STB_GLOBAL;
 149	b = symb->binding == STB_GLOBAL;
 150	if (a && !b)
 151		return SYMBOL_A;
 152	if (b && !a)
 153		return SYMBOL_B;
 154
 155	/* Prefer a symbol with less underscores */
 156	a = prefix_underscores_count(syma->name);
 157	b = prefix_underscores_count(symb->name);
 158	if (b > a)
 159		return SYMBOL_A;
 160	else if (a > b)
 161		return SYMBOL_B;
 162
 163	/* Choose the symbol with the longest name */
 164	na = strlen(syma->name);
 165	nb = strlen(symb->name);
 166	if (na > nb)
 167		return SYMBOL_A;
 168	else if (na < nb)
 169		return SYMBOL_B;
 170
 171	return arch__choose_best_symbol(syma, symb);
 172}
 173
 174void symbols__fixup_duplicate(struct rb_root *symbols)
 175{
 176	struct rb_node *nd;
 177	struct symbol *curr, *next;
 178
 179	if (symbol_conf.allow_aliases)
 180		return;
 181
 182	nd = rb_first(symbols);
 183
 184	while (nd) {
 185		curr = rb_entry(nd, struct symbol, rb_node);
 186again:
 187		nd = rb_next(&curr->rb_node);
 188		next = rb_entry(nd, struct symbol, rb_node);
 189
 190		if (!nd)
 191			break;
 192
 193		if (curr->start != next->start)
 194			continue;
 195
 196		if (choose_best_symbol(curr, next) == SYMBOL_A) {
 197			rb_erase(&next->rb_node, symbols);
 198			symbol__delete(next);
 199			goto again;
 200		} else {
 201			nd = rb_next(&curr->rb_node);
 202			rb_erase(&curr->rb_node, symbols);
 203			symbol__delete(curr);
 204		}
 205	}
 206}
 207
 208void symbols__fixup_end(struct rb_root *symbols)
 209{
 210	struct rb_node *nd, *prevnd = rb_first(symbols);
 211	struct symbol *curr, *prev;
 212
 213	if (prevnd == NULL)
 214		return;
 215
 216	curr = rb_entry(prevnd, struct symbol, rb_node);
 217
 218	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 219		prev = curr;
 220		curr = rb_entry(nd, struct symbol, rb_node);
 221
 222		if (prev->end == prev->start && prev->end != curr->start)
 223			prev->end = curr->start;
 224	}
 225
 226	/* Last entry */
 227	if (curr->end == curr->start)
 228		curr->end = roundup(curr->start, 4096) + 4096;
 229}
 230
 231void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 232{
 233	struct maps *maps = &mg->maps[type];
 234	struct map *next, *curr;
 235
 236	down_write(&maps->lock);
 
 237
 238	curr = maps__first(maps);
 239	if (curr == NULL)
 240		goto out_unlock;
 241
 242	for (next = map__next(curr); next; next = map__next(curr)) {
 243		if (!curr->end)
 244			curr->end = next->start;
 245		curr = next;
 246	}
 247
 248	/*
 249	 * We still haven't the actual symbols, so guess the
 250	 * last map final address.
 251	 */
 252	if (!curr->end)
 253		curr->end = ~0ULL;
 254
 255out_unlock:
 256	up_write(&maps->lock);
 
 
 
 257}
 258
 259struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name)
 
 260{
 261	size_t namelen = strlen(name) + 1;
 262	struct symbol *sym = calloc(1, (symbol_conf.priv_size +
 263					sizeof(*sym) + namelen));
 264	if (sym == NULL)
 265		return NULL;
 266
 267	if (symbol_conf.priv_size) {
 268		if (symbol_conf.init_annotation) {
 269			struct annotation *notes = (void *)sym;
 270			pthread_mutex_init(&notes->lock, NULL);
 271		}
 272		sym = ((void *)sym) + symbol_conf.priv_size;
 273	}
 274
 275	sym->start   = start;
 276	sym->end     = len ? start + len : start;
 277	sym->binding = binding;
 278	sym->namelen = namelen - 1;
 279
 280	pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
 281		  __func__, name, start, sym->end);
 282	memcpy(sym->name, name, namelen);
 283
 284	return sym;
 285}
 286
 287void symbol__delete(struct symbol *sym)
 288{
 289	free(((void *)sym) - symbol_conf.priv_size);
 290}
 291
 292void symbols__delete(struct rb_root *symbols)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 293{
 294	struct symbol *pos;
 295	struct rb_node *next = rb_first(symbols);
 296
 297	while (next) {
 298		pos = rb_entry(next, struct symbol, rb_node);
 299		next = rb_next(&pos->rb_node);
 300		rb_erase(&pos->rb_node, symbols);
 301		symbol__delete(pos);
 302	}
 303}
 304
 305void __symbols__insert(struct rb_root *symbols, struct symbol *sym, bool kernel)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 306{
 307	struct rb_node **p = &symbols->rb_node;
 308	struct rb_node *parent = NULL;
 309	const u64 ip = sym->start;
 310	struct symbol *s;
 311
 312	if (kernel) {
 313		const char *name = sym->name;
 314		/*
 315		 * ppc64 uses function descriptors and appends a '.' to the
 316		 * start of every instruction address. Remove it.
 317		 */
 318		if (name[0] == '.')
 319			name++;
 320		sym->idle = symbol__is_idle(name);
 321	}
 322
 323	while (*p != NULL) {
 324		parent = *p;
 325		s = rb_entry(parent, struct symbol, rb_node);
 326		if (ip < s->start)
 327			p = &(*p)->rb_left;
 328		else
 329			p = &(*p)->rb_right;
 330	}
 331	rb_link_node(&sym->rb_node, parent, p);
 332	rb_insert_color(&sym->rb_node, symbols);
 333}
 334
 335void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 336{
 337	__symbols__insert(symbols, sym, false);
 338}
 339
 340static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 341{
 342	struct rb_node *n;
 343
 344	if (symbols == NULL)
 345		return NULL;
 346
 347	n = symbols->rb_node;
 348
 349	while (n) {
 350		struct symbol *s = rb_entry(n, struct symbol, rb_node);
 351
 352		if (ip < s->start)
 353			n = n->rb_left;
 354		else if (ip > s->end || (ip == s->end && ip != s->start))
 355			n = n->rb_right;
 356		else
 357			return s;
 358	}
 359
 360	return NULL;
 361}
 362
 363static struct symbol *symbols__first(struct rb_root *symbols)
 364{
 365	struct rb_node *n = rb_first(symbols);
 366
 367	if (n)
 368		return rb_entry(n, struct symbol, rb_node);
 369
 370	return NULL;
 371}
 372
 373static struct symbol *symbols__last(struct rb_root *symbols)
 374{
 375	struct rb_node *n = rb_last(symbols);
 376
 377	if (n)
 378		return rb_entry(n, struct symbol, rb_node);
 379
 380	return NULL;
 381}
 382
 383static struct symbol *symbols__next(struct symbol *sym)
 384{
 385	struct rb_node *n = rb_next(&sym->rb_node);
 386
 387	if (n)
 388		return rb_entry(n, struct symbol, rb_node);
 389
 390	return NULL;
 391}
 392
 393static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
 394{
 395	struct rb_node **p = &symbols->rb_node;
 396	struct rb_node *parent = NULL;
 397	struct symbol_name_rb_node *symn, *s;
 398
 399	symn = container_of(sym, struct symbol_name_rb_node, sym);
 400
 401	while (*p != NULL) {
 402		parent = *p;
 403		s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 404		if (strcmp(sym->name, s->sym.name) < 0)
 405			p = &(*p)->rb_left;
 406		else
 407			p = &(*p)->rb_right;
 408	}
 409	rb_link_node(&symn->rb_node, parent, p);
 410	rb_insert_color(&symn->rb_node, symbols);
 411}
 412
 413static void symbols__sort_by_name(struct rb_root *symbols,
 414				  struct rb_root *source)
 415{
 416	struct rb_node *nd;
 417
 418	for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 419		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 420		symbols__insert_by_name(symbols, pos);
 421	}
 422}
 423
 424int symbol__match_symbol_name(const char *name, const char *str,
 425			      enum symbol_tag_include includes)
 426{
 427	const char *versioning;
 428
 429	if (includes == SYMBOL_TAG_INCLUDE__DEFAULT_ONLY &&
 430	    (versioning = strstr(name, "@@"))) {
 431		int len = strlen(str);
 432
 433		if (len < versioning - name)
 434			len = versioning - name;
 435
 436		return arch__compare_symbol_names_n(name, str, len);
 437	} else
 438		return arch__compare_symbol_names(name, str);
 439}
 440
 441static struct symbol *symbols__find_by_name(struct rb_root *symbols,
 442					    const char *name,
 443					    enum symbol_tag_include includes)
 444{
 445	struct rb_node *n;
 446	struct symbol_name_rb_node *s = NULL;
 447
 448	if (symbols == NULL)
 449		return NULL;
 450
 451	n = symbols->rb_node;
 452
 453	while (n) {
 
 454		int cmp;
 455
 456		s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 457		cmp = symbol__match_symbol_name(s->sym.name, name, includes);
 458
 459		if (cmp > 0)
 460			n = n->rb_left;
 461		else if (cmp < 0)
 462			n = n->rb_right;
 463		else
 464			break;
 465	}
 466
 467	if (n == NULL)
 468		return NULL;
 469
 470	if (includes != SYMBOL_TAG_INCLUDE__DEFAULT_ONLY)
 471		/* return first symbol that has same name (if any) */
 472		for (n = rb_prev(n); n; n = rb_prev(n)) {
 473			struct symbol_name_rb_node *tmp;
 474
 475			tmp = rb_entry(n, struct symbol_name_rb_node, rb_node);
 476			if (arch__compare_symbol_names(tmp->sym.name, s->sym.name))
 477				break;
 478
 479			s = tmp;
 480		}
 481
 482	return &s->sym;
 483}
 484
 485void dso__reset_find_symbol_cache(struct dso *dso)
 
 486{
 487	enum map_type type;
 488
 489	for (type = MAP__FUNCTION; type <= MAP__VARIABLE; ++type) {
 490		dso->last_find_result[type].addr   = 0;
 491		dso->last_find_result[type].symbol = NULL;
 492	}
 493}
 494
 495void dso__insert_symbol(struct dso *dso, enum map_type type, struct symbol *sym)
 
 496{
 497	__symbols__insert(&dso->symbols[type], sym, dso->kernel);
 
 498
 499	/* update the symbol cache if necessary */
 500	if (dso->last_find_result[type].addr >= sym->start &&
 501	    (dso->last_find_result[type].addr < sym->end ||
 502	    sym->start == sym->end)) {
 503		dso->last_find_result[type].symbol = sym;
 504	}
 505}
 506
 507struct symbol *dso__find_symbol(struct dso *dso,
 508				enum map_type type, u64 addr)
 509{
 510	if (dso->last_find_result[type].addr != addr || dso->last_find_result[type].symbol == NULL) {
 511		dso->last_find_result[type].addr   = addr;
 512		dso->last_find_result[type].symbol = symbols__find(&dso->symbols[type], addr);
 
 
 
 
 
 513	}
 514
 515	return dso->last_find_result[type].symbol;
 516}
 517
 518struct symbol *dso__first_symbol(struct dso *dso, enum map_type type)
 519{
 520	return symbols__first(&dso->symbols[type]);
 521}
 522
 523struct symbol *dso__last_symbol(struct dso *dso, enum map_type type)
 524{
 525	return symbols__last(&dso->symbols[type]);
 526}
 527
 528struct symbol *dso__next_symbol(struct symbol *sym)
 
 529{
 530	return symbols__next(sym);
 531}
 
 532
 533struct symbol *symbol__next_by_name(struct symbol *sym)
 534{
 535	struct symbol_name_rb_node *s = container_of(sym, struct symbol_name_rb_node, sym);
 536	struct rb_node *n = rb_next(&s->rb_node);
 537
 538	return n ? &rb_entry(n, struct symbol_name_rb_node, rb_node)->sym : NULL;
 539}
 540
 541 /*
 542  * Teturns first symbol that matched with @name.
 543  */
 544struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 545					const char *name)
 546{
 547	struct symbol *s = symbols__find_by_name(&dso->symbol_names[type], name,
 548						 SYMBOL_TAG_INCLUDE__NONE);
 549	if (!s)
 550		s = symbols__find_by_name(&dso->symbol_names[type], name,
 551					  SYMBOL_TAG_INCLUDE__DEFAULT_ONLY);
 552	return s;
 553}
 554
 555void dso__sort_by_name(struct dso *dso, enum map_type type)
 556{
 557	dso__set_sorted_by_name(dso, type);
 558	return symbols__sort_by_name(&dso->symbol_names[type],
 559				     &dso->symbols[type]);
 
 
 
 
 
 
 
 560}
 561
 562int modules__parse(const char *filename, void *arg,
 563		   int (*process_module)(void *arg, const char *name,
 564					 u64 start, u64 size))
 565{
 566	char *line = NULL;
 567	size_t n;
 568	FILE *file;
 569	int err = 0;
 570
 571	file = fopen(filename, "r");
 572	if (file == NULL)
 573		return -1;
 574
 575	while (1) {
 576		char name[PATH_MAX];
 577		u64 start, size;
 578		char *sep, *endptr;
 579		ssize_t line_len;
 580
 581		line_len = getline(&line, &n, file);
 582		if (line_len < 0) {
 583			if (feof(file))
 584				break;
 585			err = -1;
 586			goto out;
 587		}
 588
 589		if (!line) {
 590			err = -1;
 591			goto out;
 592		}
 593
 594		line[--line_len] = '\0'; /* \n */
 595
 596		sep = strrchr(line, 'x');
 597		if (sep == NULL)
 598			continue;
 599
 600		hex2u64(sep + 1, &start);
 601
 602		sep = strchr(line, ' ');
 603		if (sep == NULL)
 604			continue;
 605
 606		*sep = '\0';
 607
 608		scnprintf(name, sizeof(name), "[%s]", line);
 
 609
 610		size = strtoul(sep + 1, &endptr, 0);
 611		if (*endptr != ' ' && *endptr != '\t')
 612			continue;
 
 613
 614		err = process_module(arg, name, start, size);
 
 
 
 
 
 
 615		if (err)
 616			break;
 617	}
 618out:
 619	free(line);
 620	fclose(file);
 621	return err;
 
 
 
 622}
 623
 624struct process_kallsyms_args {
 625	struct map *map;
 626	struct dso *dso;
 627};
 628
 629/*
 630 * These are symbols in the kernel image, so make sure that
 631 * sym is from a kernel DSO.
 632 */
 633static bool symbol__is_idle(const char *name)
 634{
 635	const char * const idle_symbols[] = {
 636		"cpu_idle",
 637		"cpu_startup_entry",
 638		"intel_idle",
 639		"default_idle",
 640		"native_safe_halt",
 641		"enter_idle",
 642		"exit_idle",
 643		"mwait_idle",
 644		"mwait_idle_with_hints",
 645		"poll_idle",
 646		"ppc64_runlatch_off",
 647		"pseries_dedicated_idle_sleep",
 648		NULL
 649	};
 650	int i;
 651
 652	for (i = 0; idle_symbols[i]; i++) {
 653		if (!strcmp(idle_symbols[i], name))
 654			return true;
 655	}
 656
 657	return false;
 658}
 659
 660static int map__process_kallsym_symbol(void *arg, const char *name,
 661				       char type, u64 start)
 662{
 663	struct symbol *sym;
 664	struct process_kallsyms_args *a = arg;
 665	struct rb_root *root = &a->dso->symbols[a->map->type];
 666
 667	if (!symbol_type__is_a(type, a->map->type))
 668		return 0;
 669
 670	/*
 671	 * module symbols are not sorted so we add all
 672	 * symbols, setting length to 0, and rely on
 673	 * symbols__fixup_end() to fix it up.
 674	 */
 675	sym = symbol__new(start, 0, kallsyms2elf_binding(type), name);
 676	if (sym == NULL)
 677		return -ENOMEM;
 678	/*
 679	 * We will pass the symbols to the filter later, in
 680	 * map__split_kallsyms, when we have split the maps per module
 681	 */
 682	__symbols__insert(root, sym, !strchr(name, '['));
 683
 684	return 0;
 685}
 686
 687/*
 688 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
 689 * so that we can in the next step set the symbol ->end address and then
 690 * call kernel_maps__split_kallsyms.
 691 */
 692static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 693				  struct map *map)
 694{
 695	struct process_kallsyms_args args = { .map = map, .dso = dso, };
 696	return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 697}
 698
 699static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map)
 700{
 701	struct map_groups *kmaps = map__kmaps(map);
 702	struct map *curr_map;
 703	struct symbol *pos;
 704	int count = 0;
 705	struct rb_root old_root = dso->symbols[map->type];
 706	struct rb_root *root = &dso->symbols[map->type];
 707	struct rb_node *next = rb_first(root);
 708
 709	if (!kmaps)
 710		return -1;
 711
 712	*root = RB_ROOT;
 713
 714	while (next) {
 715		char *module;
 716
 717		pos = rb_entry(next, struct symbol, rb_node);
 718		next = rb_next(&pos->rb_node);
 719
 720		rb_erase_init(&pos->rb_node, &old_root);
 721
 722		module = strchr(pos->name, '\t');
 723		if (module)
 724			*module = '\0';
 725
 726		curr_map = map_groups__find(kmaps, map->type, pos->start);
 727
 728		if (!curr_map) {
 729			symbol__delete(pos);
 730			continue;
 731		}
 732
 733		pos->start -= curr_map->start - curr_map->pgoff;
 734		if (pos->end)
 735			pos->end -= curr_map->start - curr_map->pgoff;
 736		symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 737		++count;
 738	}
 739
 740	/* Symbols have been adjusted */
 741	dso->adjust_symbols = 1;
 742
 743	return count;
 744}
 745
 746/*
 747 * Split the symbols into maps, making sure there are no overlaps, i.e. the
 748 * kernel range is broken in several maps, named [kernel].N, as we don't have
 749 * the original ELF section names vmlinux have.
 750 */
 751static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta)
 
 752{
 753	struct map_groups *kmaps = map__kmaps(map);
 754	struct machine *machine;
 755	struct map *curr_map = map;
 756	struct symbol *pos;
 757	int count = 0, moved = 0;
 758	struct rb_root *root = &dso->symbols[map->type];
 759	struct rb_node *next = rb_first(root);
 760	int kernel_range = 0;
 761
 762	if (!kmaps)
 763		return -1;
 764
 765	machine = kmaps->machine;
 766
 767	while (next) {
 768		char *module;
 769
 770		pos = rb_entry(next, struct symbol, rb_node);
 771		next = rb_next(&pos->rb_node);
 772
 773		module = strchr(pos->name, '\t');
 774		if (module) {
 775			if (!symbol_conf.use_modules)
 776				goto discard_symbol;
 777
 778			*module++ = '\0';
 779
 780			if (strcmp(curr_map->dso->short_name, module)) {
 781				if (curr_map != map &&
 782				    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 783				    machine__is_default_guest(machine)) {
 784					/*
 785					 * We assume all symbols of a module are
 786					 * continuous in * kallsyms, so curr_map
 787					 * points to a module and all its
 788					 * symbols are in its kmap. Mark it as
 789					 * loaded.
 790					 */
 791					dso__set_loaded(curr_map->dso,
 792							curr_map->type);
 793				}
 794
 795				curr_map = map_groups__find_by_name(kmaps,
 796							map->type, module);
 797				if (curr_map == NULL) {
 798					pr_debug("%s/proc/{kallsyms,modules} "
 799					         "inconsistency while looking "
 800						 "for \"%s\" module!\n",
 801						 machine->root_dir, module);
 802					curr_map = map;
 803					goto discard_symbol;
 804				}
 805
 806				if (curr_map->dso->loaded &&
 807				    !machine__is_default_guest(machine))
 808					goto discard_symbol;
 809			}
 810			/*
 811			 * So that we look just like we get from .ko files,
 812			 * i.e. not prelinked, relative to map->start.
 813			 */
 814			pos->start = curr_map->map_ip(curr_map, pos->start);
 815			pos->end   = curr_map->map_ip(curr_map, pos->end);
 816		} else if (curr_map != map) {
 817			char dso_name[PATH_MAX];
 818			struct dso *ndso;
 819
 820			if (delta) {
 821				/* Kernel was relocated at boot time */
 822				pos->start -= delta;
 823				pos->end -= delta;
 824			}
 825
 826			if (count == 0) {
 827				curr_map = map;
 828				goto add_symbol;
 829			}
 830
 831			if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 832				snprintf(dso_name, sizeof(dso_name),
 833					"[guest.kernel].%d",
 834					kernel_range++);
 835			else
 836				snprintf(dso_name, sizeof(dso_name),
 837					"[kernel].%d",
 838					kernel_range++);
 839
 840			ndso = dso__new(dso_name);
 841			if (ndso == NULL)
 842				return -1;
 843
 844			ndso->kernel = dso->kernel;
 845
 846			curr_map = map__new2(pos->start, ndso, map->type);
 847			if (curr_map == NULL) {
 848				dso__put(ndso);
 849				return -1;
 850			}
 851
 852			curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 853			map_groups__insert(kmaps, curr_map);
 854			++kernel_range;
 855		} else if (delta) {
 856			/* Kernel was relocated at boot time */
 857			pos->start -= delta;
 858			pos->end -= delta;
 859		}
 860add_symbol:
 861		if (curr_map != map) {
 862			rb_erase(&pos->rb_node, root);
 863			symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 864			++moved;
 865		} else
 866			++count;
 867
 868		continue;
 869discard_symbol:
 870		rb_erase(&pos->rb_node, root);
 871		symbol__delete(pos);
 872	}
 873
 874	if (curr_map != map &&
 875	    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 876	    machine__is_default_guest(kmaps->machine)) {
 877		dso__set_loaded(curr_map->dso, curr_map->type);
 878	}
 879
 880	return count + moved;
 881}
 882
 883bool symbol__restricted_filename(const char *filename,
 884				 const char *restricted_filename)
 885{
 886	bool restricted = false;
 887
 888	if (symbol_conf.kptr_restrict) {
 889		char *r = realpath(filename, NULL);
 890
 891		if (r != NULL) {
 892			restricted = strcmp(r, restricted_filename) == 0;
 893			free(r);
 894			return restricted;
 895		}
 896	}
 897
 898	return restricted;
 899}
 900
 901struct module_info {
 902	struct rb_node rb_node;
 903	char *name;
 904	u64 start;
 905};
 906
 907static void add_module(struct module_info *mi, struct rb_root *modules)
 908{
 909	struct rb_node **p = &modules->rb_node;
 910	struct rb_node *parent = NULL;
 911	struct module_info *m;
 912
 913	while (*p != NULL) {
 914		parent = *p;
 915		m = rb_entry(parent, struct module_info, rb_node);
 916		if (strcmp(mi->name, m->name) < 0)
 917			p = &(*p)->rb_left;
 918		else
 919			p = &(*p)->rb_right;
 920	}
 921	rb_link_node(&mi->rb_node, parent, p);
 922	rb_insert_color(&mi->rb_node, modules);
 923}
 924
 925static void delete_modules(struct rb_root *modules)
 926{
 927	struct module_info *mi;
 928	struct rb_node *next = rb_first(modules);
 929
 930	while (next) {
 931		mi = rb_entry(next, struct module_info, rb_node);
 932		next = rb_next(&mi->rb_node);
 933		rb_erase(&mi->rb_node, modules);
 934		zfree(&mi->name);
 935		free(mi);
 936	}
 937}
 938
 939static struct module_info *find_module(const char *name,
 940				       struct rb_root *modules)
 941{
 942	struct rb_node *n = modules->rb_node;
 
 
 
 943
 944	while (n) {
 945		struct module_info *m;
 946		int cmp;
 947
 948		m = rb_entry(n, struct module_info, rb_node);
 949		cmp = strcmp(name, m->name);
 950		if (cmp < 0)
 951			n = n->rb_left;
 952		else if (cmp > 0)
 953			n = n->rb_right;
 954		else
 955			return m;
 956	}
 957
 958	return NULL;
 959}
 
 960
 961static int __read_proc_modules(void *arg, const char *name, u64 start,
 962			       u64 size __maybe_unused)
 963{
 964	struct rb_root *modules = arg;
 965	struct module_info *mi;
 966
 967	mi = zalloc(sizeof(struct module_info));
 968	if (!mi)
 969		return -ENOMEM;
 970
 971	mi->name = strdup(name);
 972	mi->start = start;
 973
 974	if (!mi->name) {
 975		free(mi);
 976		return -ENOMEM;
 977	}
 978
 979	add_module(mi, modules);
 980
 981	return 0;
 982}
 
 983
 984static int read_proc_modules(const char *filename, struct rb_root *modules)
 985{
 986	if (symbol__restricted_filename(filename, "/proc/modules"))
 987		return -1;
 988
 989	if (modules__parse(filename, modules, __read_proc_modules)) {
 990		delete_modules(modules);
 991		return -1;
 
 
 
 
 
 
 992	}
 993
 994	return 0;
 995}
 996
 997int compare_proc_modules(const char *from, const char *to)
 998{
 999	struct rb_root from_modules = RB_ROOT;
1000	struct rb_root to_modules = RB_ROOT;
1001	struct rb_node *from_node, *to_node;
1002	struct module_info *from_m, *to_m;
1003	int ret = -1;
1004
1005	if (read_proc_modules(from, &from_modules))
1006		return -1;
 
 
 
1007
1008	if (read_proc_modules(to, &to_modules))
1009		goto out_delete_from;
 
 
 
 
 
 
 
 
 
1010
1011	from_node = rb_first(&from_modules);
1012	to_node = rb_first(&to_modules);
1013	while (from_node) {
1014		if (!to_node)
1015			break;
1016
1017		from_m = rb_entry(from_node, struct module_info, rb_node);
1018		to_m = rb_entry(to_node, struct module_info, rb_node);
 
 
 
 
1019
1020		if (from_m->start != to_m->start ||
1021		    strcmp(from_m->name, to_m->name))
1022			break;
 
 
 
1023
1024		from_node = rb_next(from_node);
1025		to_node = rb_next(to_node);
1026	}
 
 
 
 
1027
1028	if (!from_node && !to_node)
1029		ret = 0;
 
 
 
1030
1031	delete_modules(&to_modules);
1032out_delete_from:
1033	delete_modules(&from_modules);
 
 
1034
1035	return ret;
 
 
 
1036}
1037
1038static int do_validate_kcore_modules(const char *filename, struct map *map,
1039				  struct map_groups *kmaps)
1040{
1041	struct rb_root modules = RB_ROOT;
1042	struct map *old_map;
1043	int err;
1044
1045	err = read_proc_modules(filename, &modules);
1046	if (err)
1047		return err;
 
 
 
1048
1049	old_map = map_groups__first(kmaps, map->type);
1050	while (old_map) {
1051		struct map *next = map_groups__next(old_map);
1052		struct module_info *mi;
1053
1054		if (old_map == map || old_map->start == map->start) {
1055			/* The kernel map */
1056			old_map = next;
1057			continue;
1058		}
1059
1060		/* Module must be in memory at the same address */
1061		mi = find_module(old_map->dso->short_name, &modules);
1062		if (!mi || mi->start != old_map->start) {
1063			err = -EINVAL;
1064			goto out;
 
1065		}
1066
1067		old_map = next;
1068	}
1069out:
1070	delete_modules(&modules);
1071	return err;
1072}
1073
 
 
 
 
 
 
 
 
 
 
1074/*
1075 * If kallsyms is referenced by name then we look for filename in the same
1076 * directory.
 
 
 
1077 */
1078static bool filename_from_kallsyms_filename(char *filename,
1079					    const char *base_name,
1080					    const char *kallsyms_filename)
1081{
1082	char *name;
1083
1084	strcpy(filename, kallsyms_filename);
1085	name = strrchr(filename, '/');
1086	if (!name)
1087		return false;
 
 
 
 
 
 
 
1088
1089	name += 1;
 
 
1090
1091	if (!strcmp(name, "kallsyms")) {
1092		strcpy(name, base_name);
1093		return true;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1094	}
1095
1096	return false;
1097}
1098
1099static int validate_kcore_modules(const char *kallsyms_filename,
1100				  struct map *map)
1101{
1102	struct map_groups *kmaps = map__kmaps(map);
1103	char modules_filename[PATH_MAX];
1104
1105	if (!kmaps)
1106		return -EINVAL;
1107
1108	if (!filename_from_kallsyms_filename(modules_filename, "modules",
1109					     kallsyms_filename))
1110		return -EINVAL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1111
1112	if (do_validate_kcore_modules(modules_filename, map, kmaps))
1113		return -EINVAL;
 
 
 
1114
 
 
 
 
 
1115	return 0;
1116}
1117
1118static int validate_kcore_addresses(const char *kallsyms_filename,
1119				    struct map *map)
1120{
1121	struct kmap *kmap = map__kmap(map);
 
 
 
 
 
 
 
 
1122
1123	if (!kmap)
1124		return -EINVAL;
 
 
 
 
 
 
 
 
 
 
1125
1126	if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) {
1127		u64 start;
 
 
 
1128
1129		if (kallsyms__get_function_start(kallsyms_filename,
1130						 kmap->ref_reloc_sym->name, &start))
1131			return -ENOENT;
1132		if (start != kmap->ref_reloc_sym->addr)
1133			return -EINVAL;
 
 
 
1134	}
1135
1136	return validate_kcore_modules(kallsyms_filename, map);
1137}
1138
1139struct kcore_mapfn_data {
1140	struct dso *dso;
1141	enum map_type type;
1142	struct list_head maps;
1143};
1144
1145static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data)
1146{
1147	struct kcore_mapfn_data *md = data;
1148	struct map *map;
1149
1150	map = map__new2(start, md->dso, md->type);
1151	if (map == NULL)
1152		return -ENOMEM;
1153
1154	map->end = map->start + len;
1155	map->pgoff = pgoff;
 
 
 
 
 
 
 
 
 
 
1156
1157	list_add(&map->node, &md->maps);
 
 
 
1158
1159	return 0;
1160}
1161
1162static int dso__load_kcore(struct dso *dso, struct map *map,
1163			   const char *kallsyms_filename)
 
1164{
1165	struct map_groups *kmaps = map__kmaps(map);
1166	struct machine *machine;
1167	struct kcore_mapfn_data md;
1168	struct map *old_map, *new_map, *replacement_map = NULL;
1169	bool is_64_bit;
1170	int err, fd;
1171	char kcore_filename[PATH_MAX];
1172	struct symbol *sym;
 
 
 
 
 
 
 
1173
1174	if (!kmaps)
1175		return -EINVAL;
 
 
 
1176
1177	machine = kmaps->machine;
 
 
 
1178
1179	/* This function requires that the map is the kernel map */
1180	if (map != machine->vmlinux_maps[map->type])
1181		return -EINVAL;
1182
1183	if (!filename_from_kallsyms_filename(kcore_filename, "kcore",
1184					     kallsyms_filename))
1185		return -EINVAL;
1186
1187	/* Modules and kernel must be present at their original addresses */
1188	if (validate_kcore_addresses(kallsyms_filename, map))
1189		return -EINVAL;
1190
1191	md.dso = dso;
1192	md.type = map->type;
1193	INIT_LIST_HEAD(&md.maps);
1194
1195	fd = open(kcore_filename, O_RDONLY);
1196	if (fd < 0) {
1197		pr_debug("Failed to open %s. Note /proc/kcore requires CAP_SYS_RAWIO capability to access.\n",
1198			 kcore_filename);
1199		return -EINVAL;
1200	}
1201
1202	/* Read new maps into temporary lists */
1203	err = file__read_maps(fd, md.type == MAP__FUNCTION, kcore_mapfn, &md,
1204			      &is_64_bit);
1205	if (err)
1206		goto out_err;
1207	dso->is_64_bit = is_64_bit;
1208
1209	if (list_empty(&md.maps)) {
1210		err = -EINVAL;
1211		goto out_err;
1212	}
1213
1214	/* Remove old maps */
1215	old_map = map_groups__first(kmaps, map->type);
1216	while (old_map) {
1217		struct map *next = map_groups__next(old_map);
1218
1219		if (old_map != map)
1220			map_groups__remove(kmaps, old_map);
1221		old_map = next;
1222	}
1223
1224	/* Find the kernel map using the first symbol */
1225	sym = dso__first_symbol(dso, map->type);
1226	list_for_each_entry(new_map, &md.maps, node) {
1227		if (sym && sym->start >= new_map->start &&
1228		    sym->start < new_map->end) {
1229			replacement_map = new_map;
1230			break;
1231		}
1232	}
1233
1234	if (!replacement_map)
1235		replacement_map = list_entry(md.maps.next, struct map, node);
 
 
 
1236
1237	/* Add new maps */
1238	while (!list_empty(&md.maps)) {
1239		new_map = list_entry(md.maps.next, struct map, node);
1240		list_del_init(&new_map->node);
1241		if (new_map == replacement_map) {
1242			map->start	= new_map->start;
1243			map->end	= new_map->end;
1244			map->pgoff	= new_map->pgoff;
1245			map->map_ip	= new_map->map_ip;
1246			map->unmap_ip	= new_map->unmap_ip;
1247			/* Ensure maps are correctly ordered */
1248			map__get(map);
1249			map_groups__remove(kmaps, map);
1250			map_groups__insert(kmaps, map);
1251			map__put(map);
1252		} else {
1253			map_groups__insert(kmaps, new_map);
1254		}
1255
1256		map__put(new_map);
1257	}
 
1258
1259	/*
1260	 * Set the data type and long name so that kcore can be read via
1261	 * dso__data_read_addr().
1262	 */
1263	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1264		dso->binary_type = DSO_BINARY_TYPE__GUEST_KCORE;
1265	else
1266		dso->binary_type = DSO_BINARY_TYPE__KCORE;
1267	dso__set_long_name(dso, strdup(kcore_filename), true);
1268
1269	close(fd);
 
 
1270
1271	if (map->type == MAP__FUNCTION)
1272		pr_debug("Using %s for kernel object code\n", kcore_filename);
1273	else
1274		pr_debug("Using %s for kernel data\n", kcore_filename);
1275
1276	return 0;
1277
1278out_err:
1279	while (!list_empty(&md.maps)) {
1280		map = list_entry(md.maps.next, struct map, node);
1281		list_del_init(&map->node);
1282		map__put(map);
 
 
 
1283	}
1284	close(fd);
1285	return -EINVAL;
1286}
 
 
 
 
 
 
 
1287
1288/*
1289 * If the kernel is relocated at boot time, kallsyms won't match.  Compute the
1290 * delta based on the relocation reference symbol.
1291 */
1292static int kallsyms__delta(struct map *map, const char *filename, u64 *delta)
1293{
1294	struct kmap *kmap = map__kmap(map);
1295	u64 addr;
1296
1297	if (!kmap)
1298		return -1;
 
 
 
 
 
 
 
1299
1300	if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name)
1301		return 0;
 
 
 
 
1302
1303	if (kallsyms__get_function_start(filename, kmap->ref_reloc_sym->name, &addr))
1304		return -1;
 
1305
1306	*delta = addr - kmap->ref_reloc_sym->addr;
1307	return 0;
1308}
1309
1310int __dso__load_kallsyms(struct dso *dso, const char *filename,
1311			 struct map *map, bool no_kcore)
1312{
1313	u64 delta = 0;
1314
1315	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
1316		return -1;
1317
1318	if (dso__load_all_kallsyms(dso, filename, map) < 0)
1319		return -1;
 
 
 
 
1320
1321	if (kallsyms__delta(map, filename, &delta))
1322		return -1;
1323
1324	symbols__fixup_end(&dso->symbols[map->type]);
1325	symbols__fixup_duplicate(&dso->symbols[map->type]);
 
 
1326
1327	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1328		dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
1329	else
1330		dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
 
1331
1332	if (!no_kcore && !dso__load_kcore(dso, map, filename))
1333		return dso__split_kallsyms_for_kcore(dso, map);
1334	else
1335		return dso__split_kallsyms(dso, map, delta);
1336}
1337
1338int dso__load_kallsyms(struct dso *dso, const char *filename,
1339		       struct map *map)
1340{
1341	return __dso__load_kallsyms(dso, filename, map, false);
1342}
1343
1344static int dso__load_perf_map(const char *map_path, struct dso *dso,
1345			      struct map *map)
1346{
1347	char *line = NULL;
1348	size_t n;
1349	FILE *file;
1350	int nr_syms = 0;
1351
1352	file = fopen(map_path, "r");
1353	if (file == NULL)
1354		goto out_failure;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1355
1356	while (!feof(file)) {
1357		u64 start, size;
1358		struct symbol *sym;
1359		int line_len, len;
1360
1361		line_len = getline(&line, &n, file);
1362		if (line_len < 0)
1363			break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1364
1365		if (!line)
1366			goto out_failure;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1367
1368		line[--line_len] = '\0'; /* \n */
 
 
 
1369
1370		len = hex2u64(line, &start);
 
 
 
1371
1372		len++;
1373		if (len + 2 >= line_len)
 
 
 
1374			continue;
 
 
 
 
 
 
 
1375
1376		len += hex2u64(line + len, &size);
 
1377
1378		len++;
1379		if (len + 2 >= line_len)
1380			continue;
 
1381
1382		sym = symbol__new(start, size, STB_GLOBAL, line + len);
 
 
 
 
 
 
 
 
1383
1384		if (sym == NULL)
1385			goto out_delete_line;
 
 
 
 
1386
1387		symbols__insert(&dso->symbols[map->type], sym);
1388		nr_syms++;
 
1389	}
1390
1391	free(line);
1392	fclose(file);
 
 
 
 
 
 
1393
1394	return nr_syms;
 
 
1395
1396out_delete_line:
1397	free(line);
1398out_failure:
1399	return -1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1400}
1401
1402static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod,
1403					   enum dso_binary_type type)
1404{
1405	switch (type) {
1406	case DSO_BINARY_TYPE__JAVA_JIT:
1407	case DSO_BINARY_TYPE__DEBUGLINK:
1408	case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
1409	case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
1410	case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
1411	case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
1412	case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO:
1413		return !kmod && dso->kernel == DSO_TYPE_USER;
1414
1415	case DSO_BINARY_TYPE__KALLSYMS:
1416	case DSO_BINARY_TYPE__VMLINUX:
1417	case DSO_BINARY_TYPE__KCORE:
1418		return dso->kernel == DSO_TYPE_KERNEL;
1419
1420	case DSO_BINARY_TYPE__GUEST_KALLSYMS:
1421	case DSO_BINARY_TYPE__GUEST_VMLINUX:
1422	case DSO_BINARY_TYPE__GUEST_KCORE:
1423		return dso->kernel == DSO_TYPE_GUEST_KERNEL;
1424
1425	case DSO_BINARY_TYPE__GUEST_KMODULE:
1426	case DSO_BINARY_TYPE__GUEST_KMODULE_COMP:
1427	case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
1428	case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP:
1429		/*
1430		 * kernel modules know their symtab type - it's set when
1431		 * creating a module dso in machine__findnew_module_map().
1432		 */
1433		return kmod && dso->symtab_type == type;
1434
1435	case DSO_BINARY_TYPE__BUILD_ID_CACHE:
1436	case DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO:
1437		return true;
1438
1439	case DSO_BINARY_TYPE__NOT_FOUND:
1440	default:
1441		return false;
 
 
 
 
 
1442	}
 
 
 
 
 
 
 
 
1443}
1444
1445/* Checks for the existence of the perf-<pid>.map file in two different
1446 * locations.  First, if the process is a separate mount namespace, check in
1447 * that namespace using the pid of the innermost pid namespace.  If's not in a
1448 * namespace, or the file can't be found there, try in the mount namespace of
1449 * the tracing process using our view of its pid.
1450 */
1451static int dso__find_perf_map(char *filebuf, size_t bufsz,
1452			      struct nsinfo **nsip)
1453{
1454	struct nscookie nsc;
1455	struct nsinfo *nsi;
1456	struct nsinfo *nnsi;
1457	int rc = -1;
1458
1459	nsi = *nsip;
 
1460
1461	if (nsi->need_setns) {
1462		snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nsi->nstgid);
1463		nsinfo__mountns_enter(nsi, &nsc);
1464		rc = access(filebuf, R_OK);
1465		nsinfo__mountns_exit(&nsc);
1466		if (rc == 0)
1467			return rc;
1468	}
1469
1470	nnsi = nsinfo__copy(nsi);
1471	if (nnsi) {
1472		nsinfo__put(nsi);
 
1473
1474		nnsi->need_setns = false;
1475		snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nnsi->tgid);
1476		*nsip = nnsi;
1477		rc = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1478	}
 
 
 
 
1479
1480	return rc;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1481}
1482
1483int dso__load(struct dso *dso, struct map *map)
1484{
 
1485	char *name;
1486	int ret = -1;
1487	u_int i;
1488	struct machine *machine;
1489	char *root_dir = (char *) "";
1490	int ss_pos = 0;
1491	struct symsrc ss_[2];
1492	struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
1493	bool kmod;
1494	bool perfmap;
1495	unsigned char build_id[BUILD_ID_SIZE];
1496	struct nscookie nsc;
1497	char newmapname[PATH_MAX];
1498	const char *map_path = dso->long_name;
1499
1500	perfmap = strncmp(dso->name, "/tmp/perf-", 10) == 0;
1501	if (perfmap) {
1502		if (dso->nsinfo && (dso__find_perf_map(newmapname,
1503		    sizeof(newmapname), &dso->nsinfo) == 0)) {
1504			map_path = newmapname;
1505		}
1506	}
1507
1508	nsinfo__mountns_enter(dso->nsinfo, &nsc);
1509	pthread_mutex_lock(&dso->lock);
1510
1511	/* check again under the dso->lock */
1512	if (dso__loaded(dso, map->type)) {
1513		ret = 1;
1514		goto out;
1515	}
1516
1517	if (dso->kernel) {
1518		if (dso->kernel == DSO_TYPE_KERNEL)
1519			ret = dso__load_kernel_sym(dso, map);
1520		else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1521			ret = dso__load_guest_kernel_sym(dso, map);
1522
1523		goto out;
1524	}
 
 
1525
1526	if (map->groups && map->groups->machine)
1527		machine = map->groups->machine;
1528	else
1529		machine = NULL;
1530
 
 
 
 
1531	dso->adjust_symbols = 0;
1532
1533	if (perfmap) {
1534		struct stat st;
1535
1536		if (lstat(map_path, &st) < 0)
1537			goto out;
1538
1539		if (!symbol_conf.force && st.st_uid && (st.st_uid != geteuid())) {
1540			pr_warning("File %s not owned by current user or root, "
1541				   "ignoring it (use -f to override).\n", map_path);
1542			goto out;
1543		}
1544
1545		ret = dso__load_perf_map(map_path, dso, map);
1546		dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
1547					     DSO_BINARY_TYPE__NOT_FOUND;
1548		goto out;
1549	}
1550
1551	if (machine)
1552		root_dir = machine->root_dir;
1553
1554	name = malloc(PATH_MAX);
1555	if (!name)
1556		goto out;
1557
1558	kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
1559		dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
1560		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE ||
1561		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
1562
1563
1564	/*
1565	 * Read the build id if possible. This is required for
1566	 * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work
1567	 */
1568	if (!dso->has_build_id &&
1569	    is_regular_file(dso->long_name)) {
1570	    __symbol__join_symfs(name, PATH_MAX, dso->long_name);
1571	    if (filename__read_build_id(name, build_id, BUILD_ID_SIZE) > 0)
1572		dso__set_build_id(dso, build_id);
1573	}
1574
1575	/*
1576	 * Iterate over candidate debug images.
1577	 * Keep track of "interesting" ones (those which have a symtab, dynsym,
1578	 * and/or opd section) for processing.
1579	 */
1580	for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
1581		struct symsrc *ss = &ss_[ss_pos];
1582		bool next_slot = false;
1583		bool is_reg;
1584		bool nsexit;
1585		int sirc = -1;
 
 
 
 
 
1586
1587		enum dso_binary_type symtab_type = binary_type_symtab[i];
 
1588
1589		nsexit = (symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE ||
1590		    symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1591
1592		if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type))
1593			continue;
 
 
 
 
1594
1595		if (dso__read_binary_type_filename(dso, symtab_type,
1596						   root_dir, name, PATH_MAX))
 
1597			continue;
1598
1599		if (nsexit)
1600			nsinfo__mountns_exit(&nsc);
 
1601
1602		is_reg = is_regular_file(name);
1603		if (is_reg)
1604			sirc = symsrc__init(ss, dso, name, symtab_type);
1605
1606		if (nsexit)
1607			nsinfo__mountns_enter(dso->nsinfo, &nsc);
1608
1609		if (!is_reg || sirc < 0)
1610			continue;
1611
1612		if (!syms_ss && symsrc__has_symtab(ss)) {
1613			syms_ss = ss;
1614			next_slot = true;
1615			if (!dso->symsrc_filename)
1616				dso->symsrc_filename = strdup(name);
1617		}
1618
1619		if (!runtime_ss && symsrc__possibly_runtime(ss)) {
1620			runtime_ss = ss;
1621			next_slot = true;
1622		}
1623
1624		if (next_slot) {
1625			ss_pos++;
1626
1627			if (syms_ss && runtime_ss)
1628				break;
1629		} else {
1630			symsrc__destroy(ss);
1631		}
1632
1633	}
1634
1635	if (!runtime_ss && !syms_ss)
1636		goto out_free;
1637
1638	if (runtime_ss && !syms_ss) {
1639		syms_ss = runtime_ss;
1640	}
1641
1642	/* We'll have to hope for the best */
1643	if (!runtime_ss && syms_ss)
1644		runtime_ss = syms_ss;
1645
1646	if (syms_ss)
1647		ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod);
1648	else
1649		ret = -1;
1650
1651	if (ret > 0) {
1652		int nr_plt;
1653
1654		nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map);
1655		if (nr_plt > 0)
1656			ret += nr_plt;
1657	}
1658
1659	for (; ss_pos > 0; ss_pos--)
1660		symsrc__destroy(&ss_[ss_pos - 1]);
1661out_free:
1662	free(name);
1663	if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1664		ret = 0;
1665out:
1666	dso__set_loaded(dso, map->type);
1667	pthread_mutex_unlock(&dso->lock);
1668	nsinfo__mountns_exit(&nsc);
1669
1670	return ret;
1671}
1672
1673struct map *map_groups__find_by_name(struct map_groups *mg,
1674				     enum map_type type, const char *name)
1675{
1676	struct maps *maps = &mg->maps[type];
1677	struct map *map;
1678
1679	down_read(&maps->lock);
 
1680
1681	for (map = maps__first(maps); map; map = map__next(map)) {
1682		if (map->dso && strcmp(map->dso->short_name, name) == 0)
1683			goto out_unlock;
1684	}
1685
1686	map = NULL;
1687
1688out_unlock:
1689	up_read(&maps->lock);
1690	return map;
1691}
1692
1693int dso__load_vmlinux(struct dso *dso, struct map *map,
1694		      const char *vmlinux, bool vmlinux_allocated)
1695{
1696	int err = -1;
1697	struct symsrc ss;
1698	char symfs_vmlinux[PATH_MAX];
1699	enum dso_binary_type symtab_type;
 
 
1700
1701	if (vmlinux[0] == '/')
1702		snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux);
1703	else
1704		symbol__join_symfs(symfs_vmlinux, vmlinux);
 
 
 
1705
1706	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1707		symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
1708	else
1709		symtab_type = DSO_BINARY_TYPE__VMLINUX;
1710
1711	if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
 
 
 
 
 
 
 
 
1712		return -1;
 
1713
1714	err = dso__load_sym(dso, map, &ss, &ss, 0);
1715	symsrc__destroy(&ss);
 
1716
1717	if (err > 0) {
1718		if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1719			dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
1720		else
1721			dso->binary_type = DSO_BINARY_TYPE__VMLINUX;
1722		dso__set_long_name(dso, vmlinux, vmlinux_allocated);
1723		dso__set_loaded(dso, map->type);
1724		pr_debug("Using %s for symbols\n", symfs_vmlinux);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1725	}
1726
1727	return err;
 
 
1728}
1729
1730int dso__load_vmlinux_path(struct dso *dso, struct map *map)
1731{
1732	int i, err = 0;
1733	char *filename = NULL;
 
 
1734
1735	pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1736		 vmlinux_path__nr_entries + 1);
 
 
1737
1738	for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1739		err = dso__load_vmlinux(dso, map, vmlinux_path[i], false);
1740		if (err > 0)
1741			goto out;
1742	}
1743
1744	if (!symbol_conf.ignore_vmlinux_buildid)
1745		filename = dso__build_id_filename(dso, NULL, 0, false);
1746	if (filename != NULL) {
1747		err = dso__load_vmlinux(dso, map, filename, true);
1748		if (err > 0)
1749			goto out;
1750		free(filename);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1751	}
1752out:
1753	return err;
1754}
1755
1756static bool visible_dir_filter(const char *name, struct dirent *d)
 
1757{
1758	if (d->d_type != DT_DIR)
1759		return false;
1760	return lsdir_no_dot_filter(name, d);
 
 
 
 
 
 
 
 
 
 
 
 
 
1761}
1762
1763static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz)
1764{
1765	char kallsyms_filename[PATH_MAX];
1766	int ret = -1;
1767	struct strlist *dirs;
1768	struct str_node *nd;
 
 
1769
1770	dirs = lsdir(dir, visible_dir_filter);
1771	if (!dirs)
 
 
 
 
 
 
1772		return -1;
1773
1774	strlist__for_each_entry(nd, dirs) {
1775		scnprintf(kallsyms_filename, sizeof(kallsyms_filename),
1776			  "%s/%s/kallsyms", dir, nd->s);
1777		if (!validate_kcore_addresses(kallsyms_filename, map)) {
1778			strlcpy(dir, kallsyms_filename, dir_sz);
1779			ret = 0;
 
 
 
 
 
 
1780			break;
1781		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1782	}
1783
1784	strlist__delete(dirs);
 
1785
1786	return ret;
 
 
 
 
 
1787}
1788
1789/*
1790 * Use open(O_RDONLY) to check readability directly instead of access(R_OK)
1791 * since access(R_OK) only checks with real UID/GID but open() use effective
1792 * UID/GID and actual capabilities (e.g. /proc/kcore requires CAP_SYS_RAWIO).
1793 */
1794static bool filename__readable(const char *file)
1795{
1796	int fd = open(file, O_RDONLY);
 
 
 
 
 
1797	if (fd < 0)
1798		return false;
 
 
 
 
1799	close(fd);
1800	return true;
 
 
 
 
1801}
1802
1803static char *dso__find_kallsyms(struct dso *dso, struct map *map)
 
1804{
1805	u8 host_build_id[BUILD_ID_SIZE];
1806	char sbuild_id[SBUILD_ID_SIZE];
1807	bool is_host = false;
1808	char path[PATH_MAX];
1809
1810	if (!dso->has_build_id) {
1811		/*
1812		 * Last resort, if we don't have a build-id and couldn't find
1813		 * any vmlinux file, try the running kernel kallsyms table.
1814		 */
1815		goto proc_kallsyms;
1816	}
1817
1818	if (sysfs__read_build_id("/sys/kernel/notes", host_build_id,
1819				 sizeof(host_build_id)) == 0)
1820		is_host = dso__build_id_equal(dso, host_build_id);
1821
1822	/* Try a fast path for /proc/kallsyms if possible */
1823	if (is_host) {
1824		/*
1825		 * Do not check the build-id cache, unless we know we cannot use
1826		 * /proc/kcore or module maps don't match to /proc/kallsyms.
1827		 * To check readability of /proc/kcore, do not use access(R_OK)
1828		 * since /proc/kcore requires CAP_SYS_RAWIO to read and access
1829		 * can't check it.
1830		 */
1831		if (filename__readable("/proc/kcore") &&
1832		    !validate_kcore_addresses("/proc/kallsyms", map))
1833			goto proc_kallsyms;
1834	}
1835
1836	build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
1837
1838	/* Find kallsyms in build-id cache with kcore */
1839	scnprintf(path, sizeof(path), "%s/%s/%s",
1840		  buildid_dir, DSO__NAME_KCORE, sbuild_id);
1841
1842	if (!find_matching_kcore(map, path, sizeof(path)))
1843		return strdup(path);
1844
1845	/* Use current /proc/kallsyms if possible */
1846	if (is_host) {
1847proc_kallsyms:
1848		return strdup("/proc/kallsyms");
1849	}
1850
1851	/* Finally, find a cache of kallsyms */
1852	if (!build_id_cache__kallsyms_path(sbuild_id, path, sizeof(path))) {
1853		pr_err("No kallsyms or vmlinux with build-id %s was found\n",
1854		       sbuild_id);
1855		return NULL;
1856	}
1857
1858	return strdup(path);
1859}
1860
1861static int dso__load_kernel_sym(struct dso *dso, struct map *map)
 
1862{
1863	int err;
1864	const char *kallsyms_filename = NULL;
1865	char *kallsyms_allocated_filename = NULL;
1866	/*
1867	 * Step 1: if the user specified a kallsyms or vmlinux filename, use
1868	 * it and only it, reporting errors to the user if it cannot be used.
1869	 *
1870	 * For instance, try to analyse an ARM perf.data file _without_ a
1871	 * build-id, or if the user specifies the wrong path to the right
1872	 * vmlinux file, obviously we can't fallback to another vmlinux (a
1873	 * x86_86 one, on the machine where analysis is being performed, say),
1874	 * or worse, /proc/kallsyms.
1875	 *
1876	 * If the specified file _has_ a build-id and there is a build-id
1877	 * section in the perf.data file, we will still do the expected
1878	 * validation in dso__load_vmlinux and will bail out if they don't
1879	 * match.
1880	 */
1881	if (symbol_conf.kallsyms_name != NULL) {
1882		kallsyms_filename = symbol_conf.kallsyms_name;
1883		goto do_kallsyms;
1884	}
1885
1886	if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) {
1887		return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name, false);
 
 
 
 
 
 
 
1888	}
1889
1890	if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) {
1891		err = dso__load_vmlinux_path(dso, map);
1892		if (err > 0)
1893			return err;
1894	}
1895
1896	/* do not try local files if a symfs was given */
1897	if (symbol_conf.symfs[0] != 0)
1898		return -1;
1899
1900	kallsyms_allocated_filename = dso__find_kallsyms(dso, map);
1901	if (!kallsyms_allocated_filename)
1902		return -1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1903
1904	kallsyms_filename = kallsyms_allocated_filename;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1905
1906do_kallsyms:
1907	err = dso__load_kallsyms(dso, kallsyms_filename, map);
1908	if (err > 0)
1909		pr_debug("Using %s for symbols\n", kallsyms_filename);
1910	free(kallsyms_allocated_filename);
1911
1912	if (err > 0 && !dso__is_kcore(dso)) {
1913		dso->binary_type = DSO_BINARY_TYPE__KALLSYMS;
1914		dso__set_long_name(dso, DSO__NAME_KALLSYMS, false);
 
1915		map__fixup_start(map);
1916		map__fixup_end(map);
1917	}
1918
1919	return err;
1920}
1921
1922static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map)
 
1923{
1924	int err;
1925	const char *kallsyms_filename = NULL;
1926	struct machine *machine;
1927	char path[PATH_MAX];
1928
1929	if (!map->groups) {
1930		pr_debug("Guest kernel map hasn't the point to groups\n");
1931		return -1;
1932	}
1933	machine = map->groups->machine;
1934
1935	if (machine__is_default_guest(machine)) {
1936		/*
1937		 * if the user specified a vmlinux filename, use it and only
1938		 * it, reporting errors to the user if it cannot be used.
1939		 * Or use file guest_kallsyms inputted by user on commandline
1940		 */
1941		if (symbol_conf.default_guest_vmlinux_name != NULL) {
1942			err = dso__load_vmlinux(dso, map,
1943						symbol_conf.default_guest_vmlinux_name,
1944						false);
1945			return err;
1946		}
1947
1948		kallsyms_filename = symbol_conf.default_guest_kallsyms;
1949		if (!kallsyms_filename)
1950			return -1;
1951	} else {
1952		sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1953		kallsyms_filename = path;
1954	}
1955
1956	err = dso__load_kallsyms(dso, kallsyms_filename, map);
1957	if (err > 0)
1958		pr_debug("Using %s for symbols\n", kallsyms_filename);
1959	if (err > 0 && !dso__is_kcore(dso)) {
1960		dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
1961		dso__set_long_name(dso, machine->mmap_name, false);
 
 
 
 
1962		map__fixup_start(map);
1963		map__fixup_end(map);
1964	}
1965
1966	return err;
1967}
1968
1969static void vmlinux_path__exit(void)
1970{
1971	while (--vmlinux_path__nr_entries >= 0)
1972		zfree(&vmlinux_path[vmlinux_path__nr_entries]);
1973	vmlinux_path__nr_entries = 0;
1974
1975	zfree(&vmlinux_path);
 
 
 
 
 
 
 
1976}
1977
1978static const char * const vmlinux_paths[] = {
1979	"vmlinux",
1980	"/boot/vmlinux"
1981};
1982
1983static const char * const vmlinux_paths_upd[] = {
1984	"/boot/vmlinux-%s",
1985	"/usr/lib/debug/boot/vmlinux-%s",
1986	"/lib/modules/%s/build/vmlinux",
1987	"/usr/lib/debug/lib/modules/%s/vmlinux",
1988	"/usr/lib/debug/boot/vmlinux-%s.debug"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1989};
1990
1991static int vmlinux_path__add(const char *new_entry)
 
1992{
1993	vmlinux_path[vmlinux_path__nr_entries] = strdup(new_entry);
1994	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1995		return -1;
1996	++vmlinux_path__nr_entries;
1997
 
 
 
 
 
 
1998	return 0;
1999}
2000
2001static int vmlinux_path__init(struct perf_env *env)
 
 
 
 
 
 
 
 
 
 
 
2002{
2003	struct utsname uts;
2004	char bf[PATH_MAX];
2005	char *kernel_version;
2006	unsigned int i;
2007
2008	vmlinux_path = malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) +
2009			      ARRAY_SIZE(vmlinux_paths_upd)));
2010	if (vmlinux_path == NULL)
2011		return -1;
2012
2013	for (i = 0; i < ARRAY_SIZE(vmlinux_paths); i++)
2014		if (vmlinux_path__add(vmlinux_paths[i]) < 0)
2015			goto out_fail;
 
 
 
 
 
2016
2017	/* only try kernel version if no symfs was given */
2018	if (symbol_conf.symfs[0] != 0)
2019		return 0;
2020
2021	if (env) {
2022		kernel_version = env->os_release;
2023	} else {
2024		if (uname(&uts) < 0)
2025			goto out_fail;
2026
2027		kernel_version = uts.release;
2028	}
2029
2030	for (i = 0; i < ARRAY_SIZE(vmlinux_paths_upd); i++) {
2031		snprintf(bf, sizeof(bf), vmlinux_paths_upd[i], kernel_version);
2032		if (vmlinux_path__add(bf) < 0)
2033			goto out_fail;
2034	}
 
 
 
 
 
 
 
 
 
 
 
2035
2036	return 0;
2037
2038out_fail:
2039	vmlinux_path__exit();
2040	return -1;
2041}
2042
2043int setup_list(struct strlist **list, const char *list_str,
2044		      const char *list_name)
2045{
2046	if (list_str == NULL)
2047		return 0;
 
2048
2049	*list = strlist__new(list_str, NULL);
2050	if (!*list) {
2051		pr_err("problems parsing %s list\n", list_name);
2052		return -1;
2053	}
2054
2055	symbol_conf.has_filter = true;
2056	return 0;
 
 
 
2057}
2058
2059int setup_intlist(struct intlist **list, const char *list_str,
2060		  const char *list_name)
2061{
2062	if (list_str == NULL)
2063		return 0;
2064
2065	*list = intlist__new(list_str);
2066	if (!*list) {
2067		pr_err("problems parsing %s list\n", list_name);
2068		return -1;
2069	}
2070	return 0;
2071}
2072
2073static bool symbol__read_kptr_restrict(void)
2074{
2075	bool value = false;
2076	FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2077
2078	if (fp != NULL) {
2079		char line[8];
 
 
2080
2081		if (fgets(line, sizeof(line), fp) != NULL)
2082			value = ((geteuid() != 0) || (getuid() != 0)) ?
2083					(atoi(line) != 0) :
2084					(atoi(line) == 2);
2085
2086		fclose(fp);
 
2087	}
2088
2089	return value;
2090}
2091
2092int symbol__annotation_init(void)
2093{
2094	if (symbol_conf.init_annotation)
2095		return 0;
2096
2097	if (symbol_conf.initialized) {
2098		pr_err("Annotation needs to be init before symbol__init()\n");
2099		return -1;
2100	}
2101
2102	symbol_conf.priv_size += sizeof(struct annotation);
2103	symbol_conf.init_annotation = true;
2104	return 0;
2105}
2106
2107int symbol__init(struct perf_env *env)
2108{
2109	const char *symfs;
2110
2111	if (symbol_conf.initialized)
2112		return 0;
2113
2114	symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
2115
2116	symbol__elf_init();
2117
 
2118	if (symbol_conf.sort_by_name)
2119		symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2120					  sizeof(struct symbol));
2121
2122	if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0)
2123		return -1;
2124
2125	if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2126		pr_err("'.' is the only non valid --field-separator argument\n");
2127		return -1;
2128	}
2129
2130	if (setup_list(&symbol_conf.dso_list,
2131		       symbol_conf.dso_list_str, "dso") < 0)
2132		return -1;
2133
2134	if (setup_list(&symbol_conf.comm_list,
2135		       symbol_conf.comm_list_str, "comm") < 0)
2136		goto out_free_dso_list;
2137
2138	if (setup_intlist(&symbol_conf.pid_list,
2139		       symbol_conf.pid_list_str, "pid") < 0)
2140		goto out_free_comm_list;
2141
2142	if (setup_intlist(&symbol_conf.tid_list,
2143		       symbol_conf.tid_list_str, "tid") < 0)
2144		goto out_free_pid_list;
2145
2146	if (setup_list(&symbol_conf.sym_list,
2147		       symbol_conf.sym_list_str, "symbol") < 0)
2148		goto out_free_tid_list;
2149
2150	if (setup_list(&symbol_conf.bt_stop_list,
2151		       symbol_conf.bt_stop_list_str, "symbol") < 0)
2152		goto out_free_sym_list;
2153
2154	/*
2155	 * A path to symbols of "/" is identical to ""
2156	 * reset here for simplicity.
2157	 */
2158	symfs = realpath(symbol_conf.symfs, NULL);
2159	if (symfs == NULL)
2160		symfs = symbol_conf.symfs;
2161	if (strcmp(symfs, "/") == 0)
2162		symbol_conf.symfs = "";
2163	if (symfs != symbol_conf.symfs)
2164		free((void *)symfs);
2165
2166	symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2167
2168	symbol_conf.initialized = true;
2169	return 0;
2170
2171out_free_sym_list:
2172	strlist__delete(symbol_conf.sym_list);
2173out_free_tid_list:
2174	intlist__delete(symbol_conf.tid_list);
2175out_free_pid_list:
2176	intlist__delete(symbol_conf.pid_list);
2177out_free_comm_list:
2178	strlist__delete(symbol_conf.comm_list);
2179out_free_dso_list:
2180	strlist__delete(symbol_conf.dso_list);
2181	return -1;
2182}
2183
2184void symbol__exit(void)
2185{
2186	if (!symbol_conf.initialized)
2187		return;
2188	strlist__delete(symbol_conf.bt_stop_list);
2189	strlist__delete(symbol_conf.sym_list);
2190	strlist__delete(symbol_conf.dso_list);
2191	strlist__delete(symbol_conf.comm_list);
2192	intlist__delete(symbol_conf.tid_list);
2193	intlist__delete(symbol_conf.pid_list);
2194	vmlinux_path__exit();
2195	symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2196	symbol_conf.bt_stop_list = NULL;
2197	symbol_conf.initialized = false;
2198}
2199
2200int symbol__config_symfs(const struct option *opt __maybe_unused,
2201			 const char *dir, int unset __maybe_unused)
2202{
2203	char *bf = NULL;
2204	int ret;
2205
2206	symbol_conf.symfs = strdup(dir);
2207	if (symbol_conf.symfs == NULL)
2208		return -ENOMEM;
2209
2210	/* skip the locally configured cache if a symfs is given, and
2211	 * config buildid dir to symfs/.debug
2212	 */
2213	ret = asprintf(&bf, "%s/%s", dir, ".debug");
2214	if (ret < 0)
2215		return -ENOMEM;
2216
2217	set_buildid_dir(bf);
 
 
 
 
 
 
 
 
 
2218
2219	free(bf);
2220	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2221}
2222
2223struct mem_info *mem_info__get(struct mem_info *mi)
2224{
2225	if (mi)
2226		refcount_inc(&mi->refcnt);
2227	return mi;
 
 
 
 
 
 
2228}
2229
2230void mem_info__put(struct mem_info *mi)
 
2231{
2232	if (mi && refcount_dec_and_test(&mi->refcnt))
2233		free(mi);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2234}
2235
2236struct mem_info *mem_info__new(void)
2237{
2238	struct mem_info *mi = zalloc(sizeof(*mi));
 
2239
2240	if (mi)
2241		refcount_set(&mi->refcnt, 1);
2242	return mi;
 
2243}