1#include "symbol.h" 2#include <errno.h> 3#include <inttypes.h> 4#include <limits.h> 5#include <stdlib.h> 6#include <string.h> 7#include <stdio.h> 8#include <unistd.h> 9#include "map.h" 10#include "thread.h" 11#include "strlist.h" 12#include "vdso.h" 13#include "build-id.h" 14#include "util.h" 15#include "debug.h" 16#include "machine.h" 17#include <linux/string.h> 18 19const char *map_type__name[MAP__NR_TYPES] = { 20 [MAP__FUNCTION] = "Functions", 21 [MAP__VARIABLE] = "Variables", 22}; 23 24static inline int is_anon_memory(const char *filename) 25{ 26 return !strcmp(filename, "//anon") || 27 !strcmp(filename, "/dev/zero (deleted)") || 28 !strcmp(filename, "/anon_hugepage (deleted)"); 29} 30 31static inline int is_no_dso_memory(const char *filename) 32{ 33 return !strncmp(filename, "[stack", 6) || 34 !strncmp(filename, "/SYSV",5) || 35 !strcmp(filename, "[heap]"); 36} 37 38static inline int is_android_lib(const char *filename) 39{ 40 return !strncmp(filename, "/data/app-lib", 13) || 41 !strncmp(filename, "/system/lib", 11); 42} 43 44static inline bool replace_android_lib(const char *filename, char *newfilename) 45{ 46 const char *libname; 47 char *app_abi; 48 size_t app_abi_length, new_length; 49 size_t lib_length = 0; 50 51 libname = strrchr(filename, '/'); 52 if (libname) 53 lib_length = strlen(libname); 54 55 app_abi = getenv("APP_ABI"); 56 if (!app_abi) 57 return false; 58 59 app_abi_length = strlen(app_abi); 60 61 if (!strncmp(filename, "/data/app-lib", 13)) { 62 char *apk_path; 63 64 if (!app_abi_length) 65 return false; 66 67 new_length = 7 + app_abi_length + lib_length; 68 69 apk_path = getenv("APK_PATH"); 70 if (apk_path) { 71 new_length += strlen(apk_path) + 1; 72 if (new_length > PATH_MAX) 73 return false; 74 snprintf(newfilename, new_length, 75 "%s/libs/%s/%s", apk_path, app_abi, libname); 76 } else { 77 if (new_length > PATH_MAX) 78 return false; 79 snprintf(newfilename, new_length, 80 "libs/%s/%s", app_abi, libname); 81 } 82 return true; 83 } 84 85 if (!strncmp(filename, "/system/lib/", 11)) { 86 char *ndk, *app; 87 const char *arch; 88 size_t ndk_length; 89 size_t app_length; 90 91 ndk = getenv("NDK_ROOT"); 92 app = getenv("APP_PLATFORM"); 93 94 if (!(ndk && app)) 95 return false; 96 97 ndk_length = strlen(ndk); 98 app_length = strlen(app); 99 100 if (!(ndk_length && app_length && app_abi_length)) 101 return false; 102 103 arch = !strncmp(app_abi, "arm", 3) ? "arm" : 104 !strncmp(app_abi, "mips", 4) ? "mips" : 105 !strncmp(app_abi, "x86", 3) ? "x86" : NULL; 106 107 if (!arch) 108 return false; 109 110 new_length = 27 + ndk_length + 111 app_length + lib_length 112 + strlen(arch); 113 114 if (new_length > PATH_MAX) 115 return false; 116 snprintf(newfilename, new_length, 117 "%s/platforms/%s/arch-%s/usr/lib/%s", 118 ndk, app, arch, libname); 119 120 return true; 121 } 122 return false; 123} 124 125void map__init(struct map *map, enum map_type type, 126 u64 start, u64 end, u64 pgoff, struct dso *dso) 127{ 128 map->type = type; 129 map->start = start; 130 map->end = end; 131 map->pgoff = pgoff; 132 map->reloc = 0; 133 map->dso = dso; 134 map->map_ip = map__map_ip; 135 map->unmap_ip = map__unmap_ip; 136 RB_CLEAR_NODE(&map->rb_node); 137 map->groups = NULL; 138 map->referenced = false; 139 map->erange_warned = false; 140} 141 142struct map *map__new(struct machine *machine, u64 start, u64 len, 143 u64 pgoff, u32 pid, u32 d_maj, u32 d_min, u64 ino, 144 u64 ino_gen, u32 prot, u32 flags, char *filename, 145 enum map_type type, struct thread *thread) 146{ 147 struct map *map = malloc(sizeof(*map)); 148 149 if (map != NULL) { 150 char newfilename[PATH_MAX]; 151 struct dso *dso; 152 int anon, no_dso, vdso, android; 153 154 android = is_android_lib(filename); 155 anon = is_anon_memory(filename); 156 vdso = is_vdso_map(filename); 157 no_dso = is_no_dso_memory(filename); 158 159 map->maj = d_maj; 160 map->min = d_min; 161 map->ino = ino; 162 map->ino_generation = ino_gen; 163 map->prot = prot; 164 map->flags = flags; 165 166 if ((anon || no_dso) && type == MAP__FUNCTION) { 167 snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid); 168 filename = newfilename; 169 } 170 171 if (android) { 172 if (replace_android_lib(filename, newfilename)) 173 filename = newfilename; 174 } 175 176 if (vdso) { 177 pgoff = 0; 178 dso = vdso__dso_findnew(machine, thread); 179 } else 180 dso = __dsos__findnew(&machine->user_dsos, filename); 181 182 if (dso == NULL) 183 goto out_delete; 184 185 map__init(map, type, start, start + len, pgoff, dso); 186 187 if (anon || no_dso) { 188 map->map_ip = map->unmap_ip = identity__map_ip; 189 190 /* 191 * Set memory without DSO as loaded. All map__find_* 192 * functions still return NULL, and we avoid the 193 * unnecessary map__load warning. 194 */ 195 if (type != MAP__FUNCTION) 196 dso__set_loaded(dso, map->type); 197 } 198 } 199 return map; 200out_delete: 201 free(map); 202 return NULL; 203} 204 205/* 206 * Constructor variant for modules (where we know from /proc/modules where 207 * they are loaded) and for vmlinux, where only after we load all the 208 * symbols we'll know where it starts and ends. 209 */ 210struct map *map__new2(u64 start, struct dso *dso, enum map_type type) 211{ 212 struct map *map = calloc(1, (sizeof(*map) + 213 (dso->kernel ? sizeof(struct kmap) : 0))); 214 if (map != NULL) { 215 /* 216 * ->end will be filled after we load all the symbols 217 */ 218 map__init(map, type, start, 0, 0, dso); 219 } 220 221 return map; 222} 223 224void map__delete(struct map *map) 225{ 226 free(map); 227} 228 229void map__fixup_start(struct map *map) 230{ 231 struct rb_root *symbols = &map->dso->symbols[map->type]; 232 struct rb_node *nd = rb_first(symbols); 233 if (nd != NULL) { 234 struct symbol *sym = rb_entry(nd, struct symbol, rb_node); 235 map->start = sym->start; 236 } 237} 238 239void map__fixup_end(struct map *map) 240{ 241 struct rb_root *symbols = &map->dso->symbols[map->type]; 242 struct rb_node *nd = rb_last(symbols); 243 if (nd != NULL) { 244 struct symbol *sym = rb_entry(nd, struct symbol, rb_node); 245 map->end = sym->end; 246 } 247} 248 249#define DSO__DELETED "(deleted)" 250 251int map__load(struct map *map, symbol_filter_t filter) 252{ 253 const char *name = map->dso->long_name; 254 int nr; 255 256 if (dso__loaded(map->dso, map->type)) 257 return 0; 258 259 nr = dso__load(map->dso, map, filter); 260 if (nr < 0) { 261 if (map->dso->has_build_id) { 262 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 263 264 build_id__sprintf(map->dso->build_id, 265 sizeof(map->dso->build_id), 266 sbuild_id); 267 pr_warning("%s with build id %s not found", 268 name, sbuild_id); 269 } else 270 pr_warning("Failed to open %s", name); 271 272 pr_warning(", continuing without symbols\n"); 273 return -1; 274 } else if (nr == 0) { 275#ifdef HAVE_LIBELF_SUPPORT 276 const size_t len = strlen(name); 277 const size_t real_len = len - sizeof(DSO__DELETED); 278 279 if (len > sizeof(DSO__DELETED) && 280 strcmp(name + real_len + 1, DSO__DELETED) == 0) { 281 pr_warning("%.*s was updated (is prelink enabled?). " 282 "Restart the long running apps that use it!\n", 283 (int)real_len, name); 284 } else { 285 pr_warning("no symbols found in %s, maybe install " 286 "a debug package?\n", name); 287 } 288#endif 289 return -1; 290 } 291 292 return 0; 293} 294 295struct symbol *map__find_symbol(struct map *map, u64 addr, 296 symbol_filter_t filter) 297{ 298 if (map__load(map, filter) < 0) 299 return NULL; 300 301 return dso__find_symbol(map->dso, map->type, addr); 302} 303 304struct symbol *map__find_symbol_by_name(struct map *map, const char *name, 305 symbol_filter_t filter) 306{ 307 if (map__load(map, filter) < 0) 308 return NULL; 309 310 if (!dso__sorted_by_name(map->dso, map->type)) 311 dso__sort_by_name(map->dso, map->type); 312 313 return dso__find_symbol_by_name(map->dso, map->type, name); 314} 315 316struct map *map__clone(struct map *map) 317{ 318 return memdup(map, sizeof(*map)); 319} 320 321int map__overlap(struct map *l, struct map *r) 322{ 323 if (l->start > r->start) { 324 struct map *t = l; 325 l = r; 326 r = t; 327 } 328 329 if (l->end > r->start) 330 return 1; 331 332 return 0; 333} 334 335size_t map__fprintf(struct map *map, FILE *fp) 336{ 337 return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n", 338 map->start, map->end, map->pgoff, map->dso->name); 339} 340 341size_t map__fprintf_dsoname(struct map *map, FILE *fp) 342{ 343 const char *dsoname = "[unknown]"; 344 345 if (map && map->dso && (map->dso->name || map->dso->long_name)) { 346 if (symbol_conf.show_kernel_path && map->dso->long_name) 347 dsoname = map->dso->long_name; 348 else if (map->dso->name) 349 dsoname = map->dso->name; 350 } 351 352 return fprintf(fp, "%s", dsoname); 353} 354 355int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix, 356 FILE *fp) 357{ 358 char *srcline; 359 int ret = 0; 360 361 if (map && map->dso) { 362 srcline = get_srcline(map->dso, 363 map__rip_2objdump(map, addr), NULL, true); 364 if (srcline != SRCLINE_UNKNOWN) 365 ret = fprintf(fp, "%s%s", prefix, srcline); 366 free_srcline(srcline); 367 } 368 return ret; 369} 370 371/** 372 * map__rip_2objdump - convert symbol start address to objdump address. 373 * @map: memory map 374 * @rip: symbol start address 375 * 376 * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN. 377 * map->dso->adjust_symbols==1 for ET_EXEC-like cases except ET_REL which is 378 * relative to section start. 379 * 380 * Return: Address suitable for passing to "objdump --start-address=" 381 */ 382u64 map__rip_2objdump(struct map *map, u64 rip) 383{ 384 if (!map->dso->adjust_symbols) 385 return rip; 386 387 if (map->dso->rel) 388 return rip - map->pgoff; 389 390 return map->unmap_ip(map, rip) - map->reloc; 391} 392 393/** 394 * map__objdump_2mem - convert objdump address to a memory address. 395 * @map: memory map 396 * @ip: objdump address 397 * 398 * Closely related to map__rip_2objdump(), this function takes an address from 399 * objdump and converts it to a memory address. Note this assumes that @map 400 * contains the address. To be sure the result is valid, check it forwards 401 * e.g. map__rip_2objdump(map->map_ip(map, map__objdump_2mem(map, ip))) == ip 402 * 403 * Return: Memory address. 404 */ 405u64 map__objdump_2mem(struct map *map, u64 ip) 406{ 407 if (!map->dso->adjust_symbols) 408 return map->unmap_ip(map, ip); 409 410 if (map->dso->rel) 411 return map->unmap_ip(map, ip + map->pgoff); 412 413 return ip + map->reloc; 414} 415 416void map_groups__init(struct map_groups *mg, struct machine *machine) 417{ 418 int i; 419 for (i = 0; i < MAP__NR_TYPES; ++i) { 420 mg->maps[i] = RB_ROOT; 421 INIT_LIST_HEAD(&mg->removed_maps[i]); 422 } 423 mg->machine = machine; 424 mg->refcnt = 1; 425} 426 427static void maps__delete(struct rb_root *maps) 428{ 429 struct rb_node *next = rb_first(maps); 430 431 while (next) { 432 struct map *pos = rb_entry(next, struct map, rb_node); 433 434 next = rb_next(&pos->rb_node); 435 rb_erase(&pos->rb_node, maps); 436 map__delete(pos); 437 } 438} 439 440static void maps__delete_removed(struct list_head *maps) 441{ 442 struct map *pos, *n; 443 444 list_for_each_entry_safe(pos, n, maps, node) { 445 list_del(&pos->node); 446 map__delete(pos); 447 } 448} 449 450void map_groups__exit(struct map_groups *mg) 451{ 452 int i; 453 454 for (i = 0; i < MAP__NR_TYPES; ++i) { 455 maps__delete(&mg->maps[i]); 456 maps__delete_removed(&mg->removed_maps[i]); 457 } 458} 459 460bool map_groups__empty(struct map_groups *mg) 461{ 462 int i; 463 464 for (i = 0; i < MAP__NR_TYPES; ++i) { 465 if (maps__first(&mg->maps[i])) 466 return false; 467 if (!list_empty(&mg->removed_maps[i])) 468 return false; 469 } 470 471 return true; 472} 473 474struct map_groups *map_groups__new(struct machine *machine) 475{ 476 struct map_groups *mg = malloc(sizeof(*mg)); 477 478 if (mg != NULL) 479 map_groups__init(mg, machine); 480 481 return mg; 482} 483 484void map_groups__delete(struct map_groups *mg) 485{ 486 map_groups__exit(mg); 487 free(mg); 488} 489 490void map_groups__put(struct map_groups *mg) 491{ 492 if (--mg->refcnt == 0) 493 map_groups__delete(mg); 494} 495 496void map_groups__flush(struct map_groups *mg) 497{ 498 int type; 499 500 for (type = 0; type < MAP__NR_TYPES; type++) { 501 struct rb_root *root = &mg->maps[type]; 502 struct rb_node *next = rb_first(root); 503 504 while (next) { 505 struct map *pos = rb_entry(next, struct map, rb_node); 506 next = rb_next(&pos->rb_node); 507 rb_erase(&pos->rb_node, root); 508 /* 509 * We may have references to this map, for 510 * instance in some hist_entry instances, so 511 * just move them to a separate list. 512 */ 513 list_add_tail(&pos->node, &mg->removed_maps[pos->type]); 514 } 515 } 516} 517 518struct symbol *map_groups__find_symbol(struct map_groups *mg, 519 enum map_type type, u64 addr, 520 struct map **mapp, 521 symbol_filter_t filter) 522{ 523 struct map *map = map_groups__find(mg, type, addr); 524 525 /* Ensure map is loaded before using map->map_ip */ 526 if (map != NULL && map__load(map, filter) >= 0) { 527 if (mapp != NULL) 528 *mapp = map; 529 return map__find_symbol(map, map->map_ip(map, addr), filter); 530 } 531 532 return NULL; 533} 534 535struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg, 536 enum map_type type, 537 const char *name, 538 struct map **mapp, 539 symbol_filter_t filter) 540{ 541 struct rb_node *nd; 542 543 for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) { 544 struct map *pos = rb_entry(nd, struct map, rb_node); 545 struct symbol *sym = map__find_symbol_by_name(pos, name, filter); 546 547 if (sym == NULL) 548 continue; 549 if (mapp != NULL) 550 *mapp = pos; 551 return sym; 552 } 553 554 return NULL; 555} 556 557int map_groups__find_ams(struct addr_map_symbol *ams, symbol_filter_t filter) 558{ 559 if (ams->addr < ams->map->start || ams->addr >= ams->map->end) { 560 if (ams->map->groups == NULL) 561 return -1; 562 ams->map = map_groups__find(ams->map->groups, ams->map->type, 563 ams->addr); 564 if (ams->map == NULL) 565 return -1; 566 } 567 568 ams->al_addr = ams->map->map_ip(ams->map, ams->addr); 569 ams->sym = map__find_symbol(ams->map, ams->al_addr, filter); 570 571 return ams->sym ? 0 : -1; 572} 573 574size_t __map_groups__fprintf_maps(struct map_groups *mg, enum map_type type, 575 FILE *fp) 576{ 577 size_t printed = fprintf(fp, "%s:\n", map_type__name[type]); 578 struct rb_node *nd; 579 580 for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) { 581 struct map *pos = rb_entry(nd, struct map, rb_node); 582 printed += fprintf(fp, "Map:"); 583 printed += map__fprintf(pos, fp); 584 if (verbose > 2) { 585 printed += dso__fprintf(pos->dso, type, fp); 586 printed += fprintf(fp, "--\n"); 587 } 588 } 589 590 return printed; 591} 592 593static size_t map_groups__fprintf_maps(struct map_groups *mg, FILE *fp) 594{ 595 size_t printed = 0, i; 596 for (i = 0; i < MAP__NR_TYPES; ++i) 597 printed += __map_groups__fprintf_maps(mg, i, fp); 598 return printed; 599} 600 601static size_t __map_groups__fprintf_removed_maps(struct map_groups *mg, 602 enum map_type type, FILE *fp) 603{ 604 struct map *pos; 605 size_t printed = 0; 606 607 list_for_each_entry(pos, &mg->removed_maps[type], node) { 608 printed += fprintf(fp, "Map:"); 609 printed += map__fprintf(pos, fp); 610 if (verbose > 1) { 611 printed += dso__fprintf(pos->dso, type, fp); 612 printed += fprintf(fp, "--\n"); 613 } 614 } 615 return printed; 616} 617 618static size_t map_groups__fprintf_removed_maps(struct map_groups *mg, 619 FILE *fp) 620{ 621 size_t printed = 0, i; 622 for (i = 0; i < MAP__NR_TYPES; ++i) 623 printed += __map_groups__fprintf_removed_maps(mg, i, fp); 624 return printed; 625} 626 627size_t map_groups__fprintf(struct map_groups *mg, FILE *fp) 628{ 629 size_t printed = map_groups__fprintf_maps(mg, fp); 630 printed += fprintf(fp, "Removed maps:\n"); 631 return printed + map_groups__fprintf_removed_maps(mg, fp); 632} 633 634int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map, 635 FILE *fp) 636{ 637 struct rb_root *root = &mg->maps[map->type]; 638 struct rb_node *next = rb_first(root); 639 int err = 0; 640 641 while (next) { 642 struct map *pos = rb_entry(next, struct map, rb_node); 643 next = rb_next(&pos->rb_node); 644 645 if (!map__overlap(pos, map)) 646 continue; 647 648 if (verbose >= 2) { 649 fputs("overlapping maps:\n", fp); 650 map__fprintf(map, fp); 651 map__fprintf(pos, fp); 652 } 653 654 rb_erase(&pos->rb_node, root); 655 /* 656 * Now check if we need to create new maps for areas not 657 * overlapped by the new map: 658 */ 659 if (map->start > pos->start) { 660 struct map *before = map__clone(pos); 661 662 if (before == NULL) { 663 err = -ENOMEM; 664 goto move_map; 665 } 666 667 before->end = map->start; 668 map_groups__insert(mg, before); 669 if (verbose >= 2) 670 map__fprintf(before, fp); 671 } 672 673 if (map->end < pos->end) { 674 struct map *after = map__clone(pos); 675 676 if (after == NULL) { 677 err = -ENOMEM; 678 goto move_map; 679 } 680 681 after->start = map->end; 682 map_groups__insert(mg, after); 683 if (verbose >= 2) 684 map__fprintf(after, fp); 685 } 686move_map: 687 /* 688 * If we have references, just move them to a separate list. 689 */ 690 if (pos->referenced) 691 list_add_tail(&pos->node, &mg->removed_maps[map->type]); 692 else 693 map__delete(pos); 694 695 if (err) 696 return err; 697 } 698 699 return 0; 700} 701 702/* 703 * XXX This should not really _copy_ te maps, but refcount them. 704 */ 705int map_groups__clone(struct map_groups *mg, 706 struct map_groups *parent, enum map_type type) 707{ 708 struct rb_node *nd; 709 for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) { 710 struct map *map = rb_entry(nd, struct map, rb_node); 711 struct map *new = map__clone(map); 712 if (new == NULL) 713 return -ENOMEM; 714 map_groups__insert(mg, new); 715 } 716 return 0; 717} 718 719void maps__insert(struct rb_root *maps, struct map *map) 720{ 721 struct rb_node **p = &maps->rb_node; 722 struct rb_node *parent = NULL; 723 const u64 ip = map->start; 724 struct map *m; 725 726 while (*p != NULL) { 727 parent = *p; 728 m = rb_entry(parent, struct map, rb_node); 729 if (ip < m->start) 730 p = &(*p)->rb_left; 731 else 732 p = &(*p)->rb_right; 733 } 734 735 rb_link_node(&map->rb_node, parent, p); 736 rb_insert_color(&map->rb_node, maps); 737} 738 739void maps__remove(struct rb_root *maps, struct map *map) 740{ 741 rb_erase(&map->rb_node, maps); 742} 743 744struct map *maps__find(struct rb_root *maps, u64 ip) 745{ 746 struct rb_node **p = &maps->rb_node; 747 struct rb_node *parent = NULL; 748 struct map *m; 749 750 while (*p != NULL) { 751 parent = *p; 752 m = rb_entry(parent, struct map, rb_node); 753 if (ip < m->start) 754 p = &(*p)->rb_left; 755 else if (ip >= m->end) 756 p = &(*p)->rb_right; 757 else 758 return m; 759 } 760 761 return NULL; 762} 763 764struct map *maps__first(struct rb_root *maps) 765{ 766 struct rb_node *first = rb_first(maps); 767 768 if (first) 769 return rb_entry(first, struct map, rb_node); 770 return NULL; 771} 772 773struct map *maps__next(struct map *map) 774{ 775 struct rb_node *next = rb_next(&map->rb_node); 776 777 if (next) 778 return rb_entry(next, struct map, rb_node); 779 return NULL; 780} 781 782struct kmap *map__kmap(struct map *map) 783{ 784 if (!map->dso || !map->dso->kernel) { 785 pr_err("Internal error: map__kmap with a non-kernel map\n"); 786 return NULL; 787 } 788 return (struct kmap *)(map + 1); 789} 790 791struct map_groups *map__kmaps(struct map *map) 792{ 793 struct kmap *kmap = map__kmap(map); 794 795 if (!kmap || !kmap->kmaps) { 796 pr_err("Internal error: map__kmaps with a non-kernel map\n"); 797 return NULL; 798 } 799 return kmap->kmaps; 800} 801