Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit be96ea8ffa788dccb1ba895cced29db6687c4911

Authored by Stephane Eranian
Committed by Arnaldo Carvalho de Melo
1 parent 936be50306
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

perf symbols: Fix issue with binaries using 16-bytes buildids (v2) 

Buildid can vary in size. According to the man page of ld, buildid can
be 160 bits (sha1) or 128 bits (md5, uuid). Perf assumes buildid size of
20 bytes (160 bits) regardless. When dealing with md5 buildids, it would
thus read more than needed and that would cause mismatches and samples
without symbols.

This patch fixes this by taking into account the actual buildid size as
encoded int he section header. The leftover bytes are also cleared.

This second version fixes a minor issue with the memset() base position.

Cc: David S. Miller <davem@davemloft.net>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Stephane Eranian <eranian@gmail.com>
Link: http://lkml.kernel.org/r/4cc1af3c.8ee7d80a.5a28.ffff868e@mx.google.com
Signed-off-by: Stephane Eranian <eranian@google.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

Showing 1 changed file with 13 additions and 11 deletions Inline Diff

tools/perf/util/symbol.c
Diff comments   View file @ be96ea8
1 #define _GNU_SOURCE 1 #define _GNU_SOURCE
2 #include <ctype.h> 2 #include <ctype.h>
3 #include <dirent.h> 3 #include <dirent.h>
4 #include <errno.h> 4 #include <errno.h>
5 #include <libgen.h> 5 #include <libgen.h>
6 #include <stdlib.h> 6 #include <stdlib.h>
7 #include <stdio.h> 7 #include <stdio.h>
8 #include <string.h> 8 #include <string.h>
9 #include <sys/types.h> 9 #include <sys/types.h>
10 #include <sys/stat.h> 10 #include <sys/stat.h>
11 #include <sys/param.h> 11 #include <sys/param.h>
12 #include <fcntl.h> 12 #include <fcntl.h>
13 #include <unistd.h> 13 #include <unistd.h>
14 #include <inttypes.h> 14 #include <inttypes.h>
15 #include "build-id.h" 15 #include "build-id.h"
16 #include "debug.h" 16 #include "debug.h"
17 #include "symbol.h" 17 #include "symbol.h"
18 #include "strlist.h" 18 #include "strlist.h"
19 19
20 #include <libelf.h> 20 #include <libelf.h>
21 #include <gelf.h> 21 #include <gelf.h>
22 #include <elf.h> 22 #include <elf.h>
23 #include <limits.h> 23 #include <limits.h>
24 #include <sys/utsname.h> 24 #include <sys/utsname.h>
25 25
26 #ifndef KSYM_NAME_LEN 26 #ifndef KSYM_NAME_LEN
27 #define KSYM_NAME_LEN 128 27 #define KSYM_NAME_LEN 128
28 #endif 28 #endif
29 29
30 #ifndef NT_GNU_BUILD_ID 30 #ifndef NT_GNU_BUILD_ID
31 #define NT_GNU_BUILD_ID 3 31 #define NT_GNU_BUILD_ID 3
32 #endif 32 #endif
33 33
34 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id); 34 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
35 static int elf_read_build_id(Elf *elf, void *bf, size_t size); 35 static int elf_read_build_id(Elf *elf, void *bf, size_t size);
36 static void dsos__add(struct list_head *head, struct dso *dso); 36 static void dsos__add(struct list_head *head, struct dso *dso);
37 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type); 37 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
38 static int dso__load_kernel_sym(struct dso *dso, struct map *map, 38 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
39 symbol_filter_t filter); 39 symbol_filter_t filter);
40 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map, 40 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
41 symbol_filter_t filter); 41 symbol_filter_t filter);
42 static int vmlinux_path__nr_entries; 42 static int vmlinux_path__nr_entries;
43 static char **vmlinux_path; 43 static char **vmlinux_path;
44 44
45 struct symbol_conf symbol_conf = { 45 struct symbol_conf symbol_conf = {
46 .exclude_other = true, 46 .exclude_other = true,
47 .use_modules = true, 47 .use_modules = true,
48 .try_vmlinux_path = true, 48 .try_vmlinux_path = true,
49 .symfs = "", 49 .symfs = "",
50 }; 50 };
51 51
52 int dso__name_len(const struct dso *dso) 52 int dso__name_len(const struct dso *dso)
53 { 53 {
54 if (verbose) 54 if (verbose)
55 return dso->long_name_len; 55 return dso->long_name_len;
56 56
57 return dso->short_name_len; 57 return dso->short_name_len;
58 } 58 }
59 59
60 bool dso__loaded(const struct dso *dso, enum map_type type) 60 bool dso__loaded(const struct dso *dso, enum map_type type)
61 { 61 {
62 return dso->loaded & (1 << type); 62 return dso->loaded & (1 << type);
63 } 63 }
64 64
65 bool dso__sorted_by_name(const struct dso *dso, enum map_type type) 65 bool dso__sorted_by_name(const struct dso *dso, enum map_type type)
66 { 66 {
67 return dso->sorted_by_name & (1 << type); 67 return dso->sorted_by_name & (1 << type);
68 } 68 }
69 69
70 static void dso__set_sorted_by_name(struct dso *dso, enum map_type type) 70 static void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
71 { 71 {
72 dso->sorted_by_name |= (1 << type); 72 dso->sorted_by_name |= (1 << type);
73 } 73 }
74 74
75 bool symbol_type__is_a(char symbol_type, enum map_type map_type) 75 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
76 { 76 {
77 symbol_type = toupper(symbol_type); 77 symbol_type = toupper(symbol_type);
78 78
79 switch (map_type) { 79 switch (map_type) {
80 case MAP__FUNCTION: 80 case MAP__FUNCTION:
81 return symbol_type == 'T' || symbol_type == 'W'; 81 return symbol_type == 'T' || symbol_type == 'W';
82 case MAP__VARIABLE: 82 case MAP__VARIABLE:
83 return symbol_type == 'D'; 83 return symbol_type == 'D';
84 default: 84 default:
85 return false; 85 return false;
86 } 86 }
87 } 87 }
88 88
89 static int prefix_underscores_count(const char *str) 89 static int prefix_underscores_count(const char *str)
90 { 90 {
91 const char *tail = str; 91 const char *tail = str;
92 92
93 while (*tail == '_') 93 while (*tail == '_')
94 tail++; 94 tail++;
95 95
96 return tail - str; 96 return tail - str;
97 } 97 }
98 98
99 #define SYMBOL_A 0 99 #define SYMBOL_A 0
100 #define SYMBOL_B 1 100 #define SYMBOL_B 1
101 101
102 static int choose_best_symbol(struct symbol *syma, struct symbol *symb) 102 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
103 { 103 {
104 s64 a; 104 s64 a;
105 s64 b; 105 s64 b;
106 106
107 /* Prefer a symbol with non zero length */ 107 /* Prefer a symbol with non zero length */
108 a = syma->end - syma->start; 108 a = syma->end - syma->start;
109 b = symb->end - symb->start; 109 b = symb->end - symb->start;
110 if ((b == 0) && (a > 0)) 110 if ((b == 0) && (a > 0))
111 return SYMBOL_A; 111 return SYMBOL_A;
112 else if ((a == 0) && (b > 0)) 112 else if ((a == 0) && (b > 0))
113 return SYMBOL_B; 113 return SYMBOL_B;
114 114
115 /* Prefer a non weak symbol over a weak one */ 115 /* Prefer a non weak symbol over a weak one */
116 a = syma->binding == STB_WEAK; 116 a = syma->binding == STB_WEAK;
117 b = symb->binding == STB_WEAK; 117 b = symb->binding == STB_WEAK;
118 if (b && !a) 118 if (b && !a)
119 return SYMBOL_A; 119 return SYMBOL_A;
120 if (a && !b) 120 if (a && !b)
121 return SYMBOL_B; 121 return SYMBOL_B;
122 122
123 /* Prefer a global symbol over a non global one */ 123 /* Prefer a global symbol over a non global one */
124 a = syma->binding == STB_GLOBAL; 124 a = syma->binding == STB_GLOBAL;
125 b = symb->binding == STB_GLOBAL; 125 b = symb->binding == STB_GLOBAL;
126 if (a && !b) 126 if (a && !b)
127 return SYMBOL_A; 127 return SYMBOL_A;
128 if (b && !a) 128 if (b && !a)
129 return SYMBOL_B; 129 return SYMBOL_B;
130 130
131 /* Prefer a symbol with less underscores */ 131 /* Prefer a symbol with less underscores */
132 a = prefix_underscores_count(syma->name); 132 a = prefix_underscores_count(syma->name);
133 b = prefix_underscores_count(symb->name); 133 b = prefix_underscores_count(symb->name);
134 if (b > a) 134 if (b > a)
135 return SYMBOL_A; 135 return SYMBOL_A;
136 else if (a > b) 136 else if (a > b)
137 return SYMBOL_B; 137 return SYMBOL_B;
138 138
139 /* If all else fails, choose the symbol with the longest name */ 139 /* If all else fails, choose the symbol with the longest name */
140 if (strlen(syma->name) >= strlen(symb->name)) 140 if (strlen(syma->name) >= strlen(symb->name))
141 return SYMBOL_A; 141 return SYMBOL_A;
142 else 142 else
143 return SYMBOL_B; 143 return SYMBOL_B;
144 } 144 }
145 145
146 static void symbols__fixup_duplicate(struct rb_root *symbols) 146 static void symbols__fixup_duplicate(struct rb_root *symbols)
147 { 147 {
148 struct rb_node *nd; 148 struct rb_node *nd;
149 struct symbol *curr, *next; 149 struct symbol *curr, *next;
150 150
151 nd = rb_first(symbols); 151 nd = rb_first(symbols);
152 152
153 while (nd) { 153 while (nd) {
154 curr = rb_entry(nd, struct symbol, rb_node); 154 curr = rb_entry(nd, struct symbol, rb_node);
155 again: 155 again:
156 nd = rb_next(&curr->rb_node); 156 nd = rb_next(&curr->rb_node);
157 next = rb_entry(nd, struct symbol, rb_node); 157 next = rb_entry(nd, struct symbol, rb_node);
158 158
159 if (!nd) 159 if (!nd)
160 break; 160 break;
161 161
162 if (curr->start != next->start) 162 if (curr->start != next->start)
163 continue; 163 continue;
164 164
165 if (choose_best_symbol(curr, next) == SYMBOL_A) { 165 if (choose_best_symbol(curr, next) == SYMBOL_A) {
166 rb_erase(&next->rb_node, symbols); 166 rb_erase(&next->rb_node, symbols);
167 goto again; 167 goto again;
168 } else { 168 } else {
169 nd = rb_next(&curr->rb_node); 169 nd = rb_next(&curr->rb_node);
170 rb_erase(&curr->rb_node, symbols); 170 rb_erase(&curr->rb_node, symbols);
171 } 171 }
172 } 172 }
173 } 173 }
174 174
175 static void symbols__fixup_end(struct rb_root *symbols) 175 static void symbols__fixup_end(struct rb_root *symbols)
176 { 176 {
177 struct rb_node *nd, *prevnd = rb_first(symbols); 177 struct rb_node *nd, *prevnd = rb_first(symbols);
178 struct symbol *curr, *prev; 178 struct symbol *curr, *prev;
179 179
180 if (prevnd == NULL) 180 if (prevnd == NULL)
181 return; 181 return;
182 182
183 curr = rb_entry(prevnd, struct symbol, rb_node); 183 curr = rb_entry(prevnd, struct symbol, rb_node);
184 184
185 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) { 185 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
186 prev = curr; 186 prev = curr;
187 curr = rb_entry(nd, struct symbol, rb_node); 187 curr = rb_entry(nd, struct symbol, rb_node);
188 188
189 if (prev->end == prev->start && prev->end != curr->start) 189 if (prev->end == prev->start && prev->end != curr->start)
190 prev->end = curr->start - 1; 190 prev->end = curr->start - 1;
191 } 191 }
192 192
193 /* Last entry */ 193 /* Last entry */
194 if (curr->end == curr->start) 194 if (curr->end == curr->start)
195 curr->end = roundup(curr->start, 4096); 195 curr->end = roundup(curr->start, 4096);
196 } 196 }
197 197
198 static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type) 198 static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
199 { 199 {
200 struct map *prev, *curr; 200 struct map *prev, *curr;
201 struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]); 201 struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
202 202
203 if (prevnd == NULL) 203 if (prevnd == NULL)
204 return; 204 return;
205 205
206 curr = rb_entry(prevnd, struct map, rb_node); 206 curr = rb_entry(prevnd, struct map, rb_node);
207 207
208 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) { 208 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
209 prev = curr; 209 prev = curr;
210 curr = rb_entry(nd, struct map, rb_node); 210 curr = rb_entry(nd, struct map, rb_node);
211 prev->end = curr->start - 1; 211 prev->end = curr->start - 1;
212 } 212 }
213 213
214 /* 214 /*
215 * We still haven't the actual symbols, so guess the 215 * We still haven't the actual symbols, so guess the
216 * last map final address. 216 * last map final address.
217 */ 217 */
218 curr->end = ~0ULL; 218 curr->end = ~0ULL;
219 } 219 }
220 220
221 static void map_groups__fixup_end(struct map_groups *mg) 221 static void map_groups__fixup_end(struct map_groups *mg)
222 { 222 {
223 int i; 223 int i;
224 for (i = 0; i < MAP__NR_TYPES; ++i) 224 for (i = 0; i < MAP__NR_TYPES; ++i)
225 __map_groups__fixup_end(mg, i); 225 __map_groups__fixup_end(mg, i);
226 } 226 }
227 227
228 static struct symbol *symbol__new(u64 start, u64 len, u8 binding, 228 static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
229 const char *name) 229 const char *name)
230 { 230 {
231 size_t namelen = strlen(name) + 1; 231 size_t namelen = strlen(name) + 1;
232 struct symbol *sym = calloc(1, (symbol_conf.priv_size + 232 struct symbol *sym = calloc(1, (symbol_conf.priv_size +
233 sizeof(*sym) + namelen)); 233 sizeof(*sym) + namelen));
234 if (sym == NULL) 234 if (sym == NULL)
235 return NULL; 235 return NULL;
236 236
237 if (symbol_conf.priv_size) 237 if (symbol_conf.priv_size)
238 sym = ((void *)sym) + symbol_conf.priv_size; 238 sym = ((void *)sym) + symbol_conf.priv_size;
239 239
240 sym->start = start; 240 sym->start = start;
241 sym->end = len ? start + len - 1 : start; 241 sym->end = len ? start + len - 1 : start;
242 sym->binding = binding; 242 sym->binding = binding;
243 sym->namelen = namelen - 1; 243 sym->namelen = namelen - 1;
244 244
245 pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n", 245 pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
246 __func__, name, start, sym->end); 246 __func__, name, start, sym->end);
247 memcpy(sym->name, name, namelen); 247 memcpy(sym->name, name, namelen);
248 248
249 return sym; 249 return sym;
250 } 250 }
251 251
252 void symbol__delete(struct symbol *sym) 252 void symbol__delete(struct symbol *sym)
253 { 253 {
254 free(((void *)sym) - symbol_conf.priv_size); 254 free(((void *)sym) - symbol_conf.priv_size);
255 } 255 }
256 256
257 static size_t symbol__fprintf(struct symbol *sym, FILE *fp) 257 static size_t symbol__fprintf(struct symbol *sym, FILE *fp)
258 { 258 {
259 return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n", 259 return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
260 sym->start, sym->end, 260 sym->start, sym->end,
261 sym->binding == STB_GLOBAL ? 'g' : 261 sym->binding == STB_GLOBAL ? 'g' :
262 sym->binding == STB_LOCAL ? 'l' : 'w', 262 sym->binding == STB_LOCAL ? 'l' : 'w',
263 sym->name); 263 sym->name);
264 } 264 }
265 265
266 void dso__set_long_name(struct dso *dso, char *name) 266 void dso__set_long_name(struct dso *dso, char *name)
267 { 267 {
268 if (name == NULL) 268 if (name == NULL)
269 return; 269 return;
270 dso->long_name = name; 270 dso->long_name = name;
271 dso->long_name_len = strlen(name); 271 dso->long_name_len = strlen(name);
272 } 272 }
273 273
274 static void dso__set_short_name(struct dso *dso, const char *name) 274 static void dso__set_short_name(struct dso *dso, const char *name)
275 { 275 {
276 if (name == NULL) 276 if (name == NULL)
277 return; 277 return;
278 dso->short_name = name; 278 dso->short_name = name;
279 dso->short_name_len = strlen(name); 279 dso->short_name_len = strlen(name);
280 } 280 }
281 281
282 static void dso__set_basename(struct dso *dso) 282 static void dso__set_basename(struct dso *dso)
283 { 283 {
284 dso__set_short_name(dso, basename(dso->long_name)); 284 dso__set_short_name(dso, basename(dso->long_name));
285 } 285 }
286 286
287 struct dso *dso__new(const char *name) 287 struct dso *dso__new(const char *name)
288 { 288 {
289 struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1); 289 struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1);
290 290
291 if (dso != NULL) { 291 if (dso != NULL) {
292 int i; 292 int i;
293 strcpy(dso->name, name); 293 strcpy(dso->name, name);
294 dso__set_long_name(dso, dso->name); 294 dso__set_long_name(dso, dso->name);
295 dso__set_short_name(dso, dso->name); 295 dso__set_short_name(dso, dso->name);
296 for (i = 0; i < MAP__NR_TYPES; ++i) 296 for (i = 0; i < MAP__NR_TYPES; ++i)
297 dso->symbols[i] = dso->symbol_names[i] = RB_ROOT; 297 dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
298 dso->symtab_type = SYMTAB__NOT_FOUND; 298 dso->symtab_type = SYMTAB__NOT_FOUND;
299 dso->loaded = 0; 299 dso->loaded = 0;
300 dso->sorted_by_name = 0; 300 dso->sorted_by_name = 0;
301 dso->has_build_id = 0; 301 dso->has_build_id = 0;
302 dso->kernel = DSO_TYPE_USER; 302 dso->kernel = DSO_TYPE_USER;
303 INIT_LIST_HEAD(&dso->node); 303 INIT_LIST_HEAD(&dso->node);
304 } 304 }
305 305
306 return dso; 306 return dso;
307 } 307 }
308 308
309 static void symbols__delete(struct rb_root *symbols) 309 static void symbols__delete(struct rb_root *symbols)
310 { 310 {
311 struct symbol *pos; 311 struct symbol *pos;
312 struct rb_node *next = rb_first(symbols); 312 struct rb_node *next = rb_first(symbols);
313 313
314 while (next) { 314 while (next) {
315 pos = rb_entry(next, struct symbol, rb_node); 315 pos = rb_entry(next, struct symbol, rb_node);
316 next = rb_next(&pos->rb_node); 316 next = rb_next(&pos->rb_node);
317 rb_erase(&pos->rb_node, symbols); 317 rb_erase(&pos->rb_node, symbols);
318 symbol__delete(pos); 318 symbol__delete(pos);
319 } 319 }
320 } 320 }
321 321
322 void dso__delete(struct dso *dso) 322 void dso__delete(struct dso *dso)
323 { 323 {
324 int i; 324 int i;
325 for (i = 0; i < MAP__NR_TYPES; ++i) 325 for (i = 0; i < MAP__NR_TYPES; ++i)
326 symbols__delete(&dso->symbols[i]); 326 symbols__delete(&dso->symbols[i]);
327 if (dso->sname_alloc) 327 if (dso->sname_alloc)
328 free((char *)dso->short_name); 328 free((char *)dso->short_name);
329 if (dso->lname_alloc) 329 if (dso->lname_alloc)
330 free(dso->long_name); 330 free(dso->long_name);
331 free(dso); 331 free(dso);
332 } 332 }
333 333
334 void dso__set_build_id(struct dso *dso, void *build_id) 334 void dso__set_build_id(struct dso *dso, void *build_id)
335 { 335 {
336 memcpy(dso->build_id, build_id, sizeof(dso->build_id)); 336 memcpy(dso->build_id, build_id, sizeof(dso->build_id));
337 dso->has_build_id = 1; 337 dso->has_build_id = 1;
338 } 338 }
339 339
340 static void symbols__insert(struct rb_root *symbols, struct symbol *sym) 340 static void symbols__insert(struct rb_root *symbols, struct symbol *sym)
341 { 341 {
342 struct rb_node **p = &symbols->rb_node; 342 struct rb_node **p = &symbols->rb_node;
343 struct rb_node *parent = NULL; 343 struct rb_node *parent = NULL;
344 const u64 ip = sym->start; 344 const u64 ip = sym->start;
345 struct symbol *s; 345 struct symbol *s;
346 346
347 while (*p != NULL) { 347 while (*p != NULL) {
348 parent = *p; 348 parent = *p;
349 s = rb_entry(parent, struct symbol, rb_node); 349 s = rb_entry(parent, struct symbol, rb_node);
350 if (ip < s->start) 350 if (ip < s->start)
351 p = &(*p)->rb_left; 351 p = &(*p)->rb_left;
352 else 352 else
353 p = &(*p)->rb_right; 353 p = &(*p)->rb_right;
354 } 354 }
355 rb_link_node(&sym->rb_node, parent, p); 355 rb_link_node(&sym->rb_node, parent, p);
356 rb_insert_color(&sym->rb_node, symbols); 356 rb_insert_color(&sym->rb_node, symbols);
357 } 357 }
358 358
359 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip) 359 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
360 { 360 {
361 struct rb_node *n; 361 struct rb_node *n;
362 362
363 if (symbols == NULL) 363 if (symbols == NULL)
364 return NULL; 364 return NULL;
365 365
366 n = symbols->rb_node; 366 n = symbols->rb_node;
367 367
368 while (n) { 368 while (n) {
369 struct symbol *s = rb_entry(n, struct symbol, rb_node); 369 struct symbol *s = rb_entry(n, struct symbol, rb_node);
370 370
371 if (ip < s->start) 371 if (ip < s->start)
372 n = n->rb_left; 372 n = n->rb_left;
373 else if (ip > s->end) 373 else if (ip > s->end)
374 n = n->rb_right; 374 n = n->rb_right;
375 else 375 else
376 return s; 376 return s;
377 } 377 }
378 378
379 return NULL; 379 return NULL;
380 } 380 }
381 381
382 struct symbol_name_rb_node { 382 struct symbol_name_rb_node {
383 struct rb_node rb_node; 383 struct rb_node rb_node;
384 struct symbol sym; 384 struct symbol sym;
385 }; 385 };
386 386
387 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym) 387 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
388 { 388 {
389 struct rb_node **p = &symbols->rb_node; 389 struct rb_node **p = &symbols->rb_node;
390 struct rb_node *parent = NULL; 390 struct rb_node *parent = NULL;
391 struct symbol_name_rb_node *symn, *s; 391 struct symbol_name_rb_node *symn, *s;
392 392
393 symn = container_of(sym, struct symbol_name_rb_node, sym); 393 symn = container_of(sym, struct symbol_name_rb_node, sym);
394 394
395 while (*p != NULL) { 395 while (*p != NULL) {
396 parent = *p; 396 parent = *p;
397 s = rb_entry(parent, struct symbol_name_rb_node, rb_node); 397 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
398 if (strcmp(sym->name, s->sym.name) < 0) 398 if (strcmp(sym->name, s->sym.name) < 0)
399 p = &(*p)->rb_left; 399 p = &(*p)->rb_left;
400 else 400 else
401 p = &(*p)->rb_right; 401 p = &(*p)->rb_right;
402 } 402 }
403 rb_link_node(&symn->rb_node, parent, p); 403 rb_link_node(&symn->rb_node, parent, p);
404 rb_insert_color(&symn->rb_node, symbols); 404 rb_insert_color(&symn->rb_node, symbols);
405 } 405 }
406 406
407 static void symbols__sort_by_name(struct rb_root *symbols, 407 static void symbols__sort_by_name(struct rb_root *symbols,
408 struct rb_root *source) 408 struct rb_root *source)
409 { 409 {
410 struct rb_node *nd; 410 struct rb_node *nd;
411 411
412 for (nd = rb_first(source); nd; nd = rb_next(nd)) { 412 for (nd = rb_first(source); nd; nd = rb_next(nd)) {
413 struct symbol *pos = rb_entry(nd, struct symbol, rb_node); 413 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
414 symbols__insert_by_name(symbols, pos); 414 symbols__insert_by_name(symbols, pos);
415 } 415 }
416 } 416 }
417 417
418 static struct symbol *symbols__find_by_name(struct rb_root *symbols, 418 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
419 const char *name) 419 const char *name)
420 { 420 {
421 struct rb_node *n; 421 struct rb_node *n;
422 422
423 if (symbols == NULL) 423 if (symbols == NULL)
424 return NULL; 424 return NULL;
425 425
426 n = symbols->rb_node; 426 n = symbols->rb_node;
427 427
428 while (n) { 428 while (n) {
429 struct symbol_name_rb_node *s; 429 struct symbol_name_rb_node *s;
430 int cmp; 430 int cmp;
431 431
432 s = rb_entry(n, struct symbol_name_rb_node, rb_node); 432 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
433 cmp = strcmp(name, s->sym.name); 433 cmp = strcmp(name, s->sym.name);
434 434
435 if (cmp < 0) 435 if (cmp < 0)
436 n = n->rb_left; 436 n = n->rb_left;
437 else if (cmp > 0) 437 else if (cmp > 0)
438 n = n->rb_right; 438 n = n->rb_right;
439 else 439 else
440 return &s->sym; 440 return &s->sym;
441 } 441 }
442 442
443 return NULL; 443 return NULL;
444 } 444 }
445 445
446 struct symbol *dso__find_symbol(struct dso *dso, 446 struct symbol *dso__find_symbol(struct dso *dso,
447 enum map_type type, u64 addr) 447 enum map_type type, u64 addr)
448 { 448 {
449 return symbols__find(&dso->symbols[type], addr); 449 return symbols__find(&dso->symbols[type], addr);
450 } 450 }
451 451
452 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type, 452 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
453 const char *name) 453 const char *name)
454 { 454 {
455 return symbols__find_by_name(&dso->symbol_names[type], name); 455 return symbols__find_by_name(&dso->symbol_names[type], name);
456 } 456 }
457 457
458 void dso__sort_by_name(struct dso *dso, enum map_type type) 458 void dso__sort_by_name(struct dso *dso, enum map_type type)
459 { 459 {
460 dso__set_sorted_by_name(dso, type); 460 dso__set_sorted_by_name(dso, type);
461 return symbols__sort_by_name(&dso->symbol_names[type], 461 return symbols__sort_by_name(&dso->symbol_names[type],
462 &dso->symbols[type]); 462 &dso->symbols[type]);
463 } 463 }
464 464
465 int build_id__sprintf(const u8 *build_id, int len, char *bf) 465 int build_id__sprintf(const u8 *build_id, int len, char *bf)
466 { 466 {
467 char *bid = bf; 467 char *bid = bf;
468 const u8 *raw = build_id; 468 const u8 *raw = build_id;
469 int i; 469 int i;
470 470
471 for (i = 0; i < len; ++i) { 471 for (i = 0; i < len; ++i) {
472 sprintf(bid, "%02x", *raw); 472 sprintf(bid, "%02x", *raw);
473 ++raw; 473 ++raw;
474 bid += 2; 474 bid += 2;
475 } 475 }
476 476
477 return raw - build_id; 477 return raw - build_id;
478 } 478 }
479 479
480 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp) 480 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp)
481 { 481 {
482 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 482 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
483 483
484 build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id); 484 build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
485 return fprintf(fp, "%s", sbuild_id); 485 return fprintf(fp, "%s", sbuild_id);
486 } 486 }
487 487
488 size_t dso__fprintf_symbols_by_name(struct dso *dso, 488 size_t dso__fprintf_symbols_by_name(struct dso *dso,
489 enum map_type type, FILE *fp) 489 enum map_type type, FILE *fp)
490 { 490 {
491 size_t ret = 0; 491 size_t ret = 0;
492 struct rb_node *nd; 492 struct rb_node *nd;
493 struct symbol_name_rb_node *pos; 493 struct symbol_name_rb_node *pos;
494 494
495 for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) { 495 for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
496 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node); 496 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
497 fprintf(fp, "%s\n", pos->sym.name); 497 fprintf(fp, "%s\n", pos->sym.name);
498 } 498 }
499 499
500 return ret; 500 return ret;
501 } 501 }
502 502
503 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp) 503 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
504 { 504 {
505 struct rb_node *nd; 505 struct rb_node *nd;
506 size_t ret = fprintf(fp, "dso: %s (", dso->short_name); 506 size_t ret = fprintf(fp, "dso: %s (", dso->short_name);
507 507
508 if (dso->short_name != dso->long_name) 508 if (dso->short_name != dso->long_name)
509 ret += fprintf(fp, "%s, ", dso->long_name); 509 ret += fprintf(fp, "%s, ", dso->long_name);
510 ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type], 510 ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
511 dso->loaded ? "" : "NOT "); 511 dso->loaded ? "" : "NOT ");
512 ret += dso__fprintf_buildid(dso, fp); 512 ret += dso__fprintf_buildid(dso, fp);
513 ret += fprintf(fp, ")\n"); 513 ret += fprintf(fp, ")\n");
514 for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) { 514 for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
515 struct symbol *pos = rb_entry(nd, struct symbol, rb_node); 515 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
516 ret += symbol__fprintf(pos, fp); 516 ret += symbol__fprintf(pos, fp);
517 } 517 }
518 518
519 return ret; 519 return ret;
520 } 520 }
521 521
522 int kallsyms__parse(const char *filename, void *arg, 522 int kallsyms__parse(const char *filename, void *arg,
523 int (*process_symbol)(void *arg, const char *name, 523 int (*process_symbol)(void *arg, const char *name,
524 char type, u64 start, u64 end)) 524 char type, u64 start, u64 end))
525 { 525 {
526 char *line = NULL; 526 char *line = NULL;
527 size_t n; 527 size_t n;
528 int err = -1; 528 int err = -1;
529 FILE *file = fopen(filename, "r"); 529 FILE *file = fopen(filename, "r");
530 530
531 if (file == NULL) 531 if (file == NULL)
532 goto out_failure; 532 goto out_failure;
533 533
534 err = 0; 534 err = 0;
535 535
536 while (!feof(file)) { 536 while (!feof(file)) {
537 u64 start; 537 u64 start;
538 int line_len, len; 538 int line_len, len;
539 char symbol_type; 539 char symbol_type;
540 char *symbol_name; 540 char *symbol_name;
541 541
542 line_len = getline(&line, &n, file); 542 line_len = getline(&line, &n, file);
543 if (line_len < 0 || !line) 543 if (line_len < 0 || !line)
544 break; 544 break;
545 545
546 line[--line_len] = '\0'; /* \n */ 546 line[--line_len] = '\0'; /* \n */
547 547
548 len = hex2u64(line, &start); 548 len = hex2u64(line, &start);
549 549
550 len++; 550 len++;
551 if (len + 2 >= line_len) 551 if (len + 2 >= line_len)
552 continue; 552 continue;
553 553
554 symbol_type = line[len]; 554 symbol_type = line[len];
555 len += 2; 555 len += 2;
556 symbol_name = line + len; 556 symbol_name = line + len;
557 len = line_len - len; 557 len = line_len - len;
558 558
559 if (len >= KSYM_NAME_LEN) { 559 if (len >= KSYM_NAME_LEN) {
560 err = -1; 560 err = -1;
561 break; 561 break;
562 } 562 }
563 563
564 /* 564 /*
565 * module symbols are not sorted so we add all 565 * module symbols are not sorted so we add all
566 * symbols with zero length and rely on 566 * symbols with zero length and rely on
567 * symbols__fixup_end() to fix it up. 567 * symbols__fixup_end() to fix it up.
568 */ 568 */
569 err = process_symbol(arg, symbol_name, 569 err = process_symbol(arg, symbol_name,
570 symbol_type, start, start); 570 symbol_type, start, start);
571 if (err) 571 if (err)
572 break; 572 break;
573 } 573 }
574 574
575 free(line); 575 free(line);
576 fclose(file); 576 fclose(file);
577 return err; 577 return err;
578 578
579 out_failure: 579 out_failure:
580 return -1; 580 return -1;
581 } 581 }
582 582
583 struct process_kallsyms_args { 583 struct process_kallsyms_args {
584 struct map *map; 584 struct map *map;
585 struct dso *dso; 585 struct dso *dso;
586 }; 586 };
587 587
588 static u8 kallsyms2elf_type(char type) 588 static u8 kallsyms2elf_type(char type)
589 { 589 {
590 if (type == 'W') 590 if (type == 'W')
591 return STB_WEAK; 591 return STB_WEAK;
592 592
593 return isupper(type) ? STB_GLOBAL : STB_LOCAL; 593 return isupper(type) ? STB_GLOBAL : STB_LOCAL;
594 } 594 }
595 595
596 static int map__process_kallsym_symbol(void *arg, const char *name, 596 static int map__process_kallsym_symbol(void *arg, const char *name,
597 char type, u64 start, u64 end) 597 char type, u64 start, u64 end)
598 { 598 {
599 struct symbol *sym; 599 struct symbol *sym;
600 struct process_kallsyms_args *a = arg; 600 struct process_kallsyms_args *a = arg;
601 struct rb_root *root = &a->dso->symbols[a->map->type]; 601 struct rb_root *root = &a->dso->symbols[a->map->type];
602 602
603 if (!symbol_type__is_a(type, a->map->type)) 603 if (!symbol_type__is_a(type, a->map->type))
604 return 0; 604 return 0;
605 605
606 sym = symbol__new(start, end - start + 1, 606 sym = symbol__new(start, end - start + 1,
607 kallsyms2elf_type(type), name); 607 kallsyms2elf_type(type), name);
608 if (sym == NULL) 608 if (sym == NULL)
609 return -ENOMEM; 609 return -ENOMEM;
610 /* 610 /*
611 * We will pass the symbols to the filter later, in 611 * We will pass the symbols to the filter later, in
612 * map__split_kallsyms, when we have split the maps per module 612 * map__split_kallsyms, when we have split the maps per module
613 */ 613 */
614 symbols__insert(root, sym); 614 symbols__insert(root, sym);
615 615
616 return 0; 616 return 0;
617 } 617 }
618 618
619 /* 619 /*
620 * Loads the function entries in /proc/kallsyms into kernel_map->dso, 620 * Loads the function entries in /proc/kallsyms into kernel_map->dso,
621 * so that we can in the next step set the symbol ->end address and then 621 * so that we can in the next step set the symbol ->end address and then
622 * call kernel_maps__split_kallsyms. 622 * call kernel_maps__split_kallsyms.
623 */ 623 */
624 static int dso__load_all_kallsyms(struct dso *dso, const char *filename, 624 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
625 struct map *map) 625 struct map *map)
626 { 626 {
627 struct process_kallsyms_args args = { .map = map, .dso = dso, }; 627 struct process_kallsyms_args args = { .map = map, .dso = dso, };
628 return kallsyms__parse(filename, &args, map__process_kallsym_symbol); 628 return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
629 } 629 }
630 630
631 /* 631 /*
632 * Split the symbols into maps, making sure there are no overlaps, i.e. the 632 * Split the symbols into maps, making sure there are no overlaps, i.e. the
633 * kernel range is broken in several maps, named [kernel].N, as we don't have 633 * kernel range is broken in several maps, named [kernel].N, as we don't have
634 * the original ELF section names vmlinux have. 634 * the original ELF section names vmlinux have.
635 */ 635 */
636 static int dso__split_kallsyms(struct dso *dso, struct map *map, 636 static int dso__split_kallsyms(struct dso *dso, struct map *map,
637 symbol_filter_t filter) 637 symbol_filter_t filter)
638 { 638 {
639 struct map_groups *kmaps = map__kmap(map)->kmaps; 639 struct map_groups *kmaps = map__kmap(map)->kmaps;
640 struct machine *machine = kmaps->machine; 640 struct machine *machine = kmaps->machine;
641 struct map *curr_map = map; 641 struct map *curr_map = map;
642 struct symbol *pos; 642 struct symbol *pos;
643 int count = 0, moved = 0; 643 int count = 0, moved = 0;
644 struct rb_root *root = &dso->symbols[map->type]; 644 struct rb_root *root = &dso->symbols[map->type];
645 struct rb_node *next = rb_first(root); 645 struct rb_node *next = rb_first(root);
646 int kernel_range = 0; 646 int kernel_range = 0;
647 647
648 while (next) { 648 while (next) {
649 char *module; 649 char *module;
650 650
651 pos = rb_entry(next, struct symbol, rb_node); 651 pos = rb_entry(next, struct symbol, rb_node);
652 next = rb_next(&pos->rb_node); 652 next = rb_next(&pos->rb_node);
653 653
654 module = strchr(pos->name, '\t'); 654 module = strchr(pos->name, '\t');
655 if (module) { 655 if (module) {
656 if (!symbol_conf.use_modules) 656 if (!symbol_conf.use_modules)
657 goto discard_symbol; 657 goto discard_symbol;
658 658
659 *module++ = '\0'; 659 *module++ = '\0';
660 660
661 if (strcmp(curr_map->dso->short_name, module)) { 661 if (strcmp(curr_map->dso->short_name, module)) {
662 if (curr_map != map && 662 if (curr_map != map &&
663 dso->kernel == DSO_TYPE_GUEST_KERNEL && 663 dso->kernel == DSO_TYPE_GUEST_KERNEL &&
664 machine__is_default_guest(machine)) { 664 machine__is_default_guest(machine)) {
665 /* 665 /*
666 * We assume all symbols of a module are 666 * We assume all symbols of a module are
667 * continuous in * kallsyms, so curr_map 667 * continuous in * kallsyms, so curr_map
668 * points to a module and all its 668 * points to a module and all its
669 * symbols are in its kmap. Mark it as 669 * symbols are in its kmap. Mark it as
670 * loaded. 670 * loaded.
671 */ 671 */
672 dso__set_loaded(curr_map->dso, 672 dso__set_loaded(curr_map->dso,
673 curr_map->type); 673 curr_map->type);
674 } 674 }
675 675
676 curr_map = map_groups__find_by_name(kmaps, 676 curr_map = map_groups__find_by_name(kmaps,
677 map->type, module); 677 map->type, module);
678 if (curr_map == NULL) { 678 if (curr_map == NULL) {
679 pr_debug("%s/proc/{kallsyms,modules} " 679 pr_debug("%s/proc/{kallsyms,modules} "
680 "inconsistency while looking " 680 "inconsistency while looking "
681 "for \"%s\" module!\n", 681 "for \"%s\" module!\n",
682 machine->root_dir, module); 682 machine->root_dir, module);
683 curr_map = map; 683 curr_map = map;
684 goto discard_symbol; 684 goto discard_symbol;
685 } 685 }
686 686
687 if (curr_map->dso->loaded && 687 if (curr_map->dso->loaded &&
688 !machine__is_default_guest(machine)) 688 !machine__is_default_guest(machine))
689 goto discard_symbol; 689 goto discard_symbol;
690 } 690 }
691 /* 691 /*
692 * So that we look just like we get from .ko files, 692 * So that we look just like we get from .ko files,
693 * i.e. not prelinked, relative to map->start. 693 * i.e. not prelinked, relative to map->start.
694 */ 694 */
695 pos->start = curr_map->map_ip(curr_map, pos->start); 695 pos->start = curr_map->map_ip(curr_map, pos->start);
696 pos->end = curr_map->map_ip(curr_map, pos->end); 696 pos->end = curr_map->map_ip(curr_map, pos->end);
697 } else if (curr_map != map) { 697 } else if (curr_map != map) {
698 char dso_name[PATH_MAX]; 698 char dso_name[PATH_MAX];
699 struct dso *ndso; 699 struct dso *ndso;
700 700
701 if (count == 0) { 701 if (count == 0) {
702 curr_map = map; 702 curr_map = map;
703 goto filter_symbol; 703 goto filter_symbol;
704 } 704 }
705 705
706 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 706 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
707 snprintf(dso_name, sizeof(dso_name), 707 snprintf(dso_name, sizeof(dso_name),
708 "[guest.kernel].%d", 708 "[guest.kernel].%d",
709 kernel_range++); 709 kernel_range++);
710 else 710 else
711 snprintf(dso_name, sizeof(dso_name), 711 snprintf(dso_name, sizeof(dso_name),
712 "[kernel].%d", 712 "[kernel].%d",
713 kernel_range++); 713 kernel_range++);
714 714
715 ndso = dso__new(dso_name); 715 ndso = dso__new(dso_name);
716 if (ndso == NULL) 716 if (ndso == NULL)
717 return -1; 717 return -1;
718 718
719 ndso->kernel = dso->kernel; 719 ndso->kernel = dso->kernel;
720 720
721 curr_map = map__new2(pos->start, ndso, map->type); 721 curr_map = map__new2(pos->start, ndso, map->type);
722 if (curr_map == NULL) { 722 if (curr_map == NULL) {
723 dso__delete(ndso); 723 dso__delete(ndso);
724 return -1; 724 return -1;
725 } 725 }
726 726
727 curr_map->map_ip = curr_map->unmap_ip = identity__map_ip; 727 curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
728 map_groups__insert(kmaps, curr_map); 728 map_groups__insert(kmaps, curr_map);
729 ++kernel_range; 729 ++kernel_range;
730 } 730 }
731 filter_symbol: 731 filter_symbol:
732 if (filter && filter(curr_map, pos)) { 732 if (filter && filter(curr_map, pos)) {
733 discard_symbol: rb_erase(&pos->rb_node, root); 733 discard_symbol: rb_erase(&pos->rb_node, root);
734 symbol__delete(pos); 734 symbol__delete(pos);
735 } else { 735 } else {
736 if (curr_map != map) { 736 if (curr_map != map) {
737 rb_erase(&pos->rb_node, root); 737 rb_erase(&pos->rb_node, root);
738 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos); 738 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
739 ++moved; 739 ++moved;
740 } else 740 } else
741 ++count; 741 ++count;
742 } 742 }
743 } 743 }
744 744
745 if (curr_map != map && 745 if (curr_map != map &&
746 dso->kernel == DSO_TYPE_GUEST_KERNEL && 746 dso->kernel == DSO_TYPE_GUEST_KERNEL &&
747 machine__is_default_guest(kmaps->machine)) { 747 machine__is_default_guest(kmaps->machine)) {
748 dso__set_loaded(curr_map->dso, curr_map->type); 748 dso__set_loaded(curr_map->dso, curr_map->type);
749 } 749 }
750 750
751 return count + moved; 751 return count + moved;
752 } 752 }
753 753
754 static bool symbol__restricted_filename(const char *filename, 754 static bool symbol__restricted_filename(const char *filename,
755 const char *restricted_filename) 755 const char *restricted_filename)
756 { 756 {
757 bool restricted = false; 757 bool restricted = false;
758 758
759 if (symbol_conf.kptr_restrict) { 759 if (symbol_conf.kptr_restrict) {
760 char *r = realpath(filename, NULL); 760 char *r = realpath(filename, NULL);
761 761
762 if (r != NULL) { 762 if (r != NULL) {
763 restricted = strcmp(r, restricted_filename) == 0; 763 restricted = strcmp(r, restricted_filename) == 0;
764 free(r); 764 free(r);
765 return restricted; 765 return restricted;
766 } 766 }
767 } 767 }
768 768
769 return restricted; 769 return restricted;
770 } 770 }
771 771
772 int dso__load_kallsyms(struct dso *dso, const char *filename, 772 int dso__load_kallsyms(struct dso *dso, const char *filename,
773 struct map *map, symbol_filter_t filter) 773 struct map *map, symbol_filter_t filter)
774 { 774 {
775 if (symbol__restricted_filename(filename, "/proc/kallsyms")) 775 if (symbol__restricted_filename(filename, "/proc/kallsyms"))
776 return -1; 776 return -1;
777 777
778 if (dso__load_all_kallsyms(dso, filename, map) < 0) 778 if (dso__load_all_kallsyms(dso, filename, map) < 0)
779 return -1; 779 return -1;
780 780
781 symbols__fixup_duplicate(&dso->symbols[map->type]); 781 symbols__fixup_duplicate(&dso->symbols[map->type]);
782 symbols__fixup_end(&dso->symbols[map->type]); 782 symbols__fixup_end(&dso->symbols[map->type]);
783 783
784 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 784 if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
785 dso->symtab_type = SYMTAB__GUEST_KALLSYMS; 785 dso->symtab_type = SYMTAB__GUEST_KALLSYMS;
786 else 786 else
787 dso->symtab_type = SYMTAB__KALLSYMS; 787 dso->symtab_type = SYMTAB__KALLSYMS;
788 788
789 return dso__split_kallsyms(dso, map, filter); 789 return dso__split_kallsyms(dso, map, filter);
790 } 790 }
791 791
792 static int dso__load_perf_map(struct dso *dso, struct map *map, 792 static int dso__load_perf_map(struct dso *dso, struct map *map,
793 symbol_filter_t filter) 793 symbol_filter_t filter)
794 { 794 {
795 char *line = NULL; 795 char *line = NULL;
796 size_t n; 796 size_t n;
797 FILE *file; 797 FILE *file;
798 int nr_syms = 0; 798 int nr_syms = 0;
799 799
800 file = fopen(dso->long_name, "r"); 800 file = fopen(dso->long_name, "r");
801 if (file == NULL) 801 if (file == NULL)
802 goto out_failure; 802 goto out_failure;
803 803
804 while (!feof(file)) { 804 while (!feof(file)) {
805 u64 start, size; 805 u64 start, size;
806 struct symbol *sym; 806 struct symbol *sym;
807 int line_len, len; 807 int line_len, len;
808 808
809 line_len = getline(&line, &n, file); 809 line_len = getline(&line, &n, file);
810 if (line_len < 0) 810 if (line_len < 0)
811 break; 811 break;
812 812
813 if (!line) 813 if (!line)
814 goto out_failure; 814 goto out_failure;
815 815
816 line[--line_len] = '\0'; /* \n */ 816 line[--line_len] = '\0'; /* \n */
817 817
818 len = hex2u64(line, &start); 818 len = hex2u64(line, &start);
819 819
820 len++; 820 len++;
821 if (len + 2 >= line_len) 821 if (len + 2 >= line_len)
822 continue; 822 continue;
823 823
824 len += hex2u64(line + len, &size); 824 len += hex2u64(line + len, &size);
825 825
826 len++; 826 len++;
827 if (len + 2 >= line_len) 827 if (len + 2 >= line_len)
828 continue; 828 continue;
829 829
830 sym = symbol__new(start, size, STB_GLOBAL, line + len); 830 sym = symbol__new(start, size, STB_GLOBAL, line + len);
831 831
832 if (sym == NULL) 832 if (sym == NULL)
833 goto out_delete_line; 833 goto out_delete_line;
834 834
835 if (filter && filter(map, sym)) 835 if (filter && filter(map, sym))
836 symbol__delete(sym); 836 symbol__delete(sym);
837 else { 837 else {
838 symbols__insert(&dso->symbols[map->type], sym); 838 symbols__insert(&dso->symbols[map->type], sym);
839 nr_syms++; 839 nr_syms++;
840 } 840 }
841 } 841 }
842 842
843 free(line); 843 free(line);
844 fclose(file); 844 fclose(file);
845 845
846 return nr_syms; 846 return nr_syms;
847 847
848 out_delete_line: 848 out_delete_line:
849 free(line); 849 free(line);
850 out_failure: 850 out_failure:
851 return -1; 851 return -1;
852 } 852 }
853 853
854 /** 854 /**
855 * elf_symtab__for_each_symbol - iterate thru all the symbols 855 * elf_symtab__for_each_symbol - iterate thru all the symbols
856 * 856 *
857 * @syms: struct elf_symtab instance to iterate 857 * @syms: struct elf_symtab instance to iterate
858 * @idx: uint32_t idx 858 * @idx: uint32_t idx
859 * @sym: GElf_Sym iterator 859 * @sym: GElf_Sym iterator
860 */ 860 */
861 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \ 861 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
862 for (idx = 0, gelf_getsym(syms, idx, &sym);\ 862 for (idx = 0, gelf_getsym(syms, idx, &sym);\
863 idx < nr_syms; \ 863 idx < nr_syms; \
864 idx++, gelf_getsym(syms, idx, &sym)) 864 idx++, gelf_getsym(syms, idx, &sym))
865 865
866 static inline uint8_t elf_sym__type(const GElf_Sym *sym) 866 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
867 { 867 {
868 return GELF_ST_TYPE(sym->st_info); 868 return GELF_ST_TYPE(sym->st_info);
869 } 869 }
870 870
871 static inline int elf_sym__is_function(const GElf_Sym *sym) 871 static inline int elf_sym__is_function(const GElf_Sym *sym)
872 { 872 {
873 return elf_sym__type(sym) == STT_FUNC && 873 return elf_sym__type(sym) == STT_FUNC &&
874 sym->st_name != 0 && 874 sym->st_name != 0 &&
875 sym->st_shndx != SHN_UNDEF; 875 sym->st_shndx != SHN_UNDEF;
876 } 876 }
877 877
878 static inline bool elf_sym__is_object(const GElf_Sym *sym) 878 static inline bool elf_sym__is_object(const GElf_Sym *sym)
879 { 879 {
880 return elf_sym__type(sym) == STT_OBJECT && 880 return elf_sym__type(sym) == STT_OBJECT &&
881 sym->st_name != 0 && 881 sym->st_name != 0 &&
882 sym->st_shndx != SHN_UNDEF; 882 sym->st_shndx != SHN_UNDEF;
883 } 883 }
884 884
885 static inline int elf_sym__is_label(const GElf_Sym *sym) 885 static inline int elf_sym__is_label(const GElf_Sym *sym)
886 { 886 {
887 return elf_sym__type(sym) == STT_NOTYPE && 887 return elf_sym__type(sym) == STT_NOTYPE &&
888 sym->st_name != 0 && 888 sym->st_name != 0 &&
889 sym->st_shndx != SHN_UNDEF && 889 sym->st_shndx != SHN_UNDEF &&
890 sym->st_shndx != SHN_ABS; 890 sym->st_shndx != SHN_ABS;
891 } 891 }
892 892
893 static inline const char *elf_sec__name(const GElf_Shdr *shdr, 893 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
894 const Elf_Data *secstrs) 894 const Elf_Data *secstrs)
895 { 895 {
896 return secstrs->d_buf + shdr->sh_name; 896 return secstrs->d_buf + shdr->sh_name;
897 } 897 }
898 898
899 static inline int elf_sec__is_text(const GElf_Shdr *shdr, 899 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
900 const Elf_Data *secstrs) 900 const Elf_Data *secstrs)
901 { 901 {
902 return strstr(elf_sec__name(shdr, secstrs), "text") != NULL; 902 return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
903 } 903 }
904 904
905 static inline bool elf_sec__is_data(const GElf_Shdr *shdr, 905 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
906 const Elf_Data *secstrs) 906 const Elf_Data *secstrs)
907 { 907 {
908 return strstr(elf_sec__name(shdr, secstrs), "data") != NULL; 908 return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
909 } 909 }
910 910
911 static inline const char *elf_sym__name(const GElf_Sym *sym, 911 static inline const char *elf_sym__name(const GElf_Sym *sym,
912 const Elf_Data *symstrs) 912 const Elf_Data *symstrs)
913 { 913 {
914 return symstrs->d_buf + sym->st_name; 914 return symstrs->d_buf + sym->st_name;
915 } 915 }
916 916
917 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep, 917 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
918 GElf_Shdr *shp, const char *name, 918 GElf_Shdr *shp, const char *name,
919 size_t *idx) 919 size_t *idx)
920 { 920 {
921 Elf_Scn *sec = NULL; 921 Elf_Scn *sec = NULL;
922 size_t cnt = 1; 922 size_t cnt = 1;
923 923
924 while ((sec = elf_nextscn(elf, sec)) != NULL) { 924 while ((sec = elf_nextscn(elf, sec)) != NULL) {
925 char *str; 925 char *str;
926 926
927 gelf_getshdr(sec, shp); 927 gelf_getshdr(sec, shp);
928 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name); 928 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
929 if (!strcmp(name, str)) { 929 if (!strcmp(name, str)) {
930 if (idx) 930 if (idx)
931 *idx = cnt; 931 *idx = cnt;
932 break; 932 break;
933 } 933 }
934 ++cnt; 934 ++cnt;
935 } 935 }
936 936
937 return sec; 937 return sec;
938 } 938 }
939 939
940 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \ 940 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
941 for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \ 941 for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
942 idx < nr_entries; \ 942 idx < nr_entries; \
943 ++idx, pos = gelf_getrel(reldata, idx, &pos_mem)) 943 ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
944 944
945 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \ 945 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
946 for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \ 946 for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
947 idx < nr_entries; \ 947 idx < nr_entries; \
948 ++idx, pos = gelf_getrela(reldata, idx, &pos_mem)) 948 ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
949 949
950 /* 950 /*
951 * We need to check if we have a .dynsym, so that we can handle the 951 * We need to check if we have a .dynsym, so that we can handle the
952 * .plt, synthesizing its symbols, that aren't on the symtabs (be it 952 * .plt, synthesizing its symbols, that aren't on the symtabs (be it
953 * .dynsym or .symtab). 953 * .dynsym or .symtab).
954 * And always look at the original dso, not at debuginfo packages, that 954 * And always look at the original dso, not at debuginfo packages, that
955 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS). 955 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
956 */ 956 */
957 static int dso__synthesize_plt_symbols(struct dso *dso, struct map *map, 957 static int dso__synthesize_plt_symbols(struct dso *dso, struct map *map,
958 symbol_filter_t filter) 958 symbol_filter_t filter)
959 { 959 {
960 uint32_t nr_rel_entries, idx; 960 uint32_t nr_rel_entries, idx;
961 GElf_Sym sym; 961 GElf_Sym sym;
962 u64 plt_offset; 962 u64 plt_offset;
963 GElf_Shdr shdr_plt; 963 GElf_Shdr shdr_plt;
964 struct symbol *f; 964 struct symbol *f;
965 GElf_Shdr shdr_rel_plt, shdr_dynsym; 965 GElf_Shdr shdr_rel_plt, shdr_dynsym;
966 Elf_Data *reldata, *syms, *symstrs; 966 Elf_Data *reldata, *syms, *symstrs;
967 Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym; 967 Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
968 size_t dynsym_idx; 968 size_t dynsym_idx;
969 GElf_Ehdr ehdr; 969 GElf_Ehdr ehdr;
970 char sympltname[1024]; 970 char sympltname[1024];
971 Elf *elf; 971 Elf *elf;
972 int nr = 0, symidx, fd, err = 0; 972 int nr = 0, symidx, fd, err = 0;
973 char name[PATH_MAX]; 973 char name[PATH_MAX];
974 974
975 snprintf(name, sizeof(name), "%s%s", 975 snprintf(name, sizeof(name), "%s%s",
976 symbol_conf.symfs, dso->long_name); 976 symbol_conf.symfs, dso->long_name);
977 fd = open(name, O_RDONLY); 977 fd = open(name, O_RDONLY);
978 if (fd < 0) 978 if (fd < 0)
979 goto out; 979 goto out;
980 980
981 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 981 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
982 if (elf == NULL) 982 if (elf == NULL)
983 goto out_close; 983 goto out_close;
984 984
985 if (gelf_getehdr(elf, &ehdr) == NULL) 985 if (gelf_getehdr(elf, &ehdr) == NULL)
986 goto out_elf_end; 986 goto out_elf_end;
987 987
988 scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym, 988 scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
989 ".dynsym", &dynsym_idx); 989 ".dynsym", &dynsym_idx);
990 if (scn_dynsym == NULL) 990 if (scn_dynsym == NULL)
991 goto out_elf_end; 991 goto out_elf_end;
992 992
993 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt, 993 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
994 ".rela.plt", NULL); 994 ".rela.plt", NULL);
995 if (scn_plt_rel == NULL) { 995 if (scn_plt_rel == NULL) {
996 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt, 996 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
997 ".rel.plt", NULL); 997 ".rel.plt", NULL);
998 if (scn_plt_rel == NULL) 998 if (scn_plt_rel == NULL)
999 goto out_elf_end; 999 goto out_elf_end;
1000 } 1000 }
1001 1001
1002 err = -1; 1002 err = -1;
1003 1003
1004 if (shdr_rel_plt.sh_link != dynsym_idx) 1004 if (shdr_rel_plt.sh_link != dynsym_idx)
1005 goto out_elf_end; 1005 goto out_elf_end;
1006 1006
1007 if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL) 1007 if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
1008 goto out_elf_end; 1008 goto out_elf_end;
1009 1009
1010 /* 1010 /*
1011 * Fetch the relocation section to find the idxes to the GOT 1011 * Fetch the relocation section to find the idxes to the GOT
1012 * and the symbols in the .dynsym they refer to. 1012 * and the symbols in the .dynsym they refer to.
1013 */ 1013 */
1014 reldata = elf_getdata(scn_plt_rel, NULL); 1014 reldata = elf_getdata(scn_plt_rel, NULL);
1015 if (reldata == NULL) 1015 if (reldata == NULL)
1016 goto out_elf_end; 1016 goto out_elf_end;
1017 1017
1018 syms = elf_getdata(scn_dynsym, NULL); 1018 syms = elf_getdata(scn_dynsym, NULL);
1019 if (syms == NULL) 1019 if (syms == NULL)
1020 goto out_elf_end; 1020 goto out_elf_end;
1021 1021
1022 scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link); 1022 scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
1023 if (scn_symstrs == NULL) 1023 if (scn_symstrs == NULL)
1024 goto out_elf_end; 1024 goto out_elf_end;
1025 1025
1026 symstrs = elf_getdata(scn_symstrs, NULL); 1026 symstrs = elf_getdata(scn_symstrs, NULL);
1027 if (symstrs == NULL) 1027 if (symstrs == NULL)
1028 goto out_elf_end; 1028 goto out_elf_end;
1029 1029
1030 nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize; 1030 nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
1031 plt_offset = shdr_plt.sh_offset; 1031 plt_offset = shdr_plt.sh_offset;
1032 1032
1033 if (shdr_rel_plt.sh_type == SHT_RELA) { 1033 if (shdr_rel_plt.sh_type == SHT_RELA) {
1034 GElf_Rela pos_mem, *pos; 1034 GElf_Rela pos_mem, *pos;
1035 1035
1036 elf_section__for_each_rela(reldata, pos, pos_mem, idx, 1036 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
1037 nr_rel_entries) { 1037 nr_rel_entries) {
1038 symidx = GELF_R_SYM(pos->r_info); 1038 symidx = GELF_R_SYM(pos->r_info);
1039 plt_offset += shdr_plt.sh_entsize; 1039 plt_offset += shdr_plt.sh_entsize;
1040 gelf_getsym(syms, symidx, &sym); 1040 gelf_getsym(syms, symidx, &sym);
1041 snprintf(sympltname, sizeof(sympltname), 1041 snprintf(sympltname, sizeof(sympltname),
1042 "%s@plt", elf_sym__name(&sym, symstrs)); 1042 "%s@plt", elf_sym__name(&sym, symstrs));
1043 1043
1044 f = symbol__new(plt_offset, shdr_plt.sh_entsize, 1044 f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1045 STB_GLOBAL, sympltname); 1045 STB_GLOBAL, sympltname);
1046 if (!f) 1046 if (!f)
1047 goto out_elf_end; 1047 goto out_elf_end;
1048 1048
1049 if (filter && filter(map, f)) 1049 if (filter && filter(map, f))
1050 symbol__delete(f); 1050 symbol__delete(f);
1051 else { 1051 else {
1052 symbols__insert(&dso->symbols[map->type], f); 1052 symbols__insert(&dso->symbols[map->type], f);
1053 ++nr; 1053 ++nr;
1054 } 1054 }
1055 } 1055 }
1056 } else if (shdr_rel_plt.sh_type == SHT_REL) { 1056 } else if (shdr_rel_plt.sh_type == SHT_REL) {
1057 GElf_Rel pos_mem, *pos; 1057 GElf_Rel pos_mem, *pos;
1058 elf_section__for_each_rel(reldata, pos, pos_mem, idx, 1058 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
1059 nr_rel_entries) { 1059 nr_rel_entries) {
1060 symidx = GELF_R_SYM(pos->r_info); 1060 symidx = GELF_R_SYM(pos->r_info);
1061 plt_offset += shdr_plt.sh_entsize; 1061 plt_offset += shdr_plt.sh_entsize;
1062 gelf_getsym(syms, symidx, &sym); 1062 gelf_getsym(syms, symidx, &sym);
1063 snprintf(sympltname, sizeof(sympltname), 1063 snprintf(sympltname, sizeof(sympltname),
1064 "%s@plt", elf_sym__name(&sym, symstrs)); 1064 "%s@plt", elf_sym__name(&sym, symstrs));
1065 1065
1066 f = symbol__new(plt_offset, shdr_plt.sh_entsize, 1066 f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1067 STB_GLOBAL, sympltname); 1067 STB_GLOBAL, sympltname);
1068 if (!f) 1068 if (!f)
1069 goto out_elf_end; 1069 goto out_elf_end;
1070 1070
1071 if (filter && filter(map, f)) 1071 if (filter && filter(map, f))
1072 symbol__delete(f); 1072 symbol__delete(f);
1073 else { 1073 else {
1074 symbols__insert(&dso->symbols[map->type], f); 1074 symbols__insert(&dso->symbols[map->type], f);
1075 ++nr; 1075 ++nr;
1076 } 1076 }
1077 } 1077 }
1078 } 1078 }
1079 1079
1080 err = 0; 1080 err = 0;
1081 out_elf_end: 1081 out_elf_end:
1082 elf_end(elf); 1082 elf_end(elf);
1083 out_close: 1083 out_close:
1084 close(fd); 1084 close(fd);
1085 1085
1086 if (err == 0) 1086 if (err == 0)
1087 return nr; 1087 return nr;
1088 out: 1088 out:
1089 pr_debug("%s: problems reading %s PLT info.\n", 1089 pr_debug("%s: problems reading %s PLT info.\n",
1090 __func__, dso->long_name); 1090 __func__, dso->long_name);
1091 return 0; 1091 return 0;
1092 } 1092 }
1093 1093
1094 static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type) 1094 static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
1095 { 1095 {
1096 switch (type) { 1096 switch (type) {
1097 case MAP__FUNCTION: 1097 case MAP__FUNCTION:
1098 return elf_sym__is_function(sym); 1098 return elf_sym__is_function(sym);
1099 case MAP__VARIABLE: 1099 case MAP__VARIABLE:
1100 return elf_sym__is_object(sym); 1100 return elf_sym__is_object(sym);
1101 default: 1101 default:
1102 return false; 1102 return false;
1103 } 1103 }
1104 } 1104 }
1105 1105
1106 static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs, 1106 static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
1107 enum map_type type) 1107 enum map_type type)
1108 { 1108 {
1109 switch (type) { 1109 switch (type) {
1110 case MAP__FUNCTION: 1110 case MAP__FUNCTION:
1111 return elf_sec__is_text(shdr, secstrs); 1111 return elf_sec__is_text(shdr, secstrs);
1112 case MAP__VARIABLE: 1112 case MAP__VARIABLE:
1113 return elf_sec__is_data(shdr, secstrs); 1113 return elf_sec__is_data(shdr, secstrs);
1114 default: 1114 default:
1115 return false; 1115 return false;
1116 } 1116 }
1117 } 1117 }
1118 1118
1119 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr) 1119 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
1120 { 1120 {
1121 Elf_Scn *sec = NULL; 1121 Elf_Scn *sec = NULL;
1122 GElf_Shdr shdr; 1122 GElf_Shdr shdr;
1123 size_t cnt = 1; 1123 size_t cnt = 1;
1124 1124
1125 while ((sec = elf_nextscn(elf, sec)) != NULL) { 1125 while ((sec = elf_nextscn(elf, sec)) != NULL) {
1126 gelf_getshdr(sec, &shdr); 1126 gelf_getshdr(sec, &shdr);
1127 1127
1128 if ((addr >= shdr.sh_addr) && 1128 if ((addr >= shdr.sh_addr) &&
1129 (addr < (shdr.sh_addr + shdr.sh_size))) 1129 (addr < (shdr.sh_addr + shdr.sh_size)))
1130 return cnt; 1130 return cnt;
1131 1131
1132 ++cnt; 1132 ++cnt;
1133 } 1133 }
1134 1134
1135 return -1; 1135 return -1;
1136 } 1136 }
1137 1137
1138 static int dso__load_sym(struct dso *dso, struct map *map, const char *name, 1138 static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
1139 int fd, symbol_filter_t filter, int kmodule, 1139 int fd, symbol_filter_t filter, int kmodule,
1140 int want_symtab) 1140 int want_symtab)
1141 { 1141 {
1142 struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL; 1142 struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
1143 struct map *curr_map = map; 1143 struct map *curr_map = map;
1144 struct dso *curr_dso = dso; 1144 struct dso *curr_dso = dso;
1145 Elf_Data *symstrs, *secstrs; 1145 Elf_Data *symstrs, *secstrs;
1146 uint32_t nr_syms; 1146 uint32_t nr_syms;
1147 int err = -1; 1147 int err = -1;
1148 uint32_t idx; 1148 uint32_t idx;
1149 GElf_Ehdr ehdr; 1149 GElf_Ehdr ehdr;
1150 GElf_Shdr shdr, opdshdr; 1150 GElf_Shdr shdr, opdshdr;
1151 Elf_Data *syms, *opddata = NULL; 1151 Elf_Data *syms, *opddata = NULL;
1152 GElf_Sym sym; 1152 GElf_Sym sym;
1153 Elf_Scn *sec, *sec_strndx, *opdsec; 1153 Elf_Scn *sec, *sec_strndx, *opdsec;
1154 Elf *elf; 1154 Elf *elf;
1155 int nr = 0; 1155 int nr = 0;
1156 size_t opdidx = 0; 1156 size_t opdidx = 0;
1157 1157
1158 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 1158 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1159 if (elf == NULL) { 1159 if (elf == NULL) {
1160 pr_debug("%s: cannot read %s ELF file.\n", __func__, name); 1160 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1161 goto out_close; 1161 goto out_close;
1162 } 1162 }
1163 1163
1164 if (gelf_getehdr(elf, &ehdr) == NULL) { 1164 if (gelf_getehdr(elf, &ehdr) == NULL) {
1165 pr_debug("%s: cannot get elf header.\n", __func__); 1165 pr_debug("%s: cannot get elf header.\n", __func__);
1166 goto out_elf_end; 1166 goto out_elf_end;
1167 } 1167 }
1168 1168
1169 /* Always reject images with a mismatched build-id: */ 1169 /* Always reject images with a mismatched build-id: */
1170 if (dso->has_build_id) { 1170 if (dso->has_build_id) {
1171 u8 build_id[BUILD_ID_SIZE]; 1171 u8 build_id[BUILD_ID_SIZE];
1172 1172
1173 if (elf_read_build_id(elf, build_id, 1173 if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
1174 BUILD_ID_SIZE) != BUILD_ID_SIZE)
1175 goto out_elf_end; 1174 goto out_elf_end;
1176 1175
1177 if (!dso__build_id_equal(dso, build_id)) 1176 if (!dso__build_id_equal(dso, build_id))
1178 goto out_elf_end; 1177 goto out_elf_end;
1179 } 1178 }
1180 1179
1181 sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL); 1180 sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
1182 if (sec == NULL) { 1181 if (sec == NULL) {
1183 if (want_symtab) 1182 if (want_symtab)
1184 goto out_elf_end; 1183 goto out_elf_end;
1185 1184
1186 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL); 1185 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
1187 if (sec == NULL) 1186 if (sec == NULL)
1188 goto out_elf_end; 1187 goto out_elf_end;
1189 } 1188 }
1190 1189
1191 opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx); 1190 opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
1192 if (opdshdr.sh_type != SHT_PROGBITS) 1191 if (opdshdr.sh_type != SHT_PROGBITS)
1193 opdsec = NULL; 1192 opdsec = NULL;
1194 if (opdsec) 1193 if (opdsec)
1195 opddata = elf_rawdata(opdsec, NULL); 1194 opddata = elf_rawdata(opdsec, NULL);
1196 1195
1197 syms = elf_getdata(sec, NULL); 1196 syms = elf_getdata(sec, NULL);
1198 if (syms == NULL) 1197 if (syms == NULL)
1199 goto out_elf_end; 1198 goto out_elf_end;
1200 1199
1201 sec = elf_getscn(elf, shdr.sh_link); 1200 sec = elf_getscn(elf, shdr.sh_link);
1202 if (sec == NULL) 1201 if (sec == NULL)
1203 goto out_elf_end; 1202 goto out_elf_end;
1204 1203
1205 symstrs = elf_getdata(sec, NULL); 1204 symstrs = elf_getdata(sec, NULL);
1206 if (symstrs == NULL) 1205 if (symstrs == NULL)
1207 goto out_elf_end; 1206 goto out_elf_end;
1208 1207
1209 sec_strndx = elf_getscn(elf, ehdr.e_shstrndx); 1208 sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1210 if (sec_strndx == NULL) 1209 if (sec_strndx == NULL)
1211 goto out_elf_end; 1210 goto out_elf_end;
1212 1211
1213 secstrs = elf_getdata(sec_strndx, NULL); 1212 secstrs = elf_getdata(sec_strndx, NULL);
1214 if (secstrs == NULL) 1213 if (secstrs == NULL)
1215 goto out_elf_end; 1214 goto out_elf_end;
1216 1215
1217 nr_syms = shdr.sh_size / shdr.sh_entsize; 1216 nr_syms = shdr.sh_size / shdr.sh_entsize;
1218 1217
1219 memset(&sym, 0, sizeof(sym)); 1218 memset(&sym, 0, sizeof(sym));
1220 if (dso->kernel == DSO_TYPE_USER) { 1219 if (dso->kernel == DSO_TYPE_USER) {
1221 dso->adjust_symbols = (ehdr.e_type == ET_EXEC || 1220 dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
1222 elf_section_by_name(elf, &ehdr, &shdr, 1221 elf_section_by_name(elf, &ehdr, &shdr,
1223 ".gnu.prelink_undo", 1222 ".gnu.prelink_undo",
1224 NULL) != NULL); 1223 NULL) != NULL);
1225 } else { 1224 } else {
1226 dso->adjust_symbols = 0; 1225 dso->adjust_symbols = 0;
1227 } 1226 }
1228 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) { 1227 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1229 struct symbol *f; 1228 struct symbol *f;
1230 const char *elf_name = elf_sym__name(&sym, symstrs); 1229 const char *elf_name = elf_sym__name(&sym, symstrs);
1231 char *demangled = NULL; 1230 char *demangled = NULL;
1232 int is_label = elf_sym__is_label(&sym); 1231 int is_label = elf_sym__is_label(&sym);
1233 const char *section_name; 1232 const char *section_name;
1234 1233
1235 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name && 1234 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1236 strcmp(elf_name, kmap->ref_reloc_sym->name) == 0) 1235 strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
1237 kmap->ref_reloc_sym->unrelocated_addr = sym.st_value; 1236 kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1238 1237
1239 if (!is_label && !elf_sym__is_a(&sym, map->type)) 1238 if (!is_label && !elf_sym__is_a(&sym, map->type))
1240 continue; 1239 continue;
1241 1240
1242 /* Reject ARM ELF "mapping symbols": these aren't unique and 1241 /* Reject ARM ELF "mapping symbols": these aren't unique and
1243 * don't identify functions, so will confuse the profile 1242 * don't identify functions, so will confuse the profile
1244 * output: */ 1243 * output: */
1245 if (ehdr.e_machine == EM_ARM) { 1244 if (ehdr.e_machine == EM_ARM) {
1246 if (!strcmp(elf_name, "$a") || 1245 if (!strcmp(elf_name, "$a") ||
1247 !strcmp(elf_name, "$d") || 1246 !strcmp(elf_name, "$d") ||
1248 !strcmp(elf_name, "$t")) 1247 !strcmp(elf_name, "$t"))
1249 continue; 1248 continue;
1250 } 1249 }
1251 1250
1252 if (opdsec && sym.st_shndx == opdidx) { 1251 if (opdsec && sym.st_shndx == opdidx) {
1253 u32 offset = sym.st_value - opdshdr.sh_addr; 1252 u32 offset = sym.st_value - opdshdr.sh_addr;
1254 u64 *opd = opddata->d_buf + offset; 1253 u64 *opd = opddata->d_buf + offset;
1255 sym.st_value = *opd; 1254 sym.st_value = *opd;
1256 sym.st_shndx = elf_addr_to_index(elf, sym.st_value); 1255 sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
1257 } 1256 }
1258 1257
1259 sec = elf_getscn(elf, sym.st_shndx); 1258 sec = elf_getscn(elf, sym.st_shndx);
1260 if (!sec) 1259 if (!sec)
1261 goto out_elf_end; 1260 goto out_elf_end;
1262 1261
1263 gelf_getshdr(sec, &shdr); 1262 gelf_getshdr(sec, &shdr);
1264 1263
1265 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type)) 1264 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1266 continue; 1265 continue;
1267 1266
1268 section_name = elf_sec__name(&shdr, secstrs); 1267 section_name = elf_sec__name(&shdr, secstrs);
1269 1268
1270 /* On ARM, symbols for thumb functions have 1 added to 1269 /* On ARM, symbols for thumb functions have 1 added to
1271 * the symbol address as a flag - remove it */ 1270 * the symbol address as a flag - remove it */
1272 if ((ehdr.e_machine == EM_ARM) && 1271 if ((ehdr.e_machine == EM_ARM) &&
1273 (map->type == MAP__FUNCTION) && 1272 (map->type == MAP__FUNCTION) &&
1274 (sym.st_value & 1)) 1273 (sym.st_value & 1))
1275 --sym.st_value; 1274 --sym.st_value;
1276 1275
1277 if (dso->kernel != DSO_TYPE_USER || kmodule) { 1276 if (dso->kernel != DSO_TYPE_USER || kmodule) {
1278 char dso_name[PATH_MAX]; 1277 char dso_name[PATH_MAX];
1279 1278
1280 if (strcmp(section_name, 1279 if (strcmp(section_name,
1281 (curr_dso->short_name + 1280 (curr_dso->short_name +
1282 dso->short_name_len)) == 0) 1281 dso->short_name_len)) == 0)
1283 goto new_symbol; 1282 goto new_symbol;
1284 1283
1285 if (strcmp(section_name, ".text") == 0) { 1284 if (strcmp(section_name, ".text") == 0) {
1286 curr_map = map; 1285 curr_map = map;
1287 curr_dso = dso; 1286 curr_dso = dso;
1288 goto new_symbol; 1287 goto new_symbol;
1289 } 1288 }
1290 1289
1291 snprintf(dso_name, sizeof(dso_name), 1290 snprintf(dso_name, sizeof(dso_name),
1292 "%s%s", dso->short_name, section_name); 1291 "%s%s", dso->short_name, section_name);
1293 1292
1294 curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name); 1293 curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1295 if (curr_map == NULL) { 1294 if (curr_map == NULL) {
1296 u64 start = sym.st_value; 1295 u64 start = sym.st_value;
1297 1296
1298 if (kmodule) 1297 if (kmodule)
1299 start += map->start + shdr.sh_offset; 1298 start += map->start + shdr.sh_offset;
1300 1299
1301 curr_dso = dso__new(dso_name); 1300 curr_dso = dso__new(dso_name);
1302 if (curr_dso == NULL) 1301 if (curr_dso == NULL)
1303 goto out_elf_end; 1302 goto out_elf_end;
1304 curr_dso->kernel = dso->kernel; 1303 curr_dso->kernel = dso->kernel;
1305 curr_dso->long_name = dso->long_name; 1304 curr_dso->long_name = dso->long_name;
1306 curr_dso->long_name_len = dso->long_name_len; 1305 curr_dso->long_name_len = dso->long_name_len;
1307 curr_map = map__new2(start, curr_dso, 1306 curr_map = map__new2(start, curr_dso,
1308 map->type); 1307 map->type);
1309 if (curr_map == NULL) { 1308 if (curr_map == NULL) {
1310 dso__delete(curr_dso); 1309 dso__delete(curr_dso);
1311 goto out_elf_end; 1310 goto out_elf_end;
1312 } 1311 }
1313 curr_map->map_ip = identity__map_ip; 1312 curr_map->map_ip = identity__map_ip;
1314 curr_map->unmap_ip = identity__map_ip; 1313 curr_map->unmap_ip = identity__map_ip;
1315 curr_dso->symtab_type = dso->symtab_type; 1314 curr_dso->symtab_type = dso->symtab_type;
1316 map_groups__insert(kmap->kmaps, curr_map); 1315 map_groups__insert(kmap->kmaps, curr_map);
1317 dsos__add(&dso->node, curr_dso); 1316 dsos__add(&dso->node, curr_dso);
1318 dso__set_loaded(curr_dso, map->type); 1317 dso__set_loaded(curr_dso, map->type);
1319 } else 1318 } else
1320 curr_dso = curr_map->dso; 1319 curr_dso = curr_map->dso;
1321 1320
1322 goto new_symbol; 1321 goto new_symbol;
1323 } 1322 }
1324 1323
1325 if (curr_dso->adjust_symbols) { 1324 if (curr_dso->adjust_symbols) {
1326 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " " 1325 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1327 "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__, 1326 "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
1328 (u64)sym.st_value, (u64)shdr.sh_addr, 1327 (u64)sym.st_value, (u64)shdr.sh_addr,
1329 (u64)shdr.sh_offset); 1328 (u64)shdr.sh_offset);
1330 sym.st_value -= shdr.sh_addr - shdr.sh_offset; 1329 sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1331 } 1330 }
1332 /* 1331 /*
1333 * We need to figure out if the object was created from C++ sources 1332 * We need to figure out if the object was created from C++ sources
1334 * DWARF DW_compile_unit has this, but we don't always have access 1333 * DWARF DW_compile_unit has this, but we don't always have access
1335 * to it... 1334 * to it...
1336 */ 1335 */
1337 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI); 1336 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1338 if (demangled != NULL) 1337 if (demangled != NULL)
1339 elf_name = demangled; 1338 elf_name = demangled;
1340 new_symbol: 1339 new_symbol:
1341 f = symbol__new(sym.st_value, sym.st_size, 1340 f = symbol__new(sym.st_value, sym.st_size,
1342 GELF_ST_BIND(sym.st_info), elf_name); 1341 GELF_ST_BIND(sym.st_info), elf_name);
1343 free(demangled); 1342 free(demangled);
1344 if (!f) 1343 if (!f)
1345 goto out_elf_end; 1344 goto out_elf_end;
1346 1345
1347 if (filter && filter(curr_map, f)) 1346 if (filter && filter(curr_map, f))
1348 symbol__delete(f); 1347 symbol__delete(f);
1349 else { 1348 else {
1350 symbols__insert(&curr_dso->symbols[curr_map->type], f); 1349 symbols__insert(&curr_dso->symbols[curr_map->type], f);
1351 nr++; 1350 nr++;
1352 } 1351 }
1353 } 1352 }
1354 1353
1355 /* 1354 /*
1356 * For misannotated, zeroed, ASM function sizes. 1355 * For misannotated, zeroed, ASM function sizes.
1357 */ 1356 */
1358 if (nr > 0) { 1357 if (nr > 0) {
1359 symbols__fixup_duplicate(&dso->symbols[map->type]); 1358 symbols__fixup_duplicate(&dso->symbols[map->type]);
1360 symbols__fixup_end(&dso->symbols[map->type]); 1359 symbols__fixup_end(&dso->symbols[map->type]);
1361 if (kmap) { 1360 if (kmap) {
1362 /* 1361 /*
1363 * We need to fixup this here too because we create new 1362 * We need to fixup this here too because we create new
1364 * maps here, for things like vsyscall sections. 1363 * maps here, for things like vsyscall sections.
1365 */ 1364 */
1366 __map_groups__fixup_end(kmap->kmaps, map->type); 1365 __map_groups__fixup_end(kmap->kmaps, map->type);
1367 } 1366 }
1368 } 1367 }
1369 err = nr; 1368 err = nr;
1370 out_elf_end: 1369 out_elf_end:
1371 elf_end(elf); 1370 elf_end(elf);
1372 out_close: 1371 out_close:
1373 return err; 1372 return err;
1374 } 1373 }
1375 1374
1376 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id) 1375 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
1377 { 1376 {
1378 return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0; 1377 return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
1379 } 1378 }
1380 1379
1381 bool __dsos__read_build_ids(struct list_head *head, bool with_hits) 1380 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1382 { 1381 {
1383 bool have_build_id = false; 1382 bool have_build_id = false;
1384 struct dso *pos; 1383 struct dso *pos;
1385 1384
1386 list_for_each_entry(pos, head, node) { 1385 list_for_each_entry(pos, head, node) {
1387 if (with_hits && !pos->hit) 1386 if (with_hits && !pos->hit)
1388 continue; 1387 continue;
1389 if (pos->has_build_id) { 1388 if (pos->has_build_id) {
1390 have_build_id = true; 1389 have_build_id = true;
1391 continue; 1390 continue;
1392 } 1391 }
1393 if (filename__read_build_id(pos->long_name, pos->build_id, 1392 if (filename__read_build_id(pos->long_name, pos->build_id,
1394 sizeof(pos->build_id)) > 0) { 1393 sizeof(pos->build_id)) > 0) {
1395 have_build_id = true; 1394 have_build_id = true;
1396 pos->has_build_id = true; 1395 pos->has_build_id = true;
1397 } 1396 }
1398 } 1397 }
1399 1398
1400 return have_build_id; 1399 return have_build_id;
1401 } 1400 }
1402 1401
1403 /* 1402 /*
1404 * Align offset to 4 bytes as needed for note name and descriptor data. 1403 * Align offset to 4 bytes as needed for note name and descriptor data.
1405 */ 1404 */
1406 #define NOTE_ALIGN(n) (((n) + 3) & -4U) 1405 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1407 1406
1408 static int elf_read_build_id(Elf *elf, void *bf, size_t size) 1407 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
1409 { 1408 {
1410 int err = -1; 1409 int err = -1;
1411 GElf_Ehdr ehdr; 1410 GElf_Ehdr ehdr;
1412 GElf_Shdr shdr; 1411 GElf_Shdr shdr;
1413 Elf_Data *data; 1412 Elf_Data *data;
1414 Elf_Scn *sec; 1413 Elf_Scn *sec;
1415 Elf_Kind ek; 1414 Elf_Kind ek;
1416 void *ptr; 1415 void *ptr;
1417 1416
1418 if (size < BUILD_ID_SIZE) 1417 if (size < BUILD_ID_SIZE)
1419 goto out; 1418 goto out;
1420 1419
1421 ek = elf_kind(elf); 1420 ek = elf_kind(elf);
1422 if (ek != ELF_K_ELF) 1421 if (ek != ELF_K_ELF)
1423 goto out; 1422 goto out;
1424 1423
1425 if (gelf_getehdr(elf, &ehdr) == NULL) { 1424 if (gelf_getehdr(elf, &ehdr) == NULL) {
1426 pr_err("%s: cannot get elf header.\n", __func__); 1425 pr_err("%s: cannot get elf header.\n", __func__);
1427 goto out; 1426 goto out;
1428 } 1427 }
1429 1428
1430 sec = elf_section_by_name(elf, &ehdr, &shdr, 1429 sec = elf_section_by_name(elf, &ehdr, &shdr,
1431 ".note.gnu.build-id", NULL); 1430 ".note.gnu.build-id", NULL);
1432 if (sec == NULL) { 1431 if (sec == NULL) {
1433 sec = elf_section_by_name(elf, &ehdr, &shdr, 1432 sec = elf_section_by_name(elf, &ehdr, &shdr,
1434 ".notes", NULL); 1433 ".notes", NULL);
1435 if (sec == NULL) 1434 if (sec == NULL)
1436 goto out; 1435 goto out;
1437 } 1436 }
1438 1437
1439 data = elf_getdata(sec, NULL); 1438 data = elf_getdata(sec, NULL);
1440 if (data == NULL) 1439 if (data == NULL)
1441 goto out; 1440 goto out;
1442 1441
1443 ptr = data->d_buf; 1442 ptr = data->d_buf;
1444 while (ptr < (data->d_buf + data->d_size)) { 1443 while (ptr < (data->d_buf + data->d_size)) {
1445 GElf_Nhdr *nhdr = ptr; 1444 GElf_Nhdr *nhdr = ptr;
1446 int namesz = NOTE_ALIGN(nhdr->n_namesz), 1445 size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
1447 descsz = NOTE_ALIGN(nhdr->n_descsz); 1446 descsz = NOTE_ALIGN(nhdr->n_descsz);
1448 const char *name; 1447 const char *name;
1449 1448
1450 ptr += sizeof(*nhdr); 1449 ptr += sizeof(*nhdr);
1451 name = ptr; 1450 name = ptr;
1452 ptr += namesz; 1451 ptr += namesz;
1453 if (nhdr->n_type == NT_GNU_BUILD_ID && 1452 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1454 nhdr->n_namesz == sizeof("GNU")) { 1453 nhdr->n_namesz == sizeof("GNU")) {
1455 if (memcmp(name, "GNU", sizeof("GNU")) == 0) { 1454 if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1456 memcpy(bf, ptr, BUILD_ID_SIZE); 1455 size_t sz = min(size, descsz);
1457 err = BUILD_ID_SIZE; 1456 memcpy(bf, ptr, sz);
1457 memset(bf + sz, 0, size - sz);
1458 err = descsz;
1458 break; 1459 break;
1459 } 1460 }
1460 } 1461 }
1461 ptr += descsz; 1462 ptr += descsz;
1462 } 1463 }
1463 1464
1464 out: 1465 out:
1465 return err; 1466 return err;
1466 } 1467 }
1467 1468
1468 int filename__read_build_id(const char *filename, void *bf, size_t size) 1469 int filename__read_build_id(const char *filename, void *bf, size_t size)
1469 { 1470 {
1470 int fd, err = -1; 1471 int fd, err = -1;
1471 Elf *elf; 1472 Elf *elf;
1472 1473
1473 if (size < BUILD_ID_SIZE) 1474 if (size < BUILD_ID_SIZE)
1474 goto out; 1475 goto out;
1475 1476
1476 fd = open(filename, O_RDONLY); 1477 fd = open(filename, O_RDONLY);
1477 if (fd < 0) 1478 if (fd < 0)
1478 goto out; 1479 goto out;
1479 1480
1480 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 1481 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1481 if (elf == NULL) { 1482 if (elf == NULL) {
1482 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename); 1483 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1483 goto out_close; 1484 goto out_close;
1484 } 1485 }
1485 1486
1486 err = elf_read_build_id(elf, bf, size); 1487 err = elf_read_build_id(elf, bf, size);
1487 1488
1488 elf_end(elf); 1489 elf_end(elf);
1489 out_close: 1490 out_close:
1490 close(fd); 1491 close(fd);
1491 out: 1492 out:
1492 return err; 1493 return err;
1493 } 1494 }
1494 1495
1495 int sysfs__read_build_id(const char *filename, void *build_id, size_t size) 1496 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1496 { 1497 {
1497 int fd, err = -1; 1498 int fd, err = -1;
1498 1499
1499 if (size < BUILD_ID_SIZE) 1500 if (size < BUILD_ID_SIZE)
1500 goto out; 1501 goto out;
1501 1502
1502 fd = open(filename, O_RDONLY); 1503 fd = open(filename, O_RDONLY);
1503 if (fd < 0) 1504 if (fd < 0)
1504 goto out; 1505 goto out;
1505 1506
1506 while (1) { 1507 while (1) {
1507 char bf[BUFSIZ]; 1508 char bf[BUFSIZ];
1508 GElf_Nhdr nhdr; 1509 GElf_Nhdr nhdr;
1509 int namesz, descsz; 1510 size_t namesz, descsz;
1510 1511
1511 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr)) 1512 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1512 break; 1513 break;
1513 1514
1514 namesz = NOTE_ALIGN(nhdr.n_namesz); 1515 namesz = NOTE_ALIGN(nhdr.n_namesz);
1515 descsz = NOTE_ALIGN(nhdr.n_descsz); 1516 descsz = NOTE_ALIGN(nhdr.n_descsz);
1516 if (nhdr.n_type == NT_GNU_BUILD_ID && 1517 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1517 nhdr.n_namesz == sizeof("GNU")) { 1518 nhdr.n_namesz == sizeof("GNU")) {
1518 if (read(fd, bf, namesz) != namesz) 1519 if (read(fd, bf, namesz) != (ssize_t)namesz)
1519 break; 1520 break;
1520 if (memcmp(bf, "GNU", sizeof("GNU")) == 0) { 1521 if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1521 if (read(fd, build_id, 1522 size_t sz = min(descsz, size);
1522 BUILD_ID_SIZE) == BUILD_ID_SIZE) { 1523 if (read(fd, build_id, sz) == (ssize_t)sz) {
1524 memset(build_id + sz, 0, size - sz);
1523 err = 0; 1525 err = 0;
1524 break; 1526 break;
1525 } 1527 }
1526 } else if (read(fd, bf, descsz) != descsz) 1528 } else if (read(fd, bf, descsz) != (ssize_t)descsz)
1527 break; 1529 break;
1528 } else { 1530 } else {
1529 int n = namesz + descsz; 1531 int n = namesz + descsz;
1530 if (read(fd, bf, n) != n) 1532 if (read(fd, bf, n) != n)
1531 break; 1533 break;
1532 } 1534 }
1533 } 1535 }
1534 close(fd); 1536 close(fd);
1535 out: 1537 out:
1536 return err; 1538 return err;
1537 } 1539 }
1538 1540
1539 char dso__symtab_origin(const struct dso *dso) 1541 char dso__symtab_origin(const struct dso *dso)
1540 { 1542 {
1541 static const char origin[] = { 1543 static const char origin[] = {
1542 [SYMTAB__KALLSYMS] = 'k', 1544 [SYMTAB__KALLSYMS] = 'k',
1543 [SYMTAB__JAVA_JIT] = 'j', 1545 [SYMTAB__JAVA_JIT] = 'j',
1544 [SYMTAB__BUILD_ID_CACHE] = 'B', 1546 [SYMTAB__BUILD_ID_CACHE] = 'B',
1545 [SYMTAB__FEDORA_DEBUGINFO] = 'f', 1547 [SYMTAB__FEDORA_DEBUGINFO] = 'f',
1546 [SYMTAB__UBUNTU_DEBUGINFO] = 'u', 1548 [SYMTAB__UBUNTU_DEBUGINFO] = 'u',
1547 [SYMTAB__BUILDID_DEBUGINFO] = 'b', 1549 [SYMTAB__BUILDID_DEBUGINFO] = 'b',
1548 [SYMTAB__SYSTEM_PATH_DSO] = 'd', 1550 [SYMTAB__SYSTEM_PATH_DSO] = 'd',
1549 [SYMTAB__SYSTEM_PATH_KMODULE] = 'K', 1551 [SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
1550 [SYMTAB__GUEST_KALLSYMS] = 'g', 1552 [SYMTAB__GUEST_KALLSYMS] = 'g',
1551 [SYMTAB__GUEST_KMODULE] = 'G', 1553 [SYMTAB__GUEST_KMODULE] = 'G',
1552 }; 1554 };
1553 1555
1554 if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND) 1556 if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
1555 return '!'; 1557 return '!';
1556 return origin[dso->symtab_type]; 1558 return origin[dso->symtab_type];
1557 } 1559 }
1558 1560
1559 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter) 1561 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1560 { 1562 {
1561 int size = PATH_MAX; 1563 int size = PATH_MAX;
1562 char *name; 1564 char *name;
1563 int ret = -1; 1565 int ret = -1;
1564 int fd; 1566 int fd;
1565 struct machine *machine; 1567 struct machine *machine;
1566 const char *root_dir; 1568 const char *root_dir;
1567 int want_symtab; 1569 int want_symtab;
1568 1570
1569 dso__set_loaded(dso, map->type); 1571 dso__set_loaded(dso, map->type);
1570 1572
1571 if (dso->kernel == DSO_TYPE_KERNEL) 1573 if (dso->kernel == DSO_TYPE_KERNEL)
1572 return dso__load_kernel_sym(dso, map, filter); 1574 return dso__load_kernel_sym(dso, map, filter);
1573 else if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1575 else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1574 return dso__load_guest_kernel_sym(dso, map, filter); 1576 return dso__load_guest_kernel_sym(dso, map, filter);
1575 1577
1576 if (map->groups && map->groups->machine) 1578 if (map->groups && map->groups->machine)
1577 machine = map->groups->machine; 1579 machine = map->groups->machine;
1578 else 1580 else
1579 machine = NULL; 1581 machine = NULL;
1580 1582
1581 name = malloc(size); 1583 name = malloc(size);
1582 if (!name) 1584 if (!name)
1583 return -1; 1585 return -1;
1584 1586
1585 dso->adjust_symbols = 0; 1587 dso->adjust_symbols = 0;
1586 1588
1587 if (strncmp(dso->name, "/tmp/perf-", 10) == 0) { 1589 if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1588 struct stat st; 1590 struct stat st;
1589 1591
1590 if (lstat(dso->name, &st) < 0) 1592 if (lstat(dso->name, &st) < 0)
1591 return -1; 1593 return -1;
1592 1594
1593 if (st.st_uid && (st.st_uid != geteuid())) { 1595 if (st.st_uid && (st.st_uid != geteuid())) {
1594 pr_warning("File %s not owned by current user or root, " 1596 pr_warning("File %s not owned by current user or root, "
1595 "ignoring it.\n", dso->name); 1597 "ignoring it.\n", dso->name);
1596 return -1; 1598 return -1;
1597 } 1599 }
1598 1600
1599 ret = dso__load_perf_map(dso, map, filter); 1601 ret = dso__load_perf_map(dso, map, filter);
1600 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT : 1602 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
1601 SYMTAB__NOT_FOUND; 1603 SYMTAB__NOT_FOUND;
1602 return ret; 1604 return ret;
1603 } 1605 }
1604 1606
1605 /* Iterate over candidate debug images. 1607 /* Iterate over candidate debug images.
1606 * On the first pass, only load images if they have a full symtab. 1608 * On the first pass, only load images if they have a full symtab.
1607 * Failing that, do a second pass where we accept .dynsym also 1609 * Failing that, do a second pass where we accept .dynsym also
1608 */ 1610 */
1609 want_symtab = 1; 1611 want_symtab = 1;
1610 restart: 1612 restart:
1611 for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE; 1613 for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
1612 dso->symtab_type != SYMTAB__NOT_FOUND; 1614 dso->symtab_type != SYMTAB__NOT_FOUND;
1613 dso->symtab_type++) { 1615 dso->symtab_type++) {
1614 switch (dso->symtab_type) { 1616 switch (dso->symtab_type) {
1615 case SYMTAB__BUILD_ID_CACHE: 1617 case SYMTAB__BUILD_ID_CACHE:
1616 /* skip the locally configured cache if a symfs is given */ 1618 /* skip the locally configured cache if a symfs is given */
1617 if (symbol_conf.symfs[0] || 1619 if (symbol_conf.symfs[0] ||
1618 (dso__build_id_filename(dso, name, size) == NULL)) { 1620 (dso__build_id_filename(dso, name, size) == NULL)) {
1619 continue; 1621 continue;
1620 } 1622 }
1621 break; 1623 break;
1622 case SYMTAB__FEDORA_DEBUGINFO: 1624 case SYMTAB__FEDORA_DEBUGINFO:
1623 snprintf(name, size, "%s/usr/lib/debug%s.debug", 1625 snprintf(name, size, "%s/usr/lib/debug%s.debug",
1624 symbol_conf.symfs, dso->long_name); 1626 symbol_conf.symfs, dso->long_name);
1625 break; 1627 break;
1626 case SYMTAB__UBUNTU_DEBUGINFO: 1628 case SYMTAB__UBUNTU_DEBUGINFO:
1627 snprintf(name, size, "%s/usr/lib/debug%s", 1629 snprintf(name, size, "%s/usr/lib/debug%s",
1628 symbol_conf.symfs, dso->long_name); 1630 symbol_conf.symfs, dso->long_name);
1629 break; 1631 break;
1630 case SYMTAB__BUILDID_DEBUGINFO: { 1632 case SYMTAB__BUILDID_DEBUGINFO: {
1631 char build_id_hex[BUILD_ID_SIZE * 2 + 1]; 1633 char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1632 1634
1633 if (!dso->has_build_id) 1635 if (!dso->has_build_id)
1634 continue; 1636 continue;
1635 1637
1636 build_id__sprintf(dso->build_id, 1638 build_id__sprintf(dso->build_id,
1637 sizeof(dso->build_id), 1639 sizeof(dso->build_id),
1638 build_id_hex); 1640 build_id_hex);
1639 snprintf(name, size, 1641 snprintf(name, size,
1640 "%s/usr/lib/debug/.build-id/%.2s/%s.debug", 1642 "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
1641 symbol_conf.symfs, build_id_hex, build_id_hex + 2); 1643 symbol_conf.symfs, build_id_hex, build_id_hex + 2);
1642 } 1644 }
1643 break; 1645 break;
1644 case SYMTAB__SYSTEM_PATH_DSO: 1646 case SYMTAB__SYSTEM_PATH_DSO:
1645 snprintf(name, size, "%s%s", 1647 snprintf(name, size, "%s%s",
1646 symbol_conf.symfs, dso->long_name); 1648 symbol_conf.symfs, dso->long_name);
1647 break; 1649 break;
1648 case SYMTAB__GUEST_KMODULE: 1650 case SYMTAB__GUEST_KMODULE:
1649 if (map->groups && machine) 1651 if (map->groups && machine)
1650 root_dir = machine->root_dir; 1652 root_dir = machine->root_dir;
1651 else 1653 else
1652 root_dir = ""; 1654 root_dir = "";
1653 snprintf(name, size, "%s%s%s", symbol_conf.symfs, 1655 snprintf(name, size, "%s%s%s", symbol_conf.symfs,
1654 root_dir, dso->long_name); 1656 root_dir, dso->long_name);
1655 break; 1657 break;
1656 1658
1657 case SYMTAB__SYSTEM_PATH_KMODULE: 1659 case SYMTAB__SYSTEM_PATH_KMODULE:
1658 snprintf(name, size, "%s%s", symbol_conf.symfs, 1660 snprintf(name, size, "%s%s", symbol_conf.symfs,
1659 dso->long_name); 1661 dso->long_name);
1660 break; 1662 break;
1661 default:; 1663 default:;
1662 } 1664 }
1663 1665
1664 /* Name is now the name of the next image to try */ 1666 /* Name is now the name of the next image to try */
1665 fd = open(name, O_RDONLY); 1667 fd = open(name, O_RDONLY);
1666 if (fd < 0) 1668 if (fd < 0)
1667 continue; 1669 continue;
1668 1670
1669 ret = dso__load_sym(dso, map, name, fd, filter, 0, 1671 ret = dso__load_sym(dso, map, name, fd, filter, 0,
1670 want_symtab); 1672 want_symtab);
1671 close(fd); 1673 close(fd);
1672 1674
1673 /* 1675 /*
1674 * Some people seem to have debuginfo files _WITHOUT_ debug 1676 * Some people seem to have debuginfo files _WITHOUT_ debug
1675 * info!?!? 1677 * info!?!?
1676 */ 1678 */
1677 if (!ret) 1679 if (!ret)
1678 continue; 1680 continue;
1679 1681
1680 if (ret > 0) { 1682 if (ret > 0) {
1681 int nr_plt = dso__synthesize_plt_symbols(dso, map, 1683 int nr_plt = dso__synthesize_plt_symbols(dso, map,
1682 filter); 1684 filter);
1683 if (nr_plt > 0) 1685 if (nr_plt > 0)
1684 ret += nr_plt; 1686 ret += nr_plt;
1685 break; 1687 break;
1686 } 1688 }
1687 } 1689 }
1688 1690
1689 /* 1691 /*
1690 * If we wanted a full symtab but no image had one, 1692 * If we wanted a full symtab but no image had one,
1691 * relax our requirements and repeat the search. 1693 * relax our requirements and repeat the search.
1692 */ 1694 */
1693 if (ret <= 0 && want_symtab) { 1695 if (ret <= 0 && want_symtab) {
1694 want_symtab = 0; 1696 want_symtab = 0;
1695 goto restart; 1697 goto restart;
1696 } 1698 }
1697 1699
1698 free(name); 1700 free(name);
1699 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL) 1701 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1700 return 0; 1702 return 0;
1701 return ret; 1703 return ret;
1702 } 1704 }
1703 1705
1704 struct map *map_groups__find_by_name(struct map_groups *mg, 1706 struct map *map_groups__find_by_name(struct map_groups *mg,
1705 enum map_type type, const char *name) 1707 enum map_type type, const char *name)
1706 { 1708 {
1707 struct rb_node *nd; 1709 struct rb_node *nd;
1708 1710
1709 for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) { 1711 for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
1710 struct map *map = rb_entry(nd, struct map, rb_node); 1712 struct map *map = rb_entry(nd, struct map, rb_node);
1711 1713
1712 if (map->dso && strcmp(map->dso->short_name, name) == 0) 1714 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1713 return map; 1715 return map;
1714 } 1716 }
1715 1717
1716 return NULL; 1718 return NULL;
1717 } 1719 }
1718 1720
1719 static int dso__kernel_module_get_build_id(struct dso *dso, 1721 static int dso__kernel_module_get_build_id(struct dso *dso,
1720 const char *root_dir) 1722 const char *root_dir)
1721 { 1723 {
1722 char filename[PATH_MAX]; 1724 char filename[PATH_MAX];
1723 /* 1725 /*
1724 * kernel module short names are of the form "[module]" and 1726 * kernel module short names are of the form "[module]" and
1725 * we need just "module" here. 1727 * we need just "module" here.
1726 */ 1728 */
1727 const char *name = dso->short_name + 1; 1729 const char *name = dso->short_name + 1;
1728 1730
1729 snprintf(filename, sizeof(filename), 1731 snprintf(filename, sizeof(filename),
1730 "%s/sys/module/%.*s/notes/.note.gnu.build-id", 1732 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1731 root_dir, (int)strlen(name) - 1, name); 1733 root_dir, (int)strlen(name) - 1, name);
1732 1734
1733 if (sysfs__read_build_id(filename, dso->build_id, 1735 if (sysfs__read_build_id(filename, dso->build_id,
1734 sizeof(dso->build_id)) == 0) 1736 sizeof(dso->build_id)) == 0)
1735 dso->has_build_id = true; 1737 dso->has_build_id = true;
1736 1738
1737 return 0; 1739 return 0;
1738 } 1740 }
1739 1741
1740 static int map_groups__set_modules_path_dir(struct map_groups *mg, 1742 static int map_groups__set_modules_path_dir(struct map_groups *mg,
1741 const char *dir_name) 1743 const char *dir_name)
1742 { 1744 {
1743 struct dirent *dent; 1745 struct dirent *dent;
1744 DIR *dir = opendir(dir_name); 1746 DIR *dir = opendir(dir_name);
1745 int ret = 0; 1747 int ret = 0;
1746 1748
1747 if (!dir) { 1749 if (!dir) {
1748 pr_debug("%s: cannot open %s dir\n", __func__, dir_name); 1750 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1749 return -1; 1751 return -1;
1750 } 1752 }
1751 1753
1752 while ((dent = readdir(dir)) != NULL) { 1754 while ((dent = readdir(dir)) != NULL) {
1753 char path[PATH_MAX]; 1755 char path[PATH_MAX];
1754 struct stat st; 1756 struct stat st;
1755 1757
1756 /*sshfs might return bad dent->d_type, so we have to stat*/ 1758 /*sshfs might return bad dent->d_type, so we have to stat*/
1757 sprintf(path, "%s/%s", dir_name, dent->d_name); 1759 sprintf(path, "%s/%s", dir_name, dent->d_name);
1758 if (stat(path, &st)) 1760 if (stat(path, &st))
1759 continue; 1761 continue;
1760 1762
1761 if (S_ISDIR(st.st_mode)) { 1763 if (S_ISDIR(st.st_mode)) {
1762 if (!strcmp(dent->d_name, ".") || 1764 if (!strcmp(dent->d_name, ".") ||
1763 !strcmp(dent->d_name, "..")) 1765 !strcmp(dent->d_name, ".."))
1764 continue; 1766 continue;
1765 1767
1766 snprintf(path, sizeof(path), "%s/%s", 1768 snprintf(path, sizeof(path), "%s/%s",
1767 dir_name, dent->d_name); 1769 dir_name, dent->d_name);
1768 ret = map_groups__set_modules_path_dir(mg, path); 1770 ret = map_groups__set_modules_path_dir(mg, path);
1769 if (ret < 0) 1771 if (ret < 0)
1770 goto out; 1772 goto out;
1771 } else { 1773 } else {
1772 char *dot = strrchr(dent->d_name, '.'), 1774 char *dot = strrchr(dent->d_name, '.'),
1773 dso_name[PATH_MAX]; 1775 dso_name[PATH_MAX];
1774 struct map *map; 1776 struct map *map;
1775 char *long_name; 1777 char *long_name;
1776 1778
1777 if (dot == NULL || strcmp(dot, ".ko")) 1779 if (dot == NULL || strcmp(dot, ".ko"))
1778 continue; 1780 continue;
1779 snprintf(dso_name, sizeof(dso_name), "[%.*s]", 1781 snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1780 (int)(dot - dent->d_name), dent->d_name); 1782 (int)(dot - dent->d_name), dent->d_name);
1781 1783
1782 strxfrchar(dso_name, '-', '_'); 1784 strxfrchar(dso_name, '-', '_');
1783 map = map_groups__find_by_name(mg, MAP__FUNCTION, 1785 map = map_groups__find_by_name(mg, MAP__FUNCTION,
1784 dso_name); 1786 dso_name);
1785 if (map == NULL) 1787 if (map == NULL)
1786 continue; 1788 continue;
1787 1789
1788 snprintf(path, sizeof(path), "%s/%s", 1790 snprintf(path, sizeof(path), "%s/%s",
1789 dir_name, dent->d_name); 1791 dir_name, dent->d_name);
1790 1792
1791 long_name = strdup(path); 1793 long_name = strdup(path);
1792 if (long_name == NULL) { 1794 if (long_name == NULL) {
1793 ret = -1; 1795 ret = -1;
1794 goto out; 1796 goto out;
1795 } 1797 }
1796 dso__set_long_name(map->dso, long_name); 1798 dso__set_long_name(map->dso, long_name);
1797 map->dso->lname_alloc = 1; 1799 map->dso->lname_alloc = 1;
1798 dso__kernel_module_get_build_id(map->dso, ""); 1800 dso__kernel_module_get_build_id(map->dso, "");
1799 } 1801 }
1800 } 1802 }
1801 1803
1802 out: 1804 out:
1803 closedir(dir); 1805 closedir(dir);
1804 return ret; 1806 return ret;
1805 } 1807 }
1806 1808
1807 static char *get_kernel_version(const char *root_dir) 1809 static char *get_kernel_version(const char *root_dir)
1808 { 1810 {
1809 char version[PATH_MAX]; 1811 char version[PATH_MAX];
1810 FILE *file; 1812 FILE *file;
1811 char *name, *tmp; 1813 char *name, *tmp;
1812 const char *prefix = "Linux version "; 1814 const char *prefix = "Linux version ";
1813 1815
1814 sprintf(version, "%s/proc/version", root_dir); 1816 sprintf(version, "%s/proc/version", root_dir);
1815 file = fopen(version, "r"); 1817 file = fopen(version, "r");
1816 if (!file) 1818 if (!file)
1817 return NULL; 1819 return NULL;
1818 1820
1819 version[0] = '\0'; 1821 version[0] = '\0';
1820 tmp = fgets(version, sizeof(version), file); 1822 tmp = fgets(version, sizeof(version), file);
1821 fclose(file); 1823 fclose(file);
1822 1824
1823 name = strstr(version, prefix); 1825 name = strstr(version, prefix);
1824 if (!name) 1826 if (!name)
1825 return NULL; 1827 return NULL;
1826 name += strlen(prefix); 1828 name += strlen(prefix);
1827 tmp = strchr(name, ' '); 1829 tmp = strchr(name, ' ');
1828 if (tmp) 1830 if (tmp)
1829 *tmp = '\0'; 1831 *tmp = '\0';
1830 1832
1831 return strdup(name); 1833 return strdup(name);
1832 } 1834 }
1833 1835
1834 static int machine__set_modules_path(struct machine *machine) 1836 static int machine__set_modules_path(struct machine *machine)
1835 { 1837 {
1836 char *version; 1838 char *version;
1837 char modules_path[PATH_MAX]; 1839 char modules_path[PATH_MAX];
1838 1840
1839 version = get_kernel_version(machine->root_dir); 1841 version = get_kernel_version(machine->root_dir);
1840 if (!version) 1842 if (!version)
1841 return -1; 1843 return -1;
1842 1844
1843 snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel", 1845 snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1844 machine->root_dir, version); 1846 machine->root_dir, version);
1845 free(version); 1847 free(version);
1846 1848
1847 return map_groups__set_modules_path_dir(&machine->kmaps, modules_path); 1849 return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
1848 } 1850 }
1849 1851
1850 /* 1852 /*
1851 * Constructor variant for modules (where we know from /proc/modules where 1853 * Constructor variant for modules (where we know from /proc/modules where
1852 * they are loaded) and for vmlinux, where only after we load all the 1854 * they are loaded) and for vmlinux, where only after we load all the
1853 * symbols we'll know where it starts and ends. 1855 * symbols we'll know where it starts and ends.
1854 */ 1856 */
1855 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type) 1857 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1856 { 1858 {
1857 struct map *map = calloc(1, (sizeof(*map) + 1859 struct map *map = calloc(1, (sizeof(*map) +
1858 (dso->kernel ? sizeof(struct kmap) : 0))); 1860 (dso->kernel ? sizeof(struct kmap) : 0)));
1859 if (map != NULL) { 1861 if (map != NULL) {
1860 /* 1862 /*
1861 * ->end will be filled after we load all the symbols 1863 * ->end will be filled after we load all the symbols
1862 */ 1864 */
1863 map__init(map, type, start, 0, 0, dso); 1865 map__init(map, type, start, 0, 0, dso);
1864 } 1866 }
1865 1867
1866 return map; 1868 return map;
1867 } 1869 }
1868 1870
1869 struct map *machine__new_module(struct machine *machine, u64 start, 1871 struct map *machine__new_module(struct machine *machine, u64 start,
1870 const char *filename) 1872 const char *filename)
1871 { 1873 {
1872 struct map *map; 1874 struct map *map;
1873 struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename); 1875 struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
1874 1876
1875 if (dso == NULL) 1877 if (dso == NULL)
1876 return NULL; 1878 return NULL;
1877 1879
1878 map = map__new2(start, dso, MAP__FUNCTION); 1880 map = map__new2(start, dso, MAP__FUNCTION);
1879 if (map == NULL) 1881 if (map == NULL)
1880 return NULL; 1882 return NULL;
1881 1883
1882 if (machine__is_host(machine)) 1884 if (machine__is_host(machine))
1883 dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE; 1885 dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE;
1884 else 1886 else
1885 dso->symtab_type = SYMTAB__GUEST_KMODULE; 1887 dso->symtab_type = SYMTAB__GUEST_KMODULE;
1886 map_groups__insert(&machine->kmaps, map); 1888 map_groups__insert(&machine->kmaps, map);
1887 return map; 1889 return map;
1888 } 1890 }
1889 1891
1890 static int machine__create_modules(struct machine *machine) 1892 static int machine__create_modules(struct machine *machine)
1891 { 1893 {
1892 char *line = NULL; 1894 char *line = NULL;
1893 size_t n; 1895 size_t n;
1894 FILE *file; 1896 FILE *file;
1895 struct map *map; 1897 struct map *map;
1896 const char *modules; 1898 const char *modules;
1897 char path[PATH_MAX]; 1899 char path[PATH_MAX];
1898 1900
1899 if (machine__is_default_guest(machine)) 1901 if (machine__is_default_guest(machine))
1900 modules = symbol_conf.default_guest_modules; 1902 modules = symbol_conf.default_guest_modules;
1901 else { 1903 else {
1902 sprintf(path, "%s/proc/modules", machine->root_dir); 1904 sprintf(path, "%s/proc/modules", machine->root_dir);
1903 modules = path; 1905 modules = path;
1904 } 1906 }
1905 1907
1906 if (symbol__restricted_filename(path, "/proc/modules")) 1908 if (symbol__restricted_filename(path, "/proc/modules"))
1907 return -1; 1909 return -1;
1908 1910
1909 file = fopen(modules, "r"); 1911 file = fopen(modules, "r");
1910 if (file == NULL) 1912 if (file == NULL)
1911 return -1; 1913 return -1;
1912 1914
1913 while (!feof(file)) { 1915 while (!feof(file)) {
1914 char name[PATH_MAX]; 1916 char name[PATH_MAX];
1915 u64 start; 1917 u64 start;
1916 char *sep; 1918 char *sep;
1917 int line_len; 1919 int line_len;
1918 1920
1919 line_len = getline(&line, &n, file); 1921 line_len = getline(&line, &n, file);
1920 if (line_len < 0) 1922 if (line_len < 0)
1921 break; 1923 break;
1922 1924
1923 if (!line) 1925 if (!line)
1924 goto out_failure; 1926 goto out_failure;
1925 1927
1926 line[--line_len] = '\0'; /* \n */ 1928 line[--line_len] = '\0'; /* \n */
1927 1929
1928 sep = strrchr(line, 'x'); 1930 sep = strrchr(line, 'x');
1929 if (sep == NULL) 1931 if (sep == NULL)
1930 continue; 1932 continue;
1931 1933
1932 hex2u64(sep + 1, &start); 1934 hex2u64(sep + 1, &start);
1933 1935
1934 sep = strchr(line, ' '); 1936 sep = strchr(line, ' ');
1935 if (sep == NULL) 1937 if (sep == NULL)
1936 continue; 1938 continue;
1937 1939
1938 *sep = '\0'; 1940 *sep = '\0';
1939 1941
1940 snprintf(name, sizeof(name), "[%s]", line); 1942 snprintf(name, sizeof(name), "[%s]", line);
1941 map = machine__new_module(machine, start, name); 1943 map = machine__new_module(machine, start, name);
1942 if (map == NULL) 1944 if (map == NULL)
1943 goto out_delete_line; 1945 goto out_delete_line;
1944 dso__kernel_module_get_build_id(map->dso, machine->root_dir); 1946 dso__kernel_module_get_build_id(map->dso, machine->root_dir);
1945 } 1947 }
1946 1948
1947 free(line); 1949 free(line);
1948 fclose(file); 1950 fclose(file);
1949 1951
1950 return machine__set_modules_path(machine); 1952 return machine__set_modules_path(machine);
1951 1953
1952 out_delete_line: 1954 out_delete_line:
1953 free(line); 1955 free(line);
1954 out_failure: 1956 out_failure:
1955 return -1; 1957 return -1;
1956 } 1958 }
1957 1959
1958 int dso__load_vmlinux(struct dso *dso, struct map *map, 1960 int dso__load_vmlinux(struct dso *dso, struct map *map,
1959 const char *vmlinux, symbol_filter_t filter) 1961 const char *vmlinux, symbol_filter_t filter)
1960 { 1962 {
1961 int err = -1, fd; 1963 int err = -1, fd;
1962 char symfs_vmlinux[PATH_MAX]; 1964 char symfs_vmlinux[PATH_MAX];
1963 1965
1964 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s", 1966 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
1965 symbol_conf.symfs, vmlinux); 1967 symbol_conf.symfs, vmlinux);
1966 fd = open(symfs_vmlinux, O_RDONLY); 1968 fd = open(symfs_vmlinux, O_RDONLY);
1967 if (fd < 0) 1969 if (fd < 0)
1968 return -1; 1970 return -1;
1969 1971
1970 dso__set_long_name(dso, (char *)vmlinux); 1972 dso__set_long_name(dso, (char *)vmlinux);
1971 dso__set_loaded(dso, map->type); 1973 dso__set_loaded(dso, map->type);
1972 err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0); 1974 err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
1973 close(fd); 1975 close(fd);
1974 1976
1975 if (err > 0) 1977 if (err > 0)
1976 pr_debug("Using %s for symbols\n", symfs_vmlinux); 1978 pr_debug("Using %s for symbols\n", symfs_vmlinux);
1977 1979
1978 return err; 1980 return err;
1979 } 1981 }
1980 1982
1981 int dso__load_vmlinux_path(struct dso *dso, struct map *map, 1983 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
1982 symbol_filter_t filter) 1984 symbol_filter_t filter)
1983 { 1985 {
1984 int i, err = 0; 1986 int i, err = 0;
1985 char *filename; 1987 char *filename;
1986 1988
1987 pr_debug("Looking at the vmlinux_path (%d entries long)\n", 1989 pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1988 vmlinux_path__nr_entries + 1); 1990 vmlinux_path__nr_entries + 1);
1989 1991
1990 filename = dso__build_id_filename(dso, NULL, 0); 1992 filename = dso__build_id_filename(dso, NULL, 0);
1991 if (filename != NULL) { 1993 if (filename != NULL) {
1992 err = dso__load_vmlinux(dso, map, filename, filter); 1994 err = dso__load_vmlinux(dso, map, filename, filter);
1993 if (err > 0) { 1995 if (err > 0) {
1994 dso__set_long_name(dso, filename); 1996 dso__set_long_name(dso, filename);
1995 goto out; 1997 goto out;
1996 } 1998 }
1997 free(filename); 1999 free(filename);
1998 } 2000 }
1999 2001
2000 for (i = 0; i < vmlinux_path__nr_entries; ++i) { 2002 for (i = 0; i < vmlinux_path__nr_entries; ++i) {
2001 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter); 2003 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
2002 if (err > 0) { 2004 if (err > 0) {
2003 dso__set_long_name(dso, strdup(vmlinux_path[i])); 2005 dso__set_long_name(dso, strdup(vmlinux_path[i]));
2004 break; 2006 break;
2005 } 2007 }
2006 } 2008 }
2007 out: 2009 out:
2008 return err; 2010 return err;
2009 } 2011 }
2010 2012
2011 static int dso__load_kernel_sym(struct dso *dso, struct map *map, 2013 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
2012 symbol_filter_t filter) 2014 symbol_filter_t filter)
2013 { 2015 {
2014 int err; 2016 int err;
2015 const char *kallsyms_filename = NULL; 2017 const char *kallsyms_filename = NULL;
2016 char *kallsyms_allocated_filename = NULL; 2018 char *kallsyms_allocated_filename = NULL;
2017 /* 2019 /*
2018 * Step 1: if the user specified a kallsyms or vmlinux filename, use 2020 * Step 1: if the user specified a kallsyms or vmlinux filename, use
2019 * it and only it, reporting errors to the user if it cannot be used. 2021 * it and only it, reporting errors to the user if it cannot be used.
2020 * 2022 *
2021 * For instance, try to analyse an ARM perf.data file _without_ a 2023 * For instance, try to analyse an ARM perf.data file _without_ a
2022 * build-id, or if the user specifies the wrong path to the right 2024 * build-id, or if the user specifies the wrong path to the right
2023 * vmlinux file, obviously we can't fallback to another vmlinux (a 2025 * vmlinux file, obviously we can't fallback to another vmlinux (a
2024 * x86_86 one, on the machine where analysis is being performed, say), 2026 * x86_86 one, on the machine where analysis is being performed, say),
2025 * or worse, /proc/kallsyms. 2027 * or worse, /proc/kallsyms.
2026 * 2028 *
2027 * If the specified file _has_ a build-id and there is a build-id 2029 * If the specified file _has_ a build-id and there is a build-id
2028 * section in the perf.data file, we will still do the expected 2030 * section in the perf.data file, we will still do the expected
2029 * validation in dso__load_vmlinux and will bail out if they don't 2031 * validation in dso__load_vmlinux and will bail out if they don't
2030 * match. 2032 * match.
2031 */ 2033 */
2032 if (symbol_conf.kallsyms_name != NULL) { 2034 if (symbol_conf.kallsyms_name != NULL) {
2033 kallsyms_filename = symbol_conf.kallsyms_name; 2035 kallsyms_filename = symbol_conf.kallsyms_name;
2034 goto do_kallsyms; 2036 goto do_kallsyms;
2035 } 2037 }
2036 2038
2037 if (symbol_conf.vmlinux_name != NULL) { 2039 if (symbol_conf.vmlinux_name != NULL) {
2038 err = dso__load_vmlinux(dso, map, 2040 err = dso__load_vmlinux(dso, map,
2039 symbol_conf.vmlinux_name, filter); 2041 symbol_conf.vmlinux_name, filter);
2040 if (err > 0) { 2042 if (err > 0) {
2041 dso__set_long_name(dso, 2043 dso__set_long_name(dso,
2042 strdup(symbol_conf.vmlinux_name)); 2044 strdup(symbol_conf.vmlinux_name));
2043 goto out_fixup; 2045 goto out_fixup;
2044 } 2046 }
2045 return err; 2047 return err;
2046 } 2048 }
2047 2049
2048 if (vmlinux_path != NULL) { 2050 if (vmlinux_path != NULL) {
2049 err = dso__load_vmlinux_path(dso, map, filter); 2051 err = dso__load_vmlinux_path(dso, map, filter);
2050 if (err > 0) 2052 if (err > 0)
2051 goto out_fixup; 2053 goto out_fixup;
2052 } 2054 }
2053 2055
2054 /* do not try local files if a symfs was given */ 2056 /* do not try local files if a symfs was given */
2055 if (symbol_conf.symfs[0] != 0) 2057 if (symbol_conf.symfs[0] != 0)
2056 return -1; 2058 return -1;
2057 2059
2058 /* 2060 /*
2059 * Say the kernel DSO was created when processing the build-id header table, 2061 * Say the kernel DSO was created when processing the build-id header table,
2060 * we have a build-id, so check if it is the same as the running kernel, 2062 * we have a build-id, so check if it is the same as the running kernel,
2061 * using it if it is. 2063 * using it if it is.
2062 */ 2064 */
2063 if (dso->has_build_id) { 2065 if (dso->has_build_id) {
2064 u8 kallsyms_build_id[BUILD_ID_SIZE]; 2066 u8 kallsyms_build_id[BUILD_ID_SIZE];
2065 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 2067 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
2066 2068
2067 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id, 2069 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
2068 sizeof(kallsyms_build_id)) == 0) { 2070 sizeof(kallsyms_build_id)) == 0) {
2069 if (dso__build_id_equal(dso, kallsyms_build_id)) { 2071 if (dso__build_id_equal(dso, kallsyms_build_id)) {
2070 kallsyms_filename = "/proc/kallsyms"; 2072 kallsyms_filename = "/proc/kallsyms";
2071 goto do_kallsyms; 2073 goto do_kallsyms;
2072 } 2074 }
2073 } 2075 }
2074 /* 2076 /*
2075 * Now look if we have it on the build-id cache in 2077 * Now look if we have it on the build-id cache in
2076 * $HOME/.debug/[kernel.kallsyms]. 2078 * $HOME/.debug/[kernel.kallsyms].
2077 */ 2079 */
2078 build_id__sprintf(dso->build_id, sizeof(dso->build_id), 2080 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
2079 sbuild_id); 2081 sbuild_id);
2080 2082
2081 if (asprintf(&kallsyms_allocated_filename, 2083 if (asprintf(&kallsyms_allocated_filename,
2082 "%s/.debug/[kernel.kallsyms]/%s", 2084 "%s/.debug/[kernel.kallsyms]/%s",
2083 getenv("HOME"), sbuild_id) == -1) { 2085 getenv("HOME"), sbuild_id) == -1) {
2084 pr_err("Not enough memory for kallsyms file lookup\n"); 2086 pr_err("Not enough memory for kallsyms file lookup\n");
2085 return -1; 2087 return -1;
2086 } 2088 }
2087 2089
2088 kallsyms_filename = kallsyms_allocated_filename; 2090 kallsyms_filename = kallsyms_allocated_filename;
2089 2091
2090 if (access(kallsyms_filename, F_OK)) { 2092 if (access(kallsyms_filename, F_OK)) {
2091 pr_err("No kallsyms or vmlinux with build-id %s " 2093 pr_err("No kallsyms or vmlinux with build-id %s "
2092 "was found\n", sbuild_id); 2094 "was found\n", sbuild_id);
2093 free(kallsyms_allocated_filename); 2095 free(kallsyms_allocated_filename);
2094 return -1; 2096 return -1;
2095 } 2097 }
2096 } else { 2098 } else {
2097 /* 2099 /*
2098 * Last resort, if we don't have a build-id and couldn't find 2100 * Last resort, if we don't have a build-id and couldn't find
2099 * any vmlinux file, try the running kernel kallsyms table. 2101 * any vmlinux file, try the running kernel kallsyms table.
2100 */ 2102 */
2101 kallsyms_filename = "/proc/kallsyms"; 2103 kallsyms_filename = "/proc/kallsyms";
2102 } 2104 }
2103 2105
2104 do_kallsyms: 2106 do_kallsyms:
2105 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter); 2107 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2106 if (err > 0) 2108 if (err > 0)
2107 pr_debug("Using %s for symbols\n", kallsyms_filename); 2109 pr_debug("Using %s for symbols\n", kallsyms_filename);
2108 free(kallsyms_allocated_filename); 2110 free(kallsyms_allocated_filename);
2109 2111
2110 if (err > 0) { 2112 if (err > 0) {
2111 out_fixup: 2113 out_fixup:
2112 if (kallsyms_filename != NULL) 2114 if (kallsyms_filename != NULL)
2113 dso__set_long_name(dso, strdup("[kernel.kallsyms]")); 2115 dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
2114 map__fixup_start(map); 2116 map__fixup_start(map);
2115 map__fixup_end(map); 2117 map__fixup_end(map);
2116 } 2118 }
2117 2119
2118 return err; 2120 return err;
2119 } 2121 }
2120 2122
2121 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map, 2123 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
2122 symbol_filter_t filter) 2124 symbol_filter_t filter)
2123 { 2125 {
2124 int err; 2126 int err;
2125 const char *kallsyms_filename = NULL; 2127 const char *kallsyms_filename = NULL;
2126 struct machine *machine; 2128 struct machine *machine;
2127 char path[PATH_MAX]; 2129 char path[PATH_MAX];
2128 2130
2129 if (!map->groups) { 2131 if (!map->groups) {
2130 pr_debug("Guest kernel map hasn't the point to groups\n"); 2132 pr_debug("Guest kernel map hasn't the point to groups\n");
2131 return -1; 2133 return -1;
2132 } 2134 }
2133 machine = map->groups->machine; 2135 machine = map->groups->machine;
2134 2136
2135 if (machine__is_default_guest(machine)) { 2137 if (machine__is_default_guest(machine)) {
2136 /* 2138 /*
2137 * if the user specified a vmlinux filename, use it and only 2139 * if the user specified a vmlinux filename, use it and only
2138 * it, reporting errors to the user if it cannot be used. 2140 * it, reporting errors to the user if it cannot be used.
2139 * Or use file guest_kallsyms inputted by user on commandline 2141 * Or use file guest_kallsyms inputted by user on commandline
2140 */ 2142 */
2141 if (symbol_conf.default_guest_vmlinux_name != NULL) { 2143 if (symbol_conf.default_guest_vmlinux_name != NULL) {
2142 err = dso__load_vmlinux(dso, map, 2144 err = dso__load_vmlinux(dso, map,
2143 symbol_conf.default_guest_vmlinux_name, filter); 2145 symbol_conf.default_guest_vmlinux_name, filter);
2144 goto out_try_fixup; 2146 goto out_try_fixup;
2145 } 2147 }
2146 2148
2147 kallsyms_filename = symbol_conf.default_guest_kallsyms; 2149 kallsyms_filename = symbol_conf.default_guest_kallsyms;
2148 if (!kallsyms_filename) 2150 if (!kallsyms_filename)
2149 return -1; 2151 return -1;
2150 } else { 2152 } else {
2151 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 2153 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2152 kallsyms_filename = path; 2154 kallsyms_filename = path;
2153 } 2155 }
2154 2156
2155 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter); 2157 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2156 if (err > 0) 2158 if (err > 0)
2157 pr_debug("Using %s for symbols\n", kallsyms_filename); 2159 pr_debug("Using %s for symbols\n", kallsyms_filename);
2158 2160
2159 out_try_fixup: 2161 out_try_fixup:
2160 if (err > 0) { 2162 if (err > 0) {
2161 if (kallsyms_filename != NULL) { 2163 if (kallsyms_filename != NULL) {
2162 machine__mmap_name(machine, path, sizeof(path)); 2164 machine__mmap_name(machine, path, sizeof(path));
2163 dso__set_long_name(dso, strdup(path)); 2165 dso__set_long_name(dso, strdup(path));
2164 } 2166 }
2165 map__fixup_start(map); 2167 map__fixup_start(map);
2166 map__fixup_end(map); 2168 map__fixup_end(map);
2167 } 2169 }
2168 2170
2169 return err; 2171 return err;
2170 } 2172 }
2171 2173
2172 static void dsos__add(struct list_head *head, struct dso *dso) 2174 static void dsos__add(struct list_head *head, struct dso *dso)
2173 { 2175 {
2174 list_add_tail(&dso->node, head); 2176 list_add_tail(&dso->node, head);
2175 } 2177 }
2176 2178
2177 static struct dso *dsos__find(struct list_head *head, const char *name) 2179 static struct dso *dsos__find(struct list_head *head, const char *name)
2178 { 2180 {
2179 struct dso *pos; 2181 struct dso *pos;
2180 2182
2181 list_for_each_entry(pos, head, node) 2183 list_for_each_entry(pos, head, node)
2182 if (strcmp(pos->long_name, name) == 0) 2184 if (strcmp(pos->long_name, name) == 0)
2183 return pos; 2185 return pos;
2184 return NULL; 2186 return NULL;
2185 } 2187 }
2186 2188
2187 struct dso *__dsos__findnew(struct list_head *head, const char *name) 2189 struct dso *__dsos__findnew(struct list_head *head, const char *name)
2188 { 2190 {
2189 struct dso *dso = dsos__find(head, name); 2191 struct dso *dso = dsos__find(head, name);
2190 2192
2191 if (!dso) { 2193 if (!dso) {
2192 dso = dso__new(name); 2194 dso = dso__new(name);
2193 if (dso != NULL) { 2195 if (dso != NULL) {
2194 dsos__add(head, dso); 2196 dsos__add(head, dso);
2195 dso__set_basename(dso); 2197 dso__set_basename(dso);
2196 } 2198 }
2197 } 2199 }
2198 2200
2199 return dso; 2201 return dso;
2200 } 2202 }
2201 2203
2202 size_t __dsos__fprintf(struct list_head *head, FILE *fp) 2204 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2203 { 2205 {
2204 struct dso *pos; 2206 struct dso *pos;
2205 size_t ret = 0; 2207 size_t ret = 0;
2206 2208
2207 list_for_each_entry(pos, head, node) { 2209 list_for_each_entry(pos, head, node) {
2208 int i; 2210 int i;
2209 for (i = 0; i < MAP__NR_TYPES; ++i) 2211 for (i = 0; i < MAP__NR_TYPES; ++i)
2210 ret += dso__fprintf(pos, i, fp); 2212 ret += dso__fprintf(pos, i, fp);
2211 } 2213 }
2212 2214
2213 return ret; 2215 return ret;
2214 } 2216 }
2215 2217
2216 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp) 2218 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
2217 { 2219 {
2218 struct rb_node *nd; 2220 struct rb_node *nd;
2219 size_t ret = 0; 2221 size_t ret = 0;
2220 2222
2221 for (nd = rb_first(machines); nd; nd = rb_next(nd)) { 2223 for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2222 struct machine *pos = rb_entry(nd, struct machine, rb_node); 2224 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2223 ret += __dsos__fprintf(&pos->kernel_dsos, fp); 2225 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2224 ret += __dsos__fprintf(&pos->user_dsos, fp); 2226 ret += __dsos__fprintf(&pos->user_dsos, fp);
2225 } 2227 }
2226 2228
2227 return ret; 2229 return ret;
2228 } 2230 }
2229 2231
2230 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp, 2232 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2231 bool with_hits) 2233 bool with_hits)
2232 { 2234 {
2233 struct dso *pos; 2235 struct dso *pos;
2234 size_t ret = 0; 2236 size_t ret = 0;
2235 2237
2236 list_for_each_entry(pos, head, node) { 2238 list_for_each_entry(pos, head, node) {
2237 if (with_hits && !pos->hit) 2239 if (with_hits && !pos->hit)
2238 continue; 2240 continue;
2239 ret += dso__fprintf_buildid(pos, fp); 2241 ret += dso__fprintf_buildid(pos, fp);
2240 ret += fprintf(fp, " %s\n", pos->long_name); 2242 ret += fprintf(fp, " %s\n", pos->long_name);
2241 } 2243 }
2242 return ret; 2244 return ret;
2243 } 2245 }
2244 2246
2245 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp, 2247 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
2246 bool with_hits) 2248 bool with_hits)
2247 { 2249 {
2248 return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) + 2250 return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
2249 __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits); 2251 __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
2250 } 2252 }
2251 2253
2252 size_t machines__fprintf_dsos_buildid(struct rb_root *machines, 2254 size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
2253 FILE *fp, bool with_hits) 2255 FILE *fp, bool with_hits)
2254 { 2256 {
2255 struct rb_node *nd; 2257 struct rb_node *nd;
2256 size_t ret = 0; 2258 size_t ret = 0;
2257 2259
2258 for (nd = rb_first(machines); nd; nd = rb_next(nd)) { 2260 for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2259 struct machine *pos = rb_entry(nd, struct machine, rb_node); 2261 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2260 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits); 2262 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2261 } 2263 }
2262 return ret; 2264 return ret;
2263 } 2265 }
2264 2266
2265 static struct dso* 2267 static struct dso*
2266 dso__kernel_findnew(struct machine *machine, const char *name, 2268 dso__kernel_findnew(struct machine *machine, const char *name,
2267 const char *short_name, int dso_type) 2269 const char *short_name, int dso_type)
2268 { 2270 {
2269 /* 2271 /*
2270 * The kernel dso could be created by build_id processing. 2272 * The kernel dso could be created by build_id processing.
2271 */ 2273 */
2272 struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name); 2274 struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
2273 2275
2274 /* 2276 /*
2275 * We need to run this in all cases, since during the build_id 2277 * We need to run this in all cases, since during the build_id
2276 * processing we had no idea this was the kernel dso. 2278 * processing we had no idea this was the kernel dso.
2277 */ 2279 */
2278 if (dso != NULL) { 2280 if (dso != NULL) {
2279 dso__set_short_name(dso, short_name); 2281 dso__set_short_name(dso, short_name);
2280 dso->kernel = dso_type; 2282 dso->kernel = dso_type;
2281 } 2283 }
2282 2284
2283 return dso; 2285 return dso;
2284 } 2286 }
2285 2287
2286 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine) 2288 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
2287 { 2289 {
2288 char path[PATH_MAX]; 2290 char path[PATH_MAX];
2289 2291
2290 if (machine__is_default_guest(machine)) 2292 if (machine__is_default_guest(machine))
2291 return; 2293 return;
2292 sprintf(path, "%s/sys/kernel/notes", machine->root_dir); 2294 sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2293 if (sysfs__read_build_id(path, dso->build_id, 2295 if (sysfs__read_build_id(path, dso->build_id,
2294 sizeof(dso->build_id)) == 0) 2296 sizeof(dso->build_id)) == 0)
2295 dso->has_build_id = true; 2297 dso->has_build_id = true;
2296 } 2298 }
2297 2299
2298 static struct dso *machine__get_kernel(struct machine *machine) 2300 static struct dso *machine__get_kernel(struct machine *machine)
2299 { 2301 {
2300 const char *vmlinux_name = NULL; 2302 const char *vmlinux_name = NULL;
2301 struct dso *kernel; 2303 struct dso *kernel;
2302 2304
2303 if (machine__is_host(machine)) { 2305 if (machine__is_host(machine)) {
2304 vmlinux_name = symbol_conf.vmlinux_name; 2306 vmlinux_name = symbol_conf.vmlinux_name;
2305 if (!vmlinux_name) 2307 if (!vmlinux_name)
2306 vmlinux_name = "[kernel.kallsyms]"; 2308 vmlinux_name = "[kernel.kallsyms]";
2307 2309
2308 kernel = dso__kernel_findnew(machine, vmlinux_name, 2310 kernel = dso__kernel_findnew(machine, vmlinux_name,
2309 "[kernel]", 2311 "[kernel]",
2310 DSO_TYPE_KERNEL); 2312 DSO_TYPE_KERNEL);
2311 } else { 2313 } else {
2312 char bf[PATH_MAX]; 2314 char bf[PATH_MAX];
2313 2315
2314 if (machine__is_default_guest(machine)) 2316 if (machine__is_default_guest(machine))
2315 vmlinux_name = symbol_conf.default_guest_vmlinux_name; 2317 vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2316 if (!vmlinux_name) 2318 if (!vmlinux_name)
2317 vmlinux_name = machine__mmap_name(machine, bf, 2319 vmlinux_name = machine__mmap_name(machine, bf,
2318 sizeof(bf)); 2320 sizeof(bf));
2319 2321
2320 kernel = dso__kernel_findnew(machine, vmlinux_name, 2322 kernel = dso__kernel_findnew(machine, vmlinux_name,
2321 "[guest.kernel]", 2323 "[guest.kernel]",
2322 DSO_TYPE_GUEST_KERNEL); 2324 DSO_TYPE_GUEST_KERNEL);
2323 } 2325 }
2324 2326
2325 if (kernel != NULL && (!kernel->has_build_id)) 2327 if (kernel != NULL && (!kernel->has_build_id))
2326 dso__read_running_kernel_build_id(kernel, machine); 2328 dso__read_running_kernel_build_id(kernel, machine);
2327 2329
2328 return kernel; 2330 return kernel;
2329 } 2331 }
2330 2332
2331 struct process_args { 2333 struct process_args {
2332 u64 start; 2334 u64 start;
2333 }; 2335 };
2334 2336
2335 static int symbol__in_kernel(void *arg, const char *name, 2337 static int symbol__in_kernel(void *arg, const char *name,
2336 char type __used, u64 start, u64 end __used) 2338 char type __used, u64 start, u64 end __used)
2337 { 2339 {
2338 struct process_args *args = arg; 2340 struct process_args *args = arg;
2339 2341
2340 if (strchr(name, '[')) 2342 if (strchr(name, '['))
2341 return 0; 2343 return 0;
2342 2344
2343 args->start = start; 2345 args->start = start;
2344 return 1; 2346 return 1;
2345 } 2347 }
2346 2348
2347 /* Figure out the start address of kernel map from /proc/kallsyms */ 2349 /* Figure out the start address of kernel map from /proc/kallsyms */
2348 static u64 machine__get_kernel_start_addr(struct machine *machine) 2350 static u64 machine__get_kernel_start_addr(struct machine *machine)
2349 { 2351 {
2350 const char *filename; 2352 const char *filename;
2351 char path[PATH_MAX]; 2353 char path[PATH_MAX];
2352 struct process_args args; 2354 struct process_args args;
2353 2355
2354 if (machine__is_host(machine)) { 2356 if (machine__is_host(machine)) {
2355 filename = "/proc/kallsyms"; 2357 filename = "/proc/kallsyms";
2356 } else { 2358 } else {
2357 if (machine__is_default_guest(machine)) 2359 if (machine__is_default_guest(machine))
2358 filename = (char *)symbol_conf.default_guest_kallsyms; 2360 filename = (char *)symbol_conf.default_guest_kallsyms;
2359 else { 2361 else {
2360 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 2362 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2361 filename = path; 2363 filename = path;
2362 } 2364 }
2363 } 2365 }
2364 2366
2365 if (symbol__restricted_filename(filename, "/proc/kallsyms")) 2367 if (symbol__restricted_filename(filename, "/proc/kallsyms"))
2366 return 0; 2368 return 0;
2367 2369
2368 if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0) 2370 if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
2369 return 0; 2371 return 0;
2370 2372
2371 return args.start; 2373 return args.start;
2372 } 2374 }
2373 2375
2374 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel) 2376 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
2375 { 2377 {
2376 enum map_type type; 2378 enum map_type type;
2377 u64 start = machine__get_kernel_start_addr(machine); 2379 u64 start = machine__get_kernel_start_addr(machine);
2378 2380
2379 for (type = 0; type < MAP__NR_TYPES; ++type) { 2381 for (type = 0; type < MAP__NR_TYPES; ++type) {
2380 struct kmap *kmap; 2382 struct kmap *kmap;
2381 2383
2382 machine->vmlinux_maps[type] = map__new2(start, kernel, type); 2384 machine->vmlinux_maps[type] = map__new2(start, kernel, type);
2383 if (machine->vmlinux_maps[type] == NULL) 2385 if (machine->vmlinux_maps[type] == NULL)
2384 return -1; 2386 return -1;
2385 2387
2386 machine->vmlinux_maps[type]->map_ip = 2388 machine->vmlinux_maps[type]->map_ip =
2387 machine->vmlinux_maps[type]->unmap_ip = 2389 machine->vmlinux_maps[type]->unmap_ip =
2388 identity__map_ip; 2390 identity__map_ip;
2389 kmap = map__kmap(machine->vmlinux_maps[type]); 2391 kmap = map__kmap(machine->vmlinux_maps[type]);
2390 kmap->kmaps = &machine->kmaps; 2392 kmap->kmaps = &machine->kmaps;
2391 map_groups__insert(&machine->kmaps, 2393 map_groups__insert(&machine->kmaps,
2392 machine->vmlinux_maps[type]); 2394 machine->vmlinux_maps[type]);
2393 } 2395 }
2394 2396
2395 return 0; 2397 return 0;
2396 } 2398 }
2397 2399
2398 void machine__destroy_kernel_maps(struct machine *machine) 2400 void machine__destroy_kernel_maps(struct machine *machine)
2399 { 2401 {
2400 enum map_type type; 2402 enum map_type type;
2401 2403
2402 for (type = 0; type < MAP__NR_TYPES; ++type) { 2404 for (type = 0; type < MAP__NR_TYPES; ++type) {
2403 struct kmap *kmap; 2405 struct kmap *kmap;
2404 2406
2405 if (machine->vmlinux_maps[type] == NULL) 2407 if (machine->vmlinux_maps[type] == NULL)
2406 continue; 2408 continue;
2407 2409
2408 kmap = map__kmap(machine->vmlinux_maps[type]); 2410 kmap = map__kmap(machine->vmlinux_maps[type]);
2409 map_groups__remove(&machine->kmaps, 2411 map_groups__remove(&machine->kmaps,
2410 machine->vmlinux_maps[type]); 2412 machine->vmlinux_maps[type]);
2411 if (kmap->ref_reloc_sym) { 2413 if (kmap->ref_reloc_sym) {
2412 /* 2414 /*
2413 * ref_reloc_sym is shared among all maps, so free just 2415 * ref_reloc_sym is shared among all maps, so free just
2414 * on one of them. 2416 * on one of them.
2415 */ 2417 */
2416 if (type == MAP__FUNCTION) { 2418 if (type == MAP__FUNCTION) {
2417 free((char *)kmap->ref_reloc_sym->name); 2419 free((char *)kmap->ref_reloc_sym->name);
2418 kmap->ref_reloc_sym->name = NULL; 2420 kmap->ref_reloc_sym->name = NULL;
2419 free(kmap->ref_reloc_sym); 2421 free(kmap->ref_reloc_sym);
2420 } 2422 }
2421 kmap->ref_reloc_sym = NULL; 2423 kmap->ref_reloc_sym = NULL;
2422 } 2424 }
2423 2425
2424 map__delete(machine->vmlinux_maps[type]); 2426 map__delete(machine->vmlinux_maps[type]);
2425 machine->vmlinux_maps[type] = NULL; 2427 machine->vmlinux_maps[type] = NULL;
2426 } 2428 }
2427 } 2429 }
2428 2430
2429 int machine__create_kernel_maps(struct machine *machine) 2431 int machine__create_kernel_maps(struct machine *machine)
2430 { 2432 {
2431 struct dso *kernel = machine__get_kernel(machine); 2433 struct dso *kernel = machine__get_kernel(machine);
2432 2434
2433 if (kernel == NULL || 2435 if (kernel == NULL ||
2434 __machine__create_kernel_maps(machine, kernel) < 0) 2436 __machine__create_kernel_maps(machine, kernel) < 0)
2435 return -1; 2437 return -1;
2436 2438
2437 if (symbol_conf.use_modules && machine__create_modules(machine) < 0) 2439 if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
2438 pr_debug("Problems creating module maps, continuing anyway...\n"); 2440 pr_debug("Problems creating module maps, continuing anyway...\n");
2439 /* 2441 /*
2440 * Now that we have all the maps created, just set the ->end of them: 2442 * Now that we have all the maps created, just set the ->end of them:
2441 */ 2443 */
2442 map_groups__fixup_end(&machine->kmaps); 2444 map_groups__fixup_end(&machine->kmaps);
2443 return 0; 2445 return 0;
2444 } 2446 }
2445 2447
2446 static void vmlinux_path__exit(void) 2448 static void vmlinux_path__exit(void)
2447 { 2449 {
2448 while (--vmlinux_path__nr_entries >= 0) { 2450 while (--vmlinux_path__nr_entries >= 0) {
2449 free(vmlinux_path[vmlinux_path__nr_entries]); 2451 free(vmlinux_path[vmlinux_path__nr_entries]);
2450 vmlinux_path[vmlinux_path__nr_entries] = NULL; 2452 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2451 } 2453 }
2452 2454
2453 free(vmlinux_path); 2455 free(vmlinux_path);
2454 vmlinux_path = NULL; 2456 vmlinux_path = NULL;
2455 } 2457 }
2456 2458
2457 static int vmlinux_path__init(void) 2459 static int vmlinux_path__init(void)
2458 { 2460 {
2459 struct utsname uts; 2461 struct utsname uts;
2460 char bf[PATH_MAX]; 2462 char bf[PATH_MAX];
2461 2463
2462 vmlinux_path = malloc(sizeof(char *) * 5); 2464 vmlinux_path = malloc(sizeof(char *) * 5);
2463 if (vmlinux_path == NULL) 2465 if (vmlinux_path == NULL)
2464 return -1; 2466 return -1;
2465 2467
2466 vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux"); 2468 vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2467 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2469 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2468 goto out_fail; 2470 goto out_fail;
2469 ++vmlinux_path__nr_entries; 2471 ++vmlinux_path__nr_entries;
2470 vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux"); 2472 vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2471 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2473 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2472 goto out_fail; 2474 goto out_fail;
2473 ++vmlinux_path__nr_entries; 2475 ++vmlinux_path__nr_entries;
2474 2476
2475 /* only try running kernel version if no symfs was given */ 2477 /* only try running kernel version if no symfs was given */
2476 if (symbol_conf.symfs[0] != 0) 2478 if (symbol_conf.symfs[0] != 0)
2477 return 0; 2479 return 0;
2478 2480
2479 if (uname(&uts) < 0) 2481 if (uname(&uts) < 0)
2480 return -1; 2482 return -1;
2481 2483
2482 snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release); 2484 snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2483 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf); 2485 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2484 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2486 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2485 goto out_fail; 2487 goto out_fail;
2486 ++vmlinux_path__nr_entries; 2488 ++vmlinux_path__nr_entries;
2487 snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release); 2489 snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2488 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf); 2490 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2489 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2491 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2490 goto out_fail; 2492 goto out_fail;
2491 ++vmlinux_path__nr_entries; 2493 ++vmlinux_path__nr_entries;
2492 snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux", 2494 snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2493 uts.release); 2495 uts.release);
2494 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf); 2496 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2495 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2497 if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2496 goto out_fail; 2498 goto out_fail;
2497 ++vmlinux_path__nr_entries; 2499 ++vmlinux_path__nr_entries;
2498 2500
2499 return 0; 2501 return 0;
2500 2502
2501 out_fail: 2503 out_fail:
2502 vmlinux_path__exit(); 2504 vmlinux_path__exit();
2503 return -1; 2505 return -1;
2504 } 2506 }
2505 2507
2506 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp) 2508 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
2507 { 2509 {
2508 int i; 2510 int i;
2509 size_t printed = 0; 2511 size_t printed = 0;
2510 struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso; 2512 struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
2511 2513
2512 if (kdso->has_build_id) { 2514 if (kdso->has_build_id) {
2513 char filename[PATH_MAX]; 2515 char filename[PATH_MAX];
2514 if (dso__build_id_filename(kdso, filename, sizeof(filename))) 2516 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2515 printed += fprintf(fp, "[0] %s\n", filename); 2517 printed += fprintf(fp, "[0] %s\n", filename);
2516 } 2518 }
2517 2519
2518 for (i = 0; i < vmlinux_path__nr_entries; ++i) 2520 for (i = 0; i < vmlinux_path__nr_entries; ++i)
2519 printed += fprintf(fp, "[%d] %s\n", 2521 printed += fprintf(fp, "[%d] %s\n",
2520 i + kdso->has_build_id, vmlinux_path[i]); 2522 i + kdso->has_build_id, vmlinux_path[i]);
2521 2523
2522 return printed; 2524 return printed;
2523 } 2525 }
2524 2526
2525 static int setup_list(struct strlist **list, const char *list_str, 2527 static int setup_list(struct strlist **list, const char *list_str,
2526 const char *list_name) 2528 const char *list_name)
2527 { 2529 {
2528 if (list_str == NULL) 2530 if (list_str == NULL)
2529 return 0; 2531 return 0;
2530 2532
2531 *list = strlist__new(true, list_str); 2533 *list = strlist__new(true, list_str);
2532 if (!*list) { 2534 if (!*list) {
2533 pr_err("problems parsing %s list\n", list_name); 2535 pr_err("problems parsing %s list\n", list_name);
2534 return -1; 2536 return -1;
2535 } 2537 }
2536 return 0; 2538 return 0;
2537 } 2539 }
2538 2540
2539 static bool symbol__read_kptr_restrict(void) 2541 static bool symbol__read_kptr_restrict(void)
2540 { 2542 {
2541 bool value = false; 2543 bool value = false;
2542 2544
2543 if (geteuid() != 0) { 2545 if (geteuid() != 0) {
2544 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r"); 2546 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2545 if (fp != NULL) { 2547 if (fp != NULL) {
2546 char line[8]; 2548 char line[8];
2547 2549
2548 if (fgets(line, sizeof(line), fp) != NULL) 2550 if (fgets(line, sizeof(line), fp) != NULL)
2549 value = atoi(line) != 0; 2551 value = atoi(line) != 0;
2550 2552
2551 fclose(fp); 2553 fclose(fp);
2552 } 2554 }
2553 } 2555 }
2554 2556
2555 return value; 2557 return value;
2556 } 2558 }
2557 2559
2558 int symbol__init(void) 2560 int symbol__init(void)
2559 { 2561 {
2560 const char *symfs; 2562 const char *symfs;
2561 2563
2562 if (symbol_conf.initialized) 2564 if (symbol_conf.initialized)
2563 return 0; 2565 return 0;
2564 2566
2565 symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64)); 2567 symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
2566 2568
2567 elf_version(EV_CURRENT); 2569 elf_version(EV_CURRENT);
2568 if (symbol_conf.sort_by_name) 2570 if (symbol_conf.sort_by_name)
2569 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) - 2571 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2570 sizeof(struct symbol)); 2572 sizeof(struct symbol));
2571 2573
2572 if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0) 2574 if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2573 return -1; 2575 return -1;
2574 2576
2575 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') { 2577 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2576 pr_err("'.' is the only non valid --field-separator argument\n"); 2578 pr_err("'.' is the only non valid --field-separator argument\n");
2577 return -1; 2579 return -1;
2578 } 2580 }
2579 2581
2580 if (setup_list(&symbol_conf.dso_list, 2582 if (setup_list(&symbol_conf.dso_list,
2581 symbol_conf.dso_list_str, "dso") < 0) 2583 symbol_conf.dso_list_str, "dso") < 0)
2582 return -1; 2584 return -1;
2583 2585
2584 if (setup_list(&symbol_conf.comm_list, 2586 if (setup_list(&symbol_conf.comm_list,
2585 symbol_conf.comm_list_str, "comm") < 0) 2587 symbol_conf.comm_list_str, "comm") < 0)
2586 goto out_free_dso_list; 2588 goto out_free_dso_list;
2587 2589
2588 if (setup_list(&symbol_conf.sym_list, 2590 if (setup_list(&symbol_conf.sym_list,
2589 symbol_conf.sym_list_str, "symbol") < 0) 2591 symbol_conf.sym_list_str, "symbol") < 0)
2590 goto out_free_comm_list; 2592 goto out_free_comm_list;
2591 2593
2592 /* 2594 /*
2593 * A path to symbols of "/" is identical to "" 2595 * A path to symbols of "/" is identical to ""
2594 * reset here for simplicity. 2596 * reset here for simplicity.
2595 */ 2597 */
2596 symfs = realpath(symbol_conf.symfs, NULL); 2598 symfs = realpath(symbol_conf.symfs, NULL);
2597 if (symfs == NULL) 2599 if (symfs == NULL)
2598 symfs = symbol_conf.symfs; 2600 symfs = symbol_conf.symfs;
2599 if (strcmp(symfs, "/") == 0) 2601 if (strcmp(symfs, "/") == 0)
2600 symbol_conf.symfs = ""; 2602 symbol_conf.symfs = "";
2601 if (symfs != symbol_conf.symfs) 2603 if (symfs != symbol_conf.symfs)
2602 free((void *)symfs); 2604 free((void *)symfs);
2603 2605
2604 symbol_conf.kptr_restrict = symbol__read_kptr_restrict(); 2606 symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2605 2607
2606 symbol_conf.initialized = true; 2608 symbol_conf.initialized = true;
2607 return 0; 2609 return 0;
2608 2610
2609 out_free_dso_list: 2611 out_free_dso_list:
2610 strlist__delete(symbol_conf.dso_list); 2612 strlist__delete(symbol_conf.dso_list);
2611 out_free_comm_list: 2613 out_free_comm_list:
2612 strlist__delete(symbol_conf.comm_list); 2614 strlist__delete(symbol_conf.comm_list);
2613 return -1; 2615 return -1;
2614 } 2616 }
2615 2617
2616 void symbol__exit(void) 2618 void symbol__exit(void)
2617 { 2619 {
2618 if (!symbol_conf.initialized) 2620 if (!symbol_conf.initialized)
2619 return; 2621 return;
2620 strlist__delete(symbol_conf.sym_list); 2622 strlist__delete(symbol_conf.sym_list);
2621 strlist__delete(symbol_conf.dso_list); 2623 strlist__delete(symbol_conf.dso_list);
2622 strlist__delete(symbol_conf.comm_list); 2624 strlist__delete(symbol_conf.comm_list);
2623 vmlinux_path__exit(); 2625 vmlinux_path__exit();
2624 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL; 2626 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2625 symbol_conf.initialized = false; 2627 symbol_conf.initialized = false;
2626 } 2628 }
2627 2629
2628 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid) 2630 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
2629 { 2631 {
2630 struct machine *machine = machines__findnew(machines, pid); 2632 struct machine *machine = machines__findnew(machines, pid);
2631 2633
2632 if (machine == NULL) 2634 if (machine == NULL)
2633 return -1; 2635 return -1;
2634 2636
2635 return machine__create_kernel_maps(machine); 2637 return machine__create_kernel_maps(machine);
2636 } 2638 }
2637 2639
2638 static int hex(char ch) 2640 static int hex(char ch)
2639 { 2641 {
2640 if ((ch >= '0') && (ch <= '9')) 2642 if ((ch >= '0') && (ch <= '9'))
2641 return ch - '0'; 2643 return ch - '0';
2642 if ((ch >= 'a') && (ch <= 'f')) 2644 if ((ch >= 'a') && (ch <= 'f'))
2643 return ch - 'a' + 10; 2645 return ch - 'a' + 10;
2644 if ((ch >= 'A') && (ch <= 'F')) 2646 if ((ch >= 'A') && (ch <= 'F'))
2645 return ch - 'A' + 10; 2647 return ch - 'A' + 10;
2646 return -1; 2648 return -1;
2647 } 2649 }
2648 2650
2649 /* 2651 /*
2650 * While we find nice hex chars, build a long_val. 2652 * While we find nice hex chars, build a long_val.
2651 * Return number of chars processed. 2653 * Return number of chars processed.
2652 */ 2654 */
2653 int hex2u64(const char *ptr, u64 *long_val) 2655 int hex2u64(const char *ptr, u64 *long_val)
2654 { 2656 {
2655 const char *p = ptr; 2657 const char *p = ptr;
2656 *long_val = 0; 2658 *long_val = 0;
2657 2659
2658 while (*p) { 2660 while (*p) {
2659 const int hex_val = hex(*p); 2661 const int hex_val = hex(*p);
2660 2662
2661 if (hex_val < 0) 2663 if (hex_val < 0)
2662 break; 2664 break;
2663 2665
2664 *long_val = (*long_val << 4) | hex_val; 2666 *long_val = (*long_val << 4) | hex_val;
2665 p++; 2667 p++;
2666 } 2668 }
2667 2669
2668 return p - ptr; 2670 return p - ptr;
2669 } 2671 }
2670 2672
2671 char *strxfrchar(char *s, char from, char to) 2673 char *strxfrchar(char *s, char from, char to)
2672 { 2674 {
2673 char *p = s; 2675 char *p = s;
2674 2676
2675 while ((p = strchr(p, from)) != NULL) 2677 while ((p = strchr(p, from)) != NULL)
2676 *p++ = to; 2678 *p++ = to;
2677 2679
2678 return s; 2680 return s;
2679 } 2681 }
2680 2682
2681 int machines__create_guest_kernel_maps(struct rb_root *machines) 2683 int machines__create_guest_kernel_maps(struct rb_root *machines)
2682 { 2684 {
2683 int ret = 0; 2685 int ret = 0;
2684 struct dirent **namelist = NULL; 2686 struct dirent **namelist = NULL;
2685 int i, items = 0; 2687 int i, items = 0;
2686 char path[PATH_MAX]; 2688 char path[PATH_MAX];
2687 pid_t pid; 2689 pid_t pid;
2688 2690
2689 if (symbol_conf.default_guest_vmlinux_name || 2691 if (symbol_conf.default_guest_vmlinux_name ||
2690 symbol_conf.default_guest_modules || 2692 symbol_conf.default_guest_modules ||
2691 symbol_conf.default_guest_kallsyms) { 2693 symbol_conf.default_guest_kallsyms) {
2692 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID); 2694 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
2693 } 2695 }
2694 2696
2695 if (symbol_conf.guestmount) { 2697 if (symbol_conf.guestmount) {
2696 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL); 2698 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2697 if (items <= 0) 2699 if (items <= 0)
2698 return -ENOENT; 2700 return -ENOENT;
2699 for (i = 0; i < items; i++) { 2701 for (i = 0; i < items; i++) {
2700 if (!isdigit(namelist[i]->d_name[0])) { 2702 if (!isdigit(namelist[i]->d_name[0])) {
2701 /* Filter out . and .. */ 2703 /* Filter out . and .. */
2702 continue; 2704 continue;
2703 } 2705 }
2704 pid = atoi(namelist[i]->d_name); 2706 pid = atoi(namelist[i]->d_name);
2705 sprintf(path, "%s/%s/proc/kallsyms", 2707 sprintf(path, "%s/%s/proc/kallsyms",
2706 symbol_conf.guestmount, 2708 symbol_conf.guestmount,
2707 namelist[i]->d_name); 2709 namelist[i]->d_name);
2708 ret = access(path, R_OK); 2710 ret = access(path, R_OK);
2709 if (ret) { 2711 if (ret) {
2710 pr_debug("Can't access file %s\n", path); 2712 pr_debug("Can't access file %s\n", path);
2711 goto failure; 2713 goto failure;
2712 } 2714 }
2713 machines__create_kernel_maps(machines, pid); 2715 machines__create_kernel_maps(machines, pid);
2714 } 2716 }
2715 failure: 2717 failure:
2716 free(namelist); 2718 free(namelist);
2717 } 2719 }
2718 2720
2719 return ret; 2721 return ret;
2720 } 2722 }
2721 2723
2722 void machines__destroy_guest_kernel_maps(struct rb_root *machines) 2724 void machines__destroy_guest_kernel_maps(struct rb_root *machines)
2723 { 2725 {
2724 struct rb_node *next = rb_first(machines); 2726 struct rb_node *next = rb_first(machines);
2725 2727
2726 while (next) { 2728 while (next) {
2727 struct machine *pos = rb_entry(next, struct machine, rb_node); 2729 struct machine *pos = rb_entry(next, struct machine, rb_node);
2728 2730
2729 next = rb_next(&pos->rb_node); 2731 next = rb_next(&pos->rb_node);
2730 rb_erase(&pos->rb_node, machines); 2732 rb_erase(&pos->rb_node, machines);
2731 machine__delete(pos); 2733 machine__delete(pos);
2732 } 2734 }
2733 } 2735 }
2734 2736
2735 int machine__load_kallsyms(struct machine *machine, const char *filename, 2737 int machine__load_kallsyms(struct machine *machine, const char *filename,
2736 enum map_type type, symbol_filter_t filter) 2738 enum map_type type, symbol_filter_t filter)
2737 { 2739 {
2738 struct map *map = machine->vmlinux_maps[type]; 2740 struct map *map = machine->vmlinux_maps[type];
2739 int ret = dso__load_kallsyms(map->dso, filename, map, filter); 2741 int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2740 2742
2741 if (ret > 0) { 2743 if (ret > 0) {
2742 dso__set_loaded(map->dso, type); 2744 dso__set_loaded(map->dso, type);
2743 /* 2745 /*
2744 * Since /proc/kallsyms will have multiple sessions for the 2746 * Since /proc/kallsyms will have multiple sessions for the
2745 * kernel, with modules between them, fixup the end of all 2747 * kernel, with modules between them, fixup the end of all
2746 * sections. 2748 * sections.
2747 */ 2749 */
2748 __map_groups__fixup_end(&machine->kmaps, type); 2750 __map_groups__fixup_end(&machine->kmaps, type);
2749 } 2751 }
2750 2752
2751 return ret; 2753 return ret;
2752 } 2754 }
2753 2755
2754 int machine__load_vmlinux_path(struct machine *machine, enum map_type type, 2756 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
2755 symbol_filter_t filter) 2757 symbol_filter_t filter)
2756 { 2758 {
2757 struct map *map = machine->vmlinux_maps[type]; 2759 struct map *map = machine->vmlinux_maps[type];
2758 int ret = dso__load_vmlinux_path(map->dso, map, filter); 2760 int ret = dso__load_vmlinux_path(map->dso, map, filter);
2759 2761
2760 if (ret > 0) { 2762 if (ret > 0) {
2761 dso__set_loaded(map->dso, type); 2763 dso__set_loaded(map->dso, type);
2762 map__reloc_vmlinux(map); 2764 map__reloc_vmlinux(map);
2763 } 2765 }
2764 2766
2765 return ret; 2767 return ret;
2766 } 2768 }