tools/perf/util/machine.c

   1 #include "callchain.h"
   2 #include "debug.h"
   3 #include "event.h"
   4 #include "evsel.h"
   5 #include "hist.h"
   6 #include "machine.h"
   7 #include "map.h"
   8 #include "sort.h"
   9 #include "strlist.h"
  10 #include "thread.h"
  11 #include "vdso.h"
  12 #include <stdbool.h>
  13 #include <symbol/kallsyms.h>
  14 #include "unwind.h"
  15
  16 static void dsos__init(struct dsos *dsos)
  17 {
  18         INIT_LIST_HEAD(&dsos->head);
  19         dsos->root = RB_ROOT;
  20 }
  21
  22 int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
  23 {
  24         map_groups__init(&machine->kmaps, machine);
  25         RB_CLEAR_NODE(&machine->rb_node);
  26         dsos__init(&machine->user_dsos);
  27         dsos__init(&machine->kernel_dsos);
  28
  29         machine->threads = RB_ROOT;
  30         INIT_LIST_HEAD(&machine->dead_threads);
  31         machine->last_match = NULL;
  32
  33         machine->vdso_info = NULL;
  34
  35         machine->pid = pid;
  36
  37         machine->symbol_filter = NULL;
  38         machine->id_hdr_size = 0;
  39         machine->comm_exec = false;
  40         machine->kernel_start = 0;
  41
  42         machine->root_dir = strdup(root_dir);
  43         if (machine->root_dir == NULL)
  44                 return -ENOMEM;
  45
  46         if (pid != HOST_KERNEL_ID) {
  47                 struct thread *thread = machine__findnew_thread(machine, -1,
  48                                                                 pid);
  49                 char comm[64];
  50
  51                 if (thread == NULL)
  52                         return -ENOMEM;
  53
  54                 snprintf(comm, sizeof(comm), "[guest/%d]", pid);
  55                 thread__set_comm(thread, comm, 0);
  56         }
  57
  58         machine->current_tid = NULL;
  59
  60         return 0;
  61 }
  62
  63 struct machine *machine__new_host(void)
  64 {
  65         struct machine *machine = malloc(sizeof(*machine));
  66
  67         if (machine != NULL) {
  68                 machine__init(machine, "", HOST_KERNEL_ID);
  69
  70                 if (machine__create_kernel_maps(machine) < 0)
  71                         goto out_delete;
  72         }
  73
  74         return machine;
  75 out_delete:
  76         free(machine);
  77         return NULL;
  78 }
  79
  80 static void dsos__delete(struct dsos *dsos)
  81 {
  82         struct dso *pos, *n;
  83
  84         list_for_each_entry_safe(pos, n, &dsos->head, node) {
  85                 RB_CLEAR_NODE(&pos->rb_node);
  86                 list_del(&pos->node);
  87                 dso__delete(pos);
  88         }
  89 }
  90
  91 void machine__delete_dead_threads(struct machine *machine)
  92 {
  93         struct thread *n, *t;
  94
  95         list_for_each_entry_safe(t, n, &machine->dead_threads, node) {
  96                 list_del(&t->node);
  97                 thread__delete(t);
  98         }
  99 }
 100
 101 void machine__delete_threads(struct machine *machine)
 102 {
 103         struct rb_node *nd = rb_first(&machine->threads);
 104
 105         while (nd) {
 106                 struct thread *t = rb_entry(nd, struct thread, rb_node);
 107
 108                 rb_erase(&t->rb_node, &machine->threads);
 109                 nd = rb_next(nd);
 110                 thread__delete(t);
 111         }
 112 }
 113
 114 void machine__exit(struct machine *machine)
 115 {
 116         map_groups__exit(&machine->kmaps);
 117         dsos__delete(&machine->user_dsos);
 118         dsos__delete(&machine->kernel_dsos);
 119         vdso__exit(machine);
 120         zfree(&machine->root_dir);
 121         zfree(&machine->current_tid);
 122 }
 123
 124 void machine__delete(struct machine *machine)
 125 {
 126         machine__exit(machine);
 127         free(machine);
 128 }
 129
 130 void machines__init(struct machines *machines)
 131 {
 132         machine__init(&machines->host, "", HOST_KERNEL_ID);
 133         machines->guests = RB_ROOT;
 134         machines->symbol_filter = NULL;
 135 }
 136
 137 void machines__exit(struct machines *machines)
 138 {
 139         machine__exit(&machines->host);
 140         /* XXX exit guest */
 141 }
 142
 143 struct machine *machines__add(struct machines *machines, pid_t pid,
 144                               const char *root_dir)
 145 {
 146         struct rb_node **p = &machines->guests.rb_node;
 147         struct rb_node *parent = NULL;
 148         struct machine *pos, *machine = malloc(sizeof(*machine));
 149
 150         if (machine == NULL)
 151                 return NULL;
 152
 153         if (machine__init(machine, root_dir, pid) != 0) {
 154                 free(machine);
 155                 return NULL;
 156         }
 157
 158         machine->symbol_filter = machines->symbol_filter;
 159
 160         while (*p != NULL) {
 161                 parent = *p;
 162                 pos = rb_entry(parent, struct machine, rb_node);
 163                 if (pid < pos->pid)
 164                         p = &(*p)->rb_left;
 165                 else
 166                         p = &(*p)->rb_right;
 167         }
 168
 169         rb_link_node(&machine->rb_node, parent, p);
 170         rb_insert_color(&machine->rb_node, &machines->guests);
 171
 172         return machine;
 173 }
 174
 175 void machines__set_symbol_filter(struct machines *machines,
 176                                  symbol_filter_t symbol_filter)
 177 {
 178         struct rb_node *nd;
 179
 180         machines->symbol_filter = symbol_filter;
 181         machines->host.symbol_filter = symbol_filter;
 182
 183         for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 184                 struct machine *machine = rb_entry(nd, struct machine, rb_node);
 185
 186                 machine->symbol_filter = symbol_filter;
 187         }
 188 }
 189
 190 void machines__set_comm_exec(struct machines *machines, bool comm_exec)
 191 {
 192         struct rb_node *nd;
 193
 194         machines->host.comm_exec = comm_exec;
 195
 196         for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 197                 struct machine *machine = rb_entry(nd, struct machine, rb_node);
 198
 199                 machine->comm_exec = comm_exec;
 200         }
 201 }
 202
 203 struct machine *machines__find(struct machines *machines, pid_t pid)
 204 {
 205         struct rb_node **p = &machines->guests.rb_node;
 206         struct rb_node *parent = NULL;
 207         struct machine *machine;
 208         struct machine *default_machine = NULL;
 209
 210         if (pid == HOST_KERNEL_ID)
 211                 return &machines->host;
 212
 213         while (*p != NULL) {
 214                 parent = *p;
 215                 machine = rb_entry(parent, struct machine, rb_node);
 216                 if (pid < machine->pid)
 217                         p = &(*p)->rb_left;
 218                 else if (pid > machine->pid)
 219                         p = &(*p)->rb_right;
 220                 else
 221                         return machine;
 222                 if (!machine->pid)
 223                         default_machine = machine;
 224         }
 225
 226         return default_machine;
 227 }
 228
 229 struct machine *machines__findnew(struct machines *machines, pid_t pid)
 230 {
 231         char path[PATH_MAX];
 232         const char *root_dir = "";
 233         struct machine *machine = machines__find(machines, pid);
 234
 235         if (machine && (machine->pid == pid))
 236                 goto out;
 237
 238         if ((pid != HOST_KERNEL_ID) &&
 239             (pid != DEFAULT_GUEST_KERNEL_ID) &&
 240             (symbol_conf.guestmount)) {
 241                 sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
 242                 if (access(path, R_OK)) {
 243                         static struct strlist *seen;
 244
 245                         if (!seen)
 246                                 seen = strlist__new(true, NULL);
 247
 248                         if (!strlist__has_entry(seen, path)) {
 249                                 pr_err("Can't access file %s\n", path);
 250                                 strlist__add(seen, path);
 251                         }
 252                         machine = NULL;
 253                         goto out;
 254                 }
 255                 root_dir = path;
 256         }
 257
 258         machine = machines__add(machines, pid, root_dir);
 259 out:
 260         return machine;
 261 }
 262
 263 void machines__process_guests(struct machines *machines,
 264                               machine__process_t process, void *data)
 265 {
 266         struct rb_node *nd;
 267
 268         for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 269                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
 270                 process(pos, data);
 271         }
 272 }
 273
 274 char *machine__mmap_name(struct machine *machine, char *bf, size_t size)
 275 {
 276         if (machine__is_host(machine))
 277                 snprintf(bf, size, "[%s]", "kernel.kallsyms");
 278         else if (machine__is_default_guest(machine))
 279                 snprintf(bf, size, "[%s]", "guest.kernel.kallsyms");
 280         else {
 281                 snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms",
 282                          machine->pid);
 283         }
 284
 285         return bf;
 286 }
 287
 288 void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size)
 289 {
 290         struct rb_node *node;
 291         struct machine *machine;
 292
 293         machines->host.id_hdr_size = id_hdr_size;
 294
 295         for (node = rb_first(&machines->guests); node; node = rb_next(node)) {
 296                 machine = rb_entry(node, struct machine, rb_node);
 297                 machine->id_hdr_size = id_hdr_size;
 298         }
 299
 300         return;
 301 }
 302
 303 static void machine__update_thread_pid(struct machine *machine,
 304                                        struct thread *th, pid_t pid)
 305 {
 306         struct thread *leader;
 307
 308         if (pid == th->pid_ || pid == -1 || th->pid_ != -1)
 309                 return;
 310
 311         th->pid_ = pid;
 312
 313         if (th->pid_ == th->tid)
 314                 return;
 315
 316         leader = machine__findnew_thread(machine, th->pid_, th->pid_);
 317         if (!leader)
 318                 goto out_err;
 319
 320         if (!leader->mg)
 321                 leader->mg = map_groups__new(machine);
 322
 323         if (!leader->mg)
 324                 goto out_err;
 325
 326         if (th->mg == leader->mg)
 327                 return;
 328
 329         if (th->mg) {
 330                 /*
 331                  * Maps are created from MMAP events which provide the pid and
 332                  * tid.  Consequently there never should be any maps on a thread
 333                  * with an unknown pid.  Just print an error if there are.
 334                  */
 335                 if (!map_groups__empty(th->mg))
 336                         pr_err("Discarding thread maps for %d:%d\n",
 337                                th->pid_, th->tid);
 338                 map_groups__delete(th->mg);
 339         }
 340
 341         th->mg = map_groups__get(leader->mg);
 342
 343         return;
 344
 345 out_err:
 346         pr_err("Failed to join map groups for %d:%d\n", th->pid_, th->tid);
 347 }
 348
 349 static struct thread *__machine__findnew_thread(struct machine *machine,
 350                                                 pid_t pid, pid_t tid,
 351                                                 bool create)
 352 {
 353         struct rb_node **p = &machine->threads.rb_node;
 354         struct rb_node *parent = NULL;
 355         struct thread *th;
 356
 357         /*
 358          * Front-end cache - TID lookups come in blocks,
 359          * so most of the time we dont have to look up
 360          * the full rbtree:
 361          */
 362         th = machine->last_match;
 363         if (th && th->tid == tid) {
 364                 machine__update_thread_pid(machine, th, pid);
 365                 return th;
 366         }
 367
 368         while (*p != NULL) {
 369                 parent = *p;
 370                 th = rb_entry(parent, struct thread, rb_node);
 371
 372                 if (th->tid == tid) {
 373                         machine->last_match = th;
 374                         machine__update_thread_pid(machine, th, pid);
 375                         return th;
 376                 }
 377
 378                 if (tid < th->tid)
 379                         p = &(*p)->rb_left;
 380                 else
 381                         p = &(*p)->rb_right;
 382         }
 383
 384         if (!create)
 385                 return NULL;
 386
 387         th = thread__new(pid, tid);
 388         if (th != NULL) {
 389                 rb_link_node(&th->rb_node, parent, p);
 390                 rb_insert_color(&th->rb_node, &machine->threads);
 391                 machine->last_match = th;
 392
 393                 /*
 394                  * We have to initialize map_groups separately
 395                  * after rb tree is updated.
 396                  *
 397                  * The reason is that we call machine__findnew_thread
 398                  * within thread__init_map_groups to find the thread
 399                  * leader and that would screwed the rb tree.
 400                  */
 401                 if (thread__init_map_groups(th, machine)) {
 402                         thread__delete(th);
 403                         return NULL;
 404                 }
 405         }
 406
 407         return th;
 408 }
 409
 410 struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
 411                                        pid_t tid)
 412 {
 413         return __machine__findnew_thread(machine, pid, tid, true);
 414 }
 415
 416 struct thread *machine__find_thread(struct machine *machine, pid_t pid,
 417                                     pid_t tid)
 418 {
 419         return __machine__findnew_thread(machine, pid, tid, false);
 420 }
 421
 422 struct comm *machine__thread_exec_comm(struct machine *machine,
 423                                        struct thread *thread)
 424 {
 425         if (machine->comm_exec)
 426                 return thread__exec_comm(thread);
 427         else
 428                 return thread__comm(thread);
 429 }
 430
 431 int machine__process_comm_event(struct machine *machine, union perf_event *event,
 432                                 struct perf_sample *sample)
 433 {
 434         struct thread *thread = machine__findnew_thread(machine,
 435                                                         event->comm.pid,
 436                                                         event->comm.tid);
 437         bool exec = event->header.misc & PERF_RECORD_MISC_COMM_EXEC;
 438
 439         if (exec)
 440                 machine->comm_exec = true;
 441
 442         if (dump_trace)
 443                 perf_event__fprintf_comm(event, stdout);
 444
 445         if (thread == NULL ||
 446             __thread__set_comm(thread, event->comm.comm, sample->time, exec)) {
 447                 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
 448                 return -1;
 449         }
 450
 451         return 0;
 452 }
 453
 454 int machine__process_lost_event(struct machine *machine __maybe_unused,
 455                                 union perf_event *event, struct perf_sample *sample __maybe_unused)
 456 {
 457         dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n",
 458                     event->lost.id, event->lost.lost);
 459         return 0;
 460 }
 461
 462 struct map *machine__new_module(struct machine *machine, u64 start,
 463                                 const char *filename)
 464 {
 465         struct map *map;
 466         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
 467
 468         if (dso == NULL)
 469                 return NULL;
 470
 471         map = map__new2(start, dso, MAP__FUNCTION);
 472         if (map == NULL)
 473                 return NULL;
 474
 475         if (machine__is_host(machine))
 476                 dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
 477         else
 478                 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
 479         map_groups__insert(&machine->kmaps, map);
 480         return map;
 481 }
 482
 483 size_t machines__fprintf_dsos(struct machines *machines, FILE *fp)
 484 {
 485         struct rb_node *nd;
 486         size_t ret = __dsos__fprintf(&machines->host.kernel_dsos.head, fp) +
 487                      __dsos__fprintf(&machines->host.user_dsos.head, fp);
 488
 489         for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 490                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
 491                 ret += __dsos__fprintf(&pos->kernel_dsos.head, fp);
 492                 ret += __dsos__fprintf(&pos->user_dsos.head, fp);
 493         }
 494
 495         return ret;
 496 }
 497
 498 size_t machine__fprintf_dsos_buildid(struct machine *m, FILE *fp,
 499                                      bool (skip)(struct dso *dso, int parm), int parm)
 500 {
 501         return __dsos__fprintf_buildid(&m->kernel_dsos.head, fp, skip, parm) +
 502                __dsos__fprintf_buildid(&m->user_dsos.head, fp, skip, parm);
 503 }
 504
 505 size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp,
 506                                      bool (skip)(struct dso *dso, int parm), int parm)
 507 {
 508         struct rb_node *nd;
 509         size_t ret = machine__fprintf_dsos_buildid(&machines->host, fp, skip, parm);
 510
 511         for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
 512                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
 513                 ret += machine__fprintf_dsos_buildid(pos, fp, skip, parm);
 514         }
 515         return ret;
 516 }
 517
 518 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
 519 {
 520         int i;
 521         size_t printed = 0;
 522         struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
 523
 524         if (kdso->has_build_id) {
 525                 char filename[PATH_MAX];
 526                 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
 527                         printed += fprintf(fp, "[0] %s\n", filename);
 528         }
 529
 530         for (i = 0; i < vmlinux_path__nr_entries; ++i)
 531                 printed += fprintf(fp, "[%d] %s\n",
 532                                    i + kdso->has_build_id, vmlinux_path[i]);
 533
 534         return printed;
 535 }
 536
 537 size_t machine__fprintf(struct machine *machine, FILE *fp)
 538 {
 539         size_t ret = 0;
 540         struct rb_node *nd;
 541
 542         for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
 543                 struct thread *pos = rb_entry(nd, struct thread, rb_node);
 544
 545                 ret += thread__fprintf(pos, fp);
 546         }
 547
 548         return ret;
 549 }
 550
 551 static struct dso *machine__get_kernel(struct machine *machine)
 552 {
 553         const char *vmlinux_name = NULL;
 554         struct dso *kernel;
 555
 556         if (machine__is_host(machine)) {
 557                 vmlinux_name = symbol_conf.vmlinux_name;
 558                 if (!vmlinux_name)
 559                         vmlinux_name = "[kernel.kallsyms]";
 560
 561                 kernel = dso__kernel_findnew(machine, vmlinux_name,
 562                                              "[kernel]",
 563                                              DSO_TYPE_KERNEL);
 564         } else {
 565                 char bf[PATH_MAX];
 566
 567                 if (machine__is_default_guest(machine))
 568                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
 569                 if (!vmlinux_name)
 570                         vmlinux_name = machine__mmap_name(machine, bf,
 571                                                           sizeof(bf));
 572
 573                 kernel = dso__kernel_findnew(machine, vmlinux_name,
 574                                              "[guest.kernel]",
 575                                              DSO_TYPE_GUEST_KERNEL);
 576         }
 577
 578         if (kernel != NULL && (!kernel->has_build_id))
 579                 dso__read_running_kernel_build_id(kernel, machine);
 580
 581         return kernel;
 582 }
 583
 584 struct process_args {
 585         u64 start;
 586 };
 587
 588 static void machine__get_kallsyms_filename(struct machine *machine, char *buf,
 589                                            size_t bufsz)
 590 {
 591         if (machine__is_default_guest(machine))
 592                 scnprintf(buf, bufsz, "%s", symbol_conf.default_guest_kallsyms);
 593         else
 594                 scnprintf(buf, bufsz, "%s/proc/kallsyms", machine->root_dir);
 595 }
 596
 597 const char *ref_reloc_sym_names[] = {"_text", "_stext", NULL};
 598
 599 /* Figure out the start address of kernel map from /proc/kallsyms.
 600  * Returns the name of the start symbol in *symbol_name. Pass in NULL as
 601  * symbol_name if it's not that important.
 602  */
 603 static u64 machine__get_running_kernel_start(struct machine *machine,
 604                                              const char **symbol_name)
 605 {
 606         char filename[PATH_MAX];
 607         int i;
 608         const char *name;
 609         u64 addr = 0;
 610
 611         machine__get_kallsyms_filename(machine, filename, PATH_MAX);
 612
 613         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 614                 return 0;
 615
 616         for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) {
 617                 addr = kallsyms__get_function_start(filename, name);
 618                 if (addr)
 619                         break;
 620         }
 621
 622         if (symbol_name)
 623                 *symbol_name = name;
 624
 625         return addr;
 626 }
 627
 628 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
 629 {
 630         enum map_type type;
 631         u64 start = machine__get_running_kernel_start(machine, NULL);
 632
 633         for (type = 0; type < MAP__NR_TYPES; ++type) {
 634                 struct kmap *kmap;
 635
 636                 machine->vmlinux_maps[type] = map__new2(start, kernel, type);
 637                 if (machine->vmlinux_maps[type] == NULL)
 638                         return -1;
 639
 640                 machine->vmlinux_maps[type]->map_ip =
 641                         machine->vmlinux_maps[type]->unmap_ip =
 642                                 identity__map_ip;
 643                 kmap = map__kmap(machine->vmlinux_maps[type]);
 644                 kmap->kmaps = &machine->kmaps;
 645                 map_groups__insert(&machine->kmaps,
 646                                    machine->vmlinux_maps[type]);
 647         }
 648
 649         return 0;
 650 }
 651
 652 void machine__destroy_kernel_maps(struct machine *machine)
 653 {
 654         enum map_type type;
 655
 656         for (type = 0; type < MAP__NR_TYPES; ++type) {
 657                 struct kmap *kmap;
 658
 659                 if (machine->vmlinux_maps[type] == NULL)
 660                         continue;
 661
 662                 kmap = map__kmap(machine->vmlinux_maps[type]);
 663                 map_groups__remove(&machine->kmaps,
 664                                    machine->vmlinux_maps[type]);
 665                 if (kmap->ref_reloc_sym) {
 666                         /*
 667                          * ref_reloc_sym is shared among all maps, so free just
 668                          * on one of them.
 669                          */
 670                         if (type == MAP__FUNCTION) {
 671                                 zfree((char **)&kmap->ref_reloc_sym->name);
 672                                 zfree(&kmap->ref_reloc_sym);
 673                         } else
 674                                 kmap->ref_reloc_sym = NULL;
 675                 }
 676
 677                 map__delete(machine->vmlinux_maps[type]);
 678                 machine->vmlinux_maps[type] = NULL;
 679         }
 680 }
 681
 682 int machines__create_guest_kernel_maps(struct machines *machines)
 683 {
 684         int ret = 0;
 685         struct dirent **namelist = NULL;
 686         int i, items = 0;
 687         char path[PATH_MAX];
 688         pid_t pid;
 689         char *endp;
 690
 691         if (symbol_conf.default_guest_vmlinux_name ||
 692             symbol_conf.default_guest_modules ||
 693             symbol_conf.default_guest_kallsyms) {
 694                 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
 695         }
 696
 697         if (symbol_conf.guestmount) {
 698                 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
 699                 if (items <= 0)
 700                         return -ENOENT;
 701                 for (i = 0; i < items; i++) {
 702                         if (!isdigit(namelist[i]->d_name[0])) {
 703                                 /* Filter out . and .. */
 704                                 continue;
 705                         }
 706                         pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10);
 707                         if ((*endp != '\0') ||
 708                             (endp == namelist[i]->d_name) ||
 709                             (errno == ERANGE)) {
 710                                 pr_debug("invalid directory (%s). Skipping.\n",
 711                                          namelist[i]->d_name);
 712                                 continue;
 713                         }
 714                         sprintf(path, "%s/%s/proc/kallsyms",
 715                                 symbol_conf.guestmount,
 716                                 namelist[i]->d_name);
 717                         ret = access(path, R_OK);
 718                         if (ret) {
 719                                 pr_debug("Can't access file %s\n", path);
 720                                 goto failure;
 721                         }
 722                         machines__create_kernel_maps(machines, pid);
 723                 }
 724 failure:
 725                 free(namelist);
 726         }
 727
 728         return ret;
 729 }
 730
 731 void machines__destroy_kernel_maps(struct machines *machines)
 732 {
 733         struct rb_node *next = rb_first(&machines->guests);
 734
 735         machine__destroy_kernel_maps(&machines->host);
 736
 737         while (next) {
 738                 struct machine *pos = rb_entry(next, struct machine, rb_node);
 739
 740                 next = rb_next(&pos->rb_node);
 741                 rb_erase(&pos->rb_node, &machines->guests);
 742                 machine__delete(pos);
 743         }
 744 }
 745
 746 int machines__create_kernel_maps(struct machines *machines, pid_t pid)
 747 {
 748         struct machine *machine = machines__findnew(machines, pid);
 749
 750         if (machine == NULL)
 751                 return -1;
 752
 753         return machine__create_kernel_maps(machine);
 754 }
 755
 756 int machine__load_kallsyms(struct machine *machine, const char *filename,
 757                            enum map_type type, symbol_filter_t filter)
 758 {
 759         struct map *map = machine->vmlinux_maps[type];
 760         int ret = dso__load_kallsyms(map->dso, filename, map, filter);
 761
 762         if (ret > 0) {
 763                 dso__set_loaded(map->dso, type);
 764                 /*
 765                  * Since /proc/kallsyms will have multiple sessions for the
 766                  * kernel, with modules between them, fixup the end of all
 767                  * sections.
 768                  */
 769                 __map_groups__fixup_end(&machine->kmaps, type);
 770         }
 771
 772         return ret;
 773 }
 774
 775 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
 776                                symbol_filter_t filter)
 777 {
 778         struct map *map = machine->vmlinux_maps[type];
 779         int ret = dso__load_vmlinux_path(map->dso, map, filter);
 780
 781         if (ret > 0)
 782                 dso__set_loaded(map->dso, type);
 783
 784         return ret;
 785 }
 786
 787 static void map_groups__fixup_end(struct map_groups *mg)
 788 {
 789         int i;
 790         for (i = 0; i < MAP__NR_TYPES; ++i)
 791                 __map_groups__fixup_end(mg, i);
 792 }
 793
 794 static char *get_kernel_version(const char *root_dir)
 795 {
 796         char version[PATH_MAX];
 797         FILE *file;
 798         char *name, *tmp;
 799         const char *prefix = "Linux version ";
 800
 801         sprintf(version, "%s/proc/version", root_dir);
 802         file = fopen(version, "r");
 803         if (!file)
 804                 return NULL;
 805
 806         version[0] = '\0';
 807         tmp = fgets(version, sizeof(version), file);
 808         fclose(file);
 809
 810         name = strstr(version, prefix);
 811         if (!name)
 812                 return NULL;
 813         name += strlen(prefix);
 814         tmp = strchr(name, ' ');
 815         if (tmp)
 816                 *tmp = '\0';
 817
 818         return strdup(name);
 819 }
 820
 821 static int map_groups__set_modules_path_dir(struct map_groups *mg,
 822                                 const char *dir_name, int depth)
 823 {
 824         struct dirent *dent;
 825         DIR *dir = opendir(dir_name);
 826         int ret = 0;
 827
 828         if (!dir) {
 829                 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
 830                 return -1;
 831         }
 832
 833         while ((dent = readdir(dir)) != NULL) {
 834                 char path[PATH_MAX];
 835                 struct stat st;
 836
 837                 /*sshfs might return bad dent->d_type, so we have to stat*/
 838                 snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
 839                 if (stat(path, &st))
 840                         continue;
 841
 842                 if (S_ISDIR(st.st_mode)) {
 843                         if (!strcmp(dent->d_name, ".") ||
 844                             !strcmp(dent->d_name, ".."))
 845                                 continue;
 846
 847                         /* Do not follow top-level source and build symlinks */
 848                         if (depth == 0) {
 849                                 if (!strcmp(dent->d_name, "source") ||
 850                                     !strcmp(dent->d_name, "build"))
 851                                         continue;
 852                         }
 853
 854                         ret = map_groups__set_modules_path_dir(mg, path,
 855                                                                depth + 1);
 856                         if (ret < 0)
 857                                 goto out;
 858                 } else {
 859                         char *dot = strrchr(dent->d_name, '.'),
 860                              dso_name[PATH_MAX];
 861                         struct map *map;
 862                         char *long_name;
 863
 864                         if (dot == NULL || strcmp(dot, ".ko"))
 865                                 continue;
 866                         snprintf(dso_name, sizeof(dso_name), "[%.*s]",
 867                                  (int)(dot - dent->d_name), dent->d_name);
 868
 869                         strxfrchar(dso_name, '-', '_');
 870                         map = map_groups__find_by_name(mg, MAP__FUNCTION,
 871                                                        dso_name);
 872                         if (map == NULL)
 873                                 continue;
 874
 875                         long_name = strdup(path);
 876                         if (long_name == NULL) {
 877                                 ret = -1;
 878                                 goto out;
 879                         }
 880                         dso__set_long_name(map->dso, long_name, true);
 881                         dso__kernel_module_get_build_id(map->dso, "");
 882                 }
 883         }
 884
 885 out:
 886         closedir(dir);
 887         return ret;
 888 }
 889
 890 static int machine__set_modules_path(struct machine *machine)
 891 {
 892         char *version;
 893         char modules_path[PATH_MAX];
 894
 895         version = get_kernel_version(machine->root_dir);
 896         if (!version)
 897                 return -1;
 898
 899         snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s",
 900                  machine->root_dir, version);
 901         free(version);
 902
 903         return map_groups__set_modules_path_dir(&machine->kmaps, modules_path, 0);
 904 }
 905
 906 static int machine__create_module(void *arg, const char *name, u64 start)
 907 {
 908         struct machine *machine = arg;
 909         struct map *map;
 910
 911         map = machine__new_module(machine, start, name);
 912         if (map == NULL)
 913                 return -1;
 914
 915         dso__kernel_module_get_build_id(map->dso, machine->root_dir);
 916
 917         return 0;
 918 }
 919
 920 static int machine__create_modules(struct machine *machine)
 921 {
 922         const char *modules;
 923         char path[PATH_MAX];
 924
 925         if (machine__is_default_guest(machine)) {
 926                 modules = symbol_conf.default_guest_modules;
 927         } else {
 928                 snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir);
 929                 modules = path;
 930         }
 931
 932         if (symbol__restricted_filename(modules, "/proc/modules"))
 933                 return -1;
 934
 935         if (modules__parse(modules, machine, machine__create_module))
 936                 return -1;
 937
 938         if (!machine__set_modules_path(machine))
 939                 return 0;
 940
 941         pr_debug("Problems setting modules path maps, continuing anyway...\n");
 942
 943         return 0;
 944 }
 945
 946 int machine__create_kernel_maps(struct machine *machine)
 947 {
 948         struct dso *kernel = machine__get_kernel(machine);
 949         const char *name;
 950         u64 addr = machine__get_running_kernel_start(machine, &name);
 951         if (!addr)
 952                 return -1;
 953
 954         if (kernel == NULL ||
 955             __machine__create_kernel_maps(machine, kernel) < 0)
 956                 return -1;
 957
 958         if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
 959                 if (machine__is_host(machine))
 960                         pr_debug("Problems creating module maps, "
 961                                  "continuing anyway...\n");
 962                 else
 963                         pr_debug("Problems creating module maps for guest %d, "
 964                                  "continuing anyway...\n", machine->pid);
 965         }
 966
 967         /*
 968          * Now that we have all the maps created, just set the ->end of them:
 969          */
 970         map_groups__fixup_end(&machine->kmaps);
 971
 972         if (maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, name,
 973                                              addr)) {
 974                 machine__destroy_kernel_maps(machine);
 975                 return -1;
 976         }
 977
 978         return 0;
 979 }
 980
 981 static void machine__set_kernel_mmap_len(struct machine *machine,
 982                                          union perf_event *event)
 983 {
 984         int i;
 985
 986         for (i = 0; i < MAP__NR_TYPES; i++) {
 987                 machine->vmlinux_maps[i]->start = event->mmap.start;
 988                 machine->vmlinux_maps[i]->end   = (event->mmap.start +
 989                                                    event->mmap.len);
 990                 /*
 991                  * Be a bit paranoid here, some perf.data file came with
 992                  * a zero sized synthesized MMAP event for the kernel.
 993                  */
 994                 if (machine->vmlinux_maps[i]->end == 0)
 995                         machine->vmlinux_maps[i]->end = ~0ULL;
 996         }
 997 }
 998
 999 static bool machine__uses_kcore(struct machine *machine)
1000 {
1001         struct dso *dso;
1002
1003         list_for_each_entry(dso, &machine->kernel_dsos.head, node) {
1004                 if (dso__is_kcore(dso))
1005                         return true;
1006         }
1007
1008         return false;
1009 }
1010
1011 static int machine__process_kernel_mmap_event(struct machine *machine,
1012                                               union perf_event *event)
1013 {
1014         struct map *map;
1015         char kmmap_prefix[PATH_MAX];
1016         enum dso_kernel_type kernel_type;
1017         bool is_kernel_mmap;
1018
1019         /* If we have maps from kcore then we do not need or want any others */
1020         if (machine__uses_kcore(machine))
1021                 return 0;
1022
1023         machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
1024         if (machine__is_host(machine))
1025                 kernel_type = DSO_TYPE_KERNEL;
1026         else
1027                 kernel_type = DSO_TYPE_GUEST_KERNEL;
1028
1029         is_kernel_mmap = memcmp(event->mmap.filename,
1030                                 kmmap_prefix,
1031                                 strlen(kmmap_prefix) - 1) == 0;
1032         if (event->mmap.filename[0] == '/' ||
1033             (!is_kernel_mmap && event->mmap.filename[0] == '[')) {
1034
1035                 char short_module_name[1024];
1036                 char *name, *dot;
1037
1038                 if (event->mmap.filename[0] == '/') {
1039                         name = strrchr(event->mmap.filename, '/');
1040                         if (name == NULL)
1041                                 goto out_problem;
1042
1043                         ++name; /* skip / */
1044                         dot = strrchr(name, '.');
1045                         if (dot == NULL)
1046                                 goto out_problem;
1047                         snprintf(short_module_name, sizeof(short_module_name),
1048                                         "[%.*s]", (int)(dot - name), name);
1049                         strxfrchar(short_module_name, '-', '_');
1050                 } else
1051                         strcpy(short_module_name, event->mmap.filename);
1052
1053                 map = machine__new_module(machine, event->mmap.start,
1054                                           event->mmap.filename);
1055                 if (map == NULL)
1056                         goto out_problem;
1057
1058                 name = strdup(short_module_name);
1059                 if (name == NULL)
1060                         goto out_problem;
1061
1062                 dso__set_short_name(map->dso, name, true);
1063                 map->end = map->start + event->mmap.len;
1064         } else if (is_kernel_mmap) {
1065                 const char *symbol_name = (event->mmap.filename +
1066                                 strlen(kmmap_prefix));
1067                 /*
1068                  * Should be there already, from the build-id table in
1069                  * the header.
1070                  */
1071                 struct dso *kernel = __dsos__findnew(&machine->kernel_dsos,
1072                                                      kmmap_prefix);
1073                 if (kernel == NULL)
1074                         goto out_problem;
1075
1076                 kernel->kernel = kernel_type;
1077                 if (__machine__create_kernel_maps(machine, kernel) < 0)
1078                         goto out_problem;
1079
1080                 machine__set_kernel_mmap_len(machine, event);
1081
1082                 /*
1083                  * Avoid using a zero address (kptr_restrict) for the ref reloc
1084                  * symbol. Effectively having zero here means that at record
1085                  * time /proc/sys/kernel/kptr_restrict was non zero.
1086                  */
1087                 if (event->mmap.pgoff != 0) {
1088                         maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
1089                                                          symbol_name,
1090                                                          event->mmap.pgoff);
1091                 }
1092
1093                 if (machine__is_default_guest(machine)) {
1094                         /*
1095                          * preload dso of guest kernel and modules
1096                          */
1097                         dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
1098                                   NULL);
1099                 }
1100         }
1101         return 0;
1102 out_problem:
1103         return -1;
1104 }
1105
1106 int machine__process_mmap2_event(struct machine *machine,
1107                                  union perf_event *event,
1108                                  struct perf_sample *sample __maybe_unused)
1109 {
1110         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1111         struct thread *thread;
1112         struct map *map;
1113         enum map_type type;
1114         int ret = 0;
1115
1116         if (dump_trace)
1117                 perf_event__fprintf_mmap2(event, stdout);
1118
1119         if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
1120             cpumode == PERF_RECORD_MISC_KERNEL) {
1121                 ret = machine__process_kernel_mmap_event(machine, event);
1122                 if (ret < 0)
1123                         goto out_problem;
1124                 return 0;
1125         }
1126
1127         thread = machine__findnew_thread(machine, event->mmap2.pid,
1128                                         event->mmap2.tid);
1129         if (thread == NULL)
1130                 goto out_problem;
1131
1132         if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
1133                 type = MAP__VARIABLE;
1134         else
1135                 type = MAP__FUNCTION;
1136
1137         map = map__new(machine, event->mmap2.start,
1138                         event->mmap2.len, event->mmap2.pgoff,
1139                         event->mmap2.pid, event->mmap2.maj,
1140                         event->mmap2.min, event->mmap2.ino,
1141                         event->mmap2.ino_generation,
1142                         event->mmap2.prot,
1143                         event->mmap2.flags,
1144                         event->mmap2.filename, type, thread);
1145
1146         if (map == NULL)
1147                 goto out_problem;
1148
1149         thread__insert_map(thread, map);
1150         return 0;
1151
1152 out_problem:
1153         dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
1154         return 0;
1155 }
1156
1157 int machine__process_mmap_event(struct machine *machine, union perf_event *event,
1158                                 struct perf_sample *sample __maybe_unused)
1159 {
1160         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1161         struct thread *thread;
1162         struct map *map;
1163         enum map_type type;
1164         int ret = 0;
1165
1166         if (dump_trace)
1167                 perf_event__fprintf_mmap(event, stdout);
1168
1169         if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
1170             cpumode == PERF_RECORD_MISC_KERNEL) {
1171                 ret = machine__process_kernel_mmap_event(machine, event);
1172                 if (ret < 0)
1173                         goto out_problem;
1174                 return 0;
1175         }
1176
1177         thread = machine__findnew_thread(machine, event->mmap.pid,
1178                                          event->mmap.tid);
1179         if (thread == NULL)
1180                 goto out_problem;
1181
1182         if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
1183                 type = MAP__VARIABLE;
1184         else
1185                 type = MAP__FUNCTION;
1186
1187         map = map__new(machine, event->mmap.start,
1188                         event->mmap.len, event->mmap.pgoff,
1189                         event->mmap.pid, 0, 0, 0, 0, 0, 0,
1190                         event->mmap.filename,
1191                         type, thread);
1192
1193         if (map == NULL)
1194                 goto out_problem;
1195
1196         thread__insert_map(thread, map);
1197         return 0;
1198
1199 out_problem:
1200         dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
1201         return 0;
1202 }
1203
1204 static void machine__remove_thread(struct machine *machine, struct thread *th)
1205 {
1206         machine->last_match = NULL;
1207         rb_erase(&th->rb_node, &machine->threads);
1208         /*
1209          * We may have references to this thread, for instance in some hist_entry
1210          * instances, so just move them to a separate list.
1211          */
1212         list_add_tail(&th->node, &machine->dead_threads);
1213 }
1214
1215 int machine__process_fork_event(struct machine *machine, union perf_event *event,
1216                                 struct perf_sample *sample)
1217 {
1218         struct thread *thread = machine__find_thread(machine,
1219                                                      event->fork.pid,
1220                                                      event->fork.tid);
1221         struct thread *parent = machine__findnew_thread(machine,
1222                                                         event->fork.ppid,
1223                                                         event->fork.ptid);
1224
1225         /* if a thread currently exists for the thread id remove it */
1226         if (thread != NULL)
1227                 machine__remove_thread(machine, thread);
1228
1229         thread = machine__findnew_thread(machine, event->fork.pid,
1230                                          event->fork.tid);
1231         if (dump_trace)
1232                 perf_event__fprintf_task(event, stdout);
1233
1234         if (thread == NULL || parent == NULL ||
1235             thread__fork(thread, parent, sample->time) < 0) {
1236                 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
1237                 return -1;
1238         }
1239
1240         return 0;
1241 }
1242
1243 int machine__process_exit_event(struct machine *machine, union perf_event *event,
1244                                 struct perf_sample *sample __maybe_unused)
1245 {
1246         struct thread *thread = machine__find_thread(machine,
1247                                                      event->fork.pid,
1248                                                      event->fork.tid);
1249
1250         if (dump_trace)
1251                 perf_event__fprintf_task(event, stdout);
1252
1253         if (thread != NULL)
1254                 thread__exited(thread);
1255
1256         return 0;
1257 }
1258
1259 int machine__process_event(struct machine *machine, union perf_event *event,
1260                            struct perf_sample *sample)
1261 {
1262         int ret;
1263
1264         switch (event->header.type) {
1265         case PERF_RECORD_COMM:
1266                 ret = machine__process_comm_event(machine, event, sample); break;
1267         case PERF_RECORD_MMAP:
1268                 ret = machine__process_mmap_event(machine, event, sample); break;
1269         case PERF_RECORD_MMAP2:
1270                 ret = machine__process_mmap2_event(machine, event, sample); break;
1271         case PERF_RECORD_FORK:
1272                 ret = machine__process_fork_event(machine, event, sample); break;
1273         case PERF_RECORD_EXIT:
1274                 ret = machine__process_exit_event(machine, event, sample); break;
1275         case PERF_RECORD_LOST:
1276                 ret = machine__process_lost_event(machine, event, sample); break;
1277         default:
1278                 ret = -1;
1279                 break;
1280         }
1281
1282         return ret;
1283 }
1284
1285 static bool symbol__match_regex(struct symbol *sym, regex_t *regex)
1286 {
1287         if (sym->name && !regexec(regex, sym->name, 0, NULL, 0))
1288                 return 1;
1289         return 0;
1290 }
1291
1292 static void ip__resolve_ams(struct machine *machine, struct thread *thread,
1293                             struct addr_map_symbol *ams,
1294                             u64 ip)
1295 {
1296         struct addr_location al;
1297
1298         memset(&al, 0, sizeof(al));
1299         /*
1300          * We cannot use the header.misc hint to determine whether a
1301          * branch stack address is user, kernel, guest, hypervisor.
1302          * Branches may straddle the kernel/user/hypervisor boundaries.
1303          * Thus, we have to try consecutively until we find a match
1304          * or else, the symbol is unknown
1305          */
1306         thread__find_cpumode_addr_location(thread, machine, MAP__FUNCTION, ip, &al);
1307
1308         ams->addr = ip;
1309         ams->al_addr = al.addr;
1310         ams->sym = al.sym;
1311         ams->map = al.map;
1312 }
1313
1314 static void ip__resolve_data(struct machine *machine, struct thread *thread,
1315                              u8 m, struct addr_map_symbol *ams, u64 addr)
1316 {
1317         struct addr_location al;
1318
1319         memset(&al, 0, sizeof(al));
1320
1321         thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr,
1322                                    &al);
1323         if (al.map == NULL) {
1324                 /*
1325                  * some shared data regions have execute bit set which puts
1326                  * their mapping in the MAP__FUNCTION type array.
1327                  * Check there as a fallback option before dropping the sample.
1328                  */
1329                 thread__find_addr_location(thread, machine, m, MAP__FUNCTION, addr,
1330                                            &al);
1331         }
1332
1333         ams->addr = addr;
1334         ams->al_addr = al.addr;
1335         ams->sym = al.sym;
1336         ams->map = al.map;
1337 }
1338
1339 struct mem_info *sample__resolve_mem(struct perf_sample *sample,
1340                                      struct addr_location *al)
1341 {
1342         struct mem_info *mi = zalloc(sizeof(*mi));
1343
1344         if (!mi)
1345                 return NULL;
1346
1347         ip__resolve_ams(al->machine, al->thread, &mi->iaddr, sample->ip);
1348         ip__resolve_data(al->machine, al->thread, al->cpumode,
1349                          &mi->daddr, sample->addr);
1350         mi->data_src.val = sample->data_src;
1351
1352         return mi;
1353 }
1354
1355 struct branch_info *sample__resolve_bstack(struct perf_sample *sample,
1356                                            struct addr_location *al)
1357 {
1358         unsigned int i;
1359         const struct branch_stack *bs = sample->branch_stack;
1360         struct branch_info *bi = calloc(bs->nr, sizeof(struct branch_info));
1361
1362         if (!bi)
1363                 return NULL;
1364
1365         for (i = 0; i < bs->nr; i++) {
1366                 ip__resolve_ams(al->machine, al->thread, &bi[i].to, bs->entries[i].to);
1367                 ip__resolve_ams(al->machine, al->thread, &bi[i].from, bs->entries[i].from);
1368                 bi[i].flags = bs->entries[i].flags;
1369         }
1370         return bi;
1371 }
1372
1373 static int machine__resolve_callchain_sample(struct machine *machine,
1374                                              struct thread *thread,
1375                                              struct ip_callchain *chain,
1376                                              struct symbol **parent,
1377                                              struct addr_location *root_al,
1378                                              int max_stack)
1379 {
1380         u8 cpumode = PERF_RECORD_MISC_USER;
1381         int chain_nr = min(max_stack, (int)chain->nr);
1382         int i;
1383         int j;
1384         int err;
1385         int skip_idx __maybe_unused;
1386
1387         callchain_cursor_reset(&callchain_cursor);
1388
1389         if (chain->nr > PERF_MAX_STACK_DEPTH) {
1390                 pr_warning("corrupted callchain. skipping...\n");
1391                 return 0;
1392         }
1393
1394         /*
1395          * Based on DWARF debug information, some architectures skip
1396          * a callchain entry saved by the kernel.
1397          */
1398         skip_idx = arch_skip_callchain_idx(machine, thread, chain);
1399
1400         for (i = 0; i < chain_nr; i++) {
1401                 u64 ip;
1402                 struct addr_location al;
1403
1404                 if (callchain_param.order == ORDER_CALLEE)
1405                         j = i;
1406                 else
1407                         j = chain->nr - i - 1;
1408
1409 #ifdef HAVE_SKIP_CALLCHAIN_IDX
1410                 if (j == skip_idx)
1411                         continue;
1412 #endif
1413                 ip = chain->ips[j];
1414
1415                 if (ip >= PERF_CONTEXT_MAX) {
1416                         switch (ip) {
1417                         case PERF_CONTEXT_HV:
1418                                 cpumode = PERF_RECORD_MISC_HYPERVISOR;
1419                                 break;
1420                         case PERF_CONTEXT_KERNEL:
1421                                 cpumode = PERF_RECORD_MISC_KERNEL;
1422                                 break;
1423                         case PERF_CONTEXT_USER:
1424                                 cpumode = PERF_RECORD_MISC_USER;
1425                                 break;
1426                         default:
1427                                 pr_debug("invalid callchain context: "
1428                                          "%"PRId64"\n", (s64) ip);
1429                                 /*
1430                                  * It seems the callchain is corrupted.
1431                                  * Discard all.
1432                                  */
1433                                 callchain_cursor_reset(&callchain_cursor);
1434                                 return 0;
1435                         }
1436                         continue;
1437                 }
1438
1439                 al.filtered = 0;
1440                 thread__find_addr_location(thread, machine, cpumode,
1441                                            MAP__FUNCTION, ip, &al);
1442                 if (al.sym != NULL) {
1443                         if (sort__has_parent && !*parent &&
1444                             symbol__match_regex(al.sym, &parent_regex))
1445                                 *parent = al.sym;
1446                         else if (have_ignore_callees && root_al &&
1447                           symbol__match_regex(al.sym, &ignore_callees_regex)) {
1448                                 /* Treat this symbol as the root,
1449                                    forgetting its callees. */
1450                                 *root_al = al;
1451                                 callchain_cursor_reset(&callchain_cursor);
1452                         }
1453                 }
1454
1455                 err = callchain_cursor_append(&callchain_cursor,
1456                                               ip, al.map, al.sym);
1457                 if (err)
1458                         return err;
1459         }
1460
1461         return 0;
1462 }
1463
1464 static int unwind_entry(struct unwind_entry *entry, void *arg)
1465 {
1466         struct callchain_cursor *cursor = arg;
1467         return callchain_cursor_append(cursor, entry->ip,
1468                                        entry->map, entry->sym);
1469 }
1470
1471 int machine__resolve_callchain(struct machine *machine,
1472                                struct perf_evsel *evsel,
1473                                struct thread *thread,
1474                                struct perf_sample *sample,
1475                                struct symbol **parent,
1476                                struct addr_location *root_al,
1477                                int max_stack)
1478 {
1479         int ret;
1480
1481         ret = machine__resolve_callchain_sample(machine, thread,
1482                                                 sample->callchain, parent,
1483                                                 root_al, max_stack);
1484         if (ret)
1485                 return ret;
1486
1487         /* Can we do dwarf post unwind? */
1488         if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) &&
1489               (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER)))
1490                 return 0;
1491
1492         /* Bail out if nothing was captured. */
1493         if ((!sample->user_regs.regs) ||
1494             (!sample->user_stack.size))
1495                 return 0;
1496
1497         return unwind__get_entries(unwind_entry, &callchain_cursor, machine,
1498                                    thread, sample, max_stack);
1499
1500 }
1501
1502 int machine__for_each_thread(struct machine *machine,
1503                              int (*fn)(struct thread *thread, void *p),
1504                              void *priv)
1505 {
1506         struct rb_node *nd;
1507         struct thread *thread;
1508         int rc = 0;
1509
1510         for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
1511                 thread = rb_entry(nd, struct thread, rb_node);
1512                 rc = fn(thread, priv);
1513                 if (rc != 0)
1514                         return rc;
1515         }
1516
1517         list_for_each_entry(thread, &machine->dead_threads, node) {
1518                 rc = fn(thread, priv);
1519                 if (rc != 0)
1520                         return rc;
1521         }
1522         return rc;
1523 }
1524
1525 int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool,
1526                                   struct target *target, struct thread_map *threads,
1527                                   perf_event__handler_t process, bool data_mmap)
1528 {
1529         if (target__has_task(target))
1530                 return perf_event__synthesize_thread_map(tool, threads, process, machine, data_mmap);
1531         else if (target__has_cpu(target))
1532                 return perf_event__synthesize_threads(tool, process, machine, data_mmap);
1533         /* command specified */
1534         return 0;
1535 }
1536
1537 pid_t machine__get_current_tid(struct machine *machine, int cpu)
1538 {
1539         if (cpu < 0 || cpu >= MAX_NR_CPUS || !machine->current_tid)
1540                 return -1;
1541
1542         return machine->current_tid[cpu];
1543 }
1544
1545 int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
1546                              pid_t tid)
1547 {
1548         struct thread *thread;
1549
1550         if (cpu < 0)
1551                 return -EINVAL;
1552
1553         if (!machine->current_tid) {
1554                 int i;
1555
1556                 machine->current_tid = calloc(MAX_NR_CPUS, sizeof(pid_t));
1557                 if (!machine->current_tid)
1558                         return -ENOMEM;
1559                 for (i = 0; i < MAX_NR_CPUS; i++)
1560                         machine->current_tid[i] = -1;
1561         }
1562
1563         if (cpu >= MAX_NR_CPUS) {
1564                 pr_err("Requested CPU %d too large. ", cpu);
1565                 pr_err("Consider raising MAX_NR_CPUS\n");
1566                 return -EINVAL;
1567         }
1568
1569         machine->current_tid[cpu] = tid;
1570
1571         thread = machine__findnew_thread(machine, pid, tid);
1572         if (!thread)
1573                 return -ENOMEM;
1574
1575         thread->cpu = cpu;
1576
1577         return 0;
1578 }
1579
1580 int machine__get_kernel_start(struct machine *machine)
1581 {
1582         struct map *map = machine__kernel_map(machine, MAP__FUNCTION);
1583         int err = 0;
1584
1585         /*
1586          * The only addresses above 2^63 are kernel addresses of a 64-bit
1587          * kernel.  Note that addresses are unsigned so that on a 32-bit system
1588          * all addresses including kernel addresses are less than 2^32.  In
1589          * that case (32-bit system), if the kernel mapping is unknown, all
1590          * addresses will be assumed to be in user space - see
1591          * machine__kernel_ip().
1592          */
1593         machine->kernel_start = 1ULL << 63;
1594         if (map) {
1595                 err = map__load(map, machine->symbol_filter);
1596                 if (map->start)
1597                         machine->kernel_start = map->start;
1598         }
1599         return err;
1600 }