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