1 #include "util.h" 2 #include <sys/types.h> 3 #include <byteswap.h> 4 #include <unistd.h> 5 #include <stdio.h> 6 #include <stdlib.h> 7 #include <linux/list.h> 8 #include <linux/kernel.h> 9 #include <linux/bitops.h> 10 #include <sys/utsname.h> 11 12 #include "evlist.h" 13 #include "evsel.h" 14 #include "header.h" 15 #include "../perf.h" 16 #include "trace-event.h" 17 #include "session.h" 18 #include "symbol.h" 19 #include "debug.h" 20 #include "cpumap.h" 21 #include "pmu.h" 22 #include "vdso.h" 23 #include "strbuf.h" 24 #include "build-id.h" 25 #include "data.h" 26 27 static bool no_buildid_cache = false; 28 29 static u32 header_argc; 30 static const char **header_argv; 31 32 /* 33 * magic2 = "PERFILE2" 34 * must be a numerical value to let the endianness 35 * determine the memory layout. That way we are able 36 * to detect endianness when reading the perf.data file 37 * back. 38 * 39 * we check for legacy (PERFFILE) format. 40 */ 41 static const char *__perf_magic1 = "PERFFILE"; 42 static const u64 __perf_magic2 = 0x32454c4946524550ULL; 43 static const u64 __perf_magic2_sw = 0x50455246494c4532ULL; 44 45 #define PERF_MAGIC __perf_magic2 46 47 struct perf_file_attr { 48 struct perf_event_attr attr; 49 struct perf_file_section ids; 50 }; 51 52 void perf_header__set_feat(struct perf_header *header, int feat) 53 { 54 set_bit(feat, header->adds_features); 55 } 56 57 void perf_header__clear_feat(struct perf_header *header, int feat) 58 { 59 clear_bit(feat, header->adds_features); 60 } 61 62 bool perf_header__has_feat(const struct perf_header *header, int feat) 63 { 64 return test_bit(feat, header->adds_features); 65 } 66 67 static int do_write(int fd, const void *buf, size_t size) 68 { 69 while (size) { 70 int ret = write(fd, buf, size); 71 72 if (ret < 0) 73 return -errno; 74 75 size -= ret; 76 buf += ret; 77 } 78 79 return 0; 80 } 81 82 #define NAME_ALIGN 64 83 84 static int write_padded(int fd, const void *bf, size_t count, 85 size_t count_aligned) 86 { 87 static const char zero_buf[NAME_ALIGN]; 88 int err = do_write(fd, bf, count); 89 90 if (!err) 91 err = do_write(fd, zero_buf, count_aligned - count); 92 93 return err; 94 } 95 96 static int do_write_string(int fd, const char *str) 97 { 98 u32 len, olen; 99 int ret; 100 101 olen = strlen(str) + 1; 102 len = PERF_ALIGN(olen, NAME_ALIGN); 103 104 /* write len, incl. \0 */ 105 ret = do_write(fd, &len, sizeof(len)); 106 if (ret < 0) 107 return ret; 108 109 return write_padded(fd, str, olen, len); 110 } 111 112 static char *do_read_string(int fd, struct perf_header *ph) 113 { 114 ssize_t sz, ret; 115 u32 len; 116 char *buf; 117 118 sz = readn(fd, &len, sizeof(len)); 119 if (sz < (ssize_t)sizeof(len)) 120 return NULL; 121 122 if (ph->needs_swap) 123 len = bswap_32(len); 124 125 buf = malloc(len); 126 if (!buf) 127 return NULL; 128 129 ret = readn(fd, buf, len); 130 if (ret == (ssize_t)len) { 131 /* 132 * strings are padded by zeroes 133 * thus the actual strlen of buf 134 * may be less than len 135 */ 136 return buf; 137 } 138 139 free(buf); 140 return NULL; 141 } 142 143 int 144 perf_header__set_cmdline(int argc, const char **argv) 145 { 146 int i; 147 148 /* 149 * If header_argv has already been set, do not override it. 150 * This allows a command to set the cmdline, parse args and 151 * then call another builtin function that implements a 152 * command -- e.g, cmd_kvm calling cmd_record. 153 */ 154 if (header_argv) 155 return 0; 156 157 header_argc = (u32)argc; 158 159 /* do not include NULL termination */ 160 header_argv = calloc(argc, sizeof(char *)); 161 if (!header_argv) 162 return -ENOMEM; 163 164 /* 165 * must copy argv contents because it gets moved 166 * around during option parsing 167 */ 168 for (i = 0; i < argc ; i++) 169 header_argv[i] = argv[i]; 170 171 return 0; 172 } 173 174 #define dsos__for_each_with_build_id(pos, head) \ 175 list_for_each_entry(pos, head, node) \ 176 if (!pos->has_build_id) \ 177 continue; \ 178 else 179 180 static int write_buildid(const char *name, size_t name_len, u8 *build_id, 181 pid_t pid, u16 misc, int fd) 182 { 183 int err; 184 struct build_id_event b; 185 size_t len; 186 187 len = name_len + 1; 188 len = PERF_ALIGN(len, NAME_ALIGN); 189 190 memset(&b, 0, sizeof(b)); 191 memcpy(&b.build_id, build_id, BUILD_ID_SIZE); 192 b.pid = pid; 193 b.header.misc = misc; 194 b.header.size = sizeof(b) + len; 195 196 err = do_write(fd, &b, sizeof(b)); 197 if (err < 0) 198 return err; 199 200 return write_padded(fd, name, name_len + 1, len); 201 } 202 203 static int __dsos__write_buildid_table(struct list_head *head, 204 struct machine *machine, 205 pid_t pid, u16 misc, int fd) 206 { 207 char nm[PATH_MAX]; 208 struct dso *pos; 209 210 dsos__for_each_with_build_id(pos, head) { 211 int err; 212 const char *name; 213 size_t name_len; 214 215 if (!pos->hit) 216 continue; 217 218 if (is_vdso_map(pos->short_name)) { 219 name = (char *) VDSO__MAP_NAME; 220 name_len = sizeof(VDSO__MAP_NAME) + 1; 221 } else if (dso__is_kcore(pos)) { 222 machine__mmap_name(machine, nm, sizeof(nm)); 223 name = nm; 224 name_len = strlen(nm) + 1; 225 } else { 226 name = pos->long_name; 227 name_len = pos->long_name_len + 1; 228 } 229 230 err = write_buildid(name, name_len, pos->build_id, 231 pid, misc, fd); 232 if (err) 233 return err; 234 } 235 236 return 0; 237 } 238 239 static int machine__write_buildid_table(struct machine *machine, int fd) 240 { 241 int err; 242 u16 kmisc = PERF_RECORD_MISC_KERNEL, 243 umisc = PERF_RECORD_MISC_USER; 244 245 if (!machine__is_host(machine)) { 246 kmisc = PERF_RECORD_MISC_GUEST_KERNEL; 247 umisc = PERF_RECORD_MISC_GUEST_USER; 248 } 249 250 err = __dsos__write_buildid_table(&machine->kernel_dsos, machine, 251 machine->pid, kmisc, fd); 252 if (err == 0) 253 err = __dsos__write_buildid_table(&machine->user_dsos, machine, 254 machine->pid, umisc, fd); 255 return err; 256 } 257 258 static int dsos__write_buildid_table(struct perf_header *header, int fd) 259 { 260 struct perf_session *session = container_of(header, 261 struct perf_session, header); 262 struct rb_node *nd; 263 int err = machine__write_buildid_table(&session->machines.host, fd); 264 265 if (err) 266 return err; 267 268 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 269 struct machine *pos = rb_entry(nd, struct machine, rb_node); 270 err = machine__write_buildid_table(pos, fd); 271 if (err) 272 break; 273 } 274 return err; 275 } 276 277 int build_id_cache__add_s(const char *sbuild_id, const char *debugdir, 278 const char *name, bool is_kallsyms, bool is_vdso) 279 { 280 const size_t size = PATH_MAX; 281 char *realname, *filename = zalloc(size), 282 *linkname = zalloc(size), *targetname; 283 int len, err = -1; 284 bool slash = is_kallsyms || is_vdso; 285 286 if (is_kallsyms) { 287 if (symbol_conf.kptr_restrict) { 288 pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n"); 289 err = 0; 290 goto out_free; 291 } 292 realname = (char *) name; 293 } else 294 realname = realpath(name, NULL); 295 296 if (realname == NULL || filename == NULL || linkname == NULL) 297 goto out_free; 298 299 len = scnprintf(filename, size, "%s%s%s", 300 debugdir, slash ? "/" : "", 301 is_vdso ? VDSO__MAP_NAME : realname); 302 if (mkdir_p(filename, 0755)) 303 goto out_free; 304 305 snprintf(filename + len, size - len, "/%s", sbuild_id); 306 307 if (access(filename, F_OK)) { 308 if (is_kallsyms) { 309 if (copyfile("/proc/kallsyms", filename)) 310 goto out_free; 311 } else if (link(realname, filename) && copyfile(name, filename)) 312 goto out_free; 313 } 314 315 len = scnprintf(linkname, size, "%s/.build-id/%.2s", 316 debugdir, sbuild_id); 317 318 if (access(linkname, X_OK) && mkdir_p(linkname, 0755)) 319 goto out_free; 320 321 snprintf(linkname + len, size - len, "/%s", sbuild_id + 2); 322 targetname = filename + strlen(debugdir) - 5; 323 memcpy(targetname, "../..", 5); 324 325 if (symlink(targetname, linkname) == 0) 326 err = 0; 327 out_free: 328 if (!is_kallsyms) 329 free(realname); 330 free(filename); 331 free(linkname); 332 return err; 333 } 334 335 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size, 336 const char *name, const char *debugdir, 337 bool is_kallsyms, bool is_vdso) 338 { 339 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 340 341 build_id__sprintf(build_id, build_id_size, sbuild_id); 342 343 return build_id_cache__add_s(sbuild_id, debugdir, name, 344 is_kallsyms, is_vdso); 345 } 346 347 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir) 348 { 349 const size_t size = PATH_MAX; 350 char *filename = zalloc(size), 351 *linkname = zalloc(size); 352 int err = -1; 353 354 if (filename == NULL || linkname == NULL) 355 goto out_free; 356 357 snprintf(linkname, size, "%s/.build-id/%.2s/%s", 358 debugdir, sbuild_id, sbuild_id + 2); 359 360 if (access(linkname, F_OK)) 361 goto out_free; 362 363 if (readlink(linkname, filename, size - 1) < 0) 364 goto out_free; 365 366 if (unlink(linkname)) 367 goto out_free; 368 369 /* 370 * Since the link is relative, we must make it absolute: 371 */ 372 snprintf(linkname, size, "%s/.build-id/%.2s/%s", 373 debugdir, sbuild_id, filename); 374 375 if (unlink(linkname)) 376 goto out_free; 377 378 err = 0; 379 out_free: 380 free(filename); 381 free(linkname); 382 return err; 383 } 384 385 static int dso__cache_build_id(struct dso *dso, struct machine *machine, 386 const char *debugdir) 387 { 388 bool is_kallsyms = dso->kernel && dso->long_name[0] != '/'; 389 bool is_vdso = is_vdso_map(dso->short_name); 390 const char *name = dso->long_name; 391 char nm[PATH_MAX]; 392 393 if (dso__is_kcore(dso)) { 394 is_kallsyms = true; 395 machine__mmap_name(machine, nm, sizeof(nm)); 396 name = nm; 397 } 398 return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id), name, 399 debugdir, is_kallsyms, is_vdso); 400 } 401 402 static int __dsos__cache_build_ids(struct list_head *head, 403 struct machine *machine, const char *debugdir) 404 { 405 struct dso *pos; 406 int err = 0; 407 408 dsos__for_each_with_build_id(pos, head) 409 if (dso__cache_build_id(pos, machine, debugdir)) 410 err = -1; 411 412 return err; 413 } 414 415 static int machine__cache_build_ids(struct machine *machine, const char *debugdir) 416 { 417 int ret = __dsos__cache_build_ids(&machine->kernel_dsos, machine, 418 debugdir); 419 ret |= __dsos__cache_build_ids(&machine->user_dsos, machine, debugdir); 420 return ret; 421 } 422 423 static int perf_session__cache_build_ids(struct perf_session *session) 424 { 425 struct rb_node *nd; 426 int ret; 427 char debugdir[PATH_MAX]; 428 429 snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir); 430 431 if (mkdir(debugdir, 0755) != 0 && errno != EEXIST) 432 return -1; 433 434 ret = machine__cache_build_ids(&session->machines.host, debugdir); 435 436 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 437 struct machine *pos = rb_entry(nd, struct machine, rb_node); 438 ret |= machine__cache_build_ids(pos, debugdir); 439 } 440 return ret ? -1 : 0; 441 } 442 443 static bool machine__read_build_ids(struct machine *machine, bool with_hits) 444 { 445 bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits); 446 ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits); 447 return ret; 448 } 449 450 static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits) 451 { 452 struct rb_node *nd; 453 bool ret = machine__read_build_ids(&session->machines.host, with_hits); 454 455 for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) { 456 struct machine *pos = rb_entry(nd, struct machine, rb_node); 457 ret |= machine__read_build_ids(pos, with_hits); 458 } 459 460 return ret; 461 } 462 463 static int write_tracing_data(int fd, struct perf_header *h __maybe_unused, 464 struct perf_evlist *evlist) 465 { 466 return read_tracing_data(fd, &evlist->entries); 467 } 468 469 470 static int write_build_id(int fd, struct perf_header *h, 471 struct perf_evlist *evlist __maybe_unused) 472 { 473 struct perf_session *session; 474 int err; 475 476 session = container_of(h, struct perf_session, header); 477 478 if (!perf_session__read_build_ids(session, true)) 479 return -1; 480 481 err = dsos__write_buildid_table(h, fd); 482 if (err < 0) { 483 pr_debug("failed to write buildid table\n"); 484 return err; 485 } 486 if (!no_buildid_cache) 487 perf_session__cache_build_ids(session); 488 489 return 0; 490 } 491 492 static int write_hostname(int fd, struct perf_header *h __maybe_unused, 493 struct perf_evlist *evlist __maybe_unused) 494 { 495 struct utsname uts; 496 int ret; 497 498 ret = uname(&uts); 499 if (ret < 0) 500 return -1; 501 502 return do_write_string(fd, uts.nodename); 503 } 504 505 static int write_osrelease(int fd, struct perf_header *h __maybe_unused, 506 struct perf_evlist *evlist __maybe_unused) 507 { 508 struct utsname uts; 509 int ret; 510 511 ret = uname(&uts); 512 if (ret < 0) 513 return -1; 514 515 return do_write_string(fd, uts.release); 516 } 517 518 static int write_arch(int fd, struct perf_header *h __maybe_unused, 519 struct perf_evlist *evlist __maybe_unused) 520 { 521 struct utsname uts; 522 int ret; 523 524 ret = uname(&uts); 525 if (ret < 0) 526 return -1; 527 528 return do_write_string(fd, uts.machine); 529 } 530 531 static int write_version(int fd, struct perf_header *h __maybe_unused, 532 struct perf_evlist *evlist __maybe_unused) 533 { 534 return do_write_string(fd, perf_version_string); 535 } 536 537 static int write_cpudesc(int fd, struct perf_header *h __maybe_unused, 538 struct perf_evlist *evlist __maybe_unused) 539 { 540 #ifndef CPUINFO_PROC 541 #define CPUINFO_PROC NULL 542 #endif 543 FILE *file; 544 char *buf = NULL; 545 char *s, *p; 546 const char *search = CPUINFO_PROC; 547 size_t len = 0; 548 int ret = -1; 549 550 if (!search) 551 return -1; 552 553 file = fopen("/proc/cpuinfo", "r"); 554 if (!file) 555 return -1; 556 557 while (getline(&buf, &len, file) > 0) { 558 ret = strncmp(buf, search, strlen(search)); 559 if (!ret) 560 break; 561 } 562 563 if (ret) 564 goto done; 565 566 s = buf; 567 568 p = strchr(buf, ':'); 569 if (p && *(p+1) == ' ' && *(p+2)) 570 s = p + 2; 571 p = strchr(s, '\n'); 572 if (p) 573 *p = '\0'; 574 575 /* squash extra space characters (branding string) */ 576 p = s; 577 while (*p) { 578 if (isspace(*p)) { 579 char *r = p + 1; 580 char *q = r; 581 *p = ' '; 582 while (*q && isspace(*q)) 583 q++; 584 if (q != (p+1)) 585 while ((*r++ = *q++)); 586 } 587 p++; 588 } 589 ret = do_write_string(fd, s); 590 done: 591 free(buf); 592 fclose(file); 593 return ret; 594 } 595 596 static int write_nrcpus(int fd, struct perf_header *h __maybe_unused, 597 struct perf_evlist *evlist __maybe_unused) 598 { 599 long nr; 600 u32 nrc, nra; 601 int ret; 602 603 nr = sysconf(_SC_NPROCESSORS_CONF); 604 if (nr < 0) 605 return -1; 606 607 nrc = (u32)(nr & UINT_MAX); 608 609 nr = sysconf(_SC_NPROCESSORS_ONLN); 610 if (nr < 0) 611 return -1; 612 613 nra = (u32)(nr & UINT_MAX); 614 615 ret = do_write(fd, &nrc, sizeof(nrc)); 616 if (ret < 0) 617 return ret; 618 619 return do_write(fd, &nra, sizeof(nra)); 620 } 621 622 static int write_event_desc(int fd, struct perf_header *h __maybe_unused, 623 struct perf_evlist *evlist) 624 { 625 struct perf_evsel *evsel; 626 u32 nre, nri, sz; 627 int ret; 628 629 nre = evlist->nr_entries; 630 631 /* 632 * write number of events 633 */ 634 ret = do_write(fd, &nre, sizeof(nre)); 635 if (ret < 0) 636 return ret; 637 638 /* 639 * size of perf_event_attr struct 640 */ 641 sz = (u32)sizeof(evsel->attr); 642 ret = do_write(fd, &sz, sizeof(sz)); 643 if (ret < 0) 644 return ret; 645 646 evlist__for_each(evlist, evsel) { 647 ret = do_write(fd, &evsel->attr, sz); 648 if (ret < 0) 649 return ret; 650 /* 651 * write number of unique id per event 652 * there is one id per instance of an event 653 * 654 * copy into an nri to be independent of the 655 * type of ids, 656 */ 657 nri = evsel->ids; 658 ret = do_write(fd, &nri, sizeof(nri)); 659 if (ret < 0) 660 return ret; 661 662 /* 663 * write event string as passed on cmdline 664 */ 665 ret = do_write_string(fd, perf_evsel__name(evsel)); 666 if (ret < 0) 667 return ret; 668 /* 669 * write unique ids for this event 670 */ 671 ret = do_write(fd, evsel->id, evsel->ids * sizeof(u64)); 672 if (ret < 0) 673 return ret; 674 } 675 return 0; 676 } 677 678 static int write_cmdline(int fd, struct perf_header *h __maybe_unused, 679 struct perf_evlist *evlist __maybe_unused) 680 { 681 char buf[MAXPATHLEN]; 682 char proc[32]; 683 u32 i, n; 684 int ret; 685 686 /* 687 * actual atual path to perf binary 688 */ 689 sprintf(proc, "/proc/%d/exe", getpid()); 690 ret = readlink(proc, buf, sizeof(buf)); 691 if (ret <= 0) 692 return -1; 693 694 /* readlink() does not add null termination */ 695 buf[ret] = '\0'; 696 697 /* account for binary path */ 698 n = header_argc + 1; 699 700 ret = do_write(fd, &n, sizeof(n)); 701 if (ret < 0) 702 return ret; 703 704 ret = do_write_string(fd, buf); 705 if (ret < 0) 706 return ret; 707 708 for (i = 0 ; i < header_argc; i++) { 709 ret = do_write_string(fd, header_argv[i]); 710 if (ret < 0) 711 return ret; 712 } 713 return 0; 714 } 715 716 #define CORE_SIB_FMT \ 717 "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list" 718 #define THRD_SIB_FMT \ 719 "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list" 720 721 struct cpu_topo { 722 u32 core_sib; 723 u32 thread_sib; 724 char **core_siblings; 725 char **thread_siblings; 726 }; 727 728 static int build_cpu_topo(struct cpu_topo *tp, int cpu) 729 { 730 FILE *fp; 731 char filename[MAXPATHLEN]; 732 char *buf = NULL, *p; 733 size_t len = 0; 734 ssize_t sret; 735 u32 i = 0; 736 int ret = -1; 737 738 sprintf(filename, CORE_SIB_FMT, cpu); 739 fp = fopen(filename, "r"); 740 if (!fp) 741 goto try_threads; 742 743 sret = getline(&buf, &len, fp); 744 fclose(fp); 745 if (sret <= 0) 746 goto try_threads; 747 748 p = strchr(buf, '\n'); 749 if (p) 750 *p = '\0'; 751 752 for (i = 0; i < tp->core_sib; i++) { 753 if (!strcmp(buf, tp->core_siblings[i])) 754 break; 755 } 756 if (i == tp->core_sib) { 757 tp->core_siblings[i] = buf; 758 tp->core_sib++; 759 buf = NULL; 760 len = 0; 761 } 762 ret = 0; 763 764 try_threads: 765 sprintf(filename, THRD_SIB_FMT, cpu); 766 fp = fopen(filename, "r"); 767 if (!fp) 768 goto done; 769 770 if (getline(&buf, &len, fp) <= 0) 771 goto done; 772 773 p = strchr(buf, '\n'); 774 if (p) 775 *p = '\0'; 776 777 for (i = 0; i < tp->thread_sib; i++) { 778 if (!strcmp(buf, tp->thread_siblings[i])) 779 break; 780 } 781 if (i == tp->thread_sib) { 782 tp->thread_siblings[i] = buf; 783 tp->thread_sib++; 784 buf = NULL; 785 } 786 ret = 0; 787 done: 788 if(fp) 789 fclose(fp); 790 free(buf); 791 return ret; 792 } 793 794 static void free_cpu_topo(struct cpu_topo *tp) 795 { 796 u32 i; 797 798 if (!tp) 799 return; 800 801 for (i = 0 ; i < tp->core_sib; i++) 802 zfree(&tp->core_siblings[i]); 803 804 for (i = 0 ; i < tp->thread_sib; i++) 805 zfree(&tp->thread_siblings[i]); 806 807 free(tp); 808 } 809 810 static struct cpu_topo *build_cpu_topology(void) 811 { 812 struct cpu_topo *tp; 813 void *addr; 814 u32 nr, i; 815 size_t sz; 816 long ncpus; 817 int ret = -1; 818 819 ncpus = sysconf(_SC_NPROCESSORS_CONF); 820 if (ncpus < 0) 821 return NULL; 822 823 nr = (u32)(ncpus & UINT_MAX); 824 825 sz = nr * sizeof(char *); 826 827 addr = calloc(1, sizeof(*tp) + 2 * sz); 828 if (!addr) 829 return NULL; 830 831 tp = addr; 832 833 addr += sizeof(*tp); 834 tp->core_siblings = addr; 835 addr += sz; 836 tp->thread_siblings = addr; 837 838 for (i = 0; i < nr; i++) { 839 ret = build_cpu_topo(tp, i); 840 if (ret < 0) 841 break; 842 } 843 if (ret) { 844 free_cpu_topo(tp); 845 tp = NULL; 846 } 847 return tp; 848 } 849 850 static int write_cpu_topology(int fd, struct perf_header *h __maybe_unused, 851 struct perf_evlist *evlist __maybe_unused) 852 { 853 struct cpu_topo *tp; 854 u32 i; 855 int ret; 856 857 tp = build_cpu_topology(); 858 if (!tp) 859 return -1; 860 861 ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib)); 862 if (ret < 0) 863 goto done; 864 865 for (i = 0; i < tp->core_sib; i++) { 866 ret = do_write_string(fd, tp->core_siblings[i]); 867 if (ret < 0) 868 goto done; 869 } 870 ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib)); 871 if (ret < 0) 872 goto done; 873 874 for (i = 0; i < tp->thread_sib; i++) { 875 ret = do_write_string(fd, tp->thread_siblings[i]); 876 if (ret < 0) 877 break; 878 } 879 done: 880 free_cpu_topo(tp); 881 return ret; 882 } 883 884 885 886 static int write_total_mem(int fd, struct perf_header *h __maybe_unused, 887 struct perf_evlist *evlist __maybe_unused) 888 { 889 char *buf = NULL; 890 FILE *fp; 891 size_t len = 0; 892 int ret = -1, n; 893 uint64_t mem; 894 895 fp = fopen("/proc/meminfo", "r"); 896 if (!fp) 897 return -1; 898 899 while (getline(&buf, &len, fp) > 0) { 900 ret = strncmp(buf, "MemTotal:", 9); 901 if (!ret) 902 break; 903 } 904 if (!ret) { 905 n = sscanf(buf, "%*s %"PRIu64, &mem); 906 if (n == 1) 907 ret = do_write(fd, &mem, sizeof(mem)); 908 } 909 free(buf); 910 fclose(fp); 911 return ret; 912 } 913 914 static int write_topo_node(int fd, int node) 915 { 916 char str[MAXPATHLEN]; 917 char field[32]; 918 char *buf = NULL, *p; 919 size_t len = 0; 920 FILE *fp; 921 u64 mem_total, mem_free, mem; 922 int ret = -1; 923 924 sprintf(str, "/sys/devices/system/node/node%d/meminfo", node); 925 fp = fopen(str, "r"); 926 if (!fp) 927 return -1; 928 929 while (getline(&buf, &len, fp) > 0) { 930 /* skip over invalid lines */ 931 if (!strchr(buf, ':')) 932 continue; 933 if (sscanf(buf, "%*s %*d %31s %"PRIu64, field, &mem) != 2) 934 goto done; 935 if (!strcmp(field, "MemTotal:")) 936 mem_total = mem; 937 if (!strcmp(field, "MemFree:")) 938 mem_free = mem; 939 } 940 941 fclose(fp); 942 fp = NULL; 943 944 ret = do_write(fd, &mem_total, sizeof(u64)); 945 if (ret) 946 goto done; 947 948 ret = do_write(fd, &mem_free, sizeof(u64)); 949 if (ret) 950 goto done; 951 952 ret = -1; 953 sprintf(str, "/sys/devices/system/node/node%d/cpulist", node); 954 955 fp = fopen(str, "r"); 956 if (!fp) 957 goto done; 958 959 if (getline(&buf, &len, fp) <= 0) 960 goto done; 961 962 p = strchr(buf, '\n'); 963 if (p) 964 *p = '\0'; 965 966 ret = do_write_string(fd, buf); 967 done: 968 free(buf); 969 if (fp) 970 fclose(fp); 971 return ret; 972 } 973 974 static int write_numa_topology(int fd, struct perf_header *h __maybe_unused, 975 struct perf_evlist *evlist __maybe_unused) 976 { 977 char *buf = NULL; 978 size_t len = 0; 979 FILE *fp; 980 struct cpu_map *node_map = NULL; 981 char *c; 982 u32 nr, i, j; 983 int ret = -1; 984 985 fp = fopen("/sys/devices/system/node/online", "r"); 986 if (!fp) 987 return -1; 988 989 if (getline(&buf, &len, fp) <= 0) 990 goto done; 991 992 c = strchr(buf, '\n'); 993 if (c) 994 *c = '\0'; 995 996 node_map = cpu_map__new(buf); 997 if (!node_map) 998 goto done; 999 1000 nr = (u32)node_map->nr; 1001 1002 ret = do_write(fd, &nr, sizeof(nr)); 1003 if (ret < 0) 1004 goto done; 1005 1006 for (i = 0; i < nr; i++) { 1007 j = (u32)node_map->map[i]; 1008 ret = do_write(fd, &j, sizeof(j)); 1009 if (ret < 0) 1010 break; 1011 1012 ret = write_topo_node(fd, i); 1013 if (ret < 0) 1014 break; 1015 } 1016 done: 1017 free(buf); 1018 fclose(fp); 1019 free(node_map); 1020 return ret; 1021 } 1022 1023 /* 1024 * File format: 1025 * 1026 * struct pmu_mappings { 1027 * u32 pmu_num; 1028 * struct pmu_map { 1029 * u32 type; 1030 * char name[]; 1031 * }[pmu_num]; 1032 * }; 1033 */ 1034 1035 static int write_pmu_mappings(int fd, struct perf_header *h __maybe_unused, 1036 struct perf_evlist *evlist __maybe_unused) 1037 { 1038 struct perf_pmu *pmu = NULL; 1039 off_t offset = lseek(fd, 0, SEEK_CUR); 1040 __u32 pmu_num = 0; 1041 int ret; 1042 1043 /* write real pmu_num later */ 1044 ret = do_write(fd, &pmu_num, sizeof(pmu_num)); 1045 if (ret < 0) 1046 return ret; 1047 1048 while ((pmu = perf_pmu__scan(pmu))) { 1049 if (!pmu->name) 1050 continue; 1051 pmu_num++; 1052 1053 ret = do_write(fd, &pmu->type, sizeof(pmu->type)); 1054 if (ret < 0) 1055 return ret; 1056 1057 ret = do_write_string(fd, pmu->name); 1058 if (ret < 0) 1059 return ret; 1060 } 1061 1062 if (pwrite(fd, &pmu_num, sizeof(pmu_num), offset) != sizeof(pmu_num)) { 1063 /* discard all */ 1064 lseek(fd, offset, SEEK_SET); 1065 return -1; 1066 } 1067 1068 return 0; 1069 } 1070 1071 /* 1072 * File format: 1073 * 1074 * struct group_descs { 1075 * u32 nr_groups; 1076 * struct group_desc { 1077 * char name[]; 1078 * u32 leader_idx; 1079 * u32 nr_members; 1080 * }[nr_groups]; 1081 * }; 1082 */ 1083 static int write_group_desc(int fd, struct perf_header *h __maybe_unused, 1084 struct perf_evlist *evlist) 1085 { 1086 u32 nr_groups = evlist->nr_groups; 1087 struct perf_evsel *evsel; 1088 int ret; 1089 1090 ret = do_write(fd, &nr_groups, sizeof(nr_groups)); 1091 if (ret < 0) 1092 return ret; 1093 1094 evlist__for_each(evlist, evsel) { 1095 if (perf_evsel__is_group_leader(evsel) && 1096 evsel->nr_members > 1) { 1097 const char *name = evsel->group_name ?: "{anon_group}"; 1098 u32 leader_idx = evsel->idx; 1099 u32 nr_members = evsel->nr_members; 1100 1101 ret = do_write_string(fd, name); 1102 if (ret < 0) 1103 return ret; 1104 1105 ret = do_write(fd, &leader_idx, sizeof(leader_idx)); 1106 if (ret < 0) 1107 return ret; 1108 1109 ret = do_write(fd, &nr_members, sizeof(nr_members)); 1110 if (ret < 0) 1111 return ret; 1112 } 1113 } 1114 return 0; 1115 } 1116 1117 /* 1118 * default get_cpuid(): nothing gets recorded 1119 * actual implementation must be in arch/$(ARCH)/util/header.c 1120 */ 1121 int __attribute__ ((weak)) get_cpuid(char *buffer __maybe_unused, 1122 size_t sz __maybe_unused) 1123 { 1124 return -1; 1125 } 1126 1127 static int write_cpuid(int fd, struct perf_header *h __maybe_unused, 1128 struct perf_evlist *evlist __maybe_unused) 1129 { 1130 char buffer[64]; 1131 int ret; 1132 1133 ret = get_cpuid(buffer, sizeof(buffer)); 1134 if (!ret) 1135 goto write_it; 1136 1137 return -1; 1138 write_it: 1139 return do_write_string(fd, buffer); 1140 } 1141 1142 static int write_branch_stack(int fd __maybe_unused, 1143 struct perf_header *h __maybe_unused, 1144 struct perf_evlist *evlist __maybe_unused) 1145 { 1146 return 0; 1147 } 1148 1149 static void print_hostname(struct perf_header *ph, int fd __maybe_unused, 1150 FILE *fp) 1151 { 1152 fprintf(fp, "# hostname : %s\n", ph->env.hostname); 1153 } 1154 1155 static void print_osrelease(struct perf_header *ph, int fd __maybe_unused, 1156 FILE *fp) 1157 { 1158 fprintf(fp, "# os release : %s\n", ph->env.os_release); 1159 } 1160 1161 static void print_arch(struct perf_header *ph, int fd __maybe_unused, FILE *fp) 1162 { 1163 fprintf(fp, "# arch : %s\n", ph->env.arch); 1164 } 1165 1166 static void print_cpudesc(struct perf_header *ph, int fd __maybe_unused, 1167 FILE *fp) 1168 { 1169 fprintf(fp, "# cpudesc : %s\n", ph->env.cpu_desc); 1170 } 1171 1172 static void print_nrcpus(struct perf_header *ph, int fd __maybe_unused, 1173 FILE *fp) 1174 { 1175 fprintf(fp, "# nrcpus online : %u\n", ph->env.nr_cpus_online); 1176 fprintf(fp, "# nrcpus avail : %u\n", ph->env.nr_cpus_avail); 1177 } 1178 1179 static void print_version(struct perf_header *ph, int fd __maybe_unused, 1180 FILE *fp) 1181 { 1182 fprintf(fp, "# perf version : %s\n", ph->env.version); 1183 } 1184 1185 static void print_cmdline(struct perf_header *ph, int fd __maybe_unused, 1186 FILE *fp) 1187 { 1188 int nr, i; 1189 char *str; 1190 1191 nr = ph->env.nr_cmdline; 1192 str = ph->env.cmdline; 1193 1194 fprintf(fp, "# cmdline : "); 1195 1196 for (i = 0; i < nr; i++) { 1197 fprintf(fp, "%s ", str); 1198 str += strlen(str) + 1; 1199 } 1200 fputc('\n', fp); 1201 } 1202 1203 static void print_cpu_topology(struct perf_header *ph, int fd __maybe_unused, 1204 FILE *fp) 1205 { 1206 int nr, i; 1207 char *str; 1208 1209 nr = ph->env.nr_sibling_cores; 1210 str = ph->env.sibling_cores; 1211 1212 for (i = 0; i < nr; i++) { 1213 fprintf(fp, "# sibling cores : %s\n", str); 1214 str += strlen(str) + 1; 1215 } 1216 1217 nr = ph->env.nr_sibling_threads; 1218 str = ph->env.sibling_threads; 1219 1220 for (i = 0; i < nr; i++) { 1221 fprintf(fp, "# sibling threads : %s\n", str); 1222 str += strlen(str) + 1; 1223 } 1224 } 1225 1226 static void free_event_desc(struct perf_evsel *events) 1227 { 1228 struct perf_evsel *evsel; 1229 1230 if (!events) 1231 return; 1232 1233 for (evsel = events; evsel->attr.size; evsel++) { 1234 zfree(&evsel->name); 1235 zfree(&evsel->id); 1236 } 1237 1238 free(events); 1239 } 1240 1241 static struct perf_evsel * 1242 read_event_desc(struct perf_header *ph, int fd) 1243 { 1244 struct perf_evsel *evsel, *events = NULL; 1245 u64 *id; 1246 void *buf = NULL; 1247 u32 nre, sz, nr, i, j; 1248 ssize_t ret; 1249 size_t msz; 1250 1251 /* number of events */ 1252 ret = readn(fd, &nre, sizeof(nre)); 1253 if (ret != (ssize_t)sizeof(nre)) 1254 goto error; 1255 1256 if (ph->needs_swap) 1257 nre = bswap_32(nre); 1258 1259 ret = readn(fd, &sz, sizeof(sz)); 1260 if (ret != (ssize_t)sizeof(sz)) 1261 goto error; 1262 1263 if (ph->needs_swap) 1264 sz = bswap_32(sz); 1265 1266 /* buffer to hold on file attr struct */ 1267 buf = malloc(sz); 1268 if (!buf) 1269 goto error; 1270 1271 /* the last event terminates with evsel->attr.size == 0: */ 1272 events = calloc(nre + 1, sizeof(*events)); 1273 if (!events) 1274 goto error; 1275 1276 msz = sizeof(evsel->attr); 1277 if (sz < msz) 1278 msz = sz; 1279 1280 for (i = 0, evsel = events; i < nre; evsel++, i++) { 1281 evsel->idx = i; 1282 1283 /* 1284 * must read entire on-file attr struct to 1285 * sync up with layout. 1286 */ 1287 ret = readn(fd, buf, sz); 1288 if (ret != (ssize_t)sz) 1289 goto error; 1290 1291 if (ph->needs_swap) 1292 perf_event__attr_swap(buf); 1293 1294 memcpy(&evsel->attr, buf, msz); 1295 1296 ret = readn(fd, &nr, sizeof(nr)); 1297 if (ret != (ssize_t)sizeof(nr)) 1298 goto error; 1299 1300 if (ph->needs_swap) { 1301 nr = bswap_32(nr); 1302 evsel->needs_swap = true; 1303 } 1304 1305 evsel->name = do_read_string(fd, ph); 1306 1307 if (!nr) 1308 continue; 1309 1310 id = calloc(nr, sizeof(*id)); 1311 if (!id) 1312 goto error; 1313 evsel->ids = nr; 1314 evsel->id = id; 1315 1316 for (j = 0 ; j < nr; j++) { 1317 ret = readn(fd, id, sizeof(*id)); 1318 if (ret != (ssize_t)sizeof(*id)) 1319 goto error; 1320 if (ph->needs_swap) 1321 *id = bswap_64(*id); 1322 id++; 1323 } 1324 } 1325 out: 1326 free(buf); 1327 return events; 1328 error: 1329 if (events) 1330 free_event_desc(events); 1331 events = NULL; 1332 goto out; 1333 } 1334 1335 static void print_event_desc(struct perf_header *ph, int fd, FILE *fp) 1336 { 1337 struct perf_evsel *evsel, *events = read_event_desc(ph, fd); 1338 u32 j; 1339 u64 *id; 1340 1341 if (!events) { 1342 fprintf(fp, "# event desc: not available or unable to read\n"); 1343 return; 1344 } 1345 1346 for (evsel = events; evsel->attr.size; evsel++) { 1347 fprintf(fp, "# event : name = %s, ", evsel->name); 1348 1349 fprintf(fp, "type = %d, config = 0x%"PRIx64 1350 ", config1 = 0x%"PRIx64", config2 = 0x%"PRIx64, 1351 evsel->attr.type, 1352 (u64)evsel->attr.config, 1353 (u64)evsel->attr.config1, 1354 (u64)evsel->attr.config2); 1355 1356 fprintf(fp, ", excl_usr = %d, excl_kern = %d", 1357 evsel->attr.exclude_user, 1358 evsel->attr.exclude_kernel); 1359 1360 fprintf(fp, ", excl_host = %d, excl_guest = %d", 1361 evsel->attr.exclude_host, 1362 evsel->attr.exclude_guest); 1363 1364 fprintf(fp, ", precise_ip = %d", evsel->attr.precise_ip); 1365 1366 fprintf(fp, ", attr_mmap2 = %d", evsel->attr.mmap2); 1367 fprintf(fp, ", attr_mmap = %d", evsel->attr.mmap); 1368 fprintf(fp, ", attr_mmap_data = %d", evsel->attr.mmap_data); 1369 if (evsel->ids) { 1370 fprintf(fp, ", id = {"); 1371 for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) { 1372 if (j) 1373 fputc(',', fp); 1374 fprintf(fp, " %"PRIu64, *id); 1375 } 1376 fprintf(fp, " }"); 1377 } 1378 1379 fputc('\n', fp); 1380 } 1381 1382 free_event_desc(events); 1383 } 1384 1385 static void print_total_mem(struct perf_header *ph, int fd __maybe_unused, 1386 FILE *fp) 1387 { 1388 fprintf(fp, "# total memory : %Lu kB\n", ph->env.total_mem); 1389 } 1390 1391 static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused, 1392 FILE *fp) 1393 { 1394 u32 nr, c, i; 1395 char *str, *tmp; 1396 uint64_t mem_total, mem_free; 1397 1398 /* nr nodes */ 1399 nr = ph->env.nr_numa_nodes; 1400 str = ph->env.numa_nodes; 1401 1402 for (i = 0; i < nr; i++) { 1403 /* node number */ 1404 c = strtoul(str, &tmp, 0); 1405 if (*tmp != ':') 1406 goto error; 1407 1408 str = tmp + 1; 1409 mem_total = strtoull(str, &tmp, 0); 1410 if (*tmp != ':') 1411 goto error; 1412 1413 str = tmp + 1; 1414 mem_free = strtoull(str, &tmp, 0); 1415 if (*tmp != ':') 1416 goto error; 1417 1418 fprintf(fp, "# node%u meminfo : total = %"PRIu64" kB," 1419 " free = %"PRIu64" kB\n", 1420 c, mem_total, mem_free); 1421 1422 str = tmp + 1; 1423 fprintf(fp, "# node%u cpu list : %s\n", c, str); 1424 1425 str += strlen(str) + 1; 1426 } 1427 return; 1428 error: 1429 fprintf(fp, "# numa topology : not available\n"); 1430 } 1431 1432 static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp) 1433 { 1434 fprintf(fp, "# cpuid : %s\n", ph->env.cpuid); 1435 } 1436 1437 static void print_branch_stack(struct perf_header *ph __maybe_unused, 1438 int fd __maybe_unused, FILE *fp) 1439 { 1440 fprintf(fp, "# contains samples with branch stack\n"); 1441 } 1442 1443 static void print_pmu_mappings(struct perf_header *ph, int fd __maybe_unused, 1444 FILE *fp) 1445 { 1446 const char *delimiter = "# pmu mappings: "; 1447 char *str, *tmp; 1448 u32 pmu_num; 1449 u32 type; 1450 1451 pmu_num = ph->env.nr_pmu_mappings; 1452 if (!pmu_num) { 1453 fprintf(fp, "# pmu mappings: not available\n"); 1454 return; 1455 } 1456 1457 str = ph->env.pmu_mappings; 1458 1459 while (pmu_num) { 1460 type = strtoul(str, &tmp, 0); 1461 if (*tmp != ':') 1462 goto error; 1463 1464 str = tmp + 1; 1465 fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type); 1466 1467 delimiter = ", "; 1468 str += strlen(str) + 1; 1469 pmu_num--; 1470 } 1471 1472 fprintf(fp, "\n"); 1473 1474 if (!pmu_num) 1475 return; 1476 error: 1477 fprintf(fp, "# pmu mappings: unable to read\n"); 1478 } 1479 1480 static void print_group_desc(struct perf_header *ph, int fd __maybe_unused, 1481 FILE *fp) 1482 { 1483 struct perf_session *session; 1484 struct perf_evsel *evsel; 1485 u32 nr = 0; 1486 1487 session = container_of(ph, struct perf_session, header); 1488 1489 evlist__for_each(session->evlist, evsel) { 1490 if (perf_evsel__is_group_leader(evsel) && 1491 evsel->nr_members > 1) { 1492 fprintf(fp, "# group: %s{%s", evsel->group_name ?: "", 1493 perf_evsel__name(evsel)); 1494 1495 nr = evsel->nr_members - 1; 1496 } else if (nr) { 1497 fprintf(fp, ",%s", perf_evsel__name(evsel)); 1498 1499 if (--nr == 0) 1500 fprintf(fp, "}\n"); 1501 } 1502 } 1503 } 1504 1505 static int __event_process_build_id(struct build_id_event *bev, 1506 char *filename, 1507 struct perf_session *session) 1508 { 1509 int err = -1; 1510 struct list_head *head; 1511 struct machine *machine; 1512 u16 misc; 1513 struct dso *dso; 1514 enum dso_kernel_type dso_type; 1515 1516 machine = perf_session__findnew_machine(session, bev->pid); 1517 if (!machine) 1518 goto out; 1519 1520 misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 1521 1522 switch (misc) { 1523 case PERF_RECORD_MISC_KERNEL: 1524 dso_type = DSO_TYPE_KERNEL; 1525 head = &machine->kernel_dsos; 1526 break; 1527 case PERF_RECORD_MISC_GUEST_KERNEL: 1528 dso_type = DSO_TYPE_GUEST_KERNEL; 1529 head = &machine->kernel_dsos; 1530 break; 1531 case PERF_RECORD_MISC_USER: 1532 case PERF_RECORD_MISC_GUEST_USER: 1533 dso_type = DSO_TYPE_USER; 1534 head = &machine->user_dsos; 1535 break; 1536 default: 1537 goto out; 1538 } 1539 1540 dso = __dsos__findnew(head, filename); 1541 if (dso != NULL) { 1542 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 1543 1544 dso__set_build_id(dso, &bev->build_id); 1545 1546 if (filename[0] == '[') 1547 dso->kernel = dso_type; 1548 1549 build_id__sprintf(dso->build_id, sizeof(dso->build_id), 1550 sbuild_id); 1551 pr_debug("build id event received for %s: %s\n", 1552 dso->long_name, sbuild_id); 1553 } 1554 1555 err = 0; 1556 out: 1557 return err; 1558 } 1559 1560 static int perf_header__read_build_ids_abi_quirk(struct perf_header *header, 1561 int input, u64 offset, u64 size) 1562 { 1563 struct perf_session *session = container_of(header, struct perf_session, header); 1564 struct { 1565 struct perf_event_header header; 1566 u8 build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))]; 1567 char filename[0]; 1568 } old_bev; 1569 struct build_id_event bev; 1570 char filename[PATH_MAX]; 1571 u64 limit = offset + size; 1572 1573 while (offset < limit) { 1574 ssize_t len; 1575 1576 if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev)) 1577 return -1; 1578 1579 if (header->needs_swap) 1580 perf_event_header__bswap(&old_bev.header); 1581 1582 len = old_bev.header.size - sizeof(old_bev); 1583 if (readn(input, filename, len) != len) 1584 return -1; 1585 1586 bev.header = old_bev.header; 1587 1588 /* 1589 * As the pid is the missing value, we need to fill 1590 * it properly. The header.misc value give us nice hint. 1591 */ 1592 bev.pid = HOST_KERNEL_ID; 1593 if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER || 1594 bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL) 1595 bev.pid = DEFAULT_GUEST_KERNEL_ID; 1596 1597 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id)); 1598 __event_process_build_id(&bev, filename, session); 1599 1600 offset += bev.header.size; 1601 } 1602 1603 return 0; 1604 } 1605 1606 static int perf_header__read_build_ids(struct perf_header *header, 1607 int input, u64 offset, u64 size) 1608 { 1609 struct perf_session *session = container_of(header, struct perf_session, header); 1610 struct build_id_event bev; 1611 char filename[PATH_MAX]; 1612 u64 limit = offset + size, orig_offset = offset; 1613 int err = -1; 1614 1615 while (offset < limit) { 1616 ssize_t len; 1617 1618 if (readn(input, &bev, sizeof(bev)) != sizeof(bev)) 1619 goto out; 1620 1621 if (header->needs_swap) 1622 perf_event_header__bswap(&bev.header); 1623 1624 len = bev.header.size - sizeof(bev); 1625 if (readn(input, filename, len) != len) 1626 goto out; 1627 /* 1628 * The a1645ce1 changeset: 1629 * 1630 * "perf: 'perf kvm' tool for monitoring guest performance from host" 1631 * 1632 * Added a field to struct build_id_event that broke the file 1633 * format. 1634 * 1635 * Since the kernel build-id is the first entry, process the 1636 * table using the old format if the well known 1637 * '[kernel.kallsyms]' string for the kernel build-id has the 1638 * first 4 characters chopped off (where the pid_t sits). 1639 */ 1640 if (memcmp(filename, "nel.kallsyms]", 13) == 0) { 1641 if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1) 1642 return -1; 1643 return perf_header__read_build_ids_abi_quirk(header, input, offset, size); 1644 } 1645 1646 __event_process_build_id(&bev, filename, session); 1647 1648 offset += bev.header.size; 1649 } 1650 err = 0; 1651 out: 1652 return err; 1653 } 1654 1655 static int process_tracing_data(struct perf_file_section *section __maybe_unused, 1656 struct perf_header *ph __maybe_unused, 1657 int fd, void *data) 1658 { 1659 ssize_t ret = trace_report(fd, data, false); 1660 return ret < 0 ? -1 : 0; 1661 } 1662 1663 static int process_build_id(struct perf_file_section *section, 1664 struct perf_header *ph, int fd, 1665 void *data __maybe_unused) 1666 { 1667 if (perf_header__read_build_ids(ph, fd, section->offset, section->size)) 1668 pr_debug("Failed to read buildids, continuing...\n"); 1669 return 0; 1670 } 1671 1672 static int process_hostname(struct perf_file_section *section __maybe_unused, 1673 struct perf_header *ph, int fd, 1674 void *data __maybe_unused) 1675 { 1676 ph->env.hostname = do_read_string(fd, ph); 1677 return ph->env.hostname ? 0 : -ENOMEM; 1678 } 1679 1680 static int process_osrelease(struct perf_file_section *section __maybe_unused, 1681 struct perf_header *ph, int fd, 1682 void *data __maybe_unused) 1683 { 1684 ph->env.os_release = do_read_string(fd, ph); 1685 return ph->env.os_release ? 0 : -ENOMEM; 1686 } 1687 1688 static int process_version(struct perf_file_section *section __maybe_unused, 1689 struct perf_header *ph, int fd, 1690 void *data __maybe_unused) 1691 { 1692 ph->env.version = do_read_string(fd, ph); 1693 return ph->env.version ? 0 : -ENOMEM; 1694 } 1695 1696 static int process_arch(struct perf_file_section *section __maybe_unused, 1697 struct perf_header *ph, int fd, 1698 void *data __maybe_unused) 1699 { 1700 ph->env.arch = do_read_string(fd, ph); 1701 return ph->env.arch ? 0 : -ENOMEM; 1702 } 1703 1704 static int process_nrcpus(struct perf_file_section *section __maybe_unused, 1705 struct perf_header *ph, int fd, 1706 void *data __maybe_unused) 1707 { 1708 ssize_t ret; 1709 u32 nr; 1710 1711 ret = readn(fd, &nr, sizeof(nr)); 1712 if (ret != sizeof(nr)) 1713 return -1; 1714 1715 if (ph->needs_swap) 1716 nr = bswap_32(nr); 1717 1718 ph->env.nr_cpus_online = nr; 1719 1720 ret = readn(fd, &nr, sizeof(nr)); 1721 if (ret != sizeof(nr)) 1722 return -1; 1723 1724 if (ph->needs_swap) 1725 nr = bswap_32(nr); 1726 1727 ph->env.nr_cpus_avail = nr; 1728 return 0; 1729 } 1730 1731 static int process_cpudesc(struct perf_file_section *section __maybe_unused, 1732 struct perf_header *ph, int fd, 1733 void *data __maybe_unused) 1734 { 1735 ph->env.cpu_desc = do_read_string(fd, ph); 1736 return ph->env.cpu_desc ? 0 : -ENOMEM; 1737 } 1738 1739 static int process_cpuid(struct perf_file_section *section __maybe_unused, 1740 struct perf_header *ph, int fd, 1741 void *data __maybe_unused) 1742 { 1743 ph->env.cpuid = do_read_string(fd, ph); 1744 return ph->env.cpuid ? 0 : -ENOMEM; 1745 } 1746 1747 static int process_total_mem(struct perf_file_section *section __maybe_unused, 1748 struct perf_header *ph, int fd, 1749 void *data __maybe_unused) 1750 { 1751 uint64_t mem; 1752 ssize_t ret; 1753 1754 ret = readn(fd, &mem, sizeof(mem)); 1755 if (ret != sizeof(mem)) 1756 return -1; 1757 1758 if (ph->needs_swap) 1759 mem = bswap_64(mem); 1760 1761 ph->env.total_mem = mem; 1762 return 0; 1763 } 1764 1765 static struct perf_evsel * 1766 perf_evlist__find_by_index(struct perf_evlist *evlist, int idx) 1767 { 1768 struct perf_evsel *evsel; 1769 1770 evlist__for_each(evlist, evsel) { 1771 if (evsel->idx == idx) 1772 return evsel; 1773 } 1774 1775 return NULL; 1776 } 1777 1778 static void 1779 perf_evlist__set_event_name(struct perf_evlist *evlist, 1780 struct perf_evsel *event) 1781 { 1782 struct perf_evsel *evsel; 1783 1784 if (!event->name) 1785 return; 1786 1787 evsel = perf_evlist__find_by_index(evlist, event->idx); 1788 if (!evsel) 1789 return; 1790 1791 if (evsel->name) 1792 return; 1793 1794 evsel->name = strdup(event->name); 1795 } 1796 1797 static int 1798 process_event_desc(struct perf_file_section *section __maybe_unused, 1799 struct perf_header *header, int fd, 1800 void *data __maybe_unused) 1801 { 1802 struct perf_session *session; 1803 struct perf_evsel *evsel, *events = read_event_desc(header, fd); 1804 1805 if (!events) 1806 return 0; 1807 1808 session = container_of(header, struct perf_session, header); 1809 for (evsel = events; evsel->attr.size; evsel++) 1810 perf_evlist__set_event_name(session->evlist, evsel); 1811 1812 free_event_desc(events); 1813 1814 return 0; 1815 } 1816 1817 static int process_cmdline(struct perf_file_section *section __maybe_unused, 1818 struct perf_header *ph, int fd, 1819 void *data __maybe_unused) 1820 { 1821 ssize_t ret; 1822 char *str; 1823 u32 nr, i; 1824 struct strbuf sb; 1825 1826 ret = readn(fd, &nr, sizeof(nr)); 1827 if (ret != sizeof(nr)) 1828 return -1; 1829 1830 if (ph->needs_swap) 1831 nr = bswap_32(nr); 1832 1833 ph->env.nr_cmdline = nr; 1834 strbuf_init(&sb, 128); 1835 1836 for (i = 0; i < nr; i++) { 1837 str = do_read_string(fd, ph); 1838 if (!str) 1839 goto error; 1840 1841 /* include a NULL character at the end */ 1842 strbuf_add(&sb, str, strlen(str) + 1); 1843 free(str); 1844 } 1845 ph->env.cmdline = strbuf_detach(&sb, NULL); 1846 return 0; 1847 1848 error: 1849 strbuf_release(&sb); 1850 return -1; 1851 } 1852 1853 static int process_cpu_topology(struct perf_file_section *section __maybe_unused, 1854 struct perf_header *ph, int fd, 1855 void *data __maybe_unused) 1856 { 1857 ssize_t ret; 1858 u32 nr, i; 1859 char *str; 1860 struct strbuf sb; 1861 1862 ret = readn(fd, &nr, sizeof(nr)); 1863 if (ret != sizeof(nr)) 1864 return -1; 1865 1866 if (ph->needs_swap) 1867 nr = bswap_32(nr); 1868 1869 ph->env.nr_sibling_cores = nr; 1870 strbuf_init(&sb, 128); 1871 1872 for (i = 0; i < nr; i++) { 1873 str = do_read_string(fd, ph); 1874 if (!str) 1875 goto error; 1876 1877 /* include a NULL character at the end */ 1878 strbuf_add(&sb, str, strlen(str) + 1); 1879 free(str); 1880 } 1881 ph->env.sibling_cores = strbuf_detach(&sb, NULL); 1882 1883 ret = readn(fd, &nr, sizeof(nr)); 1884 if (ret != sizeof(nr)) 1885 return -1; 1886 1887 if (ph->needs_swap) 1888 nr = bswap_32(nr); 1889 1890 ph->env.nr_sibling_threads = nr; 1891 1892 for (i = 0; i < nr; i++) { 1893 str = do_read_string(fd, ph); 1894 if (!str) 1895 goto error; 1896 1897 /* include a NULL character at the end */ 1898 strbuf_add(&sb, str, strlen(str) + 1); 1899 free(str); 1900 } 1901 ph->env.sibling_threads = strbuf_detach(&sb, NULL); 1902 return 0; 1903 1904 error: 1905 strbuf_release(&sb); 1906 return -1; 1907 } 1908 1909 static int process_numa_topology(struct perf_file_section *section __maybe_unused, 1910 struct perf_header *ph, int fd, 1911 void *data __maybe_unused) 1912 { 1913 ssize_t ret; 1914 u32 nr, node, i; 1915 char *str; 1916 uint64_t mem_total, mem_free; 1917 struct strbuf sb; 1918 1919 /* nr nodes */ 1920 ret = readn(fd, &nr, sizeof(nr)); 1921 if (ret != sizeof(nr)) 1922 goto error; 1923 1924 if (ph->needs_swap) 1925 nr = bswap_32(nr); 1926 1927 ph->env.nr_numa_nodes = nr; 1928 strbuf_init(&sb, 256); 1929 1930 for (i = 0; i < nr; i++) { 1931 /* node number */ 1932 ret = readn(fd, &node, sizeof(node)); 1933 if (ret != sizeof(node)) 1934 goto error; 1935 1936 ret = readn(fd, &mem_total, sizeof(u64)); 1937 if (ret != sizeof(u64)) 1938 goto error; 1939 1940 ret = readn(fd, &mem_free, sizeof(u64)); 1941 if (ret != sizeof(u64)) 1942 goto error; 1943 1944 if (ph->needs_swap) { 1945 node = bswap_32(node); 1946 mem_total = bswap_64(mem_total); 1947 mem_free = bswap_64(mem_free); 1948 } 1949 1950 strbuf_addf(&sb, "%u:%"PRIu64":%"PRIu64":", 1951 node, mem_total, mem_free); 1952 1953 str = do_read_string(fd, ph); 1954 if (!str) 1955 goto error; 1956 1957 /* include a NULL character at the end */ 1958 strbuf_add(&sb, str, strlen(str) + 1); 1959 free(str); 1960 } 1961 ph->env.numa_nodes = strbuf_detach(&sb, NULL); 1962 return 0; 1963 1964 error: 1965 strbuf_release(&sb); 1966 return -1; 1967 } 1968 1969 static int process_pmu_mappings(struct perf_file_section *section __maybe_unused, 1970 struct perf_header *ph, int fd, 1971 void *data __maybe_unused) 1972 { 1973 ssize_t ret; 1974 char *name; 1975 u32 pmu_num; 1976 u32 type; 1977 struct strbuf sb; 1978 1979 ret = readn(fd, &pmu_num, sizeof(pmu_num)); 1980 if (ret != sizeof(pmu_num)) 1981 return -1; 1982 1983 if (ph->needs_swap) 1984 pmu_num = bswap_32(pmu_num); 1985 1986 if (!pmu_num) { 1987 pr_debug("pmu mappings not available\n"); 1988 return 0; 1989 } 1990 1991 ph->env.nr_pmu_mappings = pmu_num; 1992 strbuf_init(&sb, 128); 1993 1994 while (pmu_num) { 1995 if (readn(fd, &type, sizeof(type)) != sizeof(type)) 1996 goto error; 1997 if (ph->needs_swap) 1998 type = bswap_32(type); 1999 2000 name = do_read_string(fd, ph); 2001 if (!name) 2002 goto error; 2003 2004 strbuf_addf(&sb, "%u:%s", type, name); 2005 /* include a NULL character at the end */ 2006 strbuf_add(&sb, "", 1); 2007 2008 free(name); 2009 pmu_num--; 2010 } 2011 ph->env.pmu_mappings = strbuf_detach(&sb, NULL); 2012 return 0; 2013 2014 error: 2015 strbuf_release(&sb); 2016 return -1; 2017 } 2018 2019 static int process_group_desc(struct perf_file_section *section __maybe_unused, 2020 struct perf_header *ph, int fd, 2021 void *data __maybe_unused) 2022 { 2023 size_t ret = -1; 2024 u32 i, nr, nr_groups; 2025 struct perf_session *session; 2026 struct perf_evsel *evsel, *leader = NULL; 2027 struct group_desc { 2028 char *name; 2029 u32 leader_idx; 2030 u32 nr_members; 2031 } *desc; 2032 2033 if (readn(fd, &nr_groups, sizeof(nr_groups)) != sizeof(nr_groups)) 2034 return -1; 2035 2036 if (ph->needs_swap) 2037 nr_groups = bswap_32(nr_groups); 2038 2039 ph->env.nr_groups = nr_groups; 2040 if (!nr_groups) { 2041 pr_debug("group desc not available\n"); 2042 return 0; 2043 } 2044 2045 desc = calloc(nr_groups, sizeof(*desc)); 2046 if (!desc) 2047 return -1; 2048 2049 for (i = 0; i < nr_groups; i++) { 2050 desc[i].name = do_read_string(fd, ph); 2051 if (!desc[i].name) 2052 goto out_free; 2053 2054 if (readn(fd, &desc[i].leader_idx, sizeof(u32)) != sizeof(u32)) 2055 goto out_free; 2056 2057 if (readn(fd, &desc[i].nr_members, sizeof(u32)) != sizeof(u32)) 2058 goto out_free; 2059 2060 if (ph->needs_swap) { 2061 desc[i].leader_idx = bswap_32(desc[i].leader_idx); 2062 desc[i].nr_members = bswap_32(desc[i].nr_members); 2063 } 2064 } 2065 2066 /* 2067 * Rebuild group relationship based on the group_desc 2068 */ 2069 session = container_of(ph, struct perf_session, header); 2070 session->evlist->nr_groups = nr_groups; 2071 2072 i = nr = 0; 2073 evlist__for_each(session->evlist, evsel) { 2074 if (evsel->idx == (int) desc[i].leader_idx) { 2075 evsel->leader = evsel; 2076 /* {anon_group} is a dummy name */ 2077 if (strcmp(desc[i].name, "{anon_group}")) { 2078 evsel->group_name = desc[i].name; 2079 desc[i].name = NULL; 2080 } 2081 evsel->nr_members = desc[i].nr_members; 2082 2083 if (i >= nr_groups || nr > 0) { 2084 pr_debug("invalid group desc\n"); 2085 goto out_free; 2086 } 2087 2088 leader = evsel; 2089 nr = evsel->nr_members - 1; 2090 i++; 2091 } else if (nr) { 2092 /* This is a group member */ 2093 evsel->leader = leader; 2094 2095 nr--; 2096 } 2097 } 2098 2099 if (i != nr_groups || nr != 0) { 2100 pr_debug("invalid group desc\n"); 2101 goto out_free; 2102 } 2103 2104 ret = 0; 2105 out_free: 2106 for (i = 0; i < nr_groups; i++) 2107 zfree(&desc[i].name); 2108 free(desc); 2109 2110 return ret; 2111 } 2112 2113 struct feature_ops { 2114 int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist); 2115 void (*print)(struct perf_header *h, int fd, FILE *fp); 2116 int (*process)(struct perf_file_section *section, 2117 struct perf_header *h, int fd, void *data); 2118 const char *name; 2119 bool full_only; 2120 }; 2121 2122 #define FEAT_OPA(n, func) \ 2123 [n] = { .name = #n, .write = write_##func, .print = print_##func } 2124 #define FEAT_OPP(n, func) \ 2125 [n] = { .name = #n, .write = write_##func, .print = print_##func, \ 2126 .process = process_##func } 2127 #define FEAT_OPF(n, func) \ 2128 [n] = { .name = #n, .write = write_##func, .print = print_##func, \ 2129 .process = process_##func, .full_only = true } 2130 2131 /* feature_ops not implemented: */ 2132 #define print_tracing_data NULL 2133 #define print_build_id NULL 2134 2135 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = { 2136 FEAT_OPP(HEADER_TRACING_DATA, tracing_data), 2137 FEAT_OPP(HEADER_BUILD_ID, build_id), 2138 FEAT_OPP(HEADER_HOSTNAME, hostname), 2139 FEAT_OPP(HEADER_OSRELEASE, osrelease), 2140 FEAT_OPP(HEADER_VERSION, version), 2141 FEAT_OPP(HEADER_ARCH, arch), 2142 FEAT_OPP(HEADER_NRCPUS, nrcpus), 2143 FEAT_OPP(HEADER_CPUDESC, cpudesc), 2144 FEAT_OPP(HEADER_CPUID, cpuid), 2145 FEAT_OPP(HEADER_TOTAL_MEM, total_mem), 2146 FEAT_OPP(HEADER_EVENT_DESC, event_desc), 2147 FEAT_OPP(HEADER_CMDLINE, cmdline), 2148 FEAT_OPF(HEADER_CPU_TOPOLOGY, cpu_topology), 2149 FEAT_OPF(HEADER_NUMA_TOPOLOGY, numa_topology), 2150 FEAT_OPA(HEADER_BRANCH_STACK, branch_stack), 2151 FEAT_OPP(HEADER_PMU_MAPPINGS, pmu_mappings), 2152 FEAT_OPP(HEADER_GROUP_DESC, group_desc), 2153 }; 2154 2155 struct header_print_data { 2156 FILE *fp; 2157 bool full; /* extended list of headers */ 2158 }; 2159 2160 static int perf_file_section__fprintf_info(struct perf_file_section *section, 2161 struct perf_header *ph, 2162 int feat, int fd, void *data) 2163 { 2164 struct header_print_data *hd = data; 2165 2166 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) { 2167 pr_debug("Failed to lseek to %" PRIu64 " offset for feature " 2168 "%d, continuing...\n", section->offset, feat); 2169 return 0; 2170 } 2171 if (feat >= HEADER_LAST_FEATURE) { 2172 pr_warning("unknown feature %d\n", feat); 2173 return 0; 2174 } 2175 if (!feat_ops[feat].print) 2176 return 0; 2177 2178 if (!feat_ops[feat].full_only || hd->full) 2179 feat_ops[feat].print(ph, fd, hd->fp); 2180 else 2181 fprintf(hd->fp, "# %s info available, use -I to display\n", 2182 feat_ops[feat].name); 2183 2184 return 0; 2185 } 2186 2187 int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full) 2188 { 2189 struct header_print_data hd; 2190 struct perf_header *header = &session->header; 2191 int fd = perf_data_file__fd(session->file); 2192 hd.fp = fp; 2193 hd.full = full; 2194 2195 perf_header__process_sections(header, fd, &hd, 2196 perf_file_section__fprintf_info); 2197 return 0; 2198 } 2199 2200 static int do_write_feat(int fd, struct perf_header *h, int type, 2201 struct perf_file_section **p, 2202 struct perf_evlist *evlist) 2203 { 2204 int err; 2205 int ret = 0; 2206 2207 if (perf_header__has_feat(h, type)) { 2208 if (!feat_ops[type].write) 2209 return -1; 2210 2211 (*p)->offset = lseek(fd, 0, SEEK_CUR); 2212 2213 err = feat_ops[type].write(fd, h, evlist); 2214 if (err < 0) { 2215 pr_debug("failed to write feature %d\n", type); 2216 2217 /* undo anything written */ 2218 lseek(fd, (*p)->offset, SEEK_SET); 2219 2220 return -1; 2221 } 2222 (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset; 2223 (*p)++; 2224 } 2225 return ret; 2226 } 2227 2228 static int perf_header__adds_write(struct perf_header *header, 2229 struct perf_evlist *evlist, int fd) 2230 { 2231 int nr_sections; 2232 struct perf_file_section *feat_sec, *p; 2233 int sec_size; 2234 u64 sec_start; 2235 int feat; 2236 int err; 2237 2238 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS); 2239 if (!nr_sections) 2240 return 0; 2241 2242 feat_sec = p = calloc(nr_sections, sizeof(*feat_sec)); 2243 if (feat_sec == NULL) 2244 return -ENOMEM; 2245 2246 sec_size = sizeof(*feat_sec) * nr_sections; 2247 2248 sec_start = header->feat_offset; 2249 lseek(fd, sec_start + sec_size, SEEK_SET); 2250 2251 for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) { 2252 if (do_write_feat(fd, header, feat, &p, evlist)) 2253 perf_header__clear_feat(header, feat); 2254 } 2255 2256 lseek(fd, sec_start, SEEK_SET); 2257 /* 2258 * may write more than needed due to dropped feature, but 2259 * this is okay, reader will skip the mising entries 2260 */ 2261 err = do_write(fd, feat_sec, sec_size); 2262 if (err < 0) 2263 pr_debug("failed to write feature section\n"); 2264 free(feat_sec); 2265 return err; 2266 } 2267 2268 int perf_header__write_pipe(int fd) 2269 { 2270 struct perf_pipe_file_header f_header; 2271 int err; 2272 2273 f_header = (struct perf_pipe_file_header){ 2274 .magic = PERF_MAGIC, 2275 .size = sizeof(f_header), 2276 }; 2277 2278 err = do_write(fd, &f_header, sizeof(f_header)); 2279 if (err < 0) { 2280 pr_debug("failed to write perf pipe header\n"); 2281 return err; 2282 } 2283 2284 return 0; 2285 } 2286 2287 int perf_session__write_header(struct perf_session *session, 2288 struct perf_evlist *evlist, 2289 int fd, bool at_exit) 2290 { 2291 struct perf_file_header f_header; 2292 struct perf_file_attr f_attr; 2293 struct perf_header *header = &session->header; 2294 struct perf_evsel *evsel; 2295 u64 attr_offset; 2296 int err; 2297 2298 lseek(fd, sizeof(f_header), SEEK_SET); 2299 2300 evlist__for_each(session->evlist, evsel) { 2301 evsel->id_offset = lseek(fd, 0, SEEK_CUR); 2302 err = do_write(fd, evsel->id, evsel->ids * sizeof(u64)); 2303 if (err < 0) { 2304 pr_debug("failed to write perf header\n"); 2305 return err; 2306 } 2307 } 2308 2309 attr_offset = lseek(fd, 0, SEEK_CUR); 2310 2311 evlist__for_each(evlist, evsel) { 2312 f_attr = (struct perf_file_attr){ 2313 .attr = evsel->attr, 2314 .ids = { 2315 .offset = evsel->id_offset, 2316 .size = evsel->ids * sizeof(u64), 2317 } 2318 }; 2319 err = do_write(fd, &f_attr, sizeof(f_attr)); 2320 if (err < 0) { 2321 pr_debug("failed to write perf header attribute\n"); 2322 return err; 2323 } 2324 } 2325 2326 if (!header->data_offset) 2327 header->data_offset = lseek(fd, 0, SEEK_CUR); 2328 header->feat_offset = header->data_offset + header->data_size; 2329 2330 if (at_exit) { 2331 err = perf_header__adds_write(header, evlist, fd); 2332 if (err < 0) 2333 return err; 2334 } 2335 2336 f_header = (struct perf_file_header){ 2337 .magic = PERF_MAGIC, 2338 .size = sizeof(f_header), 2339 .attr_size = sizeof(f_attr), 2340 .attrs = { 2341 .offset = attr_offset, 2342 .size = evlist->nr_entries * sizeof(f_attr), 2343 }, 2344 .data = { 2345 .offset = header->data_offset, 2346 .size = header->data_size, 2347 }, 2348 /* event_types is ignored, store zeros */ 2349 }; 2350 2351 memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features)); 2352 2353 lseek(fd, 0, SEEK_SET); 2354 err = do_write(fd, &f_header, sizeof(f_header)); 2355 if (err < 0) { 2356 pr_debug("failed to write perf header\n"); 2357 return err; 2358 } 2359 lseek(fd, header->data_offset + header->data_size, SEEK_SET); 2360 2361 return 0; 2362 } 2363 2364 static int perf_header__getbuffer64(struct perf_header *header, 2365 int fd, void *buf, size_t size) 2366 { 2367 if (readn(fd, buf, size) <= 0) 2368 return -1; 2369 2370 if (header->needs_swap) 2371 mem_bswap_64(buf, size); 2372 2373 return 0; 2374 } 2375 2376 int perf_header__process_sections(struct perf_header *header, int fd, 2377 void *data, 2378 int (*process)(struct perf_file_section *section, 2379 struct perf_header *ph, 2380 int feat, int fd, void *data)) 2381 { 2382 struct perf_file_section *feat_sec, *sec; 2383 int nr_sections; 2384 int sec_size; 2385 int feat; 2386 int err; 2387 2388 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS); 2389 if (!nr_sections) 2390 return 0; 2391 2392 feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec)); 2393 if (!feat_sec) 2394 return -1; 2395 2396 sec_size = sizeof(*feat_sec) * nr_sections; 2397 2398 lseek(fd, header->feat_offset, SEEK_SET); 2399 2400 err = perf_header__getbuffer64(header, fd, feat_sec, sec_size); 2401 if (err < 0) 2402 goto out_free; 2403 2404 for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) { 2405 err = process(sec++, header, feat, fd, data); 2406 if (err < 0) 2407 goto out_free; 2408 } 2409 err = 0; 2410 out_free: 2411 free(feat_sec); 2412 return err; 2413 } 2414 2415 static const int attr_file_abi_sizes[] = { 2416 [0] = PERF_ATTR_SIZE_VER0, 2417 [1] = PERF_ATTR_SIZE_VER1, 2418 [2] = PERF_ATTR_SIZE_VER2, 2419 [3] = PERF_ATTR_SIZE_VER3, 2420 0, 2421 }; 2422 2423 /* 2424 * In the legacy file format, the magic number is not used to encode endianness. 2425 * hdr_sz was used to encode endianness. But given that hdr_sz can vary based 2426 * on ABI revisions, we need to try all combinations for all endianness to 2427 * detect the endianness. 2428 */ 2429 static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph) 2430 { 2431 uint64_t ref_size, attr_size; 2432 int i; 2433 2434 for (i = 0 ; attr_file_abi_sizes[i]; i++) { 2435 ref_size = attr_file_abi_sizes[i] 2436 + sizeof(struct perf_file_section); 2437 if (hdr_sz != ref_size) { 2438 attr_size = bswap_64(hdr_sz); 2439 if (attr_size != ref_size) 2440 continue; 2441 2442 ph->needs_swap = true; 2443 } 2444 pr_debug("ABI%d perf.data file detected, need_swap=%d\n", 2445 i, 2446 ph->needs_swap); 2447 return 0; 2448 } 2449 /* could not determine endianness */ 2450 return -1; 2451 } 2452 2453 #define PERF_PIPE_HDR_VER0 16 2454 2455 static const size_t attr_pipe_abi_sizes[] = { 2456 [0] = PERF_PIPE_HDR_VER0, 2457 0, 2458 }; 2459 2460 /* 2461 * In the legacy pipe format, there is an implicit assumption that endiannesss 2462 * between host recording the samples, and host parsing the samples is the 2463 * same. This is not always the case given that the pipe output may always be 2464 * redirected into a file and analyzed on a different machine with possibly a 2465 * different endianness and perf_event ABI revsions in the perf tool itself. 2466 */ 2467 static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph) 2468 { 2469 u64 attr_size; 2470 int i; 2471 2472 for (i = 0 ; attr_pipe_abi_sizes[i]; i++) { 2473 if (hdr_sz != attr_pipe_abi_sizes[i]) { 2474 attr_size = bswap_64(hdr_sz); 2475 if (attr_size != hdr_sz) 2476 continue; 2477 2478 ph->needs_swap = true; 2479 } 2480 pr_debug("Pipe ABI%d perf.data file detected\n", i); 2481 return 0; 2482 } 2483 return -1; 2484 } 2485 2486 bool is_perf_magic(u64 magic) 2487 { 2488 if (!memcmp(&magic, __perf_magic1, sizeof(magic)) 2489 || magic == __perf_magic2 2490 || magic == __perf_magic2_sw) 2491 return true; 2492 2493 return false; 2494 } 2495 2496 static int check_magic_endian(u64 magic, uint64_t hdr_sz, 2497 bool is_pipe, struct perf_header *ph) 2498 { 2499 int ret; 2500 2501 /* check for legacy format */ 2502 ret = memcmp(&magic, __perf_magic1, sizeof(magic)); 2503 if (ret == 0) { 2504 ph->version = PERF_HEADER_VERSION_1; 2505 pr_debug("legacy perf.data format\n"); 2506 if (is_pipe) 2507 return try_all_pipe_abis(hdr_sz, ph); 2508 2509 return try_all_file_abis(hdr_sz, ph); 2510 } 2511 /* 2512 * the new magic number serves two purposes: 2513 * - unique number to identify actual perf.data files 2514 * - encode endianness of file 2515 */ 2516 2517 /* check magic number with one endianness */ 2518 if (magic == __perf_magic2) 2519 return 0; 2520 2521 /* check magic number with opposite endianness */ 2522 if (magic != __perf_magic2_sw) 2523 return -1; 2524 2525 ph->needs_swap = true; 2526 ph->version = PERF_HEADER_VERSION_2; 2527 2528 return 0; 2529 } 2530 2531 int perf_file_header__read(struct perf_file_header *header, 2532 struct perf_header *ph, int fd) 2533 { 2534 ssize_t ret; 2535 2536 lseek(fd, 0, SEEK_SET); 2537 2538 ret = readn(fd, header, sizeof(*header)); 2539 if (ret <= 0) 2540 return -1; 2541 2542 if (check_magic_endian(header->magic, 2543 header->attr_size, false, ph) < 0) { 2544 pr_debug("magic/endian check failed\n"); 2545 return -1; 2546 } 2547 2548 if (ph->needs_swap) { 2549 mem_bswap_64(header, offsetof(struct perf_file_header, 2550 adds_features)); 2551 } 2552 2553 if (header->size != sizeof(*header)) { 2554 /* Support the previous format */ 2555 if (header->size == offsetof(typeof(*header), adds_features)) 2556 bitmap_zero(header->adds_features, HEADER_FEAT_BITS); 2557 else 2558 return -1; 2559 } else if (ph->needs_swap) { 2560 /* 2561 * feature bitmap is declared as an array of unsigned longs -- 2562 * not good since its size can differ between the host that 2563 * generated the data file and the host analyzing the file. 2564 * 2565 * We need to handle endianness, but we don't know the size of 2566 * the unsigned long where the file was generated. Take a best 2567 * guess at determining it: try 64-bit swap first (ie., file 2568 * created on a 64-bit host), and check if the hostname feature 2569 * bit is set (this feature bit is forced on as of fbe96f2). 2570 * If the bit is not, undo the 64-bit swap and try a 32-bit 2571 * swap. If the hostname bit is still not set (e.g., older data 2572 * file), punt and fallback to the original behavior -- 2573 * clearing all feature bits and setting buildid. 2574 */ 2575 mem_bswap_64(&header->adds_features, 2576 BITS_TO_U64(HEADER_FEAT_BITS)); 2577 2578 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) { 2579 /* unswap as u64 */ 2580 mem_bswap_64(&header->adds_features, 2581 BITS_TO_U64(HEADER_FEAT_BITS)); 2582 2583 /* unswap as u32 */ 2584 mem_bswap_32(&header->adds_features, 2585 BITS_TO_U32(HEADER_FEAT_BITS)); 2586 } 2587 2588 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) { 2589 bitmap_zero(header->adds_features, HEADER_FEAT_BITS); 2590 set_bit(HEADER_BUILD_ID, header->adds_features); 2591 } 2592 } 2593 2594 memcpy(&ph->adds_features, &header->adds_features, 2595 sizeof(ph->adds_features)); 2596 2597 ph->data_offset = header->data.offset; 2598 ph->data_size = header->data.size; 2599 ph->feat_offset = header->data.offset + header->data.size; 2600 return 0; 2601 } 2602 2603 static int perf_file_section__process(struct perf_file_section *section, 2604 struct perf_header *ph, 2605 int feat, int fd, void *data) 2606 { 2607 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) { 2608 pr_debug("Failed to lseek to %" PRIu64 " offset for feature " 2609 "%d, continuing...\n", section->offset, feat); 2610 return 0; 2611 } 2612 2613 if (feat >= HEADER_LAST_FEATURE) { 2614 pr_debug("unknown feature %d, continuing...\n", feat); 2615 return 0; 2616 } 2617 2618 if (!feat_ops[feat].process) 2619 return 0; 2620 2621 return feat_ops[feat].process(section, ph, fd, data); 2622 } 2623 2624 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header, 2625 struct perf_header *ph, int fd, 2626 bool repipe) 2627 { 2628 ssize_t ret; 2629 2630 ret = readn(fd, header, sizeof(*header)); 2631 if (ret <= 0) 2632 return -1; 2633 2634 if (check_magic_endian(header->magic, header->size, true, ph) < 0) { 2635 pr_debug("endian/magic failed\n"); 2636 return -1; 2637 } 2638 2639 if (ph->needs_swap) 2640 header->size = bswap_64(header->size); 2641 2642 if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0) 2643 return -1; 2644 2645 return 0; 2646 } 2647 2648 static int perf_header__read_pipe(struct perf_session *session) 2649 { 2650 struct perf_header *header = &session->header; 2651 struct perf_pipe_file_header f_header; 2652 2653 if (perf_file_header__read_pipe(&f_header, header, 2654 perf_data_file__fd(session->file), 2655 session->repipe) < 0) { 2656 pr_debug("incompatible file format\n"); 2657 return -EINVAL; 2658 } 2659 2660 return 0; 2661 } 2662 2663 static int read_attr(int fd, struct perf_header *ph, 2664 struct perf_file_attr *f_attr) 2665 { 2666 struct perf_event_attr *attr = &f_attr->attr; 2667 size_t sz, left; 2668 size_t our_sz = sizeof(f_attr->attr); 2669 ssize_t ret; 2670 2671 memset(f_attr, 0, sizeof(*f_attr)); 2672 2673 /* read minimal guaranteed structure */ 2674 ret = readn(fd, attr, PERF_ATTR_SIZE_VER0); 2675 if (ret <= 0) { 2676 pr_debug("cannot read %d bytes of header attr\n", 2677 PERF_ATTR_SIZE_VER0); 2678 return -1; 2679 } 2680 2681 /* on file perf_event_attr size */ 2682 sz = attr->size; 2683 2684 if (ph->needs_swap) 2685 sz = bswap_32(sz); 2686 2687 if (sz == 0) { 2688 /* assume ABI0 */ 2689 sz = PERF_ATTR_SIZE_VER0; 2690 } else if (sz > our_sz) { 2691 pr_debug("file uses a more recent and unsupported ABI" 2692 " (%zu bytes extra)\n", sz - our_sz); 2693 return -1; 2694 } 2695 /* what we have not yet read and that we know about */ 2696 left = sz - PERF_ATTR_SIZE_VER0; 2697 if (left) { 2698 void *ptr = attr; 2699 ptr += PERF_ATTR_SIZE_VER0; 2700 2701 ret = readn(fd, ptr, left); 2702 } 2703 /* read perf_file_section, ids are read in caller */ 2704 ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids)); 2705 2706 return ret <= 0 ? -1 : 0; 2707 } 2708 2709 static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel, 2710 struct pevent *pevent) 2711 { 2712 struct event_format *event; 2713 char bf[128]; 2714 2715 /* already prepared */ 2716 if (evsel->tp_format) 2717 return 0; 2718 2719 if (pevent == NULL) { 2720 pr_debug("broken or missing trace data\n"); 2721 return -1; 2722 } 2723 2724 event = pevent_find_event(pevent, evsel->attr.config); 2725 if (event == NULL) 2726 return -1; 2727 2728 if (!evsel->name) { 2729 snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name); 2730 evsel->name = strdup(bf); 2731 if (evsel->name == NULL) 2732 return -1; 2733 } 2734 2735 evsel->tp_format = event; 2736 return 0; 2737 } 2738 2739 static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist, 2740 struct pevent *pevent) 2741 { 2742 struct perf_evsel *pos; 2743 2744 evlist__for_each(evlist, pos) { 2745 if (pos->attr.type == PERF_TYPE_TRACEPOINT && 2746 perf_evsel__prepare_tracepoint_event(pos, pevent)) 2747 return -1; 2748 } 2749 2750 return 0; 2751 } 2752 2753 int perf_session__read_header(struct perf_session *session) 2754 { 2755 struct perf_data_file *file = session->file; 2756 struct perf_header *header = &session->header; 2757 struct perf_file_header f_header; 2758 struct perf_file_attr f_attr; 2759 u64 f_id; 2760 int nr_attrs, nr_ids, i, j; 2761 int fd = perf_data_file__fd(file); 2762 2763 session->evlist = perf_evlist__new(); 2764 if (session->evlist == NULL) 2765 return -ENOMEM; 2766 2767 if (perf_data_file__is_pipe(file)) 2768 return perf_header__read_pipe(session); 2769 2770 if (perf_file_header__read(&f_header, header, fd) < 0) 2771 return -EINVAL; 2772 2773 /* 2774 * Sanity check that perf.data was written cleanly; data size is 2775 * initialized to 0 and updated only if the on_exit function is run. 2776 * If data size is still 0 then the file contains only partial 2777 * information. Just warn user and process it as much as it can. 2778 */ 2779 if (f_header.data.size == 0) { 2780 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n" 2781 "Was the 'perf record' command properly terminated?\n", 2782 file->path); 2783 } 2784 2785 nr_attrs = f_header.attrs.size / f_header.attr_size; 2786 lseek(fd, f_header.attrs.offset, SEEK_SET); 2787 2788 for (i = 0; i < nr_attrs; i++) { 2789 struct perf_evsel *evsel; 2790 off_t tmp; 2791 2792 if (read_attr(fd, header, &f_attr) < 0) 2793 goto out_errno; 2794 2795 if (header->needs_swap) 2796 perf_event__attr_swap(&f_attr.attr); 2797 2798 tmp = lseek(fd, 0, SEEK_CUR); 2799 evsel = perf_evsel__new(&f_attr.attr); 2800 2801 if (evsel == NULL) 2802 goto out_delete_evlist; 2803 2804 evsel->needs_swap = header->needs_swap; 2805 /* 2806 * Do it before so that if perf_evsel__alloc_id fails, this 2807 * entry gets purged too at perf_evlist__delete(). 2808 */ 2809 perf_evlist__add(session->evlist, evsel); 2810 2811 nr_ids = f_attr.ids.size / sizeof(u64); 2812 /* 2813 * We don't have the cpu and thread maps on the header, so 2814 * for allocating the perf_sample_id table we fake 1 cpu and 2815 * hattr->ids threads. 2816 */ 2817 if (perf_evsel__alloc_id(evsel, 1, nr_ids)) 2818 goto out_delete_evlist; 2819 2820 lseek(fd, f_attr.ids.offset, SEEK_SET); 2821 2822 for (j = 0; j < nr_ids; j++) { 2823 if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id))) 2824 goto out_errno; 2825 2826 perf_evlist__id_add(session->evlist, evsel, 0, j, f_id); 2827 } 2828 2829 lseek(fd, tmp, SEEK_SET); 2830 } 2831 2832 symbol_conf.nr_events = nr_attrs; 2833 2834 perf_header__process_sections(header, fd, &session->tevent, 2835 perf_file_section__process); 2836 2837 if (perf_evlist__prepare_tracepoint_events(session->evlist, 2838 session->tevent.pevent)) 2839 goto out_delete_evlist; 2840 2841 return 0; 2842 out_errno: 2843 return -errno; 2844 2845 out_delete_evlist: 2846 perf_evlist__delete(session->evlist); 2847 session->evlist = NULL; 2848 return -ENOMEM; 2849 } 2850 2851 int perf_event__synthesize_attr(struct perf_tool *tool, 2852 struct perf_event_attr *attr, u32 ids, u64 *id, 2853 perf_event__handler_t process) 2854 { 2855 union perf_event *ev; 2856 size_t size; 2857 int err; 2858 2859 size = sizeof(struct perf_event_attr); 2860 size = PERF_ALIGN(size, sizeof(u64)); 2861 size += sizeof(struct perf_event_header); 2862 size += ids * sizeof(u64); 2863 2864 ev = malloc(size); 2865 2866 if (ev == NULL) 2867 return -ENOMEM; 2868 2869 ev->attr.attr = *attr; 2870 memcpy(ev->attr.id, id, ids * sizeof(u64)); 2871 2872 ev->attr.header.type = PERF_RECORD_HEADER_ATTR; 2873 ev->attr.header.size = (u16)size; 2874 2875 if (ev->attr.header.size == size) 2876 err = process(tool, ev, NULL, NULL); 2877 else 2878 err = -E2BIG; 2879 2880 free(ev); 2881 2882 return err; 2883 } 2884 2885 int perf_event__synthesize_attrs(struct perf_tool *tool, 2886 struct perf_session *session, 2887 perf_event__handler_t process) 2888 { 2889 struct perf_evsel *evsel; 2890 int err = 0; 2891 2892 evlist__for_each(session->evlist, evsel) { 2893 err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids, 2894 evsel->id, process); 2895 if (err) { 2896 pr_debug("failed to create perf header attribute\n"); 2897 return err; 2898 } 2899 } 2900 2901 return err; 2902 } 2903 2904 int perf_event__process_attr(struct perf_tool *tool __maybe_unused, 2905 union perf_event *event, 2906 struct perf_evlist **pevlist) 2907 { 2908 u32 i, ids, n_ids; 2909 struct perf_evsel *evsel; 2910 struct perf_evlist *evlist = *pevlist; 2911 2912 if (evlist == NULL) { 2913 *pevlist = evlist = perf_evlist__new(); 2914 if (evlist == NULL) 2915 return -ENOMEM; 2916 } 2917 2918 evsel = perf_evsel__new(&event->attr.attr); 2919 if (evsel == NULL) 2920 return -ENOMEM; 2921 2922 perf_evlist__add(evlist, evsel); 2923 2924 ids = event->header.size; 2925 ids -= (void *)&event->attr.id - (void *)event; 2926 n_ids = ids / sizeof(u64); 2927 /* 2928 * We don't have the cpu and thread maps on the header, so 2929 * for allocating the perf_sample_id table we fake 1 cpu and 2930 * hattr->ids threads. 2931 */ 2932 if (perf_evsel__alloc_id(evsel, 1, n_ids)) 2933 return -ENOMEM; 2934 2935 for (i = 0; i < n_ids; i++) { 2936 perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]); 2937 } 2938 2939 symbol_conf.nr_events = evlist->nr_entries; 2940 2941 return 0; 2942 } 2943 2944 int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd, 2945 struct perf_evlist *evlist, 2946 perf_event__handler_t process) 2947 { 2948 union perf_event ev; 2949 struct tracing_data *tdata; 2950 ssize_t size = 0, aligned_size = 0, padding; 2951 int err __maybe_unused = 0; 2952 2953 /* 2954 * We are going to store the size of the data followed 2955 * by the data contents. Since the fd descriptor is a pipe, 2956 * we cannot seek back to store the size of the data once 2957 * we know it. Instead we: 2958 * 2959 * - write the tracing data to the temp file 2960 * - get/write the data size to pipe 2961 * - write the tracing data from the temp file 2962 * to the pipe 2963 */ 2964 tdata = tracing_data_get(&evlist->entries, fd, true); 2965 if (!tdata) 2966 return -1; 2967 2968 memset(&ev, 0, sizeof(ev)); 2969 2970 ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA; 2971 size = tdata->size; 2972 aligned_size = PERF_ALIGN(size, sizeof(u64)); 2973 padding = aligned_size - size; 2974 ev.tracing_data.header.size = sizeof(ev.tracing_data); 2975 ev.tracing_data.size = aligned_size; 2976 2977 process(tool, &ev, NULL, NULL); 2978 2979 /* 2980 * The put function will copy all the tracing data 2981 * stored in temp file to the pipe. 2982 */ 2983 tracing_data_put(tdata); 2984 2985 write_padded(fd, NULL, 0, padding); 2986 2987 return aligned_size; 2988 } 2989 2990 int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused, 2991 union perf_event *event, 2992 struct perf_session *session) 2993 { 2994 ssize_t size_read, padding, size = event->tracing_data.size; 2995 int fd = perf_data_file__fd(session->file); 2996 off_t offset = lseek(fd, 0, SEEK_CUR); 2997 char buf[BUFSIZ]; 2998 2999 /* setup for reading amidst mmap */ 3000 lseek(fd, offset + sizeof(struct tracing_data_event), 3001 SEEK_SET); 3002 3003 size_read = trace_report(fd, &session->tevent, 3004 session->repipe); 3005 padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read; 3006 3007 if (readn(fd, buf, padding) < 0) { 3008 pr_err("%s: reading input file", __func__); 3009 return -1; 3010 } 3011 if (session->repipe) { 3012 int retw = write(STDOUT_FILENO, buf, padding); 3013 if (retw <= 0 || retw != padding) { 3014 pr_err("%s: repiping tracing data padding", __func__); 3015 return -1; 3016 } 3017 } 3018 3019 if (size_read + padding != size) { 3020 pr_err("%s: tracing data size mismatch", __func__); 3021 return -1; 3022 } 3023 3024 perf_evlist__prepare_tracepoint_events(session->evlist, 3025 session->tevent.pevent); 3026 3027 return size_read + padding; 3028 } 3029 3030 int perf_event__synthesize_build_id(struct perf_tool *tool, 3031 struct dso *pos, u16 misc, 3032 perf_event__handler_t process, 3033 struct machine *machine) 3034 { 3035 union perf_event ev; 3036 size_t len; 3037 int err = 0; 3038 3039 if (!pos->hit) 3040 return err; 3041 3042 memset(&ev, 0, sizeof(ev)); 3043 3044 len = pos->long_name_len + 1; 3045 len = PERF_ALIGN(len, NAME_ALIGN); 3046 memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id)); 3047 ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID; 3048 ev.build_id.header.misc = misc; 3049 ev.build_id.pid = machine->pid; 3050 ev.build_id.header.size = sizeof(ev.build_id) + len; 3051 memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len); 3052 3053 err = process(tool, &ev, NULL, machine); 3054 3055 return err; 3056 } 3057 3058 int perf_event__process_build_id(struct perf_tool *tool __maybe_unused, 3059 union perf_event *event, 3060 struct perf_session *session) 3061 { 3062 __event_process_build_id(&event->build_id, 3063 event->build_id.filename, 3064 session); 3065 return 0; 3066 } 3067 3068 void disable_buildid_cache(void) 3069 { 3070 no_buildid_cache = true; 3071 } 3072