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