tools/perf/util/map.c

   1 #include "symbol.h"
   2 #include <errno.h>
   3 #include <limits.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <stdio.h>
   7 #include "map.h"
   8
   9 const char *map_type__name[MAP__NR_TYPES] = {
  10         [MAP__FUNCTION] = "Functions",
  11         [MAP__VARIABLE] = "Variables",
  12 };
  13
  14 static inline int is_anon_memory(const char *filename)
  15 {
  16         return strcmp(filename, "//anon") == 0;
  17 }
  18
  19 static int strcommon(const char *pathname, char *cwd, int cwdlen)
  20 {
  21         int n = 0;
  22
  23         while (n < cwdlen && pathname[n] == cwd[n])
  24                 ++n;
  25
  26         return n;
  27 }
  28
  29 void map__init(struct map *self, enum map_type type,
  30                u64 start, u64 end, u64 pgoff, struct dso *dso)
  31 {
  32         self->type     = type;
  33         self->start    = start;
  34         self->end      = end;
  35         self->pgoff    = pgoff;
  36         self->dso      = dso;
  37         self->map_ip   = map__map_ip;
  38         self->unmap_ip = map__unmap_ip;
  39         RB_CLEAR_NODE(&self->rb_node);
  40 }
  41
  42 struct map *map__new(u64 start, u64 len, u64 pgoff, u32 pid, char *filename,
  43                      enum map_type type, char *cwd, int cwdlen)
  44 {
  45         struct map *self = malloc(sizeof(*self));
  46
  47         if (self != NULL) {
  48                 char newfilename[PATH_MAX];
  49                 struct dso *dso;
  50                 int anon;
  51
  52                 if (cwd) {
  53                         int n = strcommon(filename, cwd, cwdlen);
  54
  55                         if (n == cwdlen) {
  56                                 snprintf(newfilename, sizeof(newfilename),
  57                                          ".%s", filename + n);
  58                                 filename = newfilename;
  59                         }
  60                 }
  61
  62                 anon = is_anon_memory(filename);
  63
  64                 if (anon) {
  65                         snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid);
  66                         filename = newfilename;
  67                 }
  68
  69                 dso = dsos__findnew(filename);
  70                 if (dso == NULL)
  71                         goto out_delete;
  72
  73                 map__init(self, type, start, start + len, pgoff, dso);
  74
  75                 if (anon) {
  76 set_identity:
  77                         self->map_ip = self->unmap_ip = identity__map_ip;
  78                 } else if (strcmp(filename, "[vdso]") == 0) {
  79                         dso__set_loaded(dso, self->type);
  80                         goto set_identity;
  81                 }
  82         }
  83         return self;
  84 out_delete:
  85         free(self);
  86         return NULL;
  87 }
  88
  89 void map__delete(struct map *self)
  90 {
  91         free(self);
  92 }
  93
  94 void map__fixup_start(struct map *self)
  95 {
  96         struct rb_root *symbols = &self->dso->symbols[self->type];
  97         struct rb_node *nd = rb_first(symbols);
  98         if (nd != NULL) {
  99                 struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
 100                 self->start = sym->start;
 101         }
 102 }
 103
 104 void map__fixup_end(struct map *self)
 105 {
 106         struct rb_root *symbols = &self->dso->symbols[self->type];
 107         struct rb_node *nd = rb_last(symbols);
 108         if (nd != NULL) {
 109                 struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
 110                 self->end = sym->end;
 111         }
 112 }
 113
 114 #define DSO__DELETED "(deleted)"
 115
 116 int map__load(struct map *self, symbol_filter_t filter)
 117 {
 118         const char *name = self->dso->long_name;
 119         int nr;
 120
 121         if (dso__loaded(self->dso, self->type))
 122                 return 0;
 123
 124         nr = dso__load(self->dso, self, filter);
 125         if (nr < 0) {
 126                 if (self->dso->has_build_id) {
 127                         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 128
 129                         build_id__sprintf(self->dso->build_id,
 130                                           sizeof(self->dso->build_id),
 131                                           sbuild_id);
 132                         pr_warning("%s with build id %s not found",
 133                                    name, sbuild_id);
 134                 } else
 135                         pr_warning("Failed to open %s", name);
 136
 137                 pr_warning(", continuing without symbols\n");
 138                 return -1;
 139         } else if (nr == 0) {
 140                 const size_t len = strlen(name);
 141                 const size_t real_len = len - sizeof(DSO__DELETED);
 142
 143                 if (len > sizeof(DSO__DELETED) &&
 144                     strcmp(name + real_len + 1, DSO__DELETED) == 0) {
 145                         pr_warning("%.*s was updated, restart the long "
 146                                    "running apps that use it!\n",
 147                                    (int)real_len, name);
 148                 } else {
 149                         pr_warning("no symbols found in %s, maybe install "
 150                                    "a debug package?\n", name);
 151                 }
 152
 153                 return -1;
 154         }
 155         /*
 156          * Only applies to the kernel, as its symtabs aren't relative like the
 157          * module ones.
 158          */
 159         if (self->dso->kernel)
 160                 map__reloc_vmlinux(self);
 161
 162         return 0;
 163 }
 164
 165 struct symbol *map__find_symbol(struct map *self, u64 addr,
 166                                 symbol_filter_t filter)
 167 {
 168         if (map__load(self, filter) < 0)
 169                 return NULL;
 170
 171         return dso__find_symbol(self->dso, self->type, addr);
 172 }
 173
 174 struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
 175                                         symbol_filter_t filter)
 176 {
 177         if (map__load(self, filter) < 0)
 178                 return NULL;
 179
 180         if (!dso__sorted_by_name(self->dso, self->type))
 181                 dso__sort_by_name(self->dso, self->type);
 182
 183         return dso__find_symbol_by_name(self->dso, self->type, name);
 184 }
 185
 186 struct map *map__clone(struct map *self)
 187 {
 188         struct map *map = malloc(sizeof(*self));
 189
 190         if (!map)
 191                 return NULL;
 192
 193         memcpy(map, self, sizeof(*self));
 194
 195         return map;
 196 }
 197
 198 int map__overlap(struct map *l, struct map *r)
 199 {
 200         if (l->start > r->start) {
 201                 struct map *t = l;
 202                 l = r;
 203                 r = t;
 204         }
 205
 206         if (l->end > r->start)
 207                 return 1;
 208
 209         return 0;
 210 }
 211
 212 size_t map__fprintf(struct map *self, FILE *fp)
 213 {
 214         return fprintf(fp, " %Lx-%Lx %Lx %s\n",
 215                        self->start, self->end, self->pgoff, self->dso->name);
 216 }
 217
 218 /*
 219  * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
 220  * map->dso->adjust_symbols==1 for ET_EXEC-like cases.
 221  */
 222 u64 map__rip_2objdump(struct map *map, u64 rip)
 223 {
 224         u64 addr = map->dso->adjust_symbols ?
 225                         map->unmap_ip(map, rip) :       /* RIP -> IP */
 226                         rip;
 227         return addr;
 228 }
 229
 230 u64 map__objdump_2ip(struct map *map, u64 addr)
 231 {
 232         u64 ip = map->dso->adjust_symbols ?
 233                         addr :
 234                         map->unmap_ip(map, addr);       /* RIP -> IP */
 235         return ip;
 236 }
 237
 238 void map_groups__init(struct map_groups *self)
 239 {
 240         int i;
 241         for (i = 0; i < MAP__NR_TYPES; ++i) {
 242                 self->maps[i] = RB_ROOT;
 243                 INIT_LIST_HEAD(&self->removed_maps[i]);
 244         }
 245 }
 246
 247 void map_groups__flush(struct map_groups *self)
 248 {
 249         int type;
 250
 251         for (type = 0; type < MAP__NR_TYPES; type++) {
 252                 struct rb_root *root = &self->maps[type];
 253                 struct rb_node *next = rb_first(root);
 254
 255                 while (next) {
 256                         struct map *pos = rb_entry(next, struct map, rb_node);
 257                         next = rb_next(&pos->rb_node);
 258                         rb_erase(&pos->rb_node, root);
 259                         /*
 260                          * We may have references to this map, for
 261                          * instance in some hist_entry instances, so
 262                          * just move them to a separate list.
 263                          */
 264                         list_add_tail(&pos->node, &self->removed_maps[pos->type]);
 265                 }
 266         }
 267 }
 268
 269 struct symbol *map_groups__find_symbol(struct map_groups *self,
 270                                        enum map_type type, u64 addr,
 271                                        struct map **mapp,
 272                                        symbol_filter_t filter)
 273 {
 274         struct map *map = map_groups__find(self, type, addr);
 275
 276         if (map != NULL) {
 277                 if (mapp != NULL)
 278                         *mapp = map;
 279                 return map__find_symbol(map, map->map_ip(map, addr), filter);
 280         }
 281
 282         return NULL;
 283 }
 284
 285 struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
 286                                                enum map_type type,
 287                                                const char *name,
 288                                                struct map **mapp,
 289                                                symbol_filter_t filter)
 290 {
 291         struct rb_node *nd;
 292
 293         for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
 294                 struct map *pos = rb_entry(nd, struct map, rb_node);
 295                 struct symbol *sym = map__find_symbol_by_name(pos, name, filter);
 296
 297                 if (sym == NULL)
 298                         continue;
 299                 if (mapp != NULL)
 300                         *mapp = pos;
 301                 return sym;
 302         }
 303
 304         return NULL;
 305 }
 306
 307 size_t __map_groups__fprintf_maps(struct map_groups *self,
 308                                   enum map_type type, int verbose, FILE *fp)
 309 {
 310         size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
 311         struct rb_node *nd;
 312
 313         for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
 314                 struct map *pos = rb_entry(nd, struct map, rb_node);
 315                 printed += fprintf(fp, "Map:");
 316                 printed += map__fprintf(pos, fp);
 317                 if (verbose > 2) {
 318                         printed += dso__fprintf(pos->dso, type, fp);
 319                         printed += fprintf(fp, "--\n");
 320                 }
 321         }
 322
 323         return printed;
 324 }
 325
 326 size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp)
 327 {
 328         size_t printed = 0, i;
 329         for (i = 0; i < MAP__NR_TYPES; ++i)
 330                 printed += __map_groups__fprintf_maps(self, i, verbose, fp);
 331         return printed;
 332 }
 333
 334 static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
 335                                                  enum map_type type,
 336                                                  int verbose, FILE *fp)
 337 {
 338         struct map *pos;
 339         size_t printed = 0;
 340
 341         list_for_each_entry(pos, &self->removed_maps[type], node) {
 342                 printed += fprintf(fp, "Map:");
 343                 printed += map__fprintf(pos, fp);
 344                 if (verbose > 1) {
 345                         printed += dso__fprintf(pos->dso, type, fp);
 346                         printed += fprintf(fp, "--\n");
 347                 }
 348         }
 349         return printed;
 350 }
 351
 352 static size_t map_groups__fprintf_removed_maps(struct map_groups *self,
 353                                                int verbose, FILE *fp)
 354 {
 355         size_t printed = 0, i;
 356         for (i = 0; i < MAP__NR_TYPES; ++i)
 357                 printed += __map_groups__fprintf_removed_maps(self, i, verbose, fp);
 358         return printed;
 359 }
 360
 361 size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp)
 362 {
 363         size_t printed = map_groups__fprintf_maps(self, verbose, fp);
 364         printed += fprintf(fp, "Removed maps:\n");
 365         return printed + map_groups__fprintf_removed_maps(self, verbose, fp);
 366 }
 367
 368 int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
 369                                    int verbose, FILE *fp)
 370 {
 371         struct rb_root *root = &self->maps[map->type];
 372         struct rb_node *next = rb_first(root);
 373
 374         while (next) {
 375                 struct map *pos = rb_entry(next, struct map, rb_node);
 376                 next = rb_next(&pos->rb_node);
 377
 378                 if (!map__overlap(pos, map))
 379                         continue;
 380
 381                 if (verbose >= 2) {
 382                         fputs("overlapping maps:\n", fp);
 383                         map__fprintf(map, fp);
 384                         map__fprintf(pos, fp);
 385                 }
 386
 387                 rb_erase(&pos->rb_node, root);
 388                 /*
 389                  * We may have references to this map, for instance in some
 390                  * hist_entry instances, so just move them to a separate
 391                  * list.
 392                  */
 393                 list_add_tail(&pos->node, &self->removed_maps[map->type]);
 394                 /*
 395                  * Now check if we need to create new maps for areas not
 396                  * overlapped by the new map:
 397                  */
 398                 if (map->start > pos->start) {
 399                         struct map *before = map__clone(pos);
 400
 401                         if (before == NULL)
 402                                 return -ENOMEM;
 403
 404                         before->end = map->start - 1;
 405                         map_groups__insert(self, before);
 406                         if (verbose >= 2)
 407                                 map__fprintf(before, fp);
 408                 }
 409
 410                 if (map->end < pos->end) {
 411                         struct map *after = map__clone(pos);
 412
 413                         if (after == NULL)
 414                                 return -ENOMEM;
 415
 416                         after->start = map->end + 1;
 417                         map_groups__insert(self, after);
 418                         if (verbose >= 2)
 419                                 map__fprintf(after, fp);
 420                 }
 421         }
 422
 423         return 0;
 424 }
 425
 426 /*
 427  * XXX This should not really _copy_ te maps, but refcount them.
 428  */
 429 int map_groups__clone(struct map_groups *self,
 430                       struct map_groups *parent, enum map_type type)
 431 {
 432         struct rb_node *nd;
 433         for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
 434                 struct map *map = rb_entry(nd, struct map, rb_node);
 435                 struct map *new = map__clone(map);
 436                 if (new == NULL)
 437                         return -ENOMEM;
 438                 map_groups__insert(self, new);
 439         }
 440         return 0;
 441 }
 442
 443 static u64 map__reloc_map_ip(struct map *map, u64 ip)
 444 {
 445         return ip + (s64)map->pgoff;
 446 }
 447
 448 static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
 449 {
 450         return ip - (s64)map->pgoff;
 451 }
 452
 453 void map__reloc_vmlinux(struct map *self)
 454 {
 455         struct kmap *kmap = map__kmap(self);
 456         s64 reloc;
 457
 458         if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
 459                 return;
 460
 461         reloc = (kmap->ref_reloc_sym->unrelocated_addr -
 462                  kmap->ref_reloc_sym->addr);
 463
 464         if (!reloc)
 465                 return;
 466
 467         self->map_ip   = map__reloc_map_ip;
 468         self->unmap_ip = map__reloc_unmap_ip;
 469         self->pgoff    = reloc;
 470 }
 471
 472 void maps__insert(struct rb_root *maps, struct map *map)
 473 {
 474         struct rb_node **p = &maps->rb_node;
 475         struct rb_node *parent = NULL;
 476         const u64 ip = map->start;
 477         struct map *m;
 478
 479         while (*p != NULL) {
 480                 parent = *p;
 481                 m = rb_entry(parent, struct map, rb_node);
 482                 if (ip < m->start)
 483                         p = &(*p)->rb_left;
 484                 else
 485                         p = &(*p)->rb_right;
 486         }
 487
 488         rb_link_node(&map->rb_node, parent, p);
 489         rb_insert_color(&map->rb_node, maps);
 490 }
 491
 492 struct map *maps__find(struct rb_root *maps, u64 ip)
 493 {
 494         struct rb_node **p = &maps->rb_node;
 495         struct rb_node *parent = NULL;
 496         struct map *m;
 497
 498         while (*p != NULL) {
 499                 parent = *p;
 500                 m = rb_entry(parent, struct map, rb_node);
 501                 if (ip < m->start)
 502                         p = &(*p)->rb_left;
 503                 else if (ip > m->end)
 504                         p = &(*p)->rb_right;
 505                 else
 506                         return m;
 507         }
 508
 509         return NULL;
 510 }