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