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