1 // SPDX-License-Identifier: GPL-2.0 2 #include <dirent.h> 3 #include <errno.h> 4 #include <inttypes.h> 5 #include <regex.h> 6 #include "callchain.h" 7 #include "debug.h" 8 #include "event.h" 9 #include "evsel.h" 10 #include "hist.h" 11 #include "machine.h" 12 #include "map.h" 13 #include "sort.h" 14 #include "strlist.h" 15 #include "thread.h" 16 #include "vdso.h" 17 #include <stdbool.h> 18 #include <sys/types.h> 19 #include <sys/stat.h> 20 #include <unistd.h> 21 #include "unwind.h" 22 #include "linux/hash.h" 23 #include "asm/bug.h" 24 25 #include "sane_ctype.h" 26 #include <symbol/kallsyms.h> 27 28 static void __machine__remove_thread(struct machine *machine, struct thread *th, bool lock); 29 30 static void dsos__init(struct dsos *dsos) 31 { 32 INIT_LIST_HEAD(&dsos->head); 33 dsos->root = RB_ROOT; 34 init_rwsem(&dsos->lock); 35 } 36 37 static void machine__threads_init(struct machine *machine) 38 { 39 int i; 40 41 for (i = 0; i < THREADS__TABLE_SIZE; i++) { 42 struct threads *threads = &machine->threads[i]; 43 threads->entries = RB_ROOT; 44 init_rwsem(&threads->lock); 45 threads->nr = 0; 46 INIT_LIST_HEAD(&threads->dead); 47 threads->last_match = NULL; 48 } 49 } 50 51 static int machine__set_mmap_name(struct machine *machine) 52 { 53 if (machine__is_host(machine)) 54 machine->mmap_name = strdup("[kernel.kallsyms]"); 55 else if (machine__is_default_guest(machine)) 56 machine->mmap_name = strdup("[guest.kernel.kallsyms]"); 57 else if (asprintf(&machine->mmap_name, "[guest.kernel.kallsyms.%d]", 58 machine->pid) < 0) 59 machine->mmap_name = NULL; 60 61 return machine->mmap_name ? 0 : -ENOMEM; 62 } 63 64 int machine__init(struct machine *machine, const char *root_dir, pid_t pid) 65 { 66 int err = -ENOMEM; 67 68 memset(machine, 0, sizeof(*machine)); 69 map_groups__init(&machine->kmaps, machine); 70 RB_CLEAR_NODE(&machine->rb_node); 71 dsos__init(&machine->dsos); 72 73 machine__threads_init(machine); 74 75 machine->vdso_info = NULL; 76 machine->env = NULL; 77 78 machine->pid = pid; 79 80 machine->id_hdr_size = 0; 81 machine->kptr_restrict_warned = false; 82 machine->comm_exec = false; 83 machine->kernel_start = 0; 84 85 memset(machine->vmlinux_maps, 0, sizeof(machine->vmlinux_maps)); 86 87 machine->root_dir = strdup(root_dir); 88 if (machine->root_dir == NULL) 89 return -ENOMEM; 90 91 if (machine__set_mmap_name(machine)) 92 goto out; 93 94 if (pid != HOST_KERNEL_ID) { 95 struct thread *thread = machine__findnew_thread(machine, -1, 96 pid); 97 char comm[64]; 98 99 if (thread == NULL) 100 goto out; 101 102 snprintf(comm, sizeof(comm), "[guest/%d]", pid); 103 thread__set_comm(thread, comm, 0); 104 thread__put(thread); 105 } 106 107 machine->current_tid = NULL; 108 err = 0; 109 110 out: 111 if (err) { 112 zfree(&machine->root_dir); 113 zfree(&machine->mmap_name); 114 } 115 return 0; 116 } 117 118 struct machine *machine__new_host(void) 119 { 120 struct machine *machine = malloc(sizeof(*machine)); 121 122 if (machine != NULL) { 123 machine__init(machine, "", HOST_KERNEL_ID); 124 125 if (machine__create_kernel_maps(machine) < 0) 126 goto out_delete; 127 } 128 129 return machine; 130 out_delete: 131 free(machine); 132 return NULL; 133 } 134 135 struct machine *machine__new_kallsyms(void) 136 { 137 struct machine *machine = machine__new_host(); 138 /* 139 * FIXME: 140 * 1) We should switch to machine__load_kallsyms(), i.e. not explicitely 141 * ask for not using the kcore parsing code, once this one is fixed 142 * to create a map per module. 143 */ 144 if (machine && machine__load_kallsyms(machine, "/proc/kallsyms") <= 0) { 145 machine__delete(machine); 146 machine = NULL; 147 } 148 149 return machine; 150 } 151 152 static void dsos__purge(struct dsos *dsos) 153 { 154 struct dso *pos, *n; 155 156 down_write(&dsos->lock); 157 158 list_for_each_entry_safe(pos, n, &dsos->head, node) { 159 RB_CLEAR_NODE(&pos->rb_node); 160 pos->root = NULL; 161 list_del_init(&pos->node); 162 dso__put(pos); 163 } 164 165 up_write(&dsos->lock); 166 } 167 168 static void dsos__exit(struct dsos *dsos) 169 { 170 dsos__purge(dsos); 171 exit_rwsem(&dsos->lock); 172 } 173 174 void machine__delete_threads(struct machine *machine) 175 { 176 struct rb_node *nd; 177 int i; 178 179 for (i = 0; i < THREADS__TABLE_SIZE; i++) { 180 struct threads *threads = &machine->threads[i]; 181 down_write(&threads->lock); 182 nd = rb_first(&threads->entries); 183 while (nd) { 184 struct thread *t = rb_entry(nd, struct thread, rb_node); 185 186 nd = rb_next(nd); 187 __machine__remove_thread(machine, t, false); 188 } 189 up_write(&threads->lock); 190 } 191 } 192 193 void machine__exit(struct machine *machine) 194 { 195 int i; 196 197 if (machine == NULL) 198 return; 199 200 machine__destroy_kernel_maps(machine); 201 map_groups__exit(&machine->kmaps); 202 dsos__exit(&machine->dsos); 203 machine__exit_vdso(machine); 204 zfree(&machine->root_dir); 205 zfree(&machine->mmap_name); 206 zfree(&machine->current_tid); 207 208 for (i = 0; i < THREADS__TABLE_SIZE; i++) { 209 struct threads *threads = &machine->threads[i]; 210 exit_rwsem(&threads->lock); 211 } 212 } 213 214 void machine__delete(struct machine *machine) 215 { 216 if (machine) { 217 machine__exit(machine); 218 free(machine); 219 } 220 } 221 222 void machines__init(struct machines *machines) 223 { 224 machine__init(&machines->host, "", HOST_KERNEL_ID); 225 machines->guests = RB_ROOT; 226 } 227 228 void machines__exit(struct machines *machines) 229 { 230 machine__exit(&machines->host); 231 /* XXX exit guest */ 232 } 233 234 struct machine *machines__add(struct machines *machines, pid_t pid, 235 const char *root_dir) 236 { 237 struct rb_node **p = &machines->guests.rb_node; 238 struct rb_node *parent = NULL; 239 struct machine *pos, *machine = malloc(sizeof(*machine)); 240 241 if (machine == NULL) 242 return NULL; 243 244 if (machine__init(machine, root_dir, pid) != 0) { 245 free(machine); 246 return NULL; 247 } 248 249 while (*p != NULL) { 250 parent = *p; 251 pos = rb_entry(parent, struct machine, rb_node); 252 if (pid < pos->pid) 253 p = &(*p)->rb_left; 254 else 255 p = &(*p)->rb_right; 256 } 257 258 rb_link_node(&machine->rb_node, parent, p); 259 rb_insert_color(&machine->rb_node, &machines->guests); 260 261 return machine; 262 } 263 264 void machines__set_comm_exec(struct machines *machines, bool comm_exec) 265 { 266 struct rb_node *nd; 267 268 machines->host.comm_exec = comm_exec; 269 270 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 271 struct machine *machine = rb_entry(nd, struct machine, rb_node); 272 273 machine->comm_exec = comm_exec; 274 } 275 } 276 277 struct machine *machines__find(struct machines *machines, pid_t pid) 278 { 279 struct rb_node **p = &machines->guests.rb_node; 280 struct rb_node *parent = NULL; 281 struct machine *machine; 282 struct machine *default_machine = NULL; 283 284 if (pid == HOST_KERNEL_ID) 285 return &machines->host; 286 287 while (*p != NULL) { 288 parent = *p; 289 machine = rb_entry(parent, struct machine, rb_node); 290 if (pid < machine->pid) 291 p = &(*p)->rb_left; 292 else if (pid > machine->pid) 293 p = &(*p)->rb_right; 294 else 295 return machine; 296 if (!machine->pid) 297 default_machine = machine; 298 } 299 300 return default_machine; 301 } 302 303 struct machine *machines__findnew(struct machines *machines, pid_t pid) 304 { 305 char path[PATH_MAX]; 306 const char *root_dir = ""; 307 struct machine *machine = machines__find(machines, pid); 308 309 if (machine && (machine->pid == pid)) 310 goto out; 311 312 if ((pid != HOST_KERNEL_ID) && 313 (pid != DEFAULT_GUEST_KERNEL_ID) && 314 (symbol_conf.guestmount)) { 315 sprintf(path, "%s/%d", symbol_conf.guestmount, pid); 316 if (access(path, R_OK)) { 317 static struct strlist *seen; 318 319 if (!seen) 320 seen = strlist__new(NULL, NULL); 321 322 if (!strlist__has_entry(seen, path)) { 323 pr_err("Can't access file %s\n", path); 324 strlist__add(seen, path); 325 } 326 machine = NULL; 327 goto out; 328 } 329 root_dir = path; 330 } 331 332 machine = machines__add(machines, pid, root_dir); 333 out: 334 return machine; 335 } 336 337 void machines__process_guests(struct machines *machines, 338 machine__process_t process, void *data) 339 { 340 struct rb_node *nd; 341 342 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 343 struct machine *pos = rb_entry(nd, struct machine, rb_node); 344 process(pos, data); 345 } 346 } 347 348 void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size) 349 { 350 struct rb_node *node; 351 struct machine *machine; 352 353 machines->host.id_hdr_size = id_hdr_size; 354 355 for (node = rb_first(&machines->guests); node; node = rb_next(node)) { 356 machine = rb_entry(node, struct machine, rb_node); 357 machine->id_hdr_size = id_hdr_size; 358 } 359 360 return; 361 } 362 363 static void machine__update_thread_pid(struct machine *machine, 364 struct thread *th, pid_t pid) 365 { 366 struct thread *leader; 367 368 if (pid == th->pid_ || pid == -1 || th->pid_ != -1) 369 return; 370 371 th->pid_ = pid; 372 373 if (th->pid_ == th->tid) 374 return; 375 376 leader = __machine__findnew_thread(machine, th->pid_, th->pid_); 377 if (!leader) 378 goto out_err; 379 380 if (!leader->mg) 381 leader->mg = map_groups__new(machine); 382 383 if (!leader->mg) 384 goto out_err; 385 386 if (th->mg == leader->mg) 387 return; 388 389 if (th->mg) { 390 /* 391 * Maps are created from MMAP events which provide the pid and 392 * tid. Consequently there never should be any maps on a thread 393 * with an unknown pid. Just print an error if there are. 394 */ 395 if (!map_groups__empty(th->mg)) 396 pr_err("Discarding thread maps for %d:%d\n", 397 th->pid_, th->tid); 398 map_groups__put(th->mg); 399 } 400 401 th->mg = map_groups__get(leader->mg); 402 out_put: 403 thread__put(leader); 404 return; 405 out_err: 406 pr_err("Failed to join map groups for %d:%d\n", th->pid_, th->tid); 407 goto out_put; 408 } 409 410 /* 411 * Caller must eventually drop thread->refcnt returned with a successful 412 * lookup/new thread inserted. 413 */ 414 static struct thread *____machine__findnew_thread(struct machine *machine, 415 struct threads *threads, 416 pid_t pid, pid_t tid, 417 bool create) 418 { 419 struct rb_node **p = &threads->entries.rb_node; 420 struct rb_node *parent = NULL; 421 struct thread *th; 422 423 /* 424 * Front-end cache - TID lookups come in blocks, 425 * so most of the time we dont have to look up 426 * the full rbtree: 427 */ 428 th = threads->last_match; 429 if (th != NULL) { 430 if (th->tid == tid) { 431 machine__update_thread_pid(machine, th, pid); 432 return thread__get(th); 433 } 434 435 threads->last_match = NULL; 436 } 437 438 while (*p != NULL) { 439 parent = *p; 440 th = rb_entry(parent, struct thread, rb_node); 441 442 if (th->tid == tid) { 443 threads->last_match = th; 444 machine__update_thread_pid(machine, th, pid); 445 return thread__get(th); 446 } 447 448 if (tid < th->tid) 449 p = &(*p)->rb_left; 450 else 451 p = &(*p)->rb_right; 452 } 453 454 if (!create) 455 return NULL; 456 457 th = thread__new(pid, tid); 458 if (th != NULL) { 459 rb_link_node(&th->rb_node, parent, p); 460 rb_insert_color(&th->rb_node, &threads->entries); 461 462 /* 463 * We have to initialize map_groups separately 464 * after rb tree is updated. 465 * 466 * The reason is that we call machine__findnew_thread 467 * within thread__init_map_groups to find the thread 468 * leader and that would screwed the rb tree. 469 */ 470 if (thread__init_map_groups(th, machine)) { 471 rb_erase_init(&th->rb_node, &threads->entries); 472 RB_CLEAR_NODE(&th->rb_node); 473 thread__put(th); 474 return NULL; 475 } 476 /* 477 * It is now in the rbtree, get a ref 478 */ 479 thread__get(th); 480 threads->last_match = th; 481 ++threads->nr; 482 } 483 484 return th; 485 } 486 487 struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid) 488 { 489 return ____machine__findnew_thread(machine, machine__threads(machine, tid), pid, tid, true); 490 } 491 492 struct thread *machine__findnew_thread(struct machine *machine, pid_t pid, 493 pid_t tid) 494 { 495 struct threads *threads = machine__threads(machine, tid); 496 struct thread *th; 497 498 down_write(&threads->lock); 499 th = __machine__findnew_thread(machine, pid, tid); 500 up_write(&threads->lock); 501 return th; 502 } 503 504 struct thread *machine__find_thread(struct machine *machine, pid_t pid, 505 pid_t tid) 506 { 507 struct threads *threads = machine__threads(machine, tid); 508 struct thread *th; 509 510 down_read(&threads->lock); 511 th = ____machine__findnew_thread(machine, threads, pid, tid, false); 512 up_read(&threads->lock); 513 return th; 514 } 515 516 struct comm *machine__thread_exec_comm(struct machine *machine, 517 struct thread *thread) 518 { 519 if (machine->comm_exec) 520 return thread__exec_comm(thread); 521 else 522 return thread__comm(thread); 523 } 524 525 int machine__process_comm_event(struct machine *machine, union perf_event *event, 526 struct perf_sample *sample) 527 { 528 struct thread *thread = machine__findnew_thread(machine, 529 event->comm.pid, 530 event->comm.tid); 531 bool exec = event->header.misc & PERF_RECORD_MISC_COMM_EXEC; 532 int err = 0; 533 534 if (exec) 535 machine->comm_exec = true; 536 537 if (dump_trace) 538 perf_event__fprintf_comm(event, stdout); 539 540 if (thread == NULL || 541 __thread__set_comm(thread, event->comm.comm, sample->time, exec)) { 542 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n"); 543 err = -1; 544 } 545 546 thread__put(thread); 547 548 return err; 549 } 550 551 int machine__process_namespaces_event(struct machine *machine __maybe_unused, 552 union perf_event *event, 553 struct perf_sample *sample __maybe_unused) 554 { 555 struct thread *thread = machine__findnew_thread(machine, 556 event->namespaces.pid, 557 event->namespaces.tid); 558 int err = 0; 559 560 WARN_ONCE(event->namespaces.nr_namespaces > NR_NAMESPACES, 561 "\nWARNING: kernel seems to support more namespaces than perf" 562 " tool.\nTry updating the perf tool..\n\n"); 563 564 WARN_ONCE(event->namespaces.nr_namespaces < NR_NAMESPACES, 565 "\nWARNING: perf tool seems to support more namespaces than" 566 " the kernel.\nTry updating the kernel..\n\n"); 567 568 if (dump_trace) 569 perf_event__fprintf_namespaces(event, stdout); 570 571 if (thread == NULL || 572 thread__set_namespaces(thread, sample->time, &event->namespaces)) { 573 dump_printf("problem processing PERF_RECORD_NAMESPACES, skipping event.\n"); 574 err = -1; 575 } 576 577 thread__put(thread); 578 579 return err; 580 } 581 582 int machine__process_lost_event(struct machine *machine __maybe_unused, 583 union perf_event *event, struct perf_sample *sample __maybe_unused) 584 { 585 dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n", 586 event->lost.id, event->lost.lost); 587 return 0; 588 } 589 590 int machine__process_lost_samples_event(struct machine *machine __maybe_unused, 591 union perf_event *event, struct perf_sample *sample) 592 { 593 dump_printf(": id:%" PRIu64 ": lost samples :%" PRIu64 "\n", 594 sample->id, event->lost_samples.lost); 595 return 0; 596 } 597 598 static struct dso *machine__findnew_module_dso(struct machine *machine, 599 struct kmod_path *m, 600 const char *filename) 601 { 602 struct dso *dso; 603 604 down_write(&machine->dsos.lock); 605 606 dso = __dsos__find(&machine->dsos, m->name, true); 607 if (!dso) { 608 dso = __dsos__addnew(&machine->dsos, m->name); 609 if (dso == NULL) 610 goto out_unlock; 611 612 dso__set_module_info(dso, m, machine); 613 dso__set_long_name(dso, strdup(filename), true); 614 } 615 616 dso__get(dso); 617 out_unlock: 618 up_write(&machine->dsos.lock); 619 return dso; 620 } 621 622 int machine__process_aux_event(struct machine *machine __maybe_unused, 623 union perf_event *event) 624 { 625 if (dump_trace) 626 perf_event__fprintf_aux(event, stdout); 627 return 0; 628 } 629 630 int machine__process_itrace_start_event(struct machine *machine __maybe_unused, 631 union perf_event *event) 632 { 633 if (dump_trace) 634 perf_event__fprintf_itrace_start(event, stdout); 635 return 0; 636 } 637 638 int machine__process_switch_event(struct machine *machine __maybe_unused, 639 union perf_event *event) 640 { 641 if (dump_trace) 642 perf_event__fprintf_switch(event, stdout); 643 return 0; 644 } 645 646 static void dso__adjust_kmod_long_name(struct dso *dso, const char *filename) 647 { 648 const char *dup_filename; 649 650 if (!filename || !dso || !dso->long_name) 651 return; 652 if (dso->long_name[0] != '[') 653 return; 654 if (!strchr(filename, '/')) 655 return; 656 657 dup_filename = strdup(filename); 658 if (!dup_filename) 659 return; 660 661 dso__set_long_name(dso, dup_filename, true); 662 } 663 664 struct map *machine__findnew_module_map(struct machine *machine, u64 start, 665 const char *filename) 666 { 667 struct map *map = NULL; 668 struct dso *dso = NULL; 669 struct kmod_path m; 670 671 if (kmod_path__parse_name(&m, filename)) 672 return NULL; 673 674 map = map_groups__find_by_name(&machine->kmaps, m.name); 675 if (map) { 676 /* 677 * If the map's dso is an offline module, give dso__load() 678 * a chance to find the file path of that module by fixing 679 * long_name. 680 */ 681 dso__adjust_kmod_long_name(map->dso, filename); 682 goto out; 683 } 684 685 dso = machine__findnew_module_dso(machine, &m, filename); 686 if (dso == NULL) 687 goto out; 688 689 map = map__new2(start, dso, MAP__FUNCTION); 690 if (map == NULL) 691 goto out; 692 693 map_groups__insert(&machine->kmaps, map); 694 695 /* Put the map here because map_groups__insert alread got it */ 696 map__put(map); 697 out: 698 /* put the dso here, corresponding to machine__findnew_module_dso */ 699 dso__put(dso); 700 free(m.name); 701 return map; 702 } 703 704 size_t machines__fprintf_dsos(struct machines *machines, FILE *fp) 705 { 706 struct rb_node *nd; 707 size_t ret = __dsos__fprintf(&machines->host.dsos.head, fp); 708 709 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 710 struct machine *pos = rb_entry(nd, struct machine, rb_node); 711 ret += __dsos__fprintf(&pos->dsos.head, fp); 712 } 713 714 return ret; 715 } 716 717 size_t machine__fprintf_dsos_buildid(struct machine *m, FILE *fp, 718 bool (skip)(struct dso *dso, int parm), int parm) 719 { 720 return __dsos__fprintf_buildid(&m->dsos.head, fp, skip, parm); 721 } 722 723 size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp, 724 bool (skip)(struct dso *dso, int parm), int parm) 725 { 726 struct rb_node *nd; 727 size_t ret = machine__fprintf_dsos_buildid(&machines->host, fp, skip, parm); 728 729 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 730 struct machine *pos = rb_entry(nd, struct machine, rb_node); 731 ret += machine__fprintf_dsos_buildid(pos, fp, skip, parm); 732 } 733 return ret; 734 } 735 736 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp) 737 { 738 int i; 739 size_t printed = 0; 740 struct dso *kdso = machine__kernel_map(machine)->dso; 741 742 if (kdso->has_build_id) { 743 char filename[PATH_MAX]; 744 if (dso__build_id_filename(kdso, filename, sizeof(filename), 745 false)) 746 printed += fprintf(fp, "[0] %s\n", filename); 747 } 748 749 for (i = 0; i < vmlinux_path__nr_entries; ++i) 750 printed += fprintf(fp, "[%d] %s\n", 751 i + kdso->has_build_id, vmlinux_path[i]); 752 753 return printed; 754 } 755 756 size_t machine__fprintf(struct machine *machine, FILE *fp) 757 { 758 struct rb_node *nd; 759 size_t ret; 760 int i; 761 762 for (i = 0; i < THREADS__TABLE_SIZE; i++) { 763 struct threads *threads = &machine->threads[i]; 764 765 down_read(&threads->lock); 766 767 ret = fprintf(fp, "Threads: %u\n", threads->nr); 768 769 for (nd = rb_first(&threads->entries); nd; nd = rb_next(nd)) { 770 struct thread *pos = rb_entry(nd, struct thread, rb_node); 771 772 ret += thread__fprintf(pos, fp); 773 } 774 775 up_read(&threads->lock); 776 } 777 return ret; 778 } 779 780 static struct dso *machine__get_kernel(struct machine *machine) 781 { 782 const char *vmlinux_name = machine->mmap_name; 783 struct dso *kernel; 784 785 if (machine__is_host(machine)) { 786 if (symbol_conf.vmlinux_name) 787 vmlinux_name = symbol_conf.vmlinux_name; 788 789 kernel = machine__findnew_kernel(machine, vmlinux_name, 790 "[kernel]", DSO_TYPE_KERNEL); 791 } else { 792 if (symbol_conf.default_guest_vmlinux_name) 793 vmlinux_name = symbol_conf.default_guest_vmlinux_name; 794 795 kernel = machine__findnew_kernel(machine, vmlinux_name, 796 "[guest.kernel]", 797 DSO_TYPE_GUEST_KERNEL); 798 } 799 800 if (kernel != NULL && (!kernel->has_build_id)) 801 dso__read_running_kernel_build_id(kernel, machine); 802 803 return kernel; 804 } 805 806 struct process_args { 807 u64 start; 808 }; 809 810 static void machine__get_kallsyms_filename(struct machine *machine, char *buf, 811 size_t bufsz) 812 { 813 if (machine__is_default_guest(machine)) 814 scnprintf(buf, bufsz, "%s", symbol_conf.default_guest_kallsyms); 815 else 816 scnprintf(buf, bufsz, "%s/proc/kallsyms", machine->root_dir); 817 } 818 819 const char *ref_reloc_sym_names[] = {"_text", "_stext", NULL}; 820 821 /* Figure out the start address of kernel map from /proc/kallsyms. 822 * Returns the name of the start symbol in *symbol_name. Pass in NULL as 823 * symbol_name if it's not that important. 824 */ 825 static int machine__get_running_kernel_start(struct machine *machine, 826 const char **symbol_name, u64 *start) 827 { 828 char filename[PATH_MAX]; 829 int i, err = -1; 830 const char *name; 831 u64 addr = 0; 832 833 machine__get_kallsyms_filename(machine, filename, PATH_MAX); 834 835 if (symbol__restricted_filename(filename, "/proc/kallsyms")) 836 return 0; 837 838 for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) { 839 err = kallsyms__get_function_start(filename, name, &addr); 840 if (!err) 841 break; 842 } 843 844 if (err) 845 return -1; 846 847 if (symbol_name) 848 *symbol_name = name; 849 850 *start = addr; 851 return 0; 852 } 853 854 static int 855 __machine__create_kernel_maps(struct machine *machine, struct dso *kernel) 856 { 857 int type; 858 859 /* In case of renewal the kernel map, destroy previous one */ 860 machine__destroy_kernel_maps(machine); 861 862 for (type = 0; type < MAP__NR_TYPES; ++type) { 863 struct kmap *kmap; 864 struct map *map; 865 866 machine->vmlinux_maps[type] = map__new2(0, kernel, type); 867 if (machine->vmlinux_maps[type] == NULL) 868 return -1; 869 870 machine->vmlinux_maps[type]->map_ip = 871 machine->vmlinux_maps[type]->unmap_ip = 872 identity__map_ip; 873 map = __machine__kernel_map(machine, type); 874 kmap = map__kmap(map); 875 if (!kmap) 876 return -1; 877 878 kmap->kmaps = &machine->kmaps; 879 map_groups__insert(&machine->kmaps, map); 880 } 881 882 return 0; 883 } 884 885 void machine__destroy_kernel_maps(struct machine *machine) 886 { 887 int type; 888 889 for (type = 0; type < MAP__NR_TYPES; ++type) { 890 struct kmap *kmap; 891 struct map *map = __machine__kernel_map(machine, type); 892 893 if (map == NULL) 894 continue; 895 896 kmap = map__kmap(map); 897 map_groups__remove(&machine->kmaps, map); 898 if (kmap && kmap->ref_reloc_sym) { 899 /* 900 * ref_reloc_sym is shared among all maps, so free just 901 * on one of them. 902 */ 903 if (type == MAP__FUNCTION) { 904 zfree((char **)&kmap->ref_reloc_sym->name); 905 zfree(&kmap->ref_reloc_sym); 906 } else 907 kmap->ref_reloc_sym = NULL; 908 } 909 910 map__put(machine->vmlinux_maps[type]); 911 machine->vmlinux_maps[type] = NULL; 912 } 913 } 914 915 int machines__create_guest_kernel_maps(struct machines *machines) 916 { 917 int ret = 0; 918 struct dirent **namelist = NULL; 919 int i, items = 0; 920 char path[PATH_MAX]; 921 pid_t pid; 922 char *endp; 923 924 if (symbol_conf.default_guest_vmlinux_name || 925 symbol_conf.default_guest_modules || 926 symbol_conf.default_guest_kallsyms) { 927 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID); 928 } 929 930 if (symbol_conf.guestmount) { 931 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL); 932 if (items <= 0) 933 return -ENOENT; 934 for (i = 0; i < items; i++) { 935 if (!isdigit(namelist[i]->d_name[0])) { 936 /* Filter out . and .. */ 937 continue; 938 } 939 pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10); 940 if ((*endp != '\0') || 941 (endp == namelist[i]->d_name) || 942 (errno == ERANGE)) { 943 pr_debug("invalid directory (%s). Skipping.\n", 944 namelist[i]->d_name); 945 continue; 946 } 947 sprintf(path, "%s/%s/proc/kallsyms", 948 symbol_conf.guestmount, 949 namelist[i]->d_name); 950 ret = access(path, R_OK); 951 if (ret) { 952 pr_debug("Can't access file %s\n", path); 953 goto failure; 954 } 955 machines__create_kernel_maps(machines, pid); 956 } 957 failure: 958 free(namelist); 959 } 960 961 return ret; 962 } 963 964 void machines__destroy_kernel_maps(struct machines *machines) 965 { 966 struct rb_node *next = rb_first(&machines->guests); 967 968 machine__destroy_kernel_maps(&machines->host); 969 970 while (next) { 971 struct machine *pos = rb_entry(next, struct machine, rb_node); 972 973 next = rb_next(&pos->rb_node); 974 rb_erase(&pos->rb_node, &machines->guests); 975 machine__delete(pos); 976 } 977 } 978 979 int machines__create_kernel_maps(struct machines *machines, pid_t pid) 980 { 981 struct machine *machine = machines__findnew(machines, pid); 982 983 if (machine == NULL) 984 return -1; 985 986 return machine__create_kernel_maps(machine); 987 } 988 989 int __machine__load_kallsyms(struct machine *machine, const char *filename, 990 enum map_type type) 991 { 992 struct map *map = machine__kernel_map(machine); 993 int ret = __dso__load_kallsyms(map->dso, filename, map, true); 994 995 if (ret > 0) { 996 dso__set_loaded(map->dso, type); 997 /* 998 * Since /proc/kallsyms will have multiple sessions for the 999 * kernel, with modules between them, fixup the end of all 1000 * sections. 1001 */ 1002 __map_groups__fixup_end(&machine->kmaps, type); 1003 } 1004 1005 return ret; 1006 } 1007 1008 int machine__load_vmlinux_path(struct machine *machine) 1009 { 1010 struct map *map = machine__kernel_map(machine); 1011 int ret = dso__load_vmlinux_path(map->dso, map); 1012 1013 if (ret > 0) 1014 dso__set_loaded(map->dso, map->type); 1015 1016 return ret; 1017 } 1018 1019 static char *get_kernel_version(const char *root_dir) 1020 { 1021 char version[PATH_MAX]; 1022 FILE *file; 1023 char *name, *tmp; 1024 const char *prefix = "Linux version "; 1025 1026 sprintf(version, "%s/proc/version", root_dir); 1027 file = fopen(version, "r"); 1028 if (!file) 1029 return NULL; 1030 1031 version[0] = '\0'; 1032 tmp = fgets(version, sizeof(version), file); 1033 fclose(file); 1034 1035 name = strstr(version, prefix); 1036 if (!name) 1037 return NULL; 1038 name += strlen(prefix); 1039 tmp = strchr(name, ' '); 1040 if (tmp) 1041 *tmp = '\0'; 1042 1043 return strdup(name); 1044 } 1045 1046 static bool is_kmod_dso(struct dso *dso) 1047 { 1048 return dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE || 1049 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE; 1050 } 1051 1052 static int map_groups__set_module_path(struct map_groups *mg, const char *path, 1053 struct kmod_path *m) 1054 { 1055 char *long_name; 1056 struct map *map = map_groups__find_by_name(mg, m->name); 1057 1058 if (map == NULL) 1059 return 0; 1060 1061 long_name = strdup(path); 1062 if (long_name == NULL) 1063 return -ENOMEM; 1064 1065 dso__set_long_name(map->dso, long_name, true); 1066 dso__kernel_module_get_build_id(map->dso, ""); 1067 1068 /* 1069 * Full name could reveal us kmod compression, so 1070 * we need to update the symtab_type if needed. 1071 */ 1072 if (m->comp && is_kmod_dso(map->dso)) 1073 map->dso->symtab_type++; 1074 1075 return 0; 1076 } 1077 1078 static int map_groups__set_modules_path_dir(struct map_groups *mg, 1079 const char *dir_name, int depth) 1080 { 1081 struct dirent *dent; 1082 DIR *dir = opendir(dir_name); 1083 int ret = 0; 1084 1085 if (!dir) { 1086 pr_debug("%s: cannot open %s dir\n", __func__, dir_name); 1087 return -1; 1088 } 1089 1090 while ((dent = readdir(dir)) != NULL) { 1091 char path[PATH_MAX]; 1092 struct stat st; 1093 1094 /*sshfs might return bad dent->d_type, so we have to stat*/ 1095 snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name); 1096 if (stat(path, &st)) 1097 continue; 1098 1099 if (S_ISDIR(st.st_mode)) { 1100 if (!strcmp(dent->d_name, ".") || 1101 !strcmp(dent->d_name, "..")) 1102 continue; 1103 1104 /* Do not follow top-level source and build symlinks */ 1105 if (depth == 0) { 1106 if (!strcmp(dent->d_name, "source") || 1107 !strcmp(dent->d_name, "build")) 1108 continue; 1109 } 1110 1111 ret = map_groups__set_modules_path_dir(mg, path, 1112 depth + 1); 1113 if (ret < 0) 1114 goto out; 1115 } else { 1116 struct kmod_path m; 1117 1118 ret = kmod_path__parse_name(&m, dent->d_name); 1119 if (ret) 1120 goto out; 1121 1122 if (m.kmod) 1123 ret = map_groups__set_module_path(mg, path, &m); 1124 1125 free(m.name); 1126 1127 if (ret) 1128 goto out; 1129 } 1130 } 1131 1132 out: 1133 closedir(dir); 1134 return ret; 1135 } 1136 1137 static int machine__set_modules_path(struct machine *machine) 1138 { 1139 char *version; 1140 char modules_path[PATH_MAX]; 1141 1142 version = get_kernel_version(machine->root_dir); 1143 if (!version) 1144 return -1; 1145 1146 snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s", 1147 machine->root_dir, version); 1148 free(version); 1149 1150 return map_groups__set_modules_path_dir(&machine->kmaps, modules_path, 0); 1151 } 1152 int __weak arch__fix_module_text_start(u64 *start __maybe_unused, 1153 const char *name __maybe_unused) 1154 { 1155 return 0; 1156 } 1157 1158 static int machine__create_module(void *arg, const char *name, u64 start, 1159 u64 size) 1160 { 1161 struct machine *machine = arg; 1162 struct map *map; 1163 1164 if (arch__fix_module_text_start(&start, name) < 0) 1165 return -1; 1166 1167 map = machine__findnew_module_map(machine, start, name); 1168 if (map == NULL) 1169 return -1; 1170 map->end = start + size; 1171 1172 dso__kernel_module_get_build_id(map->dso, machine->root_dir); 1173 1174 return 0; 1175 } 1176 1177 static int machine__create_modules(struct machine *machine) 1178 { 1179 const char *modules; 1180 char path[PATH_MAX]; 1181 1182 if (machine__is_default_guest(machine)) { 1183 modules = symbol_conf.default_guest_modules; 1184 } else { 1185 snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir); 1186 modules = path; 1187 } 1188 1189 if (symbol__restricted_filename(modules, "/proc/modules")) 1190 return -1; 1191 1192 if (modules__parse(modules, machine, machine__create_module)) 1193 return -1; 1194 1195 if (!machine__set_modules_path(machine)) 1196 return 0; 1197 1198 pr_debug("Problems setting modules path maps, continuing anyway...\n"); 1199 1200 return 0; 1201 } 1202 1203 static void machine__set_kernel_mmap(struct machine *machine, 1204 u64 start, u64 end) 1205 { 1206 int i; 1207 1208 for (i = 0; i < MAP__NR_TYPES; i++) { 1209 machine->vmlinux_maps[i]->start = start; 1210 machine->vmlinux_maps[i]->end = end; 1211 1212 /* 1213 * Be a bit paranoid here, some perf.data file came with 1214 * a zero sized synthesized MMAP event for the kernel. 1215 */ 1216 if (start == 0 && end == 0) 1217 machine->vmlinux_maps[i]->end = ~0ULL; 1218 } 1219 } 1220 1221 int machine__create_kernel_maps(struct machine *machine) 1222 { 1223 struct dso *kernel = machine__get_kernel(machine); 1224 const char *name = NULL; 1225 struct map *map; 1226 u64 addr = 0; 1227 int ret; 1228 1229 if (kernel == NULL) 1230 return -1; 1231 1232 ret = __machine__create_kernel_maps(machine, kernel); 1233 dso__put(kernel); 1234 if (ret < 0) 1235 return -1; 1236 1237 if (symbol_conf.use_modules && machine__create_modules(machine) < 0) { 1238 if (machine__is_host(machine)) 1239 pr_debug("Problems creating module maps, " 1240 "continuing anyway...\n"); 1241 else 1242 pr_debug("Problems creating module maps for guest %d, " 1243 "continuing anyway...\n", machine->pid); 1244 } 1245 1246 if (!machine__get_running_kernel_start(machine, &name, &addr)) { 1247 if (name && 1248 maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, name, addr)) { 1249 machine__destroy_kernel_maps(machine); 1250 return -1; 1251 } 1252 1253 /* we have a real start address now, so re-order the kmaps */ 1254 map = machine__kernel_map(machine); 1255 1256 map__get(map); 1257 map_groups__remove(&machine->kmaps, map); 1258 1259 /* assume it's the last in the kmaps */ 1260 machine__set_kernel_mmap(machine, addr, ~0ULL); 1261 1262 map_groups__insert(&machine->kmaps, map); 1263 map__put(map); 1264 } 1265 1266 /* update end address of the kernel map using adjacent module address */ 1267 map = map__next(machine__kernel_map(machine)); 1268 if (map) 1269 machine__set_kernel_mmap(machine, addr, map->start); 1270 1271 return 0; 1272 } 1273 1274 static bool machine__uses_kcore(struct machine *machine) 1275 { 1276 struct dso *dso; 1277 1278 list_for_each_entry(dso, &machine->dsos.head, node) { 1279 if (dso__is_kcore(dso)) 1280 return true; 1281 } 1282 1283 return false; 1284 } 1285 1286 static int machine__process_kernel_mmap_event(struct machine *machine, 1287 union perf_event *event) 1288 { 1289 struct map *map; 1290 enum dso_kernel_type kernel_type; 1291 bool is_kernel_mmap; 1292 1293 /* If we have maps from kcore then we do not need or want any others */ 1294 if (machine__uses_kcore(machine)) 1295 return 0; 1296 1297 if (machine__is_host(machine)) 1298 kernel_type = DSO_TYPE_KERNEL; 1299 else 1300 kernel_type = DSO_TYPE_GUEST_KERNEL; 1301 1302 is_kernel_mmap = memcmp(event->mmap.filename, 1303 machine->mmap_name, 1304 strlen(machine->mmap_name) - 1) == 0; 1305 if (event->mmap.filename[0] == '/' || 1306 (!is_kernel_mmap && event->mmap.filename[0] == '[')) { 1307 map = machine__findnew_module_map(machine, event->mmap.start, 1308 event->mmap.filename); 1309 if (map == NULL) 1310 goto out_problem; 1311 1312 map->end = map->start + event->mmap.len; 1313 } else if (is_kernel_mmap) { 1314 const char *symbol_name = (event->mmap.filename + 1315 strlen(machine->mmap_name)); 1316 /* 1317 * Should be there already, from the build-id table in 1318 * the header. 1319 */ 1320 struct dso *kernel = NULL; 1321 struct dso *dso; 1322 1323 down_read(&machine->dsos.lock); 1324 1325 list_for_each_entry(dso, &machine->dsos.head, node) { 1326 1327 /* 1328 * The cpumode passed to is_kernel_module is not the 1329 * cpumode of *this* event. If we insist on passing 1330 * correct cpumode to is_kernel_module, we should 1331 * record the cpumode when we adding this dso to the 1332 * linked list. 1333 * 1334 * However we don't really need passing correct 1335 * cpumode. We know the correct cpumode must be kernel 1336 * mode (if not, we should not link it onto kernel_dsos 1337 * list). 1338 * 1339 * Therefore, we pass PERF_RECORD_MISC_CPUMODE_UNKNOWN. 1340 * is_kernel_module() treats it as a kernel cpumode. 1341 */ 1342 1343 if (!dso->kernel || 1344 is_kernel_module(dso->long_name, 1345 PERF_RECORD_MISC_CPUMODE_UNKNOWN)) 1346 continue; 1347 1348 1349 kernel = dso; 1350 break; 1351 } 1352 1353 up_read(&machine->dsos.lock); 1354 1355 if (kernel == NULL) 1356 kernel = machine__findnew_dso(machine, machine->mmap_name); 1357 if (kernel == NULL) 1358 goto out_problem; 1359 1360 kernel->kernel = kernel_type; 1361 if (__machine__create_kernel_maps(machine, kernel) < 0) { 1362 dso__put(kernel); 1363 goto out_problem; 1364 } 1365 1366 if (strstr(kernel->long_name, "vmlinux")) 1367 dso__set_short_name(kernel, "[kernel.vmlinux]", false); 1368 1369 machine__set_kernel_mmap(machine, event->mmap.start, 1370 event->mmap.start + event->mmap.len); 1371 1372 /* 1373 * Avoid using a zero address (kptr_restrict) for the ref reloc 1374 * symbol. Effectively having zero here means that at record 1375 * time /proc/sys/kernel/kptr_restrict was non zero. 1376 */ 1377 if (event->mmap.pgoff != 0) { 1378 maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, 1379 symbol_name, 1380 event->mmap.pgoff); 1381 } 1382 1383 if (machine__is_default_guest(machine)) { 1384 /* 1385 * preload dso of guest kernel and modules 1386 */ 1387 dso__load(kernel, machine__kernel_map(machine)); 1388 } 1389 } 1390 return 0; 1391 out_problem: 1392 return -1; 1393 } 1394 1395 int machine__process_mmap2_event(struct machine *machine, 1396 union perf_event *event, 1397 struct perf_sample *sample) 1398 { 1399 struct thread *thread; 1400 struct map *map; 1401 enum map_type type; 1402 int ret = 0; 1403 1404 if (dump_trace) 1405 perf_event__fprintf_mmap2(event, stdout); 1406 1407 if (sample->cpumode == PERF_RECORD_MISC_GUEST_KERNEL || 1408 sample->cpumode == PERF_RECORD_MISC_KERNEL) { 1409 ret = machine__process_kernel_mmap_event(machine, event); 1410 if (ret < 0) 1411 goto out_problem; 1412 return 0; 1413 } 1414 1415 thread = machine__findnew_thread(machine, event->mmap2.pid, 1416 event->mmap2.tid); 1417 if (thread == NULL) 1418 goto out_problem; 1419 1420 if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) 1421 type = MAP__VARIABLE; 1422 else 1423 type = MAP__FUNCTION; 1424 1425 map = map__new(machine, event->mmap2.start, 1426 event->mmap2.len, event->mmap2.pgoff, 1427 event->mmap2.maj, 1428 event->mmap2.min, event->mmap2.ino, 1429 event->mmap2.ino_generation, 1430 event->mmap2.prot, 1431 event->mmap2.flags, 1432 event->mmap2.filename, type, thread); 1433 1434 if (map == NULL) 1435 goto out_problem_map; 1436 1437 ret = thread__insert_map(thread, map); 1438 if (ret) 1439 goto out_problem_insert; 1440 1441 thread__put(thread); 1442 map__put(map); 1443 return 0; 1444 1445 out_problem_insert: 1446 map__put(map); 1447 out_problem_map: 1448 thread__put(thread); 1449 out_problem: 1450 dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n"); 1451 return 0; 1452 } 1453 1454 int machine__process_mmap_event(struct machine *machine, union perf_event *event, 1455 struct perf_sample *sample) 1456 { 1457 struct thread *thread; 1458 struct map *map; 1459 enum map_type type; 1460 int ret = 0; 1461 1462 if (dump_trace) 1463 perf_event__fprintf_mmap(event, stdout); 1464 1465 if (sample->cpumode == PERF_RECORD_MISC_GUEST_KERNEL || 1466 sample->cpumode == PERF_RECORD_MISC_KERNEL) { 1467 ret = machine__process_kernel_mmap_event(machine, event); 1468 if (ret < 0) 1469 goto out_problem; 1470 return 0; 1471 } 1472 1473 thread = machine__findnew_thread(machine, event->mmap.pid, 1474 event->mmap.tid); 1475 if (thread == NULL) 1476 goto out_problem; 1477 1478 if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) 1479 type = MAP__VARIABLE; 1480 else 1481 type = MAP__FUNCTION; 1482 1483 map = map__new(machine, event->mmap.start, 1484 event->mmap.len, event->mmap.pgoff, 1485 0, 0, 0, 0, 0, 0, 1486 event->mmap.filename, 1487 type, thread); 1488 1489 if (map == NULL) 1490 goto out_problem_map; 1491 1492 ret = thread__insert_map(thread, map); 1493 if (ret) 1494 goto out_problem_insert; 1495 1496 thread__put(thread); 1497 map__put(map); 1498 return 0; 1499 1500 out_problem_insert: 1501 map__put(map); 1502 out_problem_map: 1503 thread__put(thread); 1504 out_problem: 1505 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n"); 1506 return 0; 1507 } 1508 1509 static void __machine__remove_thread(struct machine *machine, struct thread *th, bool lock) 1510 { 1511 struct threads *threads = machine__threads(machine, th->tid); 1512 1513 if (threads->last_match == th) 1514 threads->last_match = NULL; 1515 1516 BUG_ON(refcount_read(&th->refcnt) == 0); 1517 if (lock) 1518 down_write(&threads->lock); 1519 rb_erase_init(&th->rb_node, &threads->entries); 1520 RB_CLEAR_NODE(&th->rb_node); 1521 --threads->nr; 1522 /* 1523 * Move it first to the dead_threads list, then drop the reference, 1524 * if this is the last reference, then the thread__delete destructor 1525 * will be called and we will remove it from the dead_threads list. 1526 */ 1527 list_add_tail(&th->node, &threads->dead); 1528 if (lock) 1529 up_write(&threads->lock); 1530 thread__put(th); 1531 } 1532 1533 void machine__remove_thread(struct machine *machine, struct thread *th) 1534 { 1535 return __machine__remove_thread(machine, th, true); 1536 } 1537 1538 int machine__process_fork_event(struct machine *machine, union perf_event *event, 1539 struct perf_sample *sample) 1540 { 1541 struct thread *thread = machine__find_thread(machine, 1542 event->fork.pid, 1543 event->fork.tid); 1544 struct thread *parent = machine__findnew_thread(machine, 1545 event->fork.ppid, 1546 event->fork.ptid); 1547 int err = 0; 1548 1549 if (dump_trace) 1550 perf_event__fprintf_task(event, stdout); 1551 1552 /* 1553 * There may be an existing thread that is not actually the parent, 1554 * either because we are processing events out of order, or because the 1555 * (fork) event that would have removed the thread was lost. Assume the 1556 * latter case and continue on as best we can. 1557 */ 1558 if (parent->pid_ != (pid_t)event->fork.ppid) { 1559 dump_printf("removing erroneous parent thread %d/%d\n", 1560 parent->pid_, parent->tid); 1561 machine__remove_thread(machine, parent); 1562 thread__put(parent); 1563 parent = machine__findnew_thread(machine, event->fork.ppid, 1564 event->fork.ptid); 1565 } 1566 1567 /* if a thread currently exists for the thread id remove it */ 1568 if (thread != NULL) { 1569 machine__remove_thread(machine, thread); 1570 thread__put(thread); 1571 } 1572 1573 thread = machine__findnew_thread(machine, event->fork.pid, 1574 event->fork.tid); 1575 1576 if (thread == NULL || parent == NULL || 1577 thread__fork(thread, parent, sample->time) < 0) { 1578 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n"); 1579 err = -1; 1580 } 1581 thread__put(thread); 1582 thread__put(parent); 1583 1584 return err; 1585 } 1586 1587 int machine__process_exit_event(struct machine *machine, union perf_event *event, 1588 struct perf_sample *sample __maybe_unused) 1589 { 1590 struct thread *thread = machine__find_thread(machine, 1591 event->fork.pid, 1592 event->fork.tid); 1593 1594 if (dump_trace) 1595 perf_event__fprintf_task(event, stdout); 1596 1597 if (thread != NULL) { 1598 thread__exited(thread); 1599 thread__put(thread); 1600 } 1601 1602 return 0; 1603 } 1604 1605 int machine__process_event(struct machine *machine, union perf_event *event, 1606 struct perf_sample *sample) 1607 { 1608 int ret; 1609 1610 switch (event->header.type) { 1611 case PERF_RECORD_COMM: 1612 ret = machine__process_comm_event(machine, event, sample); break; 1613 case PERF_RECORD_MMAP: 1614 ret = machine__process_mmap_event(machine, event, sample); break; 1615 case PERF_RECORD_NAMESPACES: 1616 ret = machine__process_namespaces_event(machine, event, sample); break; 1617 case PERF_RECORD_MMAP2: 1618 ret = machine__process_mmap2_event(machine, event, sample); break; 1619 case PERF_RECORD_FORK: 1620 ret = machine__process_fork_event(machine, event, sample); break; 1621 case PERF_RECORD_EXIT: 1622 ret = machine__process_exit_event(machine, event, sample); break; 1623 case PERF_RECORD_LOST: 1624 ret = machine__process_lost_event(machine, event, sample); break; 1625 case PERF_RECORD_AUX: 1626 ret = machine__process_aux_event(machine, event); break; 1627 case PERF_RECORD_ITRACE_START: 1628 ret = machine__process_itrace_start_event(machine, event); break; 1629 case PERF_RECORD_LOST_SAMPLES: 1630 ret = machine__process_lost_samples_event(machine, event, sample); break; 1631 case PERF_RECORD_SWITCH: 1632 case PERF_RECORD_SWITCH_CPU_WIDE: 1633 ret = machine__process_switch_event(machine, event); break; 1634 default: 1635 ret = -1; 1636 break; 1637 } 1638 1639 return ret; 1640 } 1641 1642 static bool symbol__match_regex(struct symbol *sym, regex_t *regex) 1643 { 1644 if (!regexec(regex, sym->name, 0, NULL, 0)) 1645 return 1; 1646 return 0; 1647 } 1648 1649 static void ip__resolve_ams(struct thread *thread, 1650 struct addr_map_symbol *ams, 1651 u64 ip) 1652 { 1653 struct addr_location al; 1654 1655 memset(&al, 0, sizeof(al)); 1656 /* 1657 * We cannot use the header.misc hint to determine whether a 1658 * branch stack address is user, kernel, guest, hypervisor. 1659 * Branches may straddle the kernel/user/hypervisor boundaries. 1660 * Thus, we have to try consecutively until we find a match 1661 * or else, the symbol is unknown 1662 */ 1663 thread__find_cpumode_addr_location(thread, MAP__FUNCTION, ip, &al); 1664 1665 ams->addr = ip; 1666 ams->al_addr = al.addr; 1667 ams->sym = al.sym; 1668 ams->map = al.map; 1669 ams->phys_addr = 0; 1670 } 1671 1672 static void ip__resolve_data(struct thread *thread, 1673 u8 m, struct addr_map_symbol *ams, 1674 u64 addr, u64 phys_addr) 1675 { 1676 struct addr_location al; 1677 1678 memset(&al, 0, sizeof(al)); 1679 1680 __thread__find_symbol(thread, m, MAP__VARIABLE, addr, &al); 1681 if (al.map == NULL) { 1682 /* 1683 * some shared data regions have execute bit set which puts 1684 * their mapping in the MAP__FUNCTION type array. 1685 * Check there as a fallback option before dropping the sample. 1686 */ 1687 thread__find_symbol(thread, m, addr, &al); 1688 } 1689 1690 ams->addr = addr; 1691 ams->al_addr = al.addr; 1692 ams->sym = al.sym; 1693 ams->map = al.map; 1694 ams->phys_addr = phys_addr; 1695 } 1696 1697 struct mem_info *sample__resolve_mem(struct perf_sample *sample, 1698 struct addr_location *al) 1699 { 1700 struct mem_info *mi = mem_info__new(); 1701 1702 if (!mi) 1703 return NULL; 1704 1705 ip__resolve_ams(al->thread, &mi->iaddr, sample->ip); 1706 ip__resolve_data(al->thread, al->cpumode, &mi->daddr, 1707 sample->addr, sample->phys_addr); 1708 mi->data_src.val = sample->data_src; 1709 1710 return mi; 1711 } 1712 1713 static char *callchain_srcline(struct map *map, struct symbol *sym, u64 ip) 1714 { 1715 char *srcline = NULL; 1716 1717 if (!map || callchain_param.key == CCKEY_FUNCTION) 1718 return srcline; 1719 1720 srcline = srcline__tree_find(&map->dso->srclines, ip); 1721 if (!srcline) { 1722 bool show_sym = false; 1723 bool show_addr = callchain_param.key == CCKEY_ADDRESS; 1724 1725 srcline = get_srcline(map->dso, map__rip_2objdump(map, ip), 1726 sym, show_sym, show_addr, ip); 1727 srcline__tree_insert(&map->dso->srclines, ip, srcline); 1728 } 1729 1730 return srcline; 1731 } 1732 1733 struct iterations { 1734 int nr_loop_iter; 1735 u64 cycles; 1736 }; 1737 1738 static int add_callchain_ip(struct thread *thread, 1739 struct callchain_cursor *cursor, 1740 struct symbol **parent, 1741 struct addr_location *root_al, 1742 u8 *cpumode, 1743 u64 ip, 1744 bool branch, 1745 struct branch_flags *flags, 1746 struct iterations *iter, 1747 u64 branch_from) 1748 { 1749 struct addr_location al; 1750 int nr_loop_iter = 0; 1751 u64 iter_cycles = 0; 1752 const char *srcline = NULL; 1753 1754 al.filtered = 0; 1755 al.sym = NULL; 1756 if (!cpumode) { 1757 thread__find_cpumode_addr_location(thread, MAP__FUNCTION, 1758 ip, &al); 1759 } else { 1760 if (ip >= PERF_CONTEXT_MAX) { 1761 switch (ip) { 1762 case PERF_CONTEXT_HV: 1763 *cpumode = PERF_RECORD_MISC_HYPERVISOR; 1764 break; 1765 case PERF_CONTEXT_KERNEL: 1766 *cpumode = PERF_RECORD_MISC_KERNEL; 1767 break; 1768 case PERF_CONTEXT_USER: 1769 *cpumode = PERF_RECORD_MISC_USER; 1770 break; 1771 default: 1772 pr_debug("invalid callchain context: " 1773 "%"PRId64"\n", (s64) ip); 1774 /* 1775 * It seems the callchain is corrupted. 1776 * Discard all. 1777 */ 1778 callchain_cursor_reset(cursor); 1779 return 1; 1780 } 1781 return 0; 1782 } 1783 thread__find_symbol(thread, *cpumode, ip, &al); 1784 } 1785 1786 if (al.sym != NULL) { 1787 if (perf_hpp_list.parent && !*parent && 1788 symbol__match_regex(al.sym, &parent_regex)) 1789 *parent = al.sym; 1790 else if (have_ignore_callees && root_al && 1791 symbol__match_regex(al.sym, &ignore_callees_regex)) { 1792 /* Treat this symbol as the root, 1793 forgetting its callees. */ 1794 *root_al = al; 1795 callchain_cursor_reset(cursor); 1796 } 1797 } 1798 1799 if (symbol_conf.hide_unresolved && al.sym == NULL) 1800 return 0; 1801 1802 if (iter) { 1803 nr_loop_iter = iter->nr_loop_iter; 1804 iter_cycles = iter->cycles; 1805 } 1806 1807 srcline = callchain_srcline(al.map, al.sym, al.addr); 1808 return callchain_cursor_append(cursor, al.addr, al.map, al.sym, 1809 branch, flags, nr_loop_iter, 1810 iter_cycles, branch_from, srcline); 1811 } 1812 1813 struct branch_info *sample__resolve_bstack(struct perf_sample *sample, 1814 struct addr_location *al) 1815 { 1816 unsigned int i; 1817 const struct branch_stack *bs = sample->branch_stack; 1818 struct branch_info *bi = calloc(bs->nr, sizeof(struct branch_info)); 1819 1820 if (!bi) 1821 return NULL; 1822 1823 for (i = 0; i < bs->nr; i++) { 1824 ip__resolve_ams(al->thread, &bi[i].to, bs->entries[i].to); 1825 ip__resolve_ams(al->thread, &bi[i].from, bs->entries[i].from); 1826 bi[i].flags = bs->entries[i].flags; 1827 } 1828 return bi; 1829 } 1830 1831 static void save_iterations(struct iterations *iter, 1832 struct branch_entry *be, int nr) 1833 { 1834 int i; 1835 1836 iter->nr_loop_iter = nr; 1837 iter->cycles = 0; 1838 1839 for (i = 0; i < nr; i++) 1840 iter->cycles += be[i].flags.cycles; 1841 } 1842 1843 #define CHASHSZ 127 1844 #define CHASHBITS 7 1845 #define NO_ENTRY 0xff 1846 1847 #define PERF_MAX_BRANCH_DEPTH 127 1848 1849 /* Remove loops. */ 1850 static int remove_loops(struct branch_entry *l, int nr, 1851 struct iterations *iter) 1852 { 1853 int i, j, off; 1854 unsigned char chash[CHASHSZ]; 1855 1856 memset(chash, NO_ENTRY, sizeof(chash)); 1857 1858 BUG_ON(PERF_MAX_BRANCH_DEPTH > 255); 1859 1860 for (i = 0; i < nr; i++) { 1861 int h = hash_64(l[i].from, CHASHBITS) % CHASHSZ; 1862 1863 /* no collision handling for now */ 1864 if (chash[h] == NO_ENTRY) { 1865 chash[h] = i; 1866 } else if (l[chash[h]].from == l[i].from) { 1867 bool is_loop = true; 1868 /* check if it is a real loop */ 1869 off = 0; 1870 for (j = chash[h]; j < i && i + off < nr; j++, off++) 1871 if (l[j].from != l[i + off].from) { 1872 is_loop = false; 1873 break; 1874 } 1875 if (is_loop) { 1876 j = nr - (i + off); 1877 if (j > 0) { 1878 save_iterations(iter + i + off, 1879 l + i, off); 1880 1881 memmove(iter + i, iter + i + off, 1882 j * sizeof(*iter)); 1883 1884 memmove(l + i, l + i + off, 1885 j * sizeof(*l)); 1886 } 1887 1888 nr -= off; 1889 } 1890 } 1891 } 1892 return nr; 1893 } 1894 1895 /* 1896 * Recolve LBR callstack chain sample 1897 * Return: 1898 * 1 on success get LBR callchain information 1899 * 0 no available LBR callchain information, should try fp 1900 * negative error code on other errors. 1901 */ 1902 static int resolve_lbr_callchain_sample(struct thread *thread, 1903 struct callchain_cursor *cursor, 1904 struct perf_sample *sample, 1905 struct symbol **parent, 1906 struct addr_location *root_al, 1907 int max_stack) 1908 { 1909 struct ip_callchain *chain = sample->callchain; 1910 int chain_nr = min(max_stack, (int)chain->nr), i; 1911 u8 cpumode = PERF_RECORD_MISC_USER; 1912 u64 ip, branch_from = 0; 1913 1914 for (i = 0; i < chain_nr; i++) { 1915 if (chain->ips[i] == PERF_CONTEXT_USER) 1916 break; 1917 } 1918 1919 /* LBR only affects the user callchain */ 1920 if (i != chain_nr) { 1921 struct branch_stack *lbr_stack = sample->branch_stack; 1922 int lbr_nr = lbr_stack->nr, j, k; 1923 bool branch; 1924 struct branch_flags *flags; 1925 /* 1926 * LBR callstack can only get user call chain. 1927 * The mix_chain_nr is kernel call chain 1928 * number plus LBR user call chain number. 1929 * i is kernel call chain number, 1930 * 1 is PERF_CONTEXT_USER, 1931 * lbr_nr + 1 is the user call chain number. 1932 * For details, please refer to the comments 1933 * in callchain__printf 1934 */ 1935 int mix_chain_nr = i + 1 + lbr_nr + 1; 1936 1937 for (j = 0; j < mix_chain_nr; j++) { 1938 int err; 1939 branch = false; 1940 flags = NULL; 1941 1942 if (callchain_param.order == ORDER_CALLEE) { 1943 if (j < i + 1) 1944 ip = chain->ips[j]; 1945 else if (j > i + 1) { 1946 k = j - i - 2; 1947 ip = lbr_stack->entries[k].from; 1948 branch = true; 1949 flags = &lbr_stack->entries[k].flags; 1950 } else { 1951 ip = lbr_stack->entries[0].to; 1952 branch = true; 1953 flags = &lbr_stack->entries[0].flags; 1954 branch_from = 1955 lbr_stack->entries[0].from; 1956 } 1957 } else { 1958 if (j < lbr_nr) { 1959 k = lbr_nr - j - 1; 1960 ip = lbr_stack->entries[k].from; 1961 branch = true; 1962 flags = &lbr_stack->entries[k].flags; 1963 } 1964 else if (j > lbr_nr) 1965 ip = chain->ips[i + 1 - (j - lbr_nr)]; 1966 else { 1967 ip = lbr_stack->entries[0].to; 1968 branch = true; 1969 flags = &lbr_stack->entries[0].flags; 1970 branch_from = 1971 lbr_stack->entries[0].from; 1972 } 1973 } 1974 1975 err = add_callchain_ip(thread, cursor, parent, 1976 root_al, &cpumode, ip, 1977 branch, flags, NULL, 1978 branch_from); 1979 if (err) 1980 return (err < 0) ? err : 0; 1981 } 1982 return 1; 1983 } 1984 1985 return 0; 1986 } 1987 1988 static int thread__resolve_callchain_sample(struct thread *thread, 1989 struct callchain_cursor *cursor, 1990 struct perf_evsel *evsel, 1991 struct perf_sample *sample, 1992 struct symbol **parent, 1993 struct addr_location *root_al, 1994 int max_stack) 1995 { 1996 struct branch_stack *branch = sample->branch_stack; 1997 struct ip_callchain *chain = sample->callchain; 1998 int chain_nr = 0; 1999 u8 cpumode = PERF_RECORD_MISC_USER; 2000 int i, j, err, nr_entries; 2001 int skip_idx = -1; 2002 int first_call = 0; 2003 2004 if (chain) 2005 chain_nr = chain->nr; 2006 2007 if (perf_evsel__has_branch_callstack(evsel)) { 2008 err = resolve_lbr_callchain_sample(thread, cursor, sample, parent, 2009 root_al, max_stack); 2010 if (err) 2011 return (err < 0) ? err : 0; 2012 } 2013 2014 /* 2015 * Based on DWARF debug information, some architectures skip 2016 * a callchain entry saved by the kernel. 2017 */ 2018 skip_idx = arch_skip_callchain_idx(thread, chain); 2019 2020 /* 2021 * Add branches to call stack for easier browsing. This gives 2022 * more context for a sample than just the callers. 2023 * 2024 * This uses individual histograms of paths compared to the 2025 * aggregated histograms the normal LBR mode uses. 2026 * 2027 * Limitations for now: 2028 * - No extra filters 2029 * - No annotations (should annotate somehow) 2030 */ 2031 2032 if (branch && callchain_param.branch_callstack) { 2033 int nr = min(max_stack, (int)branch->nr); 2034 struct branch_entry be[nr]; 2035 struct iterations iter[nr]; 2036 2037 if (branch->nr > PERF_MAX_BRANCH_DEPTH) { 2038 pr_warning("corrupted branch chain. skipping...\n"); 2039 goto check_calls; 2040 } 2041 2042 for (i = 0; i < nr; i++) { 2043 if (callchain_param.order == ORDER_CALLEE) { 2044 be[i] = branch->entries[i]; 2045 2046 if (chain == NULL) 2047 continue; 2048 2049 /* 2050 * Check for overlap into the callchain. 2051 * The return address is one off compared to 2052 * the branch entry. To adjust for this 2053 * assume the calling instruction is not longer 2054 * than 8 bytes. 2055 */ 2056 if (i == skip_idx || 2057 chain->ips[first_call] >= PERF_CONTEXT_MAX) 2058 first_call++; 2059 else if (be[i].from < chain->ips[first_call] && 2060 be[i].from >= chain->ips[first_call] - 8) 2061 first_call++; 2062 } else 2063 be[i] = branch->entries[branch->nr - i - 1]; 2064 } 2065 2066 memset(iter, 0, sizeof(struct iterations) * nr); 2067 nr = remove_loops(be, nr, iter); 2068 2069 for (i = 0; i < nr; i++) { 2070 err = add_callchain_ip(thread, cursor, parent, 2071 root_al, 2072 NULL, be[i].to, 2073 true, &be[i].flags, 2074 NULL, be[i].from); 2075 2076 if (!err) 2077 err = add_callchain_ip(thread, cursor, parent, root_al, 2078 NULL, be[i].from, 2079 true, &be[i].flags, 2080 &iter[i], 0); 2081 if (err == -EINVAL) 2082 break; 2083 if (err) 2084 return err; 2085 } 2086 2087 if (chain_nr == 0) 2088 return 0; 2089 2090 chain_nr -= nr; 2091 } 2092 2093 check_calls: 2094 for (i = first_call, nr_entries = 0; 2095 i < chain_nr && nr_entries < max_stack; i++) { 2096 u64 ip; 2097 2098 if (callchain_param.order == ORDER_CALLEE) 2099 j = i; 2100 else 2101 j = chain->nr - i - 1; 2102 2103 #ifdef HAVE_SKIP_CALLCHAIN_IDX 2104 if (j == skip_idx) 2105 continue; 2106 #endif 2107 ip = chain->ips[j]; 2108 2109 if (ip < PERF_CONTEXT_MAX) 2110 ++nr_entries; 2111 2112 err = add_callchain_ip(thread, cursor, parent, 2113 root_al, &cpumode, ip, 2114 false, NULL, NULL, 0); 2115 2116 if (err) 2117 return (err < 0) ? err : 0; 2118 } 2119 2120 return 0; 2121 } 2122 2123 static int append_inlines(struct callchain_cursor *cursor, 2124 struct map *map, struct symbol *sym, u64 ip) 2125 { 2126 struct inline_node *inline_node; 2127 struct inline_list *ilist; 2128 u64 addr; 2129 int ret = 1; 2130 2131 if (!symbol_conf.inline_name || !map || !sym) 2132 return ret; 2133 2134 addr = map__rip_2objdump(map, ip); 2135 2136 inline_node = inlines__tree_find(&map->dso->inlined_nodes, addr); 2137 if (!inline_node) { 2138 inline_node = dso__parse_addr_inlines(map->dso, addr, sym); 2139 if (!inline_node) 2140 return ret; 2141 inlines__tree_insert(&map->dso->inlined_nodes, inline_node); 2142 } 2143 2144 list_for_each_entry(ilist, &inline_node->val, list) { 2145 ret = callchain_cursor_append(cursor, ip, map, 2146 ilist->symbol, false, 2147 NULL, 0, 0, 0, ilist->srcline); 2148 2149 if (ret != 0) 2150 return ret; 2151 } 2152 2153 return ret; 2154 } 2155 2156 static int unwind_entry(struct unwind_entry *entry, void *arg) 2157 { 2158 struct callchain_cursor *cursor = arg; 2159 const char *srcline = NULL; 2160 2161 if (symbol_conf.hide_unresolved && entry->sym == NULL) 2162 return 0; 2163 2164 if (append_inlines(cursor, entry->map, entry->sym, entry->ip) == 0) 2165 return 0; 2166 2167 srcline = callchain_srcline(entry->map, entry->sym, entry->ip); 2168 return callchain_cursor_append(cursor, entry->ip, 2169 entry->map, entry->sym, 2170 false, NULL, 0, 0, 0, srcline); 2171 } 2172 2173 static int thread__resolve_callchain_unwind(struct thread *thread, 2174 struct callchain_cursor *cursor, 2175 struct perf_evsel *evsel, 2176 struct perf_sample *sample, 2177 int max_stack) 2178 { 2179 /* Can we do dwarf post unwind? */ 2180 if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) && 2181 (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER))) 2182 return 0; 2183 2184 /* Bail out if nothing was captured. */ 2185 if ((!sample->user_regs.regs) || 2186 (!sample->user_stack.size)) 2187 return 0; 2188 2189 return unwind__get_entries(unwind_entry, cursor, 2190 thread, sample, max_stack); 2191 } 2192 2193 int thread__resolve_callchain(struct thread *thread, 2194 struct callchain_cursor *cursor, 2195 struct perf_evsel *evsel, 2196 struct perf_sample *sample, 2197 struct symbol **parent, 2198 struct addr_location *root_al, 2199 int max_stack) 2200 { 2201 int ret = 0; 2202 2203 callchain_cursor_reset(cursor); 2204 2205 if (callchain_param.order == ORDER_CALLEE) { 2206 ret = thread__resolve_callchain_sample(thread, cursor, 2207 evsel, sample, 2208 parent, root_al, 2209 max_stack); 2210 if (ret) 2211 return ret; 2212 ret = thread__resolve_callchain_unwind(thread, cursor, 2213 evsel, sample, 2214 max_stack); 2215 } else { 2216 ret = thread__resolve_callchain_unwind(thread, cursor, 2217 evsel, sample, 2218 max_stack); 2219 if (ret) 2220 return ret; 2221 ret = thread__resolve_callchain_sample(thread, cursor, 2222 evsel, sample, 2223 parent, root_al, 2224 max_stack); 2225 } 2226 2227 return ret; 2228 } 2229 2230 int machine__for_each_thread(struct machine *machine, 2231 int (*fn)(struct thread *thread, void *p), 2232 void *priv) 2233 { 2234 struct threads *threads; 2235 struct rb_node *nd; 2236 struct thread *thread; 2237 int rc = 0; 2238 int i; 2239 2240 for (i = 0; i < THREADS__TABLE_SIZE; i++) { 2241 threads = &machine->threads[i]; 2242 for (nd = rb_first(&threads->entries); nd; nd = rb_next(nd)) { 2243 thread = rb_entry(nd, struct thread, rb_node); 2244 rc = fn(thread, priv); 2245 if (rc != 0) 2246 return rc; 2247 } 2248 2249 list_for_each_entry(thread, &threads->dead, node) { 2250 rc = fn(thread, priv); 2251 if (rc != 0) 2252 return rc; 2253 } 2254 } 2255 return rc; 2256 } 2257 2258 int machines__for_each_thread(struct machines *machines, 2259 int (*fn)(struct thread *thread, void *p), 2260 void *priv) 2261 { 2262 struct rb_node *nd; 2263 int rc = 0; 2264 2265 rc = machine__for_each_thread(&machines->host, fn, priv); 2266 if (rc != 0) 2267 return rc; 2268 2269 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 2270 struct machine *machine = rb_entry(nd, struct machine, rb_node); 2271 2272 rc = machine__for_each_thread(machine, fn, priv); 2273 if (rc != 0) 2274 return rc; 2275 } 2276 return rc; 2277 } 2278 2279 int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool, 2280 struct target *target, struct thread_map *threads, 2281 perf_event__handler_t process, bool data_mmap, 2282 unsigned int proc_map_timeout, 2283 unsigned int nr_threads_synthesize) 2284 { 2285 if (target__has_task(target)) 2286 return perf_event__synthesize_thread_map(tool, threads, process, machine, data_mmap, proc_map_timeout); 2287 else if (target__has_cpu(target)) 2288 return perf_event__synthesize_threads(tool, process, 2289 machine, data_mmap, 2290 proc_map_timeout, 2291 nr_threads_synthesize); 2292 /* command specified */ 2293 return 0; 2294 } 2295 2296 pid_t machine__get_current_tid(struct machine *machine, int cpu) 2297 { 2298 if (cpu < 0 || cpu >= MAX_NR_CPUS || !machine->current_tid) 2299 return -1; 2300 2301 return machine->current_tid[cpu]; 2302 } 2303 2304 int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid, 2305 pid_t tid) 2306 { 2307 struct thread *thread; 2308 2309 if (cpu < 0) 2310 return -EINVAL; 2311 2312 if (!machine->current_tid) { 2313 int i; 2314 2315 machine->current_tid = calloc(MAX_NR_CPUS, sizeof(pid_t)); 2316 if (!machine->current_tid) 2317 return -ENOMEM; 2318 for (i = 0; i < MAX_NR_CPUS; i++) 2319 machine->current_tid[i] = -1; 2320 } 2321 2322 if (cpu >= MAX_NR_CPUS) { 2323 pr_err("Requested CPU %d too large. ", cpu); 2324 pr_err("Consider raising MAX_NR_CPUS\n"); 2325 return -EINVAL; 2326 } 2327 2328 machine->current_tid[cpu] = tid; 2329 2330 thread = machine__findnew_thread(machine, pid, tid); 2331 if (!thread) 2332 return -ENOMEM; 2333 2334 thread->cpu = cpu; 2335 thread__put(thread); 2336 2337 return 0; 2338 } 2339 2340 int machine__get_kernel_start(struct machine *machine) 2341 { 2342 struct map *map = machine__kernel_map(machine); 2343 int err = 0; 2344 2345 /* 2346 * The only addresses above 2^63 are kernel addresses of a 64-bit 2347 * kernel. Note that addresses are unsigned so that on a 32-bit system 2348 * all addresses including kernel addresses are less than 2^32. In 2349 * that case (32-bit system), if the kernel mapping is unknown, all 2350 * addresses will be assumed to be in user space - see 2351 * machine__kernel_ip(). 2352 */ 2353 machine->kernel_start = 1ULL << 63; 2354 if (map) { 2355 err = map__load(map); 2356 if (!err) 2357 machine->kernel_start = map->start; 2358 } 2359 return err; 2360 } 2361 2362 struct dso *machine__findnew_dso(struct machine *machine, const char *filename) 2363 { 2364 return dsos__findnew(&machine->dsos, filename); 2365 } 2366 2367 char *machine__resolve_kernel_addr(void *vmachine, unsigned long long *addrp, char **modp) 2368 { 2369 struct machine *machine = vmachine; 2370 struct map *map; 2371 struct symbol *sym = map_groups__find_symbol(&machine->kmaps, MAP__FUNCTION, *addrp, &map); 2372 2373 if (sym == NULL) 2374 return NULL; 2375 2376 *modp = __map__is_kmodule(map) ? (char *)map->dso->short_name : NULL; 2377 *addrp = map->unmap_ip(map, sym->start); 2378 return sym->name; 2379 } 2380