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