]>
Commit | Line | Data |
---|---|---|
1 | #include <asm/bug.h> | |
2 | #include <sys/time.h> | |
3 | #include <sys/resource.h> | |
4 | #include "symbol.h" | |
5 | #include "dso.h" | |
6 | #include "machine.h" | |
7 | #include "util.h" | |
8 | #include "debug.h" | |
9 | ||
10 | char dso__symtab_origin(const struct dso *dso) | |
11 | { | |
12 | static const char origin[] = { | |
13 | [DSO_BINARY_TYPE__KALLSYMS] = 'k', | |
14 | [DSO_BINARY_TYPE__VMLINUX] = 'v', | |
15 | [DSO_BINARY_TYPE__JAVA_JIT] = 'j', | |
16 | [DSO_BINARY_TYPE__DEBUGLINK] = 'l', | |
17 | [DSO_BINARY_TYPE__BUILD_ID_CACHE] = 'B', | |
18 | [DSO_BINARY_TYPE__FEDORA_DEBUGINFO] = 'f', | |
19 | [DSO_BINARY_TYPE__UBUNTU_DEBUGINFO] = 'u', | |
20 | [DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO] = 'o', | |
21 | [DSO_BINARY_TYPE__BUILDID_DEBUGINFO] = 'b', | |
22 | [DSO_BINARY_TYPE__SYSTEM_PATH_DSO] = 'd', | |
23 | [DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE] = 'K', | |
24 | [DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP] = 'm', | |
25 | [DSO_BINARY_TYPE__GUEST_KALLSYMS] = 'g', | |
26 | [DSO_BINARY_TYPE__GUEST_KMODULE] = 'G', | |
27 | [DSO_BINARY_TYPE__GUEST_KMODULE_COMP] = 'M', | |
28 | [DSO_BINARY_TYPE__GUEST_VMLINUX] = 'V', | |
29 | }; | |
30 | ||
31 | if (dso == NULL || dso->symtab_type == DSO_BINARY_TYPE__NOT_FOUND) | |
32 | return '!'; | |
33 | return origin[dso->symtab_type]; | |
34 | } | |
35 | ||
36 | int dso__read_binary_type_filename(const struct dso *dso, | |
37 | enum dso_binary_type type, | |
38 | char *root_dir, char *filename, size_t size) | |
39 | { | |
40 | char build_id_hex[BUILD_ID_SIZE * 2 + 1]; | |
41 | int ret = 0; | |
42 | size_t len; | |
43 | ||
44 | switch (type) { | |
45 | case DSO_BINARY_TYPE__DEBUGLINK: { | |
46 | char *debuglink; | |
47 | ||
48 | strncpy(filename, dso->long_name, size); | |
49 | debuglink = filename + dso->long_name_len; | |
50 | while (debuglink != filename && *debuglink != '/') | |
51 | debuglink--; | |
52 | if (*debuglink == '/') | |
53 | debuglink++; | |
54 | ret = filename__read_debuglink(dso->long_name, debuglink, | |
55 | size - (debuglink - filename)); | |
56 | } | |
57 | break; | |
58 | case DSO_BINARY_TYPE__BUILD_ID_CACHE: | |
59 | /* skip the locally configured cache if a symfs is given */ | |
60 | if (symbol_conf.symfs[0] || | |
61 | (dso__build_id_filename(dso, filename, size) == NULL)) | |
62 | ret = -1; | |
63 | break; | |
64 | ||
65 | case DSO_BINARY_TYPE__FEDORA_DEBUGINFO: | |
66 | len = __symbol__join_symfs(filename, size, "/usr/lib/debug"); | |
67 | snprintf(filename + len, size - len, "%s.debug", dso->long_name); | |
68 | break; | |
69 | ||
70 | case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO: | |
71 | len = __symbol__join_symfs(filename, size, "/usr/lib/debug"); | |
72 | snprintf(filename + len, size - len, "%s", dso->long_name); | |
73 | break; | |
74 | ||
75 | case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO: | |
76 | { | |
77 | const char *last_slash; | |
78 | size_t dir_size; | |
79 | ||
80 | last_slash = dso->long_name + dso->long_name_len; | |
81 | while (last_slash != dso->long_name && *last_slash != '/') | |
82 | last_slash--; | |
83 | ||
84 | len = __symbol__join_symfs(filename, size, ""); | |
85 | dir_size = last_slash - dso->long_name + 2; | |
86 | if (dir_size > (size - len)) { | |
87 | ret = -1; | |
88 | break; | |
89 | } | |
90 | len += scnprintf(filename + len, dir_size, "%s", dso->long_name); | |
91 | len += scnprintf(filename + len , size - len, ".debug%s", | |
92 | last_slash); | |
93 | break; | |
94 | } | |
95 | ||
96 | case DSO_BINARY_TYPE__BUILDID_DEBUGINFO: | |
97 | if (!dso->has_build_id) { | |
98 | ret = -1; | |
99 | break; | |
100 | } | |
101 | ||
102 | build_id__sprintf(dso->build_id, | |
103 | sizeof(dso->build_id), | |
104 | build_id_hex); | |
105 | len = __symbol__join_symfs(filename, size, "/usr/lib/debug/.build-id/"); | |
106 | snprintf(filename + len, size - len, "%.2s/%s.debug", | |
107 | build_id_hex, build_id_hex + 2); | |
108 | break; | |
109 | ||
110 | case DSO_BINARY_TYPE__VMLINUX: | |
111 | case DSO_BINARY_TYPE__GUEST_VMLINUX: | |
112 | case DSO_BINARY_TYPE__SYSTEM_PATH_DSO: | |
113 | __symbol__join_symfs(filename, size, dso->long_name); | |
114 | break; | |
115 | ||
116 | case DSO_BINARY_TYPE__GUEST_KMODULE: | |
117 | case DSO_BINARY_TYPE__GUEST_KMODULE_COMP: | |
118 | path__join3(filename, size, symbol_conf.symfs, | |
119 | root_dir, dso->long_name); | |
120 | break; | |
121 | ||
122 | case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE: | |
123 | case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP: | |
124 | __symbol__join_symfs(filename, size, dso->long_name); | |
125 | break; | |
126 | ||
127 | case DSO_BINARY_TYPE__KCORE: | |
128 | case DSO_BINARY_TYPE__GUEST_KCORE: | |
129 | snprintf(filename, size, "%s", dso->long_name); | |
130 | break; | |
131 | ||
132 | default: | |
133 | case DSO_BINARY_TYPE__KALLSYMS: | |
134 | case DSO_BINARY_TYPE__GUEST_KALLSYMS: | |
135 | case DSO_BINARY_TYPE__JAVA_JIT: | |
136 | case DSO_BINARY_TYPE__NOT_FOUND: | |
137 | ret = -1; | |
138 | break; | |
139 | } | |
140 | ||
141 | return ret; | |
142 | } | |
143 | ||
144 | static const struct { | |
145 | const char *fmt; | |
146 | int (*decompress)(const char *input, int output); | |
147 | } compressions[] = { | |
148 | #ifdef HAVE_ZLIB_SUPPORT | |
149 | { "gz", gzip_decompress_to_file }, | |
150 | #endif | |
151 | { NULL, NULL }, | |
152 | }; | |
153 | ||
154 | bool is_supported_compression(const char *ext) | |
155 | { | |
156 | unsigned i; | |
157 | ||
158 | for (i = 0; compressions[i].fmt; i++) { | |
159 | if (!strcmp(ext, compressions[i].fmt)) | |
160 | return true; | |
161 | } | |
162 | return false; | |
163 | } | |
164 | ||
165 | bool is_kmodule_extension(const char *ext) | |
166 | { | |
167 | if (strncmp(ext, "ko", 2)) | |
168 | return false; | |
169 | ||
170 | if (ext[2] == '\0' || (ext[2] == '.' && is_supported_compression(ext+3))) | |
171 | return true; | |
172 | ||
173 | return false; | |
174 | } | |
175 | ||
176 | bool is_kernel_module(const char *pathname, bool *compressed) | |
177 | { | |
178 | const char *ext = strrchr(pathname, '.'); | |
179 | ||
180 | if (ext == NULL) | |
181 | return false; | |
182 | ||
183 | if (is_supported_compression(ext + 1)) { | |
184 | if (compressed) | |
185 | *compressed = true; | |
186 | ext -= 3; | |
187 | } else if (compressed) | |
188 | *compressed = false; | |
189 | ||
190 | return is_kmodule_extension(ext + 1); | |
191 | } | |
192 | ||
193 | bool decompress_to_file(const char *ext, const char *filename, int output_fd) | |
194 | { | |
195 | unsigned i; | |
196 | ||
197 | for (i = 0; compressions[i].fmt; i++) { | |
198 | if (!strcmp(ext, compressions[i].fmt)) | |
199 | return !compressions[i].decompress(filename, | |
200 | output_fd); | |
201 | } | |
202 | return false; | |
203 | } | |
204 | ||
205 | bool dso__needs_decompress(struct dso *dso) | |
206 | { | |
207 | return dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP || | |
208 | dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP; | |
209 | } | |
210 | ||
211 | /* | |
212 | * Global list of open DSOs and the counter. | |
213 | */ | |
214 | static LIST_HEAD(dso__data_open); | |
215 | static long dso__data_open_cnt; | |
216 | ||
217 | static void dso__list_add(struct dso *dso) | |
218 | { | |
219 | list_add_tail(&dso->data.open_entry, &dso__data_open); | |
220 | dso__data_open_cnt++; | |
221 | } | |
222 | ||
223 | static void dso__list_del(struct dso *dso) | |
224 | { | |
225 | list_del(&dso->data.open_entry); | |
226 | WARN_ONCE(dso__data_open_cnt <= 0, | |
227 | "DSO data fd counter out of bounds."); | |
228 | dso__data_open_cnt--; | |
229 | } | |
230 | ||
231 | static void close_first_dso(void); | |
232 | ||
233 | static int do_open(char *name) | |
234 | { | |
235 | int fd; | |
236 | char sbuf[STRERR_BUFSIZE]; | |
237 | ||
238 | do { | |
239 | fd = open(name, O_RDONLY); | |
240 | if (fd >= 0) | |
241 | return fd; | |
242 | ||
243 | pr_debug("dso open failed: %s\n", | |
244 | strerror_r(errno, sbuf, sizeof(sbuf))); | |
245 | if (!dso__data_open_cnt || errno != EMFILE) | |
246 | break; | |
247 | ||
248 | close_first_dso(); | |
249 | } while (1); | |
250 | ||
251 | return -1; | |
252 | } | |
253 | ||
254 | static int __open_dso(struct dso *dso, struct machine *machine) | |
255 | { | |
256 | int fd; | |
257 | char *root_dir = (char *)""; | |
258 | char *name = malloc(PATH_MAX); | |
259 | ||
260 | if (!name) | |
261 | return -ENOMEM; | |
262 | ||
263 | if (machine) | |
264 | root_dir = machine->root_dir; | |
265 | ||
266 | if (dso__read_binary_type_filename(dso, dso->binary_type, | |
267 | root_dir, name, PATH_MAX)) { | |
268 | free(name); | |
269 | return -EINVAL; | |
270 | } | |
271 | ||
272 | fd = do_open(name); | |
273 | free(name); | |
274 | return fd; | |
275 | } | |
276 | ||
277 | static void check_data_close(void); | |
278 | ||
279 | /** | |
280 | * dso_close - Open DSO data file | |
281 | * @dso: dso object | |
282 | * | |
283 | * Open @dso's data file descriptor and updates | |
284 | * list/count of open DSO objects. | |
285 | */ | |
286 | static int open_dso(struct dso *dso, struct machine *machine) | |
287 | { | |
288 | int fd = __open_dso(dso, machine); | |
289 | ||
290 | if (fd >= 0) { | |
291 | dso__list_add(dso); | |
292 | /* | |
293 | * Check if we crossed the allowed number | |
294 | * of opened DSOs and close one if needed. | |
295 | */ | |
296 | check_data_close(); | |
297 | } | |
298 | ||
299 | return fd; | |
300 | } | |
301 | ||
302 | static void close_data_fd(struct dso *dso) | |
303 | { | |
304 | if (dso->data.fd >= 0) { | |
305 | close(dso->data.fd); | |
306 | dso->data.fd = -1; | |
307 | dso->data.file_size = 0; | |
308 | dso__list_del(dso); | |
309 | } | |
310 | } | |
311 | ||
312 | /** | |
313 | * dso_close - Close DSO data file | |
314 | * @dso: dso object | |
315 | * | |
316 | * Close @dso's data file descriptor and updates | |
317 | * list/count of open DSO objects. | |
318 | */ | |
319 | static void close_dso(struct dso *dso) | |
320 | { | |
321 | close_data_fd(dso); | |
322 | } | |
323 | ||
324 | static void close_first_dso(void) | |
325 | { | |
326 | struct dso *dso; | |
327 | ||
328 | dso = list_first_entry(&dso__data_open, struct dso, data.open_entry); | |
329 | close_dso(dso); | |
330 | } | |
331 | ||
332 | static rlim_t get_fd_limit(void) | |
333 | { | |
334 | struct rlimit l; | |
335 | rlim_t limit = 0; | |
336 | ||
337 | /* Allow half of the current open fd limit. */ | |
338 | if (getrlimit(RLIMIT_NOFILE, &l) == 0) { | |
339 | if (l.rlim_cur == RLIM_INFINITY) | |
340 | limit = l.rlim_cur; | |
341 | else | |
342 | limit = l.rlim_cur / 2; | |
343 | } else { | |
344 | pr_err("failed to get fd limit\n"); | |
345 | limit = 1; | |
346 | } | |
347 | ||
348 | return limit; | |
349 | } | |
350 | ||
351 | static bool may_cache_fd(void) | |
352 | { | |
353 | static rlim_t limit; | |
354 | ||
355 | if (!limit) | |
356 | limit = get_fd_limit(); | |
357 | ||
358 | if (limit == RLIM_INFINITY) | |
359 | return true; | |
360 | ||
361 | return limit > (rlim_t) dso__data_open_cnt; | |
362 | } | |
363 | ||
364 | /* | |
365 | * Check and close LRU dso if we crossed allowed limit | |
366 | * for opened dso file descriptors. The limit is half | |
367 | * of the RLIMIT_NOFILE files opened. | |
368 | */ | |
369 | static void check_data_close(void) | |
370 | { | |
371 | bool cache_fd = may_cache_fd(); | |
372 | ||
373 | if (!cache_fd) | |
374 | close_first_dso(); | |
375 | } | |
376 | ||
377 | /** | |
378 | * dso__data_close - Close DSO data file | |
379 | * @dso: dso object | |
380 | * | |
381 | * External interface to close @dso's data file descriptor. | |
382 | */ | |
383 | void dso__data_close(struct dso *dso) | |
384 | { | |
385 | close_dso(dso); | |
386 | } | |
387 | ||
388 | /** | |
389 | * dso__data_fd - Get dso's data file descriptor | |
390 | * @dso: dso object | |
391 | * @machine: machine object | |
392 | * | |
393 | * External interface to find dso's file, open it and | |
394 | * returns file descriptor. | |
395 | */ | |
396 | int dso__data_fd(struct dso *dso, struct machine *machine) | |
397 | { | |
398 | enum dso_binary_type binary_type_data[] = { | |
399 | DSO_BINARY_TYPE__BUILD_ID_CACHE, | |
400 | DSO_BINARY_TYPE__SYSTEM_PATH_DSO, | |
401 | DSO_BINARY_TYPE__NOT_FOUND, | |
402 | }; | |
403 | int i = 0; | |
404 | ||
405 | if (dso->data.status == DSO_DATA_STATUS_ERROR) | |
406 | return -1; | |
407 | ||
408 | if (dso->data.fd >= 0) | |
409 | goto out; | |
410 | ||
411 | if (dso->binary_type != DSO_BINARY_TYPE__NOT_FOUND) { | |
412 | dso->data.fd = open_dso(dso, machine); | |
413 | goto out; | |
414 | } | |
415 | ||
416 | do { | |
417 | dso->binary_type = binary_type_data[i++]; | |
418 | ||
419 | dso->data.fd = open_dso(dso, machine); | |
420 | if (dso->data.fd >= 0) | |
421 | goto out; | |
422 | ||
423 | } while (dso->binary_type != DSO_BINARY_TYPE__NOT_FOUND); | |
424 | out: | |
425 | if (dso->data.fd >= 0) | |
426 | dso->data.status = DSO_DATA_STATUS_OK; | |
427 | else | |
428 | dso->data.status = DSO_DATA_STATUS_ERROR; | |
429 | ||
430 | return dso->data.fd; | |
431 | } | |
432 | ||
433 | bool dso__data_status_seen(struct dso *dso, enum dso_data_status_seen by) | |
434 | { | |
435 | u32 flag = 1 << by; | |
436 | ||
437 | if (dso->data.status_seen & flag) | |
438 | return true; | |
439 | ||
440 | dso->data.status_seen |= flag; | |
441 | ||
442 | return false; | |
443 | } | |
444 | ||
445 | static void | |
446 | dso_cache__free(struct rb_root *root) | |
447 | { | |
448 | struct rb_node *next = rb_first(root); | |
449 | ||
450 | while (next) { | |
451 | struct dso_cache *cache; | |
452 | ||
453 | cache = rb_entry(next, struct dso_cache, rb_node); | |
454 | next = rb_next(&cache->rb_node); | |
455 | rb_erase(&cache->rb_node, root); | |
456 | free(cache); | |
457 | } | |
458 | } | |
459 | ||
460 | static struct dso_cache *dso_cache__find(const struct rb_root *root, u64 offset) | |
461 | { | |
462 | struct rb_node * const *p = &root->rb_node; | |
463 | const struct rb_node *parent = NULL; | |
464 | struct dso_cache *cache; | |
465 | ||
466 | while (*p != NULL) { | |
467 | u64 end; | |
468 | ||
469 | parent = *p; | |
470 | cache = rb_entry(parent, struct dso_cache, rb_node); | |
471 | end = cache->offset + DSO__DATA_CACHE_SIZE; | |
472 | ||
473 | if (offset < cache->offset) | |
474 | p = &(*p)->rb_left; | |
475 | else if (offset >= end) | |
476 | p = &(*p)->rb_right; | |
477 | else | |
478 | return cache; | |
479 | } | |
480 | return NULL; | |
481 | } | |
482 | ||
483 | static void | |
484 | dso_cache__insert(struct rb_root *root, struct dso_cache *new) | |
485 | { | |
486 | struct rb_node **p = &root->rb_node; | |
487 | struct rb_node *parent = NULL; | |
488 | struct dso_cache *cache; | |
489 | u64 offset = new->offset; | |
490 | ||
491 | while (*p != NULL) { | |
492 | u64 end; | |
493 | ||
494 | parent = *p; | |
495 | cache = rb_entry(parent, struct dso_cache, rb_node); | |
496 | end = cache->offset + DSO__DATA_CACHE_SIZE; | |
497 | ||
498 | if (offset < cache->offset) | |
499 | p = &(*p)->rb_left; | |
500 | else if (offset >= end) | |
501 | p = &(*p)->rb_right; | |
502 | } | |
503 | ||
504 | rb_link_node(&new->rb_node, parent, p); | |
505 | rb_insert_color(&new->rb_node, root); | |
506 | } | |
507 | ||
508 | static ssize_t | |
509 | dso_cache__memcpy(struct dso_cache *cache, u64 offset, | |
510 | u8 *data, u64 size) | |
511 | { | |
512 | u64 cache_offset = offset - cache->offset; | |
513 | u64 cache_size = min(cache->size - cache_offset, size); | |
514 | ||
515 | memcpy(data, cache->data + cache_offset, cache_size); | |
516 | return cache_size; | |
517 | } | |
518 | ||
519 | static ssize_t | |
520 | dso_cache__read(struct dso *dso, u64 offset, u8 *data, ssize_t size) | |
521 | { | |
522 | struct dso_cache *cache; | |
523 | ssize_t ret; | |
524 | ||
525 | do { | |
526 | u64 cache_offset; | |
527 | ||
528 | ret = -ENOMEM; | |
529 | ||
530 | cache = zalloc(sizeof(*cache) + DSO__DATA_CACHE_SIZE); | |
531 | if (!cache) | |
532 | break; | |
533 | ||
534 | cache_offset = offset & DSO__DATA_CACHE_MASK; | |
535 | ||
536 | ret = pread(dso->data.fd, cache->data, DSO__DATA_CACHE_SIZE, cache_offset); | |
537 | if (ret <= 0) | |
538 | break; | |
539 | ||
540 | cache->offset = cache_offset; | |
541 | cache->size = ret; | |
542 | dso_cache__insert(&dso->data.cache, cache); | |
543 | ||
544 | ret = dso_cache__memcpy(cache, offset, data, size); | |
545 | ||
546 | } while (0); | |
547 | ||
548 | if (ret <= 0) | |
549 | free(cache); | |
550 | ||
551 | return ret; | |
552 | } | |
553 | ||
554 | static ssize_t dso_cache_read(struct dso *dso, u64 offset, | |
555 | u8 *data, ssize_t size) | |
556 | { | |
557 | struct dso_cache *cache; | |
558 | ||
559 | cache = dso_cache__find(&dso->data.cache, offset); | |
560 | if (cache) | |
561 | return dso_cache__memcpy(cache, offset, data, size); | |
562 | else | |
563 | return dso_cache__read(dso, offset, data, size); | |
564 | } | |
565 | ||
566 | /* | |
567 | * Reads and caches dso data DSO__DATA_CACHE_SIZE size chunks | |
568 | * in the rb_tree. Any read to already cached data is served | |
569 | * by cached data. | |
570 | */ | |
571 | static ssize_t cached_read(struct dso *dso, u64 offset, u8 *data, ssize_t size) | |
572 | { | |
573 | ssize_t r = 0; | |
574 | u8 *p = data; | |
575 | ||
576 | do { | |
577 | ssize_t ret; | |
578 | ||
579 | ret = dso_cache_read(dso, offset, p, size); | |
580 | if (ret < 0) | |
581 | return ret; | |
582 | ||
583 | /* Reached EOF, return what we have. */ | |
584 | if (!ret) | |
585 | break; | |
586 | ||
587 | BUG_ON(ret > size); | |
588 | ||
589 | r += ret; | |
590 | p += ret; | |
591 | offset += ret; | |
592 | size -= ret; | |
593 | ||
594 | } while (size); | |
595 | ||
596 | return r; | |
597 | } | |
598 | ||
599 | static int data_file_size(struct dso *dso) | |
600 | { | |
601 | struct stat st; | |
602 | char sbuf[STRERR_BUFSIZE]; | |
603 | ||
604 | if (!dso->data.file_size) { | |
605 | if (fstat(dso->data.fd, &st)) { | |
606 | pr_err("dso mmap failed, fstat: %s\n", | |
607 | strerror_r(errno, sbuf, sizeof(sbuf))); | |
608 | return -1; | |
609 | } | |
610 | dso->data.file_size = st.st_size; | |
611 | } | |
612 | ||
613 | return 0; | |
614 | } | |
615 | ||
616 | /** | |
617 | * dso__data_size - Return dso data size | |
618 | * @dso: dso object | |
619 | * @machine: machine object | |
620 | * | |
621 | * Return: dso data size | |
622 | */ | |
623 | off_t dso__data_size(struct dso *dso, struct machine *machine) | |
624 | { | |
625 | int fd; | |
626 | ||
627 | fd = dso__data_fd(dso, machine); | |
628 | if (fd < 0) | |
629 | return fd; | |
630 | ||
631 | if (data_file_size(dso)) | |
632 | return -1; | |
633 | ||
634 | /* For now just estimate dso data size is close to file size */ | |
635 | return dso->data.file_size; | |
636 | } | |
637 | ||
638 | static ssize_t data_read_offset(struct dso *dso, u64 offset, | |
639 | u8 *data, ssize_t size) | |
640 | { | |
641 | if (data_file_size(dso)) | |
642 | return -1; | |
643 | ||
644 | /* Check the offset sanity. */ | |
645 | if (offset > dso->data.file_size) | |
646 | return -1; | |
647 | ||
648 | if (offset + size < offset) | |
649 | return -1; | |
650 | ||
651 | return cached_read(dso, offset, data, size); | |
652 | } | |
653 | ||
654 | /** | |
655 | * dso__data_read_offset - Read data from dso file offset | |
656 | * @dso: dso object | |
657 | * @machine: machine object | |
658 | * @offset: file offset | |
659 | * @data: buffer to store data | |
660 | * @size: size of the @data buffer | |
661 | * | |
662 | * External interface to read data from dso file offset. Open | |
663 | * dso data file and use cached_read to get the data. | |
664 | */ | |
665 | ssize_t dso__data_read_offset(struct dso *dso, struct machine *machine, | |
666 | u64 offset, u8 *data, ssize_t size) | |
667 | { | |
668 | if (dso__data_fd(dso, machine) < 0) | |
669 | return -1; | |
670 | ||
671 | return data_read_offset(dso, offset, data, size); | |
672 | } | |
673 | ||
674 | /** | |
675 | * dso__data_read_addr - Read data from dso address | |
676 | * @dso: dso object | |
677 | * @machine: machine object | |
678 | * @add: virtual memory address | |
679 | * @data: buffer to store data | |
680 | * @size: size of the @data buffer | |
681 | * | |
682 | * External interface to read data from dso address. | |
683 | */ | |
684 | ssize_t dso__data_read_addr(struct dso *dso, struct map *map, | |
685 | struct machine *machine, u64 addr, | |
686 | u8 *data, ssize_t size) | |
687 | { | |
688 | u64 offset = map->map_ip(map, addr); | |
689 | return dso__data_read_offset(dso, machine, offset, data, size); | |
690 | } | |
691 | ||
692 | struct map *dso__new_map(const char *name) | |
693 | { | |
694 | struct map *map = NULL; | |
695 | struct dso *dso = dso__new(name); | |
696 | ||
697 | if (dso) | |
698 | map = map__new2(0, dso, MAP__FUNCTION); | |
699 | ||
700 | return map; | |
701 | } | |
702 | ||
703 | struct dso *dso__kernel_findnew(struct machine *machine, const char *name, | |
704 | const char *short_name, int dso_type) | |
705 | { | |
706 | /* | |
707 | * The kernel dso could be created by build_id processing. | |
708 | */ | |
709 | struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name); | |
710 | ||
711 | /* | |
712 | * We need to run this in all cases, since during the build_id | |
713 | * processing we had no idea this was the kernel dso. | |
714 | */ | |
715 | if (dso != NULL) { | |
716 | dso__set_short_name(dso, short_name, false); | |
717 | dso->kernel = dso_type; | |
718 | } | |
719 | ||
720 | return dso; | |
721 | } | |
722 | ||
723 | /* | |
724 | * Find a matching entry and/or link current entry to RB tree. | |
725 | * Either one of the dso or name parameter must be non-NULL or the | |
726 | * function will not work. | |
727 | */ | |
728 | static struct dso *dso__findlink_by_longname(struct rb_root *root, | |
729 | struct dso *dso, const char *name) | |
730 | { | |
731 | struct rb_node **p = &root->rb_node; | |
732 | struct rb_node *parent = NULL; | |
733 | ||
734 | if (!name) | |
735 | name = dso->long_name; | |
736 | /* | |
737 | * Find node with the matching name | |
738 | */ | |
739 | while (*p) { | |
740 | struct dso *this = rb_entry(*p, struct dso, rb_node); | |
741 | int rc = strcmp(name, this->long_name); | |
742 | ||
743 | parent = *p; | |
744 | if (rc == 0) { | |
745 | /* | |
746 | * In case the new DSO is a duplicate of an existing | |
747 | * one, print an one-time warning & put the new entry | |
748 | * at the end of the list of duplicates. | |
749 | */ | |
750 | if (!dso || (dso == this)) | |
751 | return this; /* Find matching dso */ | |
752 | /* | |
753 | * The core kernel DSOs may have duplicated long name. | |
754 | * In this case, the short name should be different. | |
755 | * Comparing the short names to differentiate the DSOs. | |
756 | */ | |
757 | rc = strcmp(dso->short_name, this->short_name); | |
758 | if (rc == 0) { | |
759 | pr_err("Duplicated dso name: %s\n", name); | |
760 | return NULL; | |
761 | } | |
762 | } | |
763 | if (rc < 0) | |
764 | p = &parent->rb_left; | |
765 | else | |
766 | p = &parent->rb_right; | |
767 | } | |
768 | if (dso) { | |
769 | /* Add new node and rebalance tree */ | |
770 | rb_link_node(&dso->rb_node, parent, p); | |
771 | rb_insert_color(&dso->rb_node, root); | |
772 | } | |
773 | return NULL; | |
774 | } | |
775 | ||
776 | static inline struct dso * | |
777 | dso__find_by_longname(const struct rb_root *root, const char *name) | |
778 | { | |
779 | return dso__findlink_by_longname((struct rb_root *)root, NULL, name); | |
780 | } | |
781 | ||
782 | void dso__set_long_name(struct dso *dso, const char *name, bool name_allocated) | |
783 | { | |
784 | if (name == NULL) | |
785 | return; | |
786 | ||
787 | if (dso->long_name_allocated) | |
788 | free((char *)dso->long_name); | |
789 | ||
790 | dso->long_name = name; | |
791 | dso->long_name_len = strlen(name); | |
792 | dso->long_name_allocated = name_allocated; | |
793 | } | |
794 | ||
795 | void dso__set_short_name(struct dso *dso, const char *name, bool name_allocated) | |
796 | { | |
797 | if (name == NULL) | |
798 | return; | |
799 | ||
800 | if (dso->short_name_allocated) | |
801 | free((char *)dso->short_name); | |
802 | ||
803 | dso->short_name = name; | |
804 | dso->short_name_len = strlen(name); | |
805 | dso->short_name_allocated = name_allocated; | |
806 | } | |
807 | ||
808 | static void dso__set_basename(struct dso *dso) | |
809 | { | |
810 | /* | |
811 | * basename() may modify path buffer, so we must pass | |
812 | * a copy. | |
813 | */ | |
814 | char *base, *lname = strdup(dso->long_name); | |
815 | ||
816 | if (!lname) | |
817 | return; | |
818 | ||
819 | /* | |
820 | * basename() may return a pointer to internal | |
821 | * storage which is reused in subsequent calls | |
822 | * so copy the result. | |
823 | */ | |
824 | base = strdup(basename(lname)); | |
825 | ||
826 | free(lname); | |
827 | ||
828 | if (!base) | |
829 | return; | |
830 | ||
831 | dso__set_short_name(dso, base, true); | |
832 | } | |
833 | ||
834 | int dso__name_len(const struct dso *dso) | |
835 | { | |
836 | if (!dso) | |
837 | return strlen("[unknown]"); | |
838 | if (verbose) | |
839 | return dso->long_name_len; | |
840 | ||
841 | return dso->short_name_len; | |
842 | } | |
843 | ||
844 | bool dso__loaded(const struct dso *dso, enum map_type type) | |
845 | { | |
846 | return dso->loaded & (1 << type); | |
847 | } | |
848 | ||
849 | bool dso__sorted_by_name(const struct dso *dso, enum map_type type) | |
850 | { | |
851 | return dso->sorted_by_name & (1 << type); | |
852 | } | |
853 | ||
854 | void dso__set_sorted_by_name(struct dso *dso, enum map_type type) | |
855 | { | |
856 | dso->sorted_by_name |= (1 << type); | |
857 | } | |
858 | ||
859 | struct dso *dso__new(const char *name) | |
860 | { | |
861 | struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1); | |
862 | ||
863 | if (dso != NULL) { | |
864 | int i; | |
865 | strcpy(dso->name, name); | |
866 | dso__set_long_name(dso, dso->name, false); | |
867 | dso__set_short_name(dso, dso->name, false); | |
868 | for (i = 0; i < MAP__NR_TYPES; ++i) | |
869 | dso->symbols[i] = dso->symbol_names[i] = RB_ROOT; | |
870 | dso->data.cache = RB_ROOT; | |
871 | dso->data.fd = -1; | |
872 | dso->data.status = DSO_DATA_STATUS_UNKNOWN; | |
873 | dso->symtab_type = DSO_BINARY_TYPE__NOT_FOUND; | |
874 | dso->binary_type = DSO_BINARY_TYPE__NOT_FOUND; | |
875 | dso->is_64_bit = (sizeof(void *) == 8); | |
876 | dso->loaded = 0; | |
877 | dso->rel = 0; | |
878 | dso->sorted_by_name = 0; | |
879 | dso->has_build_id = 0; | |
880 | dso->has_srcline = 1; | |
881 | dso->a2l_fails = 1; | |
882 | dso->kernel = DSO_TYPE_USER; | |
883 | dso->needs_swap = DSO_SWAP__UNSET; | |
884 | RB_CLEAR_NODE(&dso->rb_node); | |
885 | INIT_LIST_HEAD(&dso->node); | |
886 | INIT_LIST_HEAD(&dso->data.open_entry); | |
887 | } | |
888 | ||
889 | return dso; | |
890 | } | |
891 | ||
892 | void dso__delete(struct dso *dso) | |
893 | { | |
894 | int i; | |
895 | ||
896 | if (!RB_EMPTY_NODE(&dso->rb_node)) | |
897 | pr_err("DSO %s is still in rbtree when being deleted!\n", | |
898 | dso->long_name); | |
899 | for (i = 0; i < MAP__NR_TYPES; ++i) | |
900 | symbols__delete(&dso->symbols[i]); | |
901 | ||
902 | if (dso->short_name_allocated) { | |
903 | zfree((char **)&dso->short_name); | |
904 | dso->short_name_allocated = false; | |
905 | } | |
906 | ||
907 | if (dso->long_name_allocated) { | |
908 | zfree((char **)&dso->long_name); | |
909 | dso->long_name_allocated = false; | |
910 | } | |
911 | ||
912 | dso__data_close(dso); | |
913 | dso_cache__free(&dso->data.cache); | |
914 | dso__free_a2l(dso); | |
915 | zfree(&dso->symsrc_filename); | |
916 | free(dso); | |
917 | } | |
918 | ||
919 | void dso__set_build_id(struct dso *dso, void *build_id) | |
920 | { | |
921 | memcpy(dso->build_id, build_id, sizeof(dso->build_id)); | |
922 | dso->has_build_id = 1; | |
923 | } | |
924 | ||
925 | bool dso__build_id_equal(const struct dso *dso, u8 *build_id) | |
926 | { | |
927 | return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0; | |
928 | } | |
929 | ||
930 | void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine) | |
931 | { | |
932 | char path[PATH_MAX]; | |
933 | ||
934 | if (machine__is_default_guest(machine)) | |
935 | return; | |
936 | sprintf(path, "%s/sys/kernel/notes", machine->root_dir); | |
937 | if (sysfs__read_build_id(path, dso->build_id, | |
938 | sizeof(dso->build_id)) == 0) | |
939 | dso->has_build_id = true; | |
940 | } | |
941 | ||
942 | int dso__kernel_module_get_build_id(struct dso *dso, | |
943 | const char *root_dir) | |
944 | { | |
945 | char filename[PATH_MAX]; | |
946 | /* | |
947 | * kernel module short names are of the form "[module]" and | |
948 | * we need just "module" here. | |
949 | */ | |
950 | const char *name = dso->short_name + 1; | |
951 | ||
952 | snprintf(filename, sizeof(filename), | |
953 | "%s/sys/module/%.*s/notes/.note.gnu.build-id", | |
954 | root_dir, (int)strlen(name) - 1, name); | |
955 | ||
956 | if (sysfs__read_build_id(filename, dso->build_id, | |
957 | sizeof(dso->build_id)) == 0) | |
958 | dso->has_build_id = true; | |
959 | ||
960 | return 0; | |
961 | } | |
962 | ||
963 | bool __dsos__read_build_ids(struct list_head *head, bool with_hits) | |
964 | { | |
965 | bool have_build_id = false; | |
966 | struct dso *pos; | |
967 | ||
968 | list_for_each_entry(pos, head, node) { | |
969 | if (with_hits && !pos->hit) | |
970 | continue; | |
971 | if (pos->has_build_id) { | |
972 | have_build_id = true; | |
973 | continue; | |
974 | } | |
975 | if (filename__read_build_id(pos->long_name, pos->build_id, | |
976 | sizeof(pos->build_id)) > 0) { | |
977 | have_build_id = true; | |
978 | pos->has_build_id = true; | |
979 | } | |
980 | } | |
981 | ||
982 | return have_build_id; | |
983 | } | |
984 | ||
985 | void dsos__add(struct dsos *dsos, struct dso *dso) | |
986 | { | |
987 | list_add_tail(&dso->node, &dsos->head); | |
988 | dso__findlink_by_longname(&dsos->root, dso, NULL); | |
989 | } | |
990 | ||
991 | struct dso *dsos__find(const struct dsos *dsos, const char *name, | |
992 | bool cmp_short) | |
993 | { | |
994 | struct dso *pos; | |
995 | ||
996 | if (cmp_short) { | |
997 | list_for_each_entry(pos, &dsos->head, node) | |
998 | if (strcmp(pos->short_name, name) == 0) | |
999 | return pos; | |
1000 | return NULL; | |
1001 | } | |
1002 | return dso__find_by_longname(&dsos->root, name); | |
1003 | } | |
1004 | ||
1005 | struct dso *__dsos__findnew(struct dsos *dsos, const char *name) | |
1006 | { | |
1007 | struct dso *dso = dsos__find(dsos, name, false); | |
1008 | ||
1009 | if (!dso) { | |
1010 | dso = dso__new(name); | |
1011 | if (dso != NULL) { | |
1012 | dsos__add(dsos, dso); | |
1013 | dso__set_basename(dso); | |
1014 | } | |
1015 | } | |
1016 | ||
1017 | return dso; | |
1018 | } | |
1019 | ||
1020 | size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp, | |
1021 | bool (skip)(struct dso *dso, int parm), int parm) | |
1022 | { | |
1023 | struct dso *pos; | |
1024 | size_t ret = 0; | |
1025 | ||
1026 | list_for_each_entry(pos, head, node) { | |
1027 | if (skip && skip(pos, parm)) | |
1028 | continue; | |
1029 | ret += dso__fprintf_buildid(pos, fp); | |
1030 | ret += fprintf(fp, " %s\n", pos->long_name); | |
1031 | } | |
1032 | return ret; | |
1033 | } | |
1034 | ||
1035 | size_t __dsos__fprintf(struct list_head *head, FILE *fp) | |
1036 | { | |
1037 | struct dso *pos; | |
1038 | size_t ret = 0; | |
1039 | ||
1040 | list_for_each_entry(pos, head, node) { | |
1041 | int i; | |
1042 | for (i = 0; i < MAP__NR_TYPES; ++i) | |
1043 | ret += dso__fprintf(pos, i, fp); | |
1044 | } | |
1045 | ||
1046 | return ret; | |
1047 | } | |
1048 | ||
1049 | size_t dso__fprintf_buildid(struct dso *dso, FILE *fp) | |
1050 | { | |
1051 | char sbuild_id[BUILD_ID_SIZE * 2 + 1]; | |
1052 | ||
1053 | build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id); | |
1054 | return fprintf(fp, "%s", sbuild_id); | |
1055 | } | |
1056 | ||
1057 | size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp) | |
1058 | { | |
1059 | struct rb_node *nd; | |
1060 | size_t ret = fprintf(fp, "dso: %s (", dso->short_name); | |
1061 | ||
1062 | if (dso->short_name != dso->long_name) | |
1063 | ret += fprintf(fp, "%s, ", dso->long_name); | |
1064 | ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type], | |
1065 | dso__loaded(dso, type) ? "" : "NOT "); | |
1066 | ret += dso__fprintf_buildid(dso, fp); | |
1067 | ret += fprintf(fp, ")\n"); | |
1068 | for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) { | |
1069 | struct symbol *pos = rb_entry(nd, struct symbol, rb_node); | |
1070 | ret += symbol__fprintf(pos, fp); | |
1071 | } | |
1072 | ||
1073 | return ret; | |
1074 | } | |
1075 | ||
1076 | enum dso_type dso__type(struct dso *dso, struct machine *machine) | |
1077 | { | |
1078 | int fd; | |
1079 | ||
1080 | fd = dso__data_fd(dso, machine); | |
1081 | if (fd < 0) | |
1082 | return DSO__TYPE_UNKNOWN; | |
1083 | ||
1084 | return dso__type_fd(fd); | |
1085 | } |