1 #include <linux/types.h> 2 #include <sys/mman.h> 3 #include "event.h" 4 #include "debug.h" 5 #include "hist.h" 6 #include "machine.h" 7 #include "sort.h" 8 #include "string.h" 9 #include "strlist.h" 10 #include "thread.h" 11 #include "thread_map.h" 12 #include "symbol/kallsyms.h" 13 14 static const char *perf_event__names[] = { 15 [0] = "TOTAL", 16 [PERF_RECORD_MMAP] = "MMAP", 17 [PERF_RECORD_MMAP2] = "MMAP2", 18 [PERF_RECORD_LOST] = "LOST", 19 [PERF_RECORD_COMM] = "COMM", 20 [PERF_RECORD_EXIT] = "EXIT", 21 [PERF_RECORD_THROTTLE] = "THROTTLE", 22 [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE", 23 [PERF_RECORD_FORK] = "FORK", 24 [PERF_RECORD_READ] = "READ", 25 [PERF_RECORD_SAMPLE] = "SAMPLE", 26 [PERF_RECORD_HEADER_ATTR] = "ATTR", 27 [PERF_RECORD_HEADER_EVENT_TYPE] = "EVENT_TYPE", 28 [PERF_RECORD_HEADER_TRACING_DATA] = "TRACING_DATA", 29 [PERF_RECORD_HEADER_BUILD_ID] = "BUILD_ID", 30 [PERF_RECORD_FINISHED_ROUND] = "FINISHED_ROUND", 31 }; 32 33 const char *perf_event__name(unsigned int id) 34 { 35 if (id >= ARRAY_SIZE(perf_event__names)) 36 return "INVALID"; 37 if (!perf_event__names[id]) 38 return "UNKNOWN"; 39 return perf_event__names[id]; 40 } 41 42 static struct perf_sample synth_sample = { 43 .pid = -1, 44 .tid = -1, 45 .time = -1, 46 .stream_id = -1, 47 .cpu = -1, 48 .period = 1, 49 }; 50 51 static pid_t perf_event__get_comm_tgid(pid_t pid, char *comm, size_t len) 52 { 53 char filename[PATH_MAX]; 54 char bf[BUFSIZ]; 55 FILE *fp; 56 size_t size = 0; 57 pid_t tgid = -1; 58 59 snprintf(filename, sizeof(filename), "/proc/%d/status", pid); 60 61 fp = fopen(filename, "r"); 62 if (fp == NULL) { 63 pr_debug("couldn't open %s\n", filename); 64 return 0; 65 } 66 67 while (!comm[0] || (tgid < 0)) { 68 if (fgets(bf, sizeof(bf), fp) == NULL) { 69 pr_warning("couldn't get COMM and pgid, malformed %s\n", 70 filename); 71 break; 72 } 73 74 if (memcmp(bf, "Name:", 5) == 0) { 75 char *name = bf + 5; 76 while (*name && isspace(*name)) 77 ++name; 78 size = strlen(name) - 1; 79 if (size >= len) 80 size = len - 1; 81 memcpy(comm, name, size); 82 comm[size] = '\0'; 83 84 } else if (memcmp(bf, "Tgid:", 5) == 0) { 85 char *tgids = bf + 5; 86 while (*tgids && isspace(*tgids)) 87 ++tgids; 88 tgid = atoi(tgids); 89 } 90 } 91 92 fclose(fp); 93 94 return tgid; 95 } 96 97 static pid_t perf_event__synthesize_comm(struct perf_tool *tool, 98 union perf_event *event, pid_t pid, 99 perf_event__handler_t process, 100 struct machine *machine) 101 { 102 size_t size; 103 pid_t tgid; 104 105 memset(&event->comm, 0, sizeof(event->comm)); 106 107 if (machine__is_host(machine)) 108 tgid = perf_event__get_comm_tgid(pid, event->comm.comm, 109 sizeof(event->comm.comm)); 110 else 111 tgid = machine->pid; 112 113 if (tgid < 0) 114 goto out; 115 116 event->comm.pid = tgid; 117 event->comm.header.type = PERF_RECORD_COMM; 118 119 size = strlen(event->comm.comm) + 1; 120 size = PERF_ALIGN(size, sizeof(u64)); 121 memset(event->comm.comm + size, 0, machine->id_hdr_size); 122 event->comm.header.size = (sizeof(event->comm) - 123 (sizeof(event->comm.comm) - size) + 124 machine->id_hdr_size); 125 event->comm.tid = pid; 126 127 if (process(tool, event, &synth_sample, machine) != 0) 128 return -1; 129 130 out: 131 return tgid; 132 } 133 134 static int perf_event__synthesize_fork(struct perf_tool *tool, 135 union perf_event *event, pid_t pid, 136 pid_t tgid, perf_event__handler_t process, 137 struct machine *machine) 138 { 139 memset(&event->fork, 0, sizeof(event->fork) + machine->id_hdr_size); 140 141 /* this is really a clone event but we use fork to synthesize it */ 142 event->fork.ppid = tgid; 143 event->fork.ptid = tgid; 144 event->fork.pid = tgid; 145 event->fork.tid = pid; 146 event->fork.header.type = PERF_RECORD_FORK; 147 148 event->fork.header.size = (sizeof(event->fork) + machine->id_hdr_size); 149 150 if (process(tool, event, &synth_sample, machine) != 0) 151 return -1; 152 153 return 0; 154 } 155 156 int perf_event__synthesize_mmap_events(struct perf_tool *tool, 157 union perf_event *event, 158 pid_t pid, pid_t tgid, 159 perf_event__handler_t process, 160 struct machine *machine, 161 bool mmap_data) 162 { 163 char filename[PATH_MAX]; 164 FILE *fp; 165 int rc = 0; 166 167 if (machine__is_default_guest(machine)) 168 return 0; 169 170 snprintf(filename, sizeof(filename), "%s/proc/%d/maps", 171 machine->root_dir, pid); 172 173 fp = fopen(filename, "r"); 174 if (fp == NULL) { 175 /* 176 * We raced with a task exiting - just return: 177 */ 178 pr_debug("couldn't open %s\n", filename); 179 return -1; 180 } 181 182 event->header.type = PERF_RECORD_MMAP2; 183 184 while (1) { 185 char bf[BUFSIZ]; 186 char prot[5]; 187 char execname[PATH_MAX]; 188 char anonstr[] = "//anon"; 189 unsigned int ino; 190 size_t size; 191 ssize_t n; 192 193 if (fgets(bf, sizeof(bf), fp) == NULL) 194 break; 195 196 /* ensure null termination since stack will be reused. */ 197 strcpy(execname, ""); 198 199 /* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */ 200 n = sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %x:%x %u %s\n", 201 &event->mmap2.start, &event->mmap2.len, prot, 202 &event->mmap2.pgoff, &event->mmap2.maj, 203 &event->mmap2.min, 204 &ino, execname); 205 206 /* 207 * Anon maps don't have the execname. 208 */ 209 if (n < 7) 210 continue; 211 212 event->mmap2.ino = (u64)ino; 213 214 /* 215 * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c 216 */ 217 if (machine__is_host(machine)) 218 event->header.misc = PERF_RECORD_MISC_USER; 219 else 220 event->header.misc = PERF_RECORD_MISC_GUEST_USER; 221 222 /* map protection and flags bits */ 223 event->mmap2.prot = 0; 224 event->mmap2.flags = 0; 225 if (prot[0] == 'r') 226 event->mmap2.prot |= PROT_READ; 227 if (prot[1] == 'w') 228 event->mmap2.prot |= PROT_WRITE; 229 if (prot[2] == 'x') 230 event->mmap2.prot |= PROT_EXEC; 231 232 if (prot[3] == 's') 233 event->mmap2.flags |= MAP_SHARED; 234 else 235 event->mmap2.flags |= MAP_PRIVATE; 236 237 if (prot[2] != 'x') { 238 if (!mmap_data || prot[0] != 'r') 239 continue; 240 241 event->header.misc |= PERF_RECORD_MISC_MMAP_DATA; 242 } 243 244 if (!strcmp(execname, "")) 245 strcpy(execname, anonstr); 246 247 size = strlen(execname) + 1; 248 memcpy(event->mmap2.filename, execname, size); 249 size = PERF_ALIGN(size, sizeof(u64)); 250 event->mmap2.len -= event->mmap.start; 251 event->mmap2.header.size = (sizeof(event->mmap2) - 252 (sizeof(event->mmap2.filename) - size)); 253 memset(event->mmap2.filename + size, 0, machine->id_hdr_size); 254 event->mmap2.header.size += machine->id_hdr_size; 255 event->mmap2.pid = tgid; 256 event->mmap2.tid = pid; 257 258 if (process(tool, event, &synth_sample, machine) != 0) { 259 rc = -1; 260 break; 261 } 262 } 263 264 fclose(fp); 265 return rc; 266 } 267 268 int perf_event__synthesize_modules(struct perf_tool *tool, 269 perf_event__handler_t process, 270 struct machine *machine) 271 { 272 int rc = 0; 273 struct rb_node *nd; 274 struct map_groups *kmaps = &machine->kmaps; 275 union perf_event *event = zalloc((sizeof(event->mmap) + 276 machine->id_hdr_size)); 277 if (event == NULL) { 278 pr_debug("Not enough memory synthesizing mmap event " 279 "for kernel modules\n"); 280 return -1; 281 } 282 283 event->header.type = PERF_RECORD_MMAP; 284 285 /* 286 * kernel uses 0 for user space maps, see kernel/perf_event.c 287 * __perf_event_mmap 288 */ 289 if (machine__is_host(machine)) 290 event->header.misc = PERF_RECORD_MISC_KERNEL; 291 else 292 event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL; 293 294 for (nd = rb_first(&kmaps->maps[MAP__FUNCTION]); 295 nd; nd = rb_next(nd)) { 296 size_t size; 297 struct map *pos = rb_entry(nd, struct map, rb_node); 298 299 if (pos->dso->kernel) 300 continue; 301 302 size = PERF_ALIGN(pos->dso->long_name_len + 1, sizeof(u64)); 303 event->mmap.header.type = PERF_RECORD_MMAP; 304 event->mmap.header.size = (sizeof(event->mmap) - 305 (sizeof(event->mmap.filename) - size)); 306 memset(event->mmap.filename + size, 0, machine->id_hdr_size); 307 event->mmap.header.size += machine->id_hdr_size; 308 event->mmap.start = pos->start; 309 event->mmap.len = pos->end - pos->start; 310 event->mmap.pid = machine->pid; 311 312 memcpy(event->mmap.filename, pos->dso->long_name, 313 pos->dso->long_name_len + 1); 314 if (process(tool, event, &synth_sample, machine) != 0) { 315 rc = -1; 316 break; 317 } 318 } 319 320 free(event); 321 return rc; 322 } 323 324 static int __event__synthesize_thread(union perf_event *comm_event, 325 union perf_event *mmap_event, 326 union perf_event *fork_event, 327 pid_t pid, int full, 328 perf_event__handler_t process, 329 struct perf_tool *tool, 330 struct machine *machine, bool mmap_data) 331 { 332 char filename[PATH_MAX]; 333 DIR *tasks; 334 struct dirent dirent, *next; 335 pid_t tgid; 336 337 /* special case: only send one comm event using passed in pid */ 338 if (!full) { 339 tgid = perf_event__synthesize_comm(tool, comm_event, pid, 340 process, machine); 341 342 if (tgid == -1) 343 return -1; 344 345 return perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid, 346 process, machine, mmap_data); 347 } 348 349 if (machine__is_default_guest(machine)) 350 return 0; 351 352 snprintf(filename, sizeof(filename), "%s/proc/%d/task", 353 machine->root_dir, pid); 354 355 tasks = opendir(filename); 356 if (tasks == NULL) { 357 pr_debug("couldn't open %s\n", filename); 358 return 0; 359 } 360 361 while (!readdir_r(tasks, &dirent, &next) && next) { 362 char *end; 363 int rc = 0; 364 pid_t _pid; 365 366 _pid = strtol(dirent.d_name, &end, 10); 367 if (*end) 368 continue; 369 370 tgid = perf_event__synthesize_comm(tool, comm_event, _pid, 371 process, machine); 372 if (tgid == -1) 373 return -1; 374 375 if (_pid == pid) { 376 /* process the parent's maps too */ 377 rc = perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid, 378 process, machine, mmap_data); 379 } else { 380 /* only fork the tid's map, to save time */ 381 rc = perf_event__synthesize_fork(tool, fork_event, _pid, tgid, 382 process, machine); 383 } 384 385 if (rc) 386 return rc; 387 } 388 389 closedir(tasks); 390 return 0; 391 } 392 393 int perf_event__synthesize_thread_map(struct perf_tool *tool, 394 struct thread_map *threads, 395 perf_event__handler_t process, 396 struct machine *machine, 397 bool mmap_data) 398 { 399 union perf_event *comm_event, *mmap_event, *fork_event; 400 int err = -1, thread, j; 401 402 comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size); 403 if (comm_event == NULL) 404 goto out; 405 406 mmap_event = malloc(sizeof(mmap_event->mmap) + machine->id_hdr_size); 407 if (mmap_event == NULL) 408 goto out_free_comm; 409 410 fork_event = malloc(sizeof(fork_event->fork) + machine->id_hdr_size); 411 if (fork_event == NULL) 412 goto out_free_mmap; 413 414 err = 0; 415 for (thread = 0; thread < threads->nr; ++thread) { 416 if (__event__synthesize_thread(comm_event, mmap_event, 417 fork_event, 418 threads->map[thread], 0, 419 process, tool, machine, 420 mmap_data)) { 421 err = -1; 422 break; 423 } 424 425 /* 426 * comm.pid is set to thread group id by 427 * perf_event__synthesize_comm 428 */ 429 if ((int) comm_event->comm.pid != threads->map[thread]) { 430 bool need_leader = true; 431 432 /* is thread group leader in thread_map? */ 433 for (j = 0; j < threads->nr; ++j) { 434 if ((int) comm_event->comm.pid == threads->map[j]) { 435 need_leader = false; 436 break; 437 } 438 } 439 440 /* if not, generate events for it */ 441 if (need_leader && 442 __event__synthesize_thread(comm_event, mmap_event, 443 fork_event, 444 comm_event->comm.pid, 0, 445 process, tool, machine, 446 mmap_data)) { 447 err = -1; 448 break; 449 } 450 } 451 } 452 free(fork_event); 453 out_free_mmap: 454 free(mmap_event); 455 out_free_comm: 456 free(comm_event); 457 out: 458 return err; 459 } 460 461 int perf_event__synthesize_threads(struct perf_tool *tool, 462 perf_event__handler_t process, 463 struct machine *machine, bool mmap_data) 464 { 465 DIR *proc; 466 char proc_path[PATH_MAX]; 467 struct dirent dirent, *next; 468 union perf_event *comm_event, *mmap_event, *fork_event; 469 int err = -1; 470 471 if (machine__is_default_guest(machine)) 472 return 0; 473 474 comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size); 475 if (comm_event == NULL) 476 goto out; 477 478 mmap_event = malloc(sizeof(mmap_event->mmap) + machine->id_hdr_size); 479 if (mmap_event == NULL) 480 goto out_free_comm; 481 482 fork_event = malloc(sizeof(fork_event->fork) + machine->id_hdr_size); 483 if (fork_event == NULL) 484 goto out_free_mmap; 485 486 snprintf(proc_path, sizeof(proc_path), "%s/proc", machine->root_dir); 487 proc = opendir(proc_path); 488 489 if (proc == NULL) 490 goto out_free_fork; 491 492 while (!readdir_r(proc, &dirent, &next) && next) { 493 char *end; 494 pid_t pid = strtol(dirent.d_name, &end, 10); 495 496 if (*end) /* only interested in proper numerical dirents */ 497 continue; 498 /* 499 * We may race with exiting thread, so don't stop just because 500 * one thread couldn't be synthesized. 501 */ 502 __event__synthesize_thread(comm_event, mmap_event, fork_event, pid, 503 1, process, tool, machine, mmap_data); 504 } 505 506 err = 0; 507 closedir(proc); 508 out_free_fork: 509 free(fork_event); 510 out_free_mmap: 511 free(mmap_event); 512 out_free_comm: 513 free(comm_event); 514 out: 515 return err; 516 } 517 518 struct process_symbol_args { 519 const char *name; 520 u64 start; 521 }; 522 523 static int find_symbol_cb(void *arg, const char *name, char type, 524 u64 start) 525 { 526 struct process_symbol_args *args = arg; 527 528 /* 529 * Must be a function or at least an alias, as in PARISC64, where "_text" is 530 * an 'A' to the same address as "_stext". 531 */ 532 if (!(symbol_type__is_a(type, MAP__FUNCTION) || 533 type == 'A') || strcmp(name, args->name)) 534 return 0; 535 536 args->start = start; 537 return 1; 538 } 539 540 u64 kallsyms__get_function_start(const char *kallsyms_filename, 541 const char *symbol_name) 542 { 543 struct process_symbol_args args = { .name = symbol_name, }; 544 545 if (kallsyms__parse(kallsyms_filename, &args, find_symbol_cb) <= 0) 546 return 0; 547 548 return args.start; 549 } 550 551 int perf_event__synthesize_kernel_mmap(struct perf_tool *tool, 552 perf_event__handler_t process, 553 struct machine *machine) 554 { 555 size_t size; 556 const char *mmap_name; 557 char name_buff[PATH_MAX]; 558 struct map *map; 559 struct kmap *kmap; 560 int err; 561 /* 562 * We should get this from /sys/kernel/sections/.text, but till that is 563 * available use this, and after it is use this as a fallback for older 564 * kernels. 565 */ 566 union perf_event *event = zalloc((sizeof(event->mmap) + 567 machine->id_hdr_size)); 568 if (event == NULL) { 569 pr_debug("Not enough memory synthesizing mmap event " 570 "for kernel modules\n"); 571 return -1; 572 } 573 574 mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff)); 575 if (machine__is_host(machine)) { 576 /* 577 * kernel uses PERF_RECORD_MISC_USER for user space maps, 578 * see kernel/perf_event.c __perf_event_mmap 579 */ 580 event->header.misc = PERF_RECORD_MISC_KERNEL; 581 } else { 582 event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL; 583 } 584 585 map = machine->vmlinux_maps[MAP__FUNCTION]; 586 kmap = map__kmap(map); 587 size = snprintf(event->mmap.filename, sizeof(event->mmap.filename), 588 "%s%s", mmap_name, kmap->ref_reloc_sym->name) + 1; 589 size = PERF_ALIGN(size, sizeof(u64)); 590 event->mmap.header.type = PERF_RECORD_MMAP; 591 event->mmap.header.size = (sizeof(event->mmap) - 592 (sizeof(event->mmap.filename) - size) + machine->id_hdr_size); 593 event->mmap.pgoff = kmap->ref_reloc_sym->addr; 594 event->mmap.start = map->start; 595 event->mmap.len = map->end - event->mmap.start; 596 event->mmap.pid = machine->pid; 597 598 err = process(tool, event, &synth_sample, machine); 599 free(event); 600 601 return err; 602 } 603 604 size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp) 605 { 606 const char *s; 607 608 if (event->header.misc & PERF_RECORD_MISC_COMM_EXEC) 609 s = " exec"; 610 else 611 s = ""; 612 613 return fprintf(fp, "%s: %s:%d\n", s, event->comm.comm, event->comm.tid); 614 } 615 616 int perf_event__process_comm(struct perf_tool *tool __maybe_unused, 617 union perf_event *event, 618 struct perf_sample *sample, 619 struct machine *machine) 620 { 621 return machine__process_comm_event(machine, event, sample); 622 } 623 624 int perf_event__process_lost(struct perf_tool *tool __maybe_unused, 625 union perf_event *event, 626 struct perf_sample *sample, 627 struct machine *machine) 628 { 629 return machine__process_lost_event(machine, event, sample); 630 } 631 632 size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp) 633 { 634 return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 "]: %c %s\n", 635 event->mmap.pid, event->mmap.tid, event->mmap.start, 636 event->mmap.len, event->mmap.pgoff, 637 (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) ? 'r' : 'x', 638 event->mmap.filename); 639 } 640 641 size_t perf_event__fprintf_mmap2(union perf_event *event, FILE *fp) 642 { 643 return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 644 " %02x:%02x %"PRIu64" %"PRIu64"]: %c%c%c%c %s\n", 645 event->mmap2.pid, event->mmap2.tid, event->mmap2.start, 646 event->mmap2.len, event->mmap2.pgoff, event->mmap2.maj, 647 event->mmap2.min, event->mmap2.ino, 648 event->mmap2.ino_generation, 649 (event->mmap2.prot & PROT_READ) ? 'r' : '-', 650 (event->mmap2.prot & PROT_WRITE) ? 'w' : '-', 651 (event->mmap2.prot & PROT_EXEC) ? 'x' : '-', 652 (event->mmap2.flags & MAP_SHARED) ? 's' : 'p', 653 event->mmap2.filename); 654 } 655 656 int perf_event__process_mmap(struct perf_tool *tool __maybe_unused, 657 union perf_event *event, 658 struct perf_sample *sample, 659 struct machine *machine) 660 { 661 return machine__process_mmap_event(machine, event, sample); 662 } 663 664 int perf_event__process_mmap2(struct perf_tool *tool __maybe_unused, 665 union perf_event *event, 666 struct perf_sample *sample, 667 struct machine *machine) 668 { 669 return machine__process_mmap2_event(machine, event, sample); 670 } 671 672 size_t perf_event__fprintf_task(union perf_event *event, FILE *fp) 673 { 674 return fprintf(fp, "(%d:%d):(%d:%d)\n", 675 event->fork.pid, event->fork.tid, 676 event->fork.ppid, event->fork.ptid); 677 } 678 679 int perf_event__process_fork(struct perf_tool *tool __maybe_unused, 680 union perf_event *event, 681 struct perf_sample *sample, 682 struct machine *machine) 683 { 684 return machine__process_fork_event(machine, event, sample); 685 } 686 687 int perf_event__process_exit(struct perf_tool *tool __maybe_unused, 688 union perf_event *event, 689 struct perf_sample *sample, 690 struct machine *machine) 691 { 692 return machine__process_exit_event(machine, event, sample); 693 } 694 695 size_t perf_event__fprintf(union perf_event *event, FILE *fp) 696 { 697 size_t ret = fprintf(fp, "PERF_RECORD_%s", 698 perf_event__name(event->header.type)); 699 700 switch (event->header.type) { 701 case PERF_RECORD_COMM: 702 ret += perf_event__fprintf_comm(event, fp); 703 break; 704 case PERF_RECORD_FORK: 705 case PERF_RECORD_EXIT: 706 ret += perf_event__fprintf_task(event, fp); 707 break; 708 case PERF_RECORD_MMAP: 709 ret += perf_event__fprintf_mmap(event, fp); 710 break; 711 case PERF_RECORD_MMAP2: 712 ret += perf_event__fprintf_mmap2(event, fp); 713 break; 714 default: 715 ret += fprintf(fp, "\n"); 716 } 717 718 return ret; 719 } 720 721 int perf_event__process(struct perf_tool *tool __maybe_unused, 722 union perf_event *event, 723 struct perf_sample *sample, 724 struct machine *machine) 725 { 726 return machine__process_event(machine, event, sample); 727 } 728 729 void thread__find_addr_map(struct thread *thread, 730 struct machine *machine, u8 cpumode, 731 enum map_type type, u64 addr, 732 struct addr_location *al) 733 { 734 struct map_groups *mg = thread->mg; 735 bool load_map = false; 736 737 al->machine = machine; 738 al->thread = thread; 739 al->addr = addr; 740 al->cpumode = cpumode; 741 al->filtered = 0; 742 743 if (machine == NULL) { 744 al->map = NULL; 745 return; 746 } 747 748 if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) { 749 al->level = 'k'; 750 mg = &machine->kmaps; 751 load_map = true; 752 } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) { 753 al->level = '.'; 754 } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) { 755 al->level = 'g'; 756 mg = &machine->kmaps; 757 load_map = true; 758 } else if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest) { 759 al->level = 'u'; 760 } else { 761 al->level = 'H'; 762 al->map = NULL; 763 764 if ((cpumode == PERF_RECORD_MISC_GUEST_USER || 765 cpumode == PERF_RECORD_MISC_GUEST_KERNEL) && 766 !perf_guest) 767 al->filtered |= (1 << HIST_FILTER__GUEST); 768 if ((cpumode == PERF_RECORD_MISC_USER || 769 cpumode == PERF_RECORD_MISC_KERNEL) && 770 !perf_host) 771 al->filtered |= (1 << HIST_FILTER__HOST); 772 773 return; 774 } 775 try_again: 776 al->map = map_groups__find(mg, type, al->addr); 777 if (al->map == NULL) { 778 /* 779 * If this is outside of all known maps, and is a negative 780 * address, try to look it up in the kernel dso, as it might be 781 * a vsyscall or vdso (which executes in user-mode). 782 * 783 * XXX This is nasty, we should have a symbol list in the 784 * "[vdso]" dso, but for now lets use the old trick of looking 785 * in the whole kernel symbol list. 786 */ 787 if ((long long)al->addr < 0 && 788 cpumode == PERF_RECORD_MISC_USER && 789 machine && mg != &machine->kmaps) { 790 mg = &machine->kmaps; 791 load_map = true; 792 goto try_again; 793 } 794 } else { 795 /* 796 * Kernel maps might be changed when loading symbols so loading 797 * must be done prior to using kernel maps. 798 */ 799 if (load_map) 800 map__load(al->map, machine->symbol_filter); 801 al->addr = al->map->map_ip(al->map, al->addr); 802 } 803 } 804 805 void thread__find_addr_location(struct thread *thread, struct machine *machine, 806 u8 cpumode, enum map_type type, u64 addr, 807 struct addr_location *al) 808 { 809 thread__find_addr_map(thread, machine, cpumode, type, addr, al); 810 if (al->map != NULL) 811 al->sym = map__find_symbol(al->map, al->addr, 812 machine->symbol_filter); 813 else 814 al->sym = NULL; 815 } 816 817 int perf_event__preprocess_sample(const union perf_event *event, 818 struct machine *machine, 819 struct addr_location *al, 820 struct perf_sample *sample) 821 { 822 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 823 struct thread *thread = machine__findnew_thread(machine, sample->pid, 824 sample->tid); 825 826 if (thread == NULL) 827 return -1; 828 829 dump_printf(" ... thread: %s:%d\n", thread__comm_str(thread), thread->tid); 830 /* 831 * Have we already created the kernel maps for this machine? 832 * 833 * This should have happened earlier, when we processed the kernel MMAP 834 * events, but for older perf.data files there was no such thing, so do 835 * it now. 836 */ 837 if (cpumode == PERF_RECORD_MISC_KERNEL && 838 machine->vmlinux_maps[MAP__FUNCTION] == NULL) 839 machine__create_kernel_maps(machine); 840 841 thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION, 842 sample->ip, al); 843 dump_printf(" ...... dso: %s\n", 844 al->map ? al->map->dso->long_name : 845 al->level == 'H' ? "[hypervisor]" : "<not found>"); 846 847 if (thread__is_filtered(thread)) 848 al->filtered |= (1 << HIST_FILTER__THREAD); 849 850 al->sym = NULL; 851 al->cpu = sample->cpu; 852 853 if (al->map) { 854 struct dso *dso = al->map->dso; 855 856 if (symbol_conf.dso_list && 857 (!dso || !(strlist__has_entry(symbol_conf.dso_list, 858 dso->short_name) || 859 (dso->short_name != dso->long_name && 860 strlist__has_entry(symbol_conf.dso_list, 861 dso->long_name))))) { 862 al->filtered |= (1 << HIST_FILTER__DSO); 863 } 864 865 al->sym = map__find_symbol(al->map, al->addr, 866 machine->symbol_filter); 867 } 868 869 if (symbol_conf.sym_list && 870 (!al->sym || !strlist__has_entry(symbol_conf.sym_list, 871 al->sym->name))) { 872 al->filtered |= (1 << HIST_FILTER__SYMBOL); 873 } 874 875 return 0; 876 } 877 878 bool is_bts_event(struct perf_event_attr *attr) 879 { 880 return attr->type == PERF_TYPE_HARDWARE && 881 (attr->config & PERF_COUNT_HW_BRANCH_INSTRUCTIONS) && 882 attr->sample_period == 1; 883 } 884 885 bool sample_addr_correlates_sym(struct perf_event_attr *attr) 886 { 887 if (attr->type == PERF_TYPE_SOFTWARE && 888 (attr->config == PERF_COUNT_SW_PAGE_FAULTS || 889 attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN || 890 attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)) 891 return true; 892 893 if (is_bts_event(attr)) 894 return true; 895 896 return false; 897 } 898 899 void perf_event__preprocess_sample_addr(union perf_event *event, 900 struct perf_sample *sample, 901 struct machine *machine, 902 struct thread *thread, 903 struct addr_location *al) 904 { 905 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 906 907 thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION, 908 sample->addr, al); 909 if (!al->map) 910 thread__find_addr_map(thread, machine, cpumode, MAP__VARIABLE, 911 sample->addr, al); 912 913 al->cpu = sample->cpu; 914 al->sym = NULL; 915 916 if (al->map) 917 al->sym = map__find_symbol(al->map, al->addr, NULL); 918 } 919