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 "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                !strncmp(filename, "/SYSV",5)   ||
  35                !strcmp(filename, "[heap]");
  36 }
  37
  38 static 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
  44 static 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
 125 void 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
 142 struct 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;
 200 out_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  */
 210 struct 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
 224 void map__delete(struct map *map)
 225 {
 226         free(map);
 227 }
 228
 229 void 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
 239 void 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
 251 int 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
 295 int __weak arch__compare_symbol_names(const char *namea, const char *nameb)
 296 {
 297         return strcmp(namea, nameb);
 298 }
 299
 300 struct symbol *map__find_symbol(struct map *map, u64 addr,
 301                                 symbol_filter_t filter)
 302 {
 303         if (map__load(map, filter) < 0)
 304                 return NULL;
 305
 306         return dso__find_symbol(map->dso, map->type, addr);
 307 }
 308
 309 struct symbol *map__find_symbol_by_name(struct map *map, const char *name,
 310                                         symbol_filter_t filter)
 311 {
 312         if (map__load(map, filter) < 0)
 313                 return NULL;
 314
 315         if (!dso__sorted_by_name(map->dso, map->type))
 316                 dso__sort_by_name(map->dso, map->type);
 317
 318         return dso__find_symbol_by_name(map->dso, map->type, name);
 319 }
 320
 321 struct map *map__clone(struct map *map)
 322 {
 323         return memdup(map, sizeof(*map));
 324 }
 325
 326 int map__overlap(struct map *l, struct map *r)
 327 {
 328         if (l->start > r->start) {
 329                 struct map *t = l;
 330                 l = r;
 331                 r = t;
 332         }
 333
 334         if (l->end > r->start)
 335                 return 1;
 336
 337         return 0;
 338 }
 339
 340 size_t map__fprintf(struct map *map, FILE *fp)
 341 {
 342         return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n",
 343                        map->start, map->end, map->pgoff, map->dso->name);
 344 }
 345
 346 size_t map__fprintf_dsoname(struct map *map, FILE *fp)
 347 {
 348         const char *dsoname = "[unknown]";
 349
 350         if (map && map->dso && (map->dso->name || map->dso->long_name)) {
 351                 if (symbol_conf.show_kernel_path && map->dso->long_name)
 352                         dsoname = map->dso->long_name;
 353                 else if (map->dso->name)
 354                         dsoname = map->dso->name;
 355         }
 356
 357         return fprintf(fp, "%s", dsoname);
 358 }
 359
 360 int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix,
 361                          FILE *fp)
 362 {
 363         char *srcline;
 364         int ret = 0;
 365
 366         if (map && map->dso) {
 367                 srcline = get_srcline(map->dso,
 368                                       map__rip_2objdump(map, addr), NULL, true);
 369                 if (srcline != SRCLINE_UNKNOWN)
 370                         ret = fprintf(fp, "%s%s", prefix, srcline);
 371                 free_srcline(srcline);
 372         }
 373         return ret;
 374 }
 375
 376 /**
 377  * map__rip_2objdump - convert symbol start address to objdump address.
 378  * @map: memory map
 379  * @rip: symbol start address
 380  *
 381  * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
 382  * map->dso->adjust_symbols==1 for ET_EXEC-like cases except ET_REL which is
 383  * relative to section start.
 384  *
 385  * Return: Address suitable for passing to "objdump --start-address="
 386  */
 387 u64 map__rip_2objdump(struct map *map, u64 rip)
 388 {
 389         if (!map->dso->adjust_symbols)
 390                 return rip;
 391
 392         if (map->dso->rel)
 393                 return rip - map->pgoff;
 394
 395         return map->unmap_ip(map, rip) - map->reloc;
 396 }
 397
 398 /**
 399  * map__objdump_2mem - convert objdump address to a memory address.
 400  * @map: memory map
 401  * @ip: objdump address
 402  *
 403  * Closely related to map__rip_2objdump(), this function takes an address from
 404  * objdump and converts it to a memory address.  Note this assumes that @map
 405  * contains the address.  To be sure the result is valid, check it forwards
 406  * e.g. map__rip_2objdump(map->map_ip(map, map__objdump_2mem(map, ip))) == ip
 407  *
 408  * Return: Memory address.
 409  */
 410 u64 map__objdump_2mem(struct map *map, u64 ip)
 411 {
 412         if (!map->dso->adjust_symbols)
 413                 return map->unmap_ip(map, ip);
 414
 415         if (map->dso->rel)
 416                 return map->unmap_ip(map, ip + map->pgoff);
 417
 418         return ip + map->reloc;
 419 }
 420
 421 void map_groups__init(struct map_groups *mg, struct machine *machine)
 422 {
 423         int i;
 424         for (i = 0; i < MAP__NR_TYPES; ++i) {
 425                 mg->maps[i] = RB_ROOT;
 426                 INIT_LIST_HEAD(&mg->removed_maps[i]);
 427         }
 428         mg->machine = machine;
 429         atomic_set(&mg->refcnt, 1);
 430 }
 431
 432 static void maps__delete(struct rb_root *maps)
 433 {
 434         struct rb_node *next = rb_first(maps);
 435
 436         while (next) {
 437                 struct map *pos = rb_entry(next, struct map, rb_node);
 438
 439                 next = rb_next(&pos->rb_node);
 440                 rb_erase(&pos->rb_node, maps);
 441                 map__delete(pos);
 442         }
 443 }
 444
 445 static void maps__delete_removed(struct list_head *maps)
 446 {
 447         struct map *pos, *n;
 448
 449         list_for_each_entry_safe(pos, n, maps, node) {
 450                 list_del(&pos->node);
 451                 map__delete(pos);
 452         }
 453 }
 454
 455 void map_groups__exit(struct map_groups *mg)
 456 {
 457         int i;
 458
 459         for (i = 0; i < MAP__NR_TYPES; ++i) {
 460                 maps__delete(&mg->maps[i]);
 461                 maps__delete_removed(&mg->removed_maps[i]);
 462         }
 463 }
 464
 465 bool map_groups__empty(struct map_groups *mg)
 466 {
 467         int i;
 468
 469         for (i = 0; i < MAP__NR_TYPES; ++i) {
 470                 if (maps__first(&mg->maps[i]))
 471                         return false;
 472                 if (!list_empty(&mg->removed_maps[i]))
 473                         return false;
 474         }
 475
 476         return true;
 477 }
 478
 479 struct map_groups *map_groups__new(struct machine *machine)
 480 {
 481         struct map_groups *mg = malloc(sizeof(*mg));
 482
 483         if (mg != NULL)
 484                 map_groups__init(mg, machine);
 485
 486         return mg;
 487 }
 488
 489 void map_groups__delete(struct map_groups *mg)
 490 {
 491         map_groups__exit(mg);
 492         free(mg);
 493 }
 494
 495 void map_groups__put(struct map_groups *mg)
 496 {
 497         if (mg && atomic_dec_and_test(&mg->refcnt))
 498                 map_groups__delete(mg);
 499 }
 500
 501 void map_groups__flush(struct map_groups *mg)
 502 {
 503         int type;
 504
 505         for (type = 0; type < MAP__NR_TYPES; type++) {
 506                 struct rb_root *root = &mg->maps[type];
 507                 struct rb_node *next = rb_first(root);
 508
 509                 while (next) {
 510                         struct map *pos = rb_entry(next, struct map, rb_node);
 511                         next = rb_next(&pos->rb_node);
 512                         rb_erase(&pos->rb_node, root);
 513                         /*
 514                          * We may have references to this map, for
 515                          * instance in some hist_entry instances, so
 516                          * just move them to a separate list.
 517                          */
 518                         list_add_tail(&pos->node, &mg->removed_maps[pos->type]);
 519                 }
 520         }
 521 }
 522
 523 struct symbol *map_groups__find_symbol(struct map_groups *mg,
 524                                        enum map_type type, u64 addr,
 525                                        struct map **mapp,
 526                                        symbol_filter_t filter)
 527 {
 528         struct map *map = map_groups__find(mg, type, addr);
 529
 530         /* Ensure map is loaded before using map->map_ip */
 531         if (map != NULL && map__load(map, filter) >= 0) {
 532                 if (mapp != NULL)
 533                         *mapp = map;
 534                 return map__find_symbol(map, map->map_ip(map, addr), filter);
 535         }
 536
 537         return NULL;
 538 }
 539
 540 struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg,
 541                                                enum map_type type,
 542                                                const char *name,
 543                                                struct map **mapp,
 544                                                symbol_filter_t filter)
 545 {
 546         struct rb_node *nd;
 547
 548         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
 549                 struct map *pos = rb_entry(nd, struct map, rb_node);
 550                 struct symbol *sym = map__find_symbol_by_name(pos, name, filter);
 551
 552                 if (sym == NULL)
 553                         continue;
 554                 if (mapp != NULL)
 555                         *mapp = pos;
 556                 return sym;
 557         }
 558
 559         return NULL;
 560 }
 561
 562 int map_groups__find_ams(struct addr_map_symbol *ams, symbol_filter_t filter)
 563 {
 564         if (ams->addr < ams->map->start || ams->addr >= ams->map->end) {
 565                 if (ams->map->groups == NULL)
 566                         return -1;
 567                 ams->map = map_groups__find(ams->map->groups, ams->map->type,
 568                                             ams->addr);
 569                 if (ams->map == NULL)
 570                         return -1;
 571         }
 572
 573         ams->al_addr = ams->map->map_ip(ams->map, ams->addr);
 574         ams->sym = map__find_symbol(ams->map, ams->al_addr, filter);
 575
 576         return ams->sym ? 0 : -1;
 577 }
 578
 579 size_t __map_groups__fprintf_maps(struct map_groups *mg, enum map_type type,
 580                                   FILE *fp)
 581 {
 582         size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
 583         struct rb_node *nd;
 584
 585         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
 586                 struct map *pos = rb_entry(nd, struct map, rb_node);
 587                 printed += fprintf(fp, "Map:");
 588                 printed += map__fprintf(pos, fp);
 589                 if (verbose > 2) {
 590                         printed += dso__fprintf(pos->dso, type, fp);
 591                         printed += fprintf(fp, "--\n");
 592                 }
 593         }
 594
 595         return printed;
 596 }
 597
 598 static size_t map_groups__fprintf_maps(struct map_groups *mg, FILE *fp)
 599 {
 600         size_t printed = 0, i;
 601         for (i = 0; i < MAP__NR_TYPES; ++i)
 602                 printed += __map_groups__fprintf_maps(mg, i, fp);
 603         return printed;
 604 }
 605
 606 static size_t __map_groups__fprintf_removed_maps(struct map_groups *mg,
 607                                                  enum map_type type, FILE *fp)
 608 {
 609         struct map *pos;
 610         size_t printed = 0;
 611
 612         list_for_each_entry(pos, &mg->removed_maps[type], node) {
 613                 printed += fprintf(fp, "Map:");
 614                 printed += map__fprintf(pos, fp);
 615                 if (verbose > 1) {
 616                         printed += dso__fprintf(pos->dso, type, fp);
 617                         printed += fprintf(fp, "--\n");
 618                 }
 619         }
 620         return printed;
 621 }
 622
 623 static size_t map_groups__fprintf_removed_maps(struct map_groups *mg,
 624                                                FILE *fp)
 625 {
 626         size_t printed = 0, i;
 627         for (i = 0; i < MAP__NR_TYPES; ++i)
 628                 printed += __map_groups__fprintf_removed_maps(mg, i, fp);
 629         return printed;
 630 }
 631
 632 size_t map_groups__fprintf(struct map_groups *mg, FILE *fp)
 633 {
 634         size_t printed = map_groups__fprintf_maps(mg, fp);
 635         printed += fprintf(fp, "Removed maps:\n");
 636         return printed + map_groups__fprintf_removed_maps(mg, fp);
 637 }
 638
 639 int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
 640                                    FILE *fp)
 641 {
 642         struct rb_root *root = &mg->maps[map->type];
 643         struct rb_node *next = rb_first(root);
 644         int err = 0;
 645
 646         while (next) {
 647                 struct map *pos = rb_entry(next, struct map, rb_node);
 648                 next = rb_next(&pos->rb_node);
 649
 650                 if (!map__overlap(pos, map))
 651                         continue;
 652
 653                 if (verbose >= 2) {
 654                         fputs("overlapping maps:\n", fp);
 655                         map__fprintf(map, fp);
 656                         map__fprintf(pos, fp);
 657                 }
 658
 659                 rb_erase(&pos->rb_node, root);
 660                 /*
 661                  * Now check if we need to create new maps for areas not
 662                  * overlapped by the new map:
 663                  */
 664                 if (map->start > pos->start) {
 665                         struct map *before = map__clone(pos);
 666
 667                         if (before == NULL) {
 668                                 err = -ENOMEM;
 669                                 goto move_map;
 670                         }
 671
 672                         before->end = map->start;
 673                         map_groups__insert(mg, before);
 674                         if (verbose >= 2)
 675                                 map__fprintf(before, fp);
 676                 }
 677
 678                 if (map->end < pos->end) {
 679                         struct map *after = map__clone(pos);
 680
 681                         if (after == NULL) {
 682                                 err = -ENOMEM;
 683                                 goto move_map;
 684                         }
 685
 686                         after->start = map->end;
 687                         map_groups__insert(mg, after);
 688                         if (verbose >= 2)
 689                                 map__fprintf(after, fp);
 690                 }
 691 move_map:
 692                 /*
 693                  * If we have references, just move them to a separate list.
 694                  */
 695                 if (pos->referenced)
 696                         list_add_tail(&pos->node, &mg->removed_maps[map->type]);
 697                 else
 698                         map__delete(pos);
 699
 700                 if (err)
 701                         return err;
 702         }
 703
 704         return 0;
 705 }
 706
 707 /*
 708  * XXX This should not really _copy_ te maps, but refcount them.
 709  */
 710 int map_groups__clone(struct map_groups *mg,
 711                       struct map_groups *parent, enum map_type type)
 712 {
 713         struct rb_node *nd;
 714         for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
 715                 struct map *map = rb_entry(nd, struct map, rb_node);
 716                 struct map *new = map__clone(map);
 717                 if (new == NULL)
 718                         return -ENOMEM;
 719                 map_groups__insert(mg, new);
 720         }
 721         return 0;
 722 }
 723
 724 void maps__insert(struct rb_root *maps, struct map *map)
 725 {
 726         struct rb_node **p = &maps->rb_node;
 727         struct rb_node *parent = NULL;
 728         const u64 ip = map->start;
 729         struct map *m;
 730
 731         while (*p != NULL) {
 732                 parent = *p;
 733                 m = rb_entry(parent, struct map, rb_node);
 734                 if (ip < m->start)
 735                         p = &(*p)->rb_left;
 736                 else
 737                         p = &(*p)->rb_right;
 738         }
 739
 740         rb_link_node(&map->rb_node, parent, p);
 741         rb_insert_color(&map->rb_node, maps);
 742 }
 743
 744 void maps__remove(struct rb_root *maps, struct map *map)
 745 {
 746         rb_erase(&map->rb_node, maps);
 747 }
 748
 749 struct map *maps__find(struct rb_root *maps, u64 ip)
 750 {
 751         struct rb_node **p = &maps->rb_node;
 752         struct rb_node *parent = NULL;
 753         struct map *m;
 754
 755         while (*p != NULL) {
 756                 parent = *p;
 757                 m = rb_entry(parent, struct map, rb_node);
 758                 if (ip < m->start)
 759                         p = &(*p)->rb_left;
 760                 else if (ip >= m->end)
 761                         p = &(*p)->rb_right;
 762                 else
 763                         return m;
 764         }
 765
 766         return NULL;
 767 }
 768
 769 struct map *maps__first(struct rb_root *maps)
 770 {
 771         struct rb_node *first = rb_first(maps);
 772
 773         if (first)
 774                 return rb_entry(first, struct map, rb_node);
 775         return NULL;
 776 }
 777
 778 struct map *map__next(struct map *map)
 779 {
 780         struct rb_node *next = rb_next(&map->rb_node);
 781
 782         if (next)
 783                 return rb_entry(next, struct map, rb_node);
 784         return NULL;
 785 }
 786
 787 struct kmap *map__kmap(struct map *map)
 788 {
 789         if (!map->dso || !map->dso->kernel) {
 790                 pr_err("Internal error: map__kmap with a non-kernel map\n");
 791                 return NULL;
 792         }
 793         return (struct kmap *)(map + 1);
 794 }
 795
 796 struct map_groups *map__kmaps(struct map *map)
 797 {
 798         struct kmap *kmap = map__kmap(map);
 799
 800         if (!kmap || !kmap->kmaps) {
 801                 pr_err("Internal error: map__kmaps with a non-kernel map\n");
 802                 return NULL;
 803         }
 804         return kmap->kmaps;
 805 }