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