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_module(void *arg, const char *name, u64 start)
 797 {
 798         struct machine *machine = arg;
 799         struct map *map;
 800
 801         map = machine__new_module(machine, start, name);
 802         if (map == NULL)
 803                 return -1;
 804
 805         dso__kernel_module_get_build_id(map->dso, machine->root_dir);
 806
 807         return 0;
 808 }
 809
 810 static int machine__create_modules(struct machine *machine)
 811 {
 812         const char *modules;
 813         char path[PATH_MAX];
 814
 815         if (machine__is_default_guest(machine)) {
 816                 modules = symbol_conf.default_guest_modules;
 817         } else {
 818                 snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir);
 819                 modules = path;
 820         }
 821
 822         if (symbol__restricted_filename(modules, "/proc/modules"))
 823                 return -1;
 824
 825         if (modules__parse(modules, machine, machine__create_module))
 826                 return -1;
 827
 828         if (!machine__set_modules_path(machine))
 829                 return 0;
 830
 831         pr_debug("Problems setting modules path maps, continuing anyway...\n");
 832
 833         return 0;
 834 }
 835
 836 int machine__create_kernel_maps(struct machine *machine)
 837 {
 838         struct dso *kernel = machine__get_kernel(machine);
 839
 840         if (kernel == NULL ||
 841             __machine__create_kernel_maps(machine, kernel) < 0)
 842                 return -1;
 843
 844         if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
 845                 if (machine__is_host(machine))
 846                         pr_debug("Problems creating module maps, "
 847                                  "continuing anyway...\n");
 848                 else
 849                         pr_debug("Problems creating module maps for guest %d, "
 850                                  "continuing anyway...\n", machine->pid);
 851         }
 852
 853         /*
 854          * Now that we have all the maps created, just set the ->end of them:
 855          */
 856         map_groups__fixup_end(&machine->kmaps);
 857         return 0;
 858 }
 859
 860 static void machine__set_kernel_mmap_len(struct machine *machine,
 861                                          union perf_event *event)
 862 {
 863         int i;
 864
 865         for (i = 0; i < MAP__NR_TYPES; i++) {
 866                 machine->vmlinux_maps[i]->start = event->mmap.start;
 867                 machine->vmlinux_maps[i]->end   = (event->mmap.start +
 868                                                    event->mmap.len);
 869                 /*
 870                  * Be a bit paranoid here, some perf.data file came with
 871                  * a zero sized synthesized MMAP event for the kernel.
 872                  */
 873                 if (machine->vmlinux_maps[i]->end == 0)
 874                         machine->vmlinux_maps[i]->end = ~0ULL;
 875         }
 876 }
 877
 878 static bool machine__uses_kcore(struct machine *machine)
 879 {
 880         struct dso *dso;
 881
 882         list_for_each_entry(dso, &machine->kernel_dsos, node) {
 883                 if (dso__is_kcore(dso))
 884                         return true;
 885         }
 886
 887         return false;
 888 }
 889
 890 static int machine__process_kernel_mmap_event(struct machine *machine,
 891                                               union perf_event *event)
 892 {
 893         struct map *map;
 894         char kmmap_prefix[PATH_MAX];
 895         enum dso_kernel_type kernel_type;
 896         bool is_kernel_mmap;
 897
 898         /* If we have maps from kcore then we do not need or want any others */
 899         if (machine__uses_kcore(machine))
 900                 return 0;
 901
 902         machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
 903         if (machine__is_host(machine))
 904                 kernel_type = DSO_TYPE_KERNEL;
 905         else
 906                 kernel_type = DSO_TYPE_GUEST_KERNEL;
 907
 908         is_kernel_mmap = memcmp(event->mmap.filename,
 909                                 kmmap_prefix,
 910                                 strlen(kmmap_prefix) - 1) == 0;
 911         if (event->mmap.filename[0] == '/' ||
 912             (!is_kernel_mmap && event->mmap.filename[0] == '[')) {
 913
 914                 char short_module_name[1024];
 915                 char *name, *dot;
 916
 917                 if (event->mmap.filename[0] == '/') {
 918                         name = strrchr(event->mmap.filename, '/');
 919                         if (name == NULL)
 920                                 goto out_problem;
 921
 922                         ++name; /* skip / */
 923                         dot = strrchr(name, '.');
 924                         if (dot == NULL)
 925                                 goto out_problem;
 926                         snprintf(short_module_name, sizeof(short_module_name),
 927                                         "[%.*s]", (int)(dot - name), name);
 928                         strxfrchar(short_module_name, '-', '_');
 929                 } else
 930                         strcpy(short_module_name, event->mmap.filename);
 931
 932                 map = machine__new_module(machine, event->mmap.start,
 933                                           event->mmap.filename);
 934                 if (map == NULL)
 935                         goto out_problem;
 936
 937                 name = strdup(short_module_name);
 938                 if (name == NULL)
 939                         goto out_problem;
 940
 941                 map->dso->short_name = name;
 942                 map->dso->sname_alloc = 1;
 943                 map->end = map->start + event->mmap.len;
 944         } else if (is_kernel_mmap) {
 945                 const char *symbol_name = (event->mmap.filename +
 946                                 strlen(kmmap_prefix));
 947                 /*
 948                  * Should be there already, from the build-id table in
 949                  * the header.
 950                  */
 951                 struct dso *kernel = __dsos__findnew(&machine->kernel_dsos,
 952                                                      kmmap_prefix);
 953                 if (kernel == NULL)
 954                         goto out_problem;
 955
 956                 kernel->kernel = kernel_type;
 957                 if (__machine__create_kernel_maps(machine, kernel) < 0)
 958                         goto out_problem;
 959
 960                 machine__set_kernel_mmap_len(machine, event);
 961
 962                 /*
 963                  * Avoid using a zero address (kptr_restrict) for the ref reloc
 964                  * symbol. Effectively having zero here means that at record
 965                  * time /proc/sys/kernel/kptr_restrict was non zero.
 966                  */
 967                 if (event->mmap.pgoff != 0) {
 968                         maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
 969                                                          symbol_name,
 970                                                          event->mmap.pgoff);
 971                 }
 972
 973                 if (machine__is_default_guest(machine)) {
 974                         /*
 975                          * preload dso of guest kernel and modules
 976                          */
 977                         dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
 978                                   NULL);
 979                 }
 980         }
 981         return 0;
 982 out_problem:
 983         return -1;
 984 }
 985
 986 int machine__process_mmap2_event(struct machine *machine,
 987                                  union perf_event *event)
 988 {
 989         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 990         struct thread *thread;
 991         struct map *map;
 992         enum map_type type;
 993         int ret = 0;
 994
 995         if (dump_trace)
 996                 perf_event__fprintf_mmap2(event, stdout);
 997
 998         if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
 999             cpumode == PERF_RECORD_MISC_KERNEL) {
1000                 ret = machine__process_kernel_mmap_event(machine, event);
1001                 if (ret < 0)
1002                         goto out_problem;
1003                 return 0;
1004         }
1005
1006         thread = machine__findnew_thread(machine, event->mmap2.pid,
1007                                         event->mmap2.pid);
1008         if (thread == NULL)
1009                 goto out_problem;
1010
1011         if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
1012                 type = MAP__VARIABLE;
1013         else
1014                 type = MAP__FUNCTION;
1015
1016         map = map__new(&machine->user_dsos, event->mmap2.start,
1017                         event->mmap2.len, event->mmap2.pgoff,
1018                         event->mmap2.pid, event->mmap2.maj,
1019                         event->mmap2.min, event->mmap2.ino,
1020                         event->mmap2.ino_generation,
1021                         event->mmap2.filename, type);
1022
1023         if (map == NULL)
1024                 goto out_problem;
1025
1026         thread__insert_map(thread, map);
1027         return 0;
1028
1029 out_problem:
1030         dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
1031         return 0;
1032 }
1033
1034 int machine__process_mmap_event(struct machine *machine, union perf_event *event)
1035 {
1036         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1037         struct thread *thread;
1038         struct map *map;
1039         enum map_type type;
1040         int ret = 0;
1041
1042         if (dump_trace)
1043                 perf_event__fprintf_mmap(event, stdout);
1044
1045         if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
1046             cpumode == PERF_RECORD_MISC_KERNEL) {
1047                 ret = machine__process_kernel_mmap_event(machine, event);
1048                 if (ret < 0)
1049                         goto out_problem;
1050                 return 0;
1051         }
1052
1053         thread = machine__findnew_thread(machine, event->mmap.pid,
1054                                          event->mmap.pid);
1055         if (thread == NULL)
1056                 goto out_problem;
1057
1058         if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
1059                 type = MAP__VARIABLE;
1060         else
1061                 type = MAP__FUNCTION;
1062
1063         map = map__new(&machine->user_dsos, event->mmap.start,
1064                         event->mmap.len, event->mmap.pgoff,
1065                         event->mmap.pid, 0, 0, 0, 0,
1066                         event->mmap.filename,
1067                         type);
1068
1069         if (map == NULL)
1070                 goto out_problem;
1071
1072         thread__insert_map(thread, map);
1073         return 0;
1074
1075 out_problem:
1076         dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
1077         return 0;
1078 }
1079
1080 static void machine__remove_thread(struct machine *machine, struct thread *th)
1081 {
1082         machine->last_match = NULL;
1083         rb_erase(&th->rb_node, &machine->threads);
1084         /*
1085          * We may have references to this thread, for instance in some hist_entry
1086          * instances, so just move them to a separate list.
1087          */
1088         list_add_tail(&th->node, &machine->dead_threads);
1089 }
1090
1091 int machine__process_fork_event(struct machine *machine, union perf_event *event)
1092 {
1093         struct thread *thread = machine__find_thread(machine, event->fork.tid);
1094         struct thread *parent = machine__findnew_thread(machine,
1095                                                         event->fork.ppid,
1096                                                         event->fork.ptid);
1097
1098         /* if a thread currently exists for the thread id remove it */
1099         if (thread != NULL)
1100                 machine__remove_thread(machine, thread);
1101
1102         thread = machine__findnew_thread(machine, event->fork.pid,
1103                                          event->fork.tid);
1104         if (dump_trace)
1105                 perf_event__fprintf_task(event, stdout);
1106
1107         if (thread == NULL || parent == NULL ||
1108             thread__fork(thread, parent) < 0) {
1109                 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
1110                 return -1;
1111         }
1112
1113         return 0;
1114 }
1115
1116 int machine__process_exit_event(struct machine *machine __maybe_unused,
1117                                 union perf_event *event)
1118 {
1119         struct thread *thread = machine__find_thread(machine, event->fork.tid);
1120
1121         if (dump_trace)
1122                 perf_event__fprintf_task(event, stdout);
1123
1124         if (thread != NULL)
1125                 thread__exited(thread);
1126
1127         return 0;
1128 }
1129
1130 int machine__process_event(struct machine *machine, union perf_event *event)
1131 {
1132         int ret;
1133
1134         switch (event->header.type) {
1135         case PERF_RECORD_COMM:
1136                 ret = machine__process_comm_event(machine, event); break;
1137         case PERF_RECORD_MMAP:
1138                 ret = machine__process_mmap_event(machine, event); break;
1139         case PERF_RECORD_MMAP2:
1140                 ret = machine__process_mmap2_event(machine, event); break;
1141         case PERF_RECORD_FORK:
1142                 ret = machine__process_fork_event(machine, event); break;
1143         case PERF_RECORD_EXIT:
1144                 ret = machine__process_exit_event(machine, event); break;
1145         case PERF_RECORD_LOST:
1146                 ret = machine__process_lost_event(machine, event); break;
1147         default:
1148                 ret = -1;
1149                 break;
1150         }
1151
1152         return ret;
1153 }
1154
1155 static bool symbol__match_regex(struct symbol *sym, regex_t *regex)
1156 {
1157         if (sym->name && !regexec(regex, sym->name, 0, NULL, 0))
1158                 return 1;
1159         return 0;
1160 }
1161
1162 static const u8 cpumodes[] = {
1163         PERF_RECORD_MISC_USER,
1164         PERF_RECORD_MISC_KERNEL,
1165         PERF_RECORD_MISC_GUEST_USER,
1166         PERF_RECORD_MISC_GUEST_KERNEL
1167 };
1168 #define NCPUMODES (sizeof(cpumodes)/sizeof(u8))
1169
1170 static void ip__resolve_ams(struct machine *machine, struct thread *thread,
1171                             struct addr_map_symbol *ams,
1172                             u64 ip)
1173 {
1174         struct addr_location al;
1175         size_t i;
1176         u8 m;
1177
1178         memset(&al, 0, sizeof(al));
1179
1180         for (i = 0; i < NCPUMODES; i++) {
1181                 m = cpumodes[i];
1182                 /*
1183                  * We cannot use the header.misc hint to determine whether a
1184                  * branch stack address is user, kernel, guest, hypervisor.
1185                  * Branches may straddle the kernel/user/hypervisor boundaries.
1186                  * Thus, we have to try consecutively until we find a match
1187                  * or else, the symbol is unknown
1188                  */
1189                 thread__find_addr_location(thread, machine, m, MAP__FUNCTION,
1190                                 ip, &al);
1191                 if (al.sym)
1192                         goto found;
1193         }
1194 found:
1195         ams->addr = ip;
1196         ams->al_addr = al.addr;
1197         ams->sym = al.sym;
1198         ams->map = al.map;
1199 }
1200
1201 static void ip__resolve_data(struct machine *machine, struct thread *thread,
1202                              u8 m, struct addr_map_symbol *ams, u64 addr)
1203 {
1204         struct addr_location al;
1205
1206         memset(&al, 0, sizeof(al));
1207
1208         thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr,
1209                                    &al);
1210         ams->addr = addr;
1211         ams->al_addr = al.addr;
1212         ams->sym = al.sym;
1213         ams->map = al.map;
1214 }
1215
1216 struct mem_info *machine__resolve_mem(struct machine *machine,
1217                                       struct thread *thr,
1218                                       struct perf_sample *sample,
1219                                       u8 cpumode)
1220 {
1221         struct mem_info *mi = zalloc(sizeof(*mi));
1222
1223         if (!mi)
1224                 return NULL;
1225
1226         ip__resolve_ams(machine, thr, &mi->iaddr, sample->ip);
1227         ip__resolve_data(machine, thr, cpumode, &mi->daddr, sample->addr);
1228         mi->data_src.val = sample->data_src;
1229
1230         return mi;
1231 }
1232
1233 struct branch_info *machine__resolve_bstack(struct machine *machine,
1234                                             struct thread *thr,
1235                                             struct branch_stack *bs)
1236 {
1237         struct branch_info *bi;
1238         unsigned int i;
1239
1240         bi = calloc(bs->nr, sizeof(struct branch_info));
1241         if (!bi)
1242                 return NULL;
1243
1244         for (i = 0; i < bs->nr; i++) {
1245                 ip__resolve_ams(machine, thr, &bi[i].to, bs->entries[i].to);
1246                 ip__resolve_ams(machine, thr, &bi[i].from, bs->entries[i].from);
1247                 bi[i].flags = bs->entries[i].flags;
1248         }
1249         return bi;
1250 }
1251
1252 static int machine__resolve_callchain_sample(struct machine *machine,
1253                                              struct thread *thread,
1254                                              struct ip_callchain *chain,
1255                                              struct symbol **parent,
1256                                              struct addr_location *root_al,
1257                                              int max_stack)
1258 {
1259         u8 cpumode = PERF_RECORD_MISC_USER;
1260         int chain_nr = min(max_stack, (int)chain->nr);
1261         int i;
1262         int err;
1263
1264         callchain_cursor_reset(&callchain_cursor);
1265
1266         if (chain->nr > PERF_MAX_STACK_DEPTH) {
1267                 pr_warning("corrupted callchain. skipping...\n");
1268                 return 0;
1269         }
1270
1271         for (i = 0; i < chain_nr; i++) {
1272                 u64 ip;
1273                 struct addr_location al;
1274
1275                 if (callchain_param.order == ORDER_CALLEE)
1276                         ip = chain->ips[i];
1277                 else
1278                         ip = chain->ips[chain->nr - i - 1];
1279
1280                 if (ip >= PERF_CONTEXT_MAX) {
1281                         switch (ip) {
1282                         case PERF_CONTEXT_HV:
1283                                 cpumode = PERF_RECORD_MISC_HYPERVISOR;
1284                                 break;
1285                         case PERF_CONTEXT_KERNEL:
1286                                 cpumode = PERF_RECORD_MISC_KERNEL;
1287                                 break;
1288                         case PERF_CONTEXT_USER:
1289                                 cpumode = PERF_RECORD_MISC_USER;
1290                                 break;
1291                         default:
1292                                 pr_debug("invalid callchain context: "
1293                                          "%"PRId64"\n", (s64) ip);
1294                                 /*
1295                                  * It seems the callchain is corrupted.
1296                                  * Discard all.
1297                                  */
1298                                 callchain_cursor_reset(&callchain_cursor);
1299                                 return 0;
1300                         }
1301                         continue;
1302                 }
1303
1304                 al.filtered = false;
1305                 thread__find_addr_location(thread, machine, cpumode,
1306                                            MAP__FUNCTION, ip, &al);
1307                 if (al.sym != NULL) {
1308                         if (sort__has_parent && !*parent &&
1309                             symbol__match_regex(al.sym, &parent_regex))
1310                                 *parent = al.sym;
1311                         else if (have_ignore_callees && root_al &&
1312                           symbol__match_regex(al.sym, &ignore_callees_regex)) {
1313                                 /* Treat this symbol as the root,
1314                                    forgetting its callees. */
1315                                 *root_al = al;
1316                                 callchain_cursor_reset(&callchain_cursor);
1317                         }
1318                         if (!symbol_conf.use_callchain)
1319                                 break;
1320                 }
1321
1322                 err = callchain_cursor_append(&callchain_cursor,
1323                                               ip, al.map, al.sym);
1324                 if (err)
1325                         return err;
1326         }
1327
1328         return 0;
1329 }
1330
1331 static int unwind_entry(struct unwind_entry *entry, void *arg)
1332 {
1333         struct callchain_cursor *cursor = arg;
1334         return callchain_cursor_append(cursor, entry->ip,
1335                                        entry->map, entry->sym);
1336 }
1337
1338 int machine__resolve_callchain(struct machine *machine,
1339                                struct perf_evsel *evsel,
1340                                struct thread *thread,
1341                                struct perf_sample *sample,
1342                                struct symbol **parent,
1343                                struct addr_location *root_al,
1344                                int max_stack)
1345 {
1346         int ret;
1347
1348         ret = machine__resolve_callchain_sample(machine, thread,
1349                                                 sample->callchain, parent,
1350                                                 root_al, max_stack);
1351         if (ret)
1352                 return ret;
1353
1354         /* Can we do dwarf post unwind? */
1355         if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) &&
1356               (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER)))
1357                 return 0;
1358
1359         /* Bail out if nothing was captured. */
1360         if ((!sample->user_regs.regs) ||
1361             (!sample->user_stack.size))
1362                 return 0;
1363
1364         return unwind__get_entries(unwind_entry, &callchain_cursor, machine,
1365                                    thread, evsel->attr.sample_regs_user,
1366                                    sample);
1367
1368 }
1369
1370 int machine__for_each_thread(struct machine *machine,
1371                              int (*fn)(struct thread *thread, void *p),
1372                              void *priv)
1373 {
1374         struct rb_node *nd;
1375         struct thread *thread;
1376         int rc = 0;
1377
1378         for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
1379                 thread = rb_entry(nd, struct thread, rb_node);
1380                 rc = fn(thread, priv);
1381                 if (rc != 0)
1382                         return rc;
1383         }
1384
1385         list_for_each_entry(thread, &machine->dead_threads, node) {
1386                 rc = fn(thread, priv);
1387                 if (rc != 0)
1388                         return rc;
1389         }
1390         return rc;
1391 }