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 11 const char *map_type__name[MAP__NR_TYPES] = { 12 [MAP__FUNCTION] = "Functions", 13 [MAP__VARIABLE] = "Variables", 14 }; 15 16 static inline int is_anon_memory(const char *filename) 17 { 18 return strcmp(filename, "//anon") == 0; 19 } 20 21 static inline int is_no_dso_memory(const char *filename) 22 { 23 return !strcmp(filename, "[stack]") || 24 !strcmp(filename, "[vdso]") || 25 !strcmp(filename, "[heap]"); 26 } 27 28 void map__init(struct map *self, enum map_type type, 29 u64 start, u64 end, u64 pgoff, struct dso *dso) 30 { 31 self->type = type; 32 self->start = start; 33 self->end = end; 34 self->pgoff = pgoff; 35 self->dso = dso; 36 self->map_ip = map__map_ip; 37 self->unmap_ip = map__unmap_ip; 38 RB_CLEAR_NODE(&self->rb_node); 39 self->groups = NULL; 40 self->referenced = false; 41 } 42 43 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len, 44 u64 pgoff, u32 pid, char *filename, 45 enum map_type type) 46 { 47 struct map *self = malloc(sizeof(*self)); 48 49 if (self != NULL) { 50 char newfilename[PATH_MAX]; 51 struct dso *dso; 52 int anon, no_dso; 53 54 anon = is_anon_memory(filename); 55 no_dso = is_no_dso_memory(filename); 56 57 if (anon) { 58 snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid); 59 filename = newfilename; 60 } 61 62 dso = __dsos__findnew(dsos__list, filename); 63 if (dso == NULL) 64 goto out_delete; 65 66 map__init(self, type, start, start + len, pgoff, dso); 67 68 if (anon || no_dso) { 69 self->map_ip = self->unmap_ip = identity__map_ip; 70 71 /* 72 * Set memory without DSO as loaded. All map__find_* 73 * functions still return NULL, and we avoid the 74 * unnecessary map__load warning. 75 */ 76 if (no_dso) 77 dso__set_loaded(dso, self->type); 78 } 79 } 80 return self; 81 out_delete: 82 free(self); 83 return NULL; 84 } 85 86 void map__delete(struct map *self) 87 { 88 free(self); 89 } 90 91 void map__fixup_start(struct map *self) 92 { 93 struct rb_root *symbols = &self->dso->symbols[self->type]; 94 struct rb_node *nd = rb_first(symbols); 95 if (nd != NULL) { 96 struct symbol *sym = rb_entry(nd, struct symbol, rb_node); 97 self->start = sym->start; 98 } 99 } 100 101 void map__fixup_end(struct map *self) 102 { 103 struct rb_root *symbols = &self->dso->symbols[self->type]; 104 struct rb_node *nd = rb_last(symbols); 105 if (nd != NULL) { 106 struct symbol *sym = rb_entry(nd, struct symbol, rb_node); 107 self->end = sym->end; 108 } 109 } 110 111 #define DSO__DELETED "(deleted)" 112 113 int map__load(struct map *self, symbol_filter_t filter) 114 { 115 const char *name = self->dso->long_name; 116 int nr; 117 118 if (dso__loaded(self->dso, self->type)) 119 return 0; 120 121 nr = dso__load(self->dso, self, filter); 122 if (nr < 0) { 123 if (self->dso->has_build_id) { 124 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 125 126 build_id__sprintf(self->dso->build_id, 127 sizeof(self->dso->build_id), 128 sbuild_id); 129 pr_warning("%s with build id %s not found", 130 name, sbuild_id); 131 } else 132 pr_warning("Failed to open %s", name); 133 134 pr_warning(", continuing without symbols\n"); 135 return -1; 136 } else if (nr == 0) { 137 const size_t len = strlen(name); 138 const size_t real_len = len - sizeof(DSO__DELETED); 139 140 if (len > sizeof(DSO__DELETED) && 141 strcmp(name + real_len + 1, DSO__DELETED) == 0) { 142 pr_warning("%.*s was updated (is prelink enabled?). " 143 "Restart the long running apps that use it!\n", 144 (int)real_len, name); 145 } else { 146 pr_warning("no symbols found in %s, maybe install " 147 "a debug package?\n", name); 148 } 149 150 return -1; 151 } 152 /* 153 * Only applies to the kernel, as its symtabs aren't relative like the 154 * module ones. 155 */ 156 if (self->dso->kernel) 157 map__reloc_vmlinux(self); 158 159 return 0; 160 } 161 162 struct symbol *map__find_symbol(struct map *self, u64 addr, 163 symbol_filter_t filter) 164 { 165 if (map__load(self, filter) < 0) 166 return NULL; 167 168 return dso__find_symbol(self->dso, self->type, addr); 169 } 170 171 struct symbol *map__find_symbol_by_name(struct map *self, const char *name, 172 symbol_filter_t filter) 173 { 174 if (map__load(self, filter) < 0) 175 return NULL; 176 177 if (!dso__sorted_by_name(self->dso, self->type)) 178 dso__sort_by_name(self->dso, self->type); 179 180 return dso__find_symbol_by_name(self->dso, self->type, name); 181 } 182 183 struct map *map__clone(struct map *self) 184 { 185 struct map *map = malloc(sizeof(*self)); 186 187 if (!map) 188 return NULL; 189 190 memcpy(map, self, sizeof(*self)); 191 192 return map; 193 } 194 195 int map__overlap(struct map *l, struct map *r) 196 { 197 if (l->start > r->start) { 198 struct map *t = l; 199 l = r; 200 r = t; 201 } 202 203 if (l->end > r->start) 204 return 1; 205 206 return 0; 207 } 208 209 size_t map__fprintf(struct map *self, FILE *fp) 210 { 211 return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n", 212 self->start, self->end, self->pgoff, self->dso->name); 213 } 214 215 size_t map__fprintf_dsoname(struct map *map, FILE *fp) 216 { 217 const char *dsoname; 218 219 if (map && map->dso && (map->dso->name || map->dso->long_name)) { 220 if (symbol_conf.show_kernel_path && map->dso->long_name) 221 dsoname = map->dso->long_name; 222 else if (map->dso->name) 223 dsoname = map->dso->name; 224 } else 225 dsoname = "[unknown]"; 226 227 return fprintf(fp, "%s", dsoname); 228 } 229 230 /* 231 * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN. 232 * map->dso->adjust_symbols==1 for ET_EXEC-like cases. 233 */ 234 u64 map__rip_2objdump(struct map *map, u64 rip) 235 { 236 u64 addr = map->dso->adjust_symbols ? 237 map->unmap_ip(map, rip) : /* RIP -> IP */ 238 rip; 239 return addr; 240 } 241 242 u64 map__objdump_2ip(struct map *map, u64 addr) 243 { 244 u64 ip = map->dso->adjust_symbols ? 245 addr : 246 map->unmap_ip(map, addr); /* RIP -> IP */ 247 return ip; 248 } 249 250 void map_groups__init(struct map_groups *mg) 251 { 252 int i; 253 for (i = 0; i < MAP__NR_TYPES; ++i) { 254 mg->maps[i] = RB_ROOT; 255 INIT_LIST_HEAD(&mg->removed_maps[i]); 256 } 257 mg->machine = NULL; 258 } 259 260 static void maps__delete(struct rb_root *maps) 261 { 262 struct rb_node *next = rb_first(maps); 263 264 while (next) { 265 struct map *pos = rb_entry(next, struct map, rb_node); 266 267 next = rb_next(&pos->rb_node); 268 rb_erase(&pos->rb_node, maps); 269 map__delete(pos); 270 } 271 } 272 273 static void maps__delete_removed(struct list_head *maps) 274 { 275 struct map *pos, *n; 276 277 list_for_each_entry_safe(pos, n, maps, node) { 278 list_del(&pos->node); 279 map__delete(pos); 280 } 281 } 282 283 void map_groups__exit(struct map_groups *mg) 284 { 285 int i; 286 287 for (i = 0; i < MAP__NR_TYPES; ++i) { 288 maps__delete(&mg->maps[i]); 289 maps__delete_removed(&mg->removed_maps[i]); 290 } 291 } 292 293 void map_groups__flush(struct map_groups *mg) 294 { 295 int type; 296 297 for (type = 0; type < MAP__NR_TYPES; type++) { 298 struct rb_root *root = &mg->maps[type]; 299 struct rb_node *next = rb_first(root); 300 301 while (next) { 302 struct map *pos = rb_entry(next, struct map, rb_node); 303 next = rb_next(&pos->rb_node); 304 rb_erase(&pos->rb_node, root); 305 /* 306 * We may have references to this map, for 307 * instance in some hist_entry instances, so 308 * just move them to a separate list. 309 */ 310 list_add_tail(&pos->node, &mg->removed_maps[pos->type]); 311 } 312 } 313 } 314 315 struct symbol *map_groups__find_symbol(struct map_groups *mg, 316 enum map_type type, u64 addr, 317 struct map **mapp, 318 symbol_filter_t filter) 319 { 320 struct map *map = map_groups__find(mg, type, addr); 321 322 if (map != NULL) { 323 if (mapp != NULL) 324 *mapp = map; 325 return map__find_symbol(map, map->map_ip(map, addr), filter); 326 } 327 328 return NULL; 329 } 330 331 struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg, 332 enum map_type type, 333 const char *name, 334 struct map **mapp, 335 symbol_filter_t filter) 336 { 337 struct rb_node *nd; 338 339 for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) { 340 struct map *pos = rb_entry(nd, struct map, rb_node); 341 struct symbol *sym = map__find_symbol_by_name(pos, name, filter); 342 343 if (sym == NULL) 344 continue; 345 if (mapp != NULL) 346 *mapp = pos; 347 return sym; 348 } 349 350 return NULL; 351 } 352 353 size_t __map_groups__fprintf_maps(struct map_groups *mg, 354 enum map_type type, int verbose, FILE *fp) 355 { 356 size_t printed = fprintf(fp, "%s:\n", map_type__name[type]); 357 struct rb_node *nd; 358 359 for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) { 360 struct map *pos = rb_entry(nd, struct map, rb_node); 361 printed += fprintf(fp, "Map:"); 362 printed += map__fprintf(pos, fp); 363 if (verbose > 2) { 364 printed += dso__fprintf(pos->dso, type, fp); 365 printed += fprintf(fp, "--\n"); 366 } 367 } 368 369 return printed; 370 } 371 372 size_t map_groups__fprintf_maps(struct map_groups *mg, int verbose, FILE *fp) 373 { 374 size_t printed = 0, i; 375 for (i = 0; i < MAP__NR_TYPES; ++i) 376 printed += __map_groups__fprintf_maps(mg, i, verbose, fp); 377 return printed; 378 } 379 380 static size_t __map_groups__fprintf_removed_maps(struct map_groups *mg, 381 enum map_type type, 382 int verbose, FILE *fp) 383 { 384 struct map *pos; 385 size_t printed = 0; 386 387 list_for_each_entry(pos, &mg->removed_maps[type], node) { 388 printed += fprintf(fp, "Map:"); 389 printed += map__fprintf(pos, fp); 390 if (verbose > 1) { 391 printed += dso__fprintf(pos->dso, type, fp); 392 printed += fprintf(fp, "--\n"); 393 } 394 } 395 return printed; 396 } 397 398 static size_t map_groups__fprintf_removed_maps(struct map_groups *mg, 399 int verbose, FILE *fp) 400 { 401 size_t printed = 0, i; 402 for (i = 0; i < MAP__NR_TYPES; ++i) 403 printed += __map_groups__fprintf_removed_maps(mg, i, verbose, fp); 404 return printed; 405 } 406 407 size_t map_groups__fprintf(struct map_groups *mg, int verbose, FILE *fp) 408 { 409 size_t printed = map_groups__fprintf_maps(mg, verbose, fp); 410 printed += fprintf(fp, "Removed maps:\n"); 411 return printed + map_groups__fprintf_removed_maps(mg, verbose, fp); 412 } 413 414 int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map, 415 int verbose, FILE *fp) 416 { 417 struct rb_root *root = &mg->maps[map->type]; 418 struct rb_node *next = rb_first(root); 419 int err = 0; 420 421 while (next) { 422 struct map *pos = rb_entry(next, struct map, rb_node); 423 next = rb_next(&pos->rb_node); 424 425 if (!map__overlap(pos, map)) 426 continue; 427 428 if (verbose >= 2) { 429 fputs("overlapping maps:\n", fp); 430 map__fprintf(map, fp); 431 map__fprintf(pos, fp); 432 } 433 434 rb_erase(&pos->rb_node, root); 435 /* 436 * Now check if we need to create new maps for areas not 437 * overlapped by the new map: 438 */ 439 if (map->start > pos->start) { 440 struct map *before = map__clone(pos); 441 442 if (before == NULL) { 443 err = -ENOMEM; 444 goto move_map; 445 } 446 447 before->end = map->start - 1; 448 map_groups__insert(mg, before); 449 if (verbose >= 2) 450 map__fprintf(before, fp); 451 } 452 453 if (map->end < pos->end) { 454 struct map *after = map__clone(pos); 455 456 if (after == NULL) { 457 err = -ENOMEM; 458 goto move_map; 459 } 460 461 after->start = map->end + 1; 462 map_groups__insert(mg, after); 463 if (verbose >= 2) 464 map__fprintf(after, fp); 465 } 466 move_map: 467 /* 468 * If we have references, just move them to a separate list. 469 */ 470 if (pos->referenced) 471 list_add_tail(&pos->node, &mg->removed_maps[map->type]); 472 else 473 map__delete(pos); 474 475 if (err) 476 return err; 477 } 478 479 return 0; 480 } 481 482 /* 483 * XXX This should not really _copy_ te maps, but refcount them. 484 */ 485 int map_groups__clone(struct map_groups *mg, 486 struct map_groups *parent, enum map_type type) 487 { 488 struct rb_node *nd; 489 for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) { 490 struct map *map = rb_entry(nd, struct map, rb_node); 491 struct map *new = map__clone(map); 492 if (new == NULL) 493 return -ENOMEM; 494 map_groups__insert(mg, new); 495 } 496 return 0; 497 } 498 499 static u64 map__reloc_map_ip(struct map *map, u64 ip) 500 { 501 return ip + (s64)map->pgoff; 502 } 503 504 static u64 map__reloc_unmap_ip(struct map *map, u64 ip) 505 { 506 return ip - (s64)map->pgoff; 507 } 508 509 void map__reloc_vmlinux(struct map *self) 510 { 511 struct kmap *kmap = map__kmap(self); 512 s64 reloc; 513 514 if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr) 515 return; 516 517 reloc = (kmap->ref_reloc_sym->unrelocated_addr - 518 kmap->ref_reloc_sym->addr); 519 520 if (!reloc) 521 return; 522 523 self->map_ip = map__reloc_map_ip; 524 self->unmap_ip = map__reloc_unmap_ip; 525 self->pgoff = reloc; 526 } 527 528 void maps__insert(struct rb_root *maps, struct map *map) 529 { 530 struct rb_node **p = &maps->rb_node; 531 struct rb_node *parent = NULL; 532 const u64 ip = map->start; 533 struct map *m; 534 535 while (*p != NULL) { 536 parent = *p; 537 m = rb_entry(parent, struct map, rb_node); 538 if (ip < m->start) 539 p = &(*p)->rb_left; 540 else 541 p = &(*p)->rb_right; 542 } 543 544 rb_link_node(&map->rb_node, parent, p); 545 rb_insert_color(&map->rb_node, maps); 546 } 547 548 void maps__remove(struct rb_root *self, struct map *map) 549 { 550 rb_erase(&map->rb_node, self); 551 } 552 553 struct map *maps__find(struct rb_root *maps, u64 ip) 554 { 555 struct rb_node **p = &maps->rb_node; 556 struct rb_node *parent = NULL; 557 struct map *m; 558 559 while (*p != NULL) { 560 parent = *p; 561 m = rb_entry(parent, struct map, rb_node); 562 if (ip < m->start) 563 p = &(*p)->rb_left; 564 else if (ip > m->end) 565 p = &(*p)->rb_right; 566 else 567 return m; 568 } 569 570 return NULL; 571 } 572 573 int machine__init(struct machine *self, const char *root_dir, pid_t pid) 574 { 575 map_groups__init(&self->kmaps); 576 RB_CLEAR_NODE(&self->rb_node); 577 INIT_LIST_HEAD(&self->user_dsos); 578 INIT_LIST_HEAD(&self->kernel_dsos); 579 580 self->threads = RB_ROOT; 581 INIT_LIST_HEAD(&self->dead_threads); 582 self->last_match = NULL; 583 584 self->kmaps.machine = self; 585 self->pid = pid; 586 self->root_dir = strdup(root_dir); 587 return self->root_dir == NULL ? -ENOMEM : 0; 588 } 589 590 static void dsos__delete(struct list_head *self) 591 { 592 struct dso *pos, *n; 593 594 list_for_each_entry_safe(pos, n, self, node) { 595 list_del(&pos->node); 596 dso__delete(pos); 597 } 598 } 599 600 void machine__exit(struct machine *self) 601 { 602 map_groups__exit(&self->kmaps); 603 dsos__delete(&self->user_dsos); 604 dsos__delete(&self->kernel_dsos); 605 free(self->root_dir); 606 self->root_dir = NULL; 607 } 608 609 void machine__delete(struct machine *self) 610 { 611 machine__exit(self); 612 free(self); 613 } 614 615 struct machine *machines__add(struct rb_root *self, pid_t pid, 616 const char *root_dir) 617 { 618 struct rb_node **p = &self->rb_node; 619 struct rb_node *parent = NULL; 620 struct machine *pos, *machine = malloc(sizeof(*machine)); 621 622 if (!machine) 623 return NULL; 624 625 if (machine__init(machine, root_dir, pid) != 0) { 626 free(machine); 627 return NULL; 628 } 629 630 while (*p != NULL) { 631 parent = *p; 632 pos = rb_entry(parent, struct machine, rb_node); 633 if (pid < pos->pid) 634 p = &(*p)->rb_left; 635 else 636 p = &(*p)->rb_right; 637 } 638 639 rb_link_node(&machine->rb_node, parent, p); 640 rb_insert_color(&machine->rb_node, self); 641 642 return machine; 643 } 644 645 struct machine *machines__find(struct rb_root *self, pid_t pid) 646 { 647 struct rb_node **p = &self->rb_node; 648 struct rb_node *parent = NULL; 649 struct machine *machine; 650 struct machine *default_machine = NULL; 651 652 while (*p != NULL) { 653 parent = *p; 654 machine = rb_entry(parent, struct machine, rb_node); 655 if (pid < machine->pid) 656 p = &(*p)->rb_left; 657 else if (pid > machine->pid) 658 p = &(*p)->rb_right; 659 else 660 return machine; 661 if (!machine->pid) 662 default_machine = machine; 663 } 664 665 return default_machine; 666 } 667 668 struct machine *machines__findnew(struct rb_root *self, pid_t pid) 669 { 670 char path[PATH_MAX]; 671 const char *root_dir; 672 struct machine *machine = machines__find(self, pid); 673 674 if (!machine || machine->pid != pid) { 675 if (pid == HOST_KERNEL_ID || pid == DEFAULT_GUEST_KERNEL_ID) 676 root_dir = ""; 677 else { 678 if (!symbol_conf.guestmount) 679 goto out; 680 sprintf(path, "%s/%d", symbol_conf.guestmount, pid); 681 if (access(path, R_OK)) { 682 pr_err("Can't access file %s\n", path); 683 goto out; 684 } 685 root_dir = path; 686 } 687 machine = machines__add(self, pid, root_dir); 688 } 689 690 out: 691 return machine; 692 } 693 694 void machines__process(struct rb_root *self, machine__process_t process, void *data) 695 { 696 struct rb_node *nd; 697 698 for (nd = rb_first(self); nd; nd = rb_next(nd)) { 699 struct machine *pos = rb_entry(nd, struct machine, rb_node); 700 process(pos, data); 701 } 702 } 703 704 char *machine__mmap_name(struct machine *self, char *bf, size_t size) 705 { 706 if (machine__is_host(self)) 707 snprintf(bf, size, "[%s]", "kernel.kallsyms"); 708 else if (machine__is_default_guest(self)) 709 snprintf(bf, size, "[%s]", "guest.kernel.kallsyms"); 710 else 711 snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms", self->pid); 712 713 return bf; 714 } 715