tools/perf/util/map.c

   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 "strlist.h"
  13 #include "vdso.h"
  14 #include "build-id.h"
  15 #include "util.h"
  16 #include "debug.h"
  17 #include "machine.h"
  18 #include <linux/string.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 }