1 // SPDX-License-Identifier: GPL-2.0 2 #include <errno.h> 3 #include <inttypes.h> 4 #include "string2.h" 5 #include <sys/param.h> 6 #include <sys/types.h> 7 #include <byteswap.h> 8 #include <unistd.h> 9 #include <stdio.h> 10 #include <stdlib.h> 11 #include <linux/compiler.h> 12 #include <linux/list.h> 13 #include <linux/kernel.h> 14 #include <linux/bitops.h> 15 #include <linux/string.h> 16 #include <linux/stringify.h> 17 #include <linux/zalloc.h> 18 #include <sys/stat.h> 19 #include <sys/utsname.h> 20 #include <linux/time64.h> 21 #include <dirent.h> 22 #ifdef HAVE_LIBBPF_SUPPORT 23 #include <bpf/libbpf.h> 24 #endif 25 #include <perf/cpumap.h> 26 27 #include "dso.h" 28 #include "evlist.h" 29 #include "evsel.h" 30 #include "util/evsel_fprintf.h" 31 #include "header.h" 32 #include "memswap.h" 33 #include "trace-event.h" 34 #include "session.h" 35 #include "symbol.h" 36 #include "debug.h" 37 #include "cpumap.h" 38 #include "pmu.h" 39 #include "vdso.h" 40 #include "strbuf.h" 41 #include "build-id.h" 42 #include "data.h" 43 #include <api/fs/fs.h> 44 #include "asm/bug.h" 45 #include "tool.h" 46 #include "time-utils.h" 47 #include "units.h" 48 #include "util/util.h" // perf_exe() 49 #include "cputopo.h" 50 #include "bpf-event.h" 51 #include "bpf-utils.h" 52 #include "clockid.h" 53 #include "pmu-hybrid.h" 54 55 #include <linux/ctype.h> 56 #include <internal/lib.h> 57 58 /* 59 * magic2 = "PERFILE2" 60 * must be a numerical value to let the endianness 61 * determine the memory layout. That way we are able 62 * to detect endianness when reading the perf.data file 63 * back. 64 * 65 * we check for legacy (PERFFILE) format. 66 */ 67 static const char *__perf_magic1 = "PERFFILE"; 68 static const u64 __perf_magic2 = 0x32454c4946524550ULL; 69 static const u64 __perf_magic2_sw = 0x50455246494c4532ULL; 70 71 #define PERF_MAGIC __perf_magic2 72 73 const char perf_version_string[] = PERF_VERSION; 74 75 struct perf_file_attr { 76 struct perf_event_attr attr; 77 struct perf_file_section ids; 78 }; 79 80 void perf_header__set_feat(struct perf_header *header, int feat) 81 { 82 set_bit(feat, header->adds_features); 83 } 84 85 void perf_header__clear_feat(struct perf_header *header, int feat) 86 { 87 clear_bit(feat, header->adds_features); 88 } 89 90 bool perf_header__has_feat(const struct perf_header *header, int feat) 91 { 92 return test_bit(feat, header->adds_features); 93 } 94 95 static int __do_write_fd(struct feat_fd *ff, const void *buf, size_t size) 96 { 97 ssize_t ret = writen(ff->fd, buf, size); 98 99 if (ret != (ssize_t)size) 100 return ret < 0 ? (int)ret : -1; 101 return 0; 102 } 103 104 static int __do_write_buf(struct feat_fd *ff, const void *buf, size_t size) 105 { 106 /* struct perf_event_header::size is u16 */ 107 const size_t max_size = 0xffff - sizeof(struct perf_event_header); 108 size_t new_size = ff->size; 109 void *addr; 110 111 if (size + ff->offset > max_size) 112 return -E2BIG; 113 114 while (size > (new_size - ff->offset)) 115 new_size <<= 1; 116 new_size = min(max_size, new_size); 117 118 if (ff->size < new_size) { 119 addr = realloc(ff->buf, new_size); 120 if (!addr) 121 return -ENOMEM; 122 ff->buf = addr; 123 ff->size = new_size; 124 } 125 126 memcpy(ff->buf + ff->offset, buf, size); 127 ff->offset += size; 128 129 return 0; 130 } 131 132 /* Return: 0 if succeeded, -ERR if failed. */ 133 int do_write(struct feat_fd *ff, const void *buf, size_t size) 134 { 135 if (!ff->buf) 136 return __do_write_fd(ff, buf, size); 137 return __do_write_buf(ff, buf, size); 138 } 139 140 /* Return: 0 if succeeded, -ERR if failed. */ 141 static int do_write_bitmap(struct feat_fd *ff, unsigned long *set, u64 size) 142 { 143 u64 *p = (u64 *) set; 144 int i, ret; 145 146 ret = do_write(ff, &size, sizeof(size)); 147 if (ret < 0) 148 return ret; 149 150 for (i = 0; (u64) i < BITS_TO_U64(size); i++) { 151 ret = do_write(ff, p + i, sizeof(*p)); 152 if (ret < 0) 153 return ret; 154 } 155 156 return 0; 157 } 158 159 /* Return: 0 if succeeded, -ERR if failed. */ 160 int write_padded(struct feat_fd *ff, const void *bf, 161 size_t count, size_t count_aligned) 162 { 163 static const char zero_buf[NAME_ALIGN]; 164 int err = do_write(ff, bf, count); 165 166 if (!err) 167 err = do_write(ff, zero_buf, count_aligned - count); 168 169 return err; 170 } 171 172 #define string_size(str) \ 173 (PERF_ALIGN((strlen(str) + 1), NAME_ALIGN) + sizeof(u32)) 174 175 /* Return: 0 if succeeded, -ERR if failed. */ 176 static int do_write_string(struct feat_fd *ff, const char *str) 177 { 178 u32 len, olen; 179 int ret; 180 181 olen = strlen(str) + 1; 182 len = PERF_ALIGN(olen, NAME_ALIGN); 183 184 /* write len, incl. \0 */ 185 ret = do_write(ff, &len, sizeof(len)); 186 if (ret < 0) 187 return ret; 188 189 return write_padded(ff, str, olen, len); 190 } 191 192 static int __do_read_fd(struct feat_fd *ff, void *addr, ssize_t size) 193 { 194 ssize_t ret = readn(ff->fd, addr, size); 195 196 if (ret != size) 197 return ret < 0 ? (int)ret : -1; 198 return 0; 199 } 200 201 static int __do_read_buf(struct feat_fd *ff, void *addr, ssize_t size) 202 { 203 if (size > (ssize_t)ff->size - ff->offset) 204 return -1; 205 206 memcpy(addr, ff->buf + ff->offset, size); 207 ff->offset += size; 208 209 return 0; 210 211 } 212 213 static int __do_read(struct feat_fd *ff, void *addr, ssize_t size) 214 { 215 if (!ff->buf) 216 return __do_read_fd(ff, addr, size); 217 return __do_read_buf(ff, addr, size); 218 } 219 220 static int do_read_u32(struct feat_fd *ff, u32 *addr) 221 { 222 int ret; 223 224 ret = __do_read(ff, addr, sizeof(*addr)); 225 if (ret) 226 return ret; 227 228 if (ff->ph->needs_swap) 229 *addr = bswap_32(*addr); 230 return 0; 231 } 232 233 static int do_read_u64(struct feat_fd *ff, u64 *addr) 234 { 235 int ret; 236 237 ret = __do_read(ff, addr, sizeof(*addr)); 238 if (ret) 239 return ret; 240 241 if (ff->ph->needs_swap) 242 *addr = bswap_64(*addr); 243 return 0; 244 } 245 246 static char *do_read_string(struct feat_fd *ff) 247 { 248 u32 len; 249 char *buf; 250 251 if (do_read_u32(ff, &len)) 252 return NULL; 253 254 buf = malloc(len); 255 if (!buf) 256 return NULL; 257 258 if (!__do_read(ff, buf, len)) { 259 /* 260 * strings are padded by zeroes 261 * thus the actual strlen of buf 262 * may be less than len 263 */ 264 return buf; 265 } 266 267 free(buf); 268 return NULL; 269 } 270 271 /* Return: 0 if succeeded, -ERR if failed. */ 272 static int do_read_bitmap(struct feat_fd *ff, unsigned long **pset, u64 *psize) 273 { 274 unsigned long *set; 275 u64 size, *p; 276 int i, ret; 277 278 ret = do_read_u64(ff, &size); 279 if (ret) 280 return ret; 281 282 set = bitmap_zalloc(size); 283 if (!set) 284 return -ENOMEM; 285 286 p = (u64 *) set; 287 288 for (i = 0; (u64) i < BITS_TO_U64(size); i++) { 289 ret = do_read_u64(ff, p + i); 290 if (ret < 0) { 291 free(set); 292 return ret; 293 } 294 } 295 296 *pset = set; 297 *psize = size; 298 return 0; 299 } 300 301 static int write_tracing_data(struct feat_fd *ff, 302 struct evlist *evlist) 303 { 304 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__)) 305 return -1; 306 307 return read_tracing_data(ff->fd, &evlist->core.entries); 308 } 309 310 static int write_build_id(struct feat_fd *ff, 311 struct evlist *evlist __maybe_unused) 312 { 313 struct perf_session *session; 314 int err; 315 316 session = container_of(ff->ph, struct perf_session, header); 317 318 if (!perf_session__read_build_ids(session, true)) 319 return -1; 320 321 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__)) 322 return -1; 323 324 err = perf_session__write_buildid_table(session, ff); 325 if (err < 0) { 326 pr_debug("failed to write buildid table\n"); 327 return err; 328 } 329 perf_session__cache_build_ids(session); 330 331 return 0; 332 } 333 334 static int write_hostname(struct feat_fd *ff, 335 struct evlist *evlist __maybe_unused) 336 { 337 struct utsname uts; 338 int ret; 339 340 ret = uname(&uts); 341 if (ret < 0) 342 return -1; 343 344 return do_write_string(ff, uts.nodename); 345 } 346 347 static int write_osrelease(struct feat_fd *ff, 348 struct evlist *evlist __maybe_unused) 349 { 350 struct utsname uts; 351 int ret; 352 353 ret = uname(&uts); 354 if (ret < 0) 355 return -1; 356 357 return do_write_string(ff, uts.release); 358 } 359 360 static int write_arch(struct feat_fd *ff, 361 struct evlist *evlist __maybe_unused) 362 { 363 struct utsname uts; 364 int ret; 365 366 ret = uname(&uts); 367 if (ret < 0) 368 return -1; 369 370 return do_write_string(ff, uts.machine); 371 } 372 373 static int write_version(struct feat_fd *ff, 374 struct evlist *evlist __maybe_unused) 375 { 376 return do_write_string(ff, perf_version_string); 377 } 378 379 static int __write_cpudesc(struct feat_fd *ff, const char *cpuinfo_proc) 380 { 381 FILE *file; 382 char *buf = NULL; 383 char *s, *p; 384 const char *search = cpuinfo_proc; 385 size_t len = 0; 386 int ret = -1; 387 388 if (!search) 389 return -1; 390 391 file = fopen("/proc/cpuinfo", "r"); 392 if (!file) 393 return -1; 394 395 while (getline(&buf, &len, file) > 0) { 396 ret = strncmp(buf, search, strlen(search)); 397 if (!ret) 398 break; 399 } 400 401 if (ret) { 402 ret = -1; 403 goto done; 404 } 405 406 s = buf; 407 408 p = strchr(buf, ':'); 409 if (p && *(p+1) == ' ' && *(p+2)) 410 s = p + 2; 411 p = strchr(s, '\n'); 412 if (p) 413 *p = '\0'; 414 415 /* squash extra space characters (branding string) */ 416 p = s; 417 while (*p) { 418 if (isspace(*p)) { 419 char *r = p + 1; 420 char *q = skip_spaces(r); 421 *p = ' '; 422 if (q != (p+1)) 423 while ((*r++ = *q++)); 424 } 425 p++; 426 } 427 ret = do_write_string(ff, s); 428 done: 429 free(buf); 430 fclose(file); 431 return ret; 432 } 433 434 static int write_cpudesc(struct feat_fd *ff, 435 struct evlist *evlist __maybe_unused) 436 { 437 #if defined(__powerpc__) || defined(__hppa__) || defined(__sparc__) 438 #define CPUINFO_PROC { "cpu", } 439 #elif defined(__s390__) 440 #define CPUINFO_PROC { "vendor_id", } 441 #elif defined(__sh__) 442 #define CPUINFO_PROC { "cpu type", } 443 #elif defined(__alpha__) || defined(__mips__) 444 #define CPUINFO_PROC { "cpu model", } 445 #elif defined(__arm__) 446 #define CPUINFO_PROC { "model name", "Processor", } 447 #elif defined(__arc__) 448 #define CPUINFO_PROC { "Processor", } 449 #elif defined(__xtensa__) 450 #define CPUINFO_PROC { "core ID", } 451 #else 452 #define CPUINFO_PROC { "model name", } 453 #endif 454 const char *cpuinfo_procs[] = CPUINFO_PROC; 455 #undef CPUINFO_PROC 456 unsigned int i; 457 458 for (i = 0; i < ARRAY_SIZE(cpuinfo_procs); i++) { 459 int ret; 460 ret = __write_cpudesc(ff, cpuinfo_procs[i]); 461 if (ret >= 0) 462 return ret; 463 } 464 return -1; 465 } 466 467 468 static int write_nrcpus(struct feat_fd *ff, 469 struct evlist *evlist __maybe_unused) 470 { 471 long nr; 472 u32 nrc, nra; 473 int ret; 474 475 nrc = cpu__max_present_cpu().cpu; 476 477 nr = sysconf(_SC_NPROCESSORS_ONLN); 478 if (nr < 0) 479 return -1; 480 481 nra = (u32)(nr & UINT_MAX); 482 483 ret = do_write(ff, &nrc, sizeof(nrc)); 484 if (ret < 0) 485 return ret; 486 487 return do_write(ff, &nra, sizeof(nra)); 488 } 489 490 static int write_event_desc(struct feat_fd *ff, 491 struct evlist *evlist) 492 { 493 struct evsel *evsel; 494 u32 nre, nri, sz; 495 int ret; 496 497 nre = evlist->core.nr_entries; 498 499 /* 500 * write number of events 501 */ 502 ret = do_write(ff, &nre, sizeof(nre)); 503 if (ret < 0) 504 return ret; 505 506 /* 507 * size of perf_event_attr struct 508 */ 509 sz = (u32)sizeof(evsel->core.attr); 510 ret = do_write(ff, &sz, sizeof(sz)); 511 if (ret < 0) 512 return ret; 513 514 evlist__for_each_entry(evlist, evsel) { 515 ret = do_write(ff, &evsel->core.attr, sz); 516 if (ret < 0) 517 return ret; 518 /* 519 * write number of unique id per event 520 * there is one id per instance of an event 521 * 522 * copy into an nri to be independent of the 523 * type of ids, 524 */ 525 nri = evsel->core.ids; 526 ret = do_write(ff, &nri, sizeof(nri)); 527 if (ret < 0) 528 return ret; 529 530 /* 531 * write event string as passed on cmdline 532 */ 533 ret = do_write_string(ff, evsel__name(evsel)); 534 if (ret < 0) 535 return ret; 536 /* 537 * write unique ids for this event 538 */ 539 ret = do_write(ff, evsel->core.id, evsel->core.ids * sizeof(u64)); 540 if (ret < 0) 541 return ret; 542 } 543 return 0; 544 } 545 546 static int write_cmdline(struct feat_fd *ff, 547 struct evlist *evlist __maybe_unused) 548 { 549 char pbuf[MAXPATHLEN], *buf; 550 int i, ret, n; 551 552 /* actual path to perf binary */ 553 buf = perf_exe(pbuf, MAXPATHLEN); 554 555 /* account for binary path */ 556 n = perf_env.nr_cmdline + 1; 557 558 ret = do_write(ff, &n, sizeof(n)); 559 if (ret < 0) 560 return ret; 561 562 ret = do_write_string(ff, buf); 563 if (ret < 0) 564 return ret; 565 566 for (i = 0 ; i < perf_env.nr_cmdline; i++) { 567 ret = do_write_string(ff, perf_env.cmdline_argv[i]); 568 if (ret < 0) 569 return ret; 570 } 571 return 0; 572 } 573 574 575 static int write_cpu_topology(struct feat_fd *ff, 576 struct evlist *evlist __maybe_unused) 577 { 578 struct cpu_topology *tp; 579 u32 i; 580 int ret, j; 581 582 tp = cpu_topology__new(); 583 if (!tp) 584 return -1; 585 586 ret = do_write(ff, &tp->package_cpus_lists, sizeof(tp->package_cpus_lists)); 587 if (ret < 0) 588 goto done; 589 590 for (i = 0; i < tp->package_cpus_lists; i++) { 591 ret = do_write_string(ff, tp->package_cpus_list[i]); 592 if (ret < 0) 593 goto done; 594 } 595 ret = do_write(ff, &tp->core_cpus_lists, sizeof(tp->core_cpus_lists)); 596 if (ret < 0) 597 goto done; 598 599 for (i = 0; i < tp->core_cpus_lists; i++) { 600 ret = do_write_string(ff, tp->core_cpus_list[i]); 601 if (ret < 0) 602 break; 603 } 604 605 ret = perf_env__read_cpu_topology_map(&perf_env); 606 if (ret < 0) 607 goto done; 608 609 for (j = 0; j < perf_env.nr_cpus_avail; j++) { 610 ret = do_write(ff, &perf_env.cpu[j].core_id, 611 sizeof(perf_env.cpu[j].core_id)); 612 if (ret < 0) 613 return ret; 614 ret = do_write(ff, &perf_env.cpu[j].socket_id, 615 sizeof(perf_env.cpu[j].socket_id)); 616 if (ret < 0) 617 return ret; 618 } 619 620 if (!tp->die_cpus_lists) 621 goto done; 622 623 ret = do_write(ff, &tp->die_cpus_lists, sizeof(tp->die_cpus_lists)); 624 if (ret < 0) 625 goto done; 626 627 for (i = 0; i < tp->die_cpus_lists; i++) { 628 ret = do_write_string(ff, tp->die_cpus_list[i]); 629 if (ret < 0) 630 goto done; 631 } 632 633 for (j = 0; j < perf_env.nr_cpus_avail; j++) { 634 ret = do_write(ff, &perf_env.cpu[j].die_id, 635 sizeof(perf_env.cpu[j].die_id)); 636 if (ret < 0) 637 return ret; 638 } 639 640 done: 641 cpu_topology__delete(tp); 642 return ret; 643 } 644 645 646 647 static int write_total_mem(struct feat_fd *ff, 648 struct evlist *evlist __maybe_unused) 649 { 650 char *buf = NULL; 651 FILE *fp; 652 size_t len = 0; 653 int ret = -1, n; 654 uint64_t mem; 655 656 fp = fopen("/proc/meminfo", "r"); 657 if (!fp) 658 return -1; 659 660 while (getline(&buf, &len, fp) > 0) { 661 ret = strncmp(buf, "MemTotal:", 9); 662 if (!ret) 663 break; 664 } 665 if (!ret) { 666 n = sscanf(buf, "%*s %"PRIu64, &mem); 667 if (n == 1) 668 ret = do_write(ff, &mem, sizeof(mem)); 669 } else 670 ret = -1; 671 free(buf); 672 fclose(fp); 673 return ret; 674 } 675 676 static int write_numa_topology(struct feat_fd *ff, 677 struct evlist *evlist __maybe_unused) 678 { 679 struct numa_topology *tp; 680 int ret = -1; 681 u32 i; 682 683 tp = numa_topology__new(); 684 if (!tp) 685 return -ENOMEM; 686 687 ret = do_write(ff, &tp->nr, sizeof(u32)); 688 if (ret < 0) 689 goto err; 690 691 for (i = 0; i < tp->nr; i++) { 692 struct numa_topology_node *n = &tp->nodes[i]; 693 694 ret = do_write(ff, &n->node, sizeof(u32)); 695 if (ret < 0) 696 goto err; 697 698 ret = do_write(ff, &n->mem_total, sizeof(u64)); 699 if (ret) 700 goto err; 701 702 ret = do_write(ff, &n->mem_free, sizeof(u64)); 703 if (ret) 704 goto err; 705 706 ret = do_write_string(ff, n->cpus); 707 if (ret < 0) 708 goto err; 709 } 710 711 ret = 0; 712 713 err: 714 numa_topology__delete(tp); 715 return ret; 716 } 717 718 /* 719 * File format: 720 * 721 * struct pmu_mappings { 722 * u32 pmu_num; 723 * struct pmu_map { 724 * u32 type; 725 * char name[]; 726 * }[pmu_num]; 727 * }; 728 */ 729 730 static int write_pmu_mappings(struct feat_fd *ff, 731 struct evlist *evlist __maybe_unused) 732 { 733 struct perf_pmu *pmu = NULL; 734 u32 pmu_num = 0; 735 int ret; 736 737 /* 738 * Do a first pass to count number of pmu to avoid lseek so this 739 * works in pipe mode as well. 740 */ 741 while ((pmu = perf_pmu__scan(pmu))) { 742 if (!pmu->name) 743 continue; 744 pmu_num++; 745 } 746 747 ret = do_write(ff, &pmu_num, sizeof(pmu_num)); 748 if (ret < 0) 749 return ret; 750 751 while ((pmu = perf_pmu__scan(pmu))) { 752 if (!pmu->name) 753 continue; 754 755 ret = do_write(ff, &pmu->type, sizeof(pmu->type)); 756 if (ret < 0) 757 return ret; 758 759 ret = do_write_string(ff, pmu->name); 760 if (ret < 0) 761 return ret; 762 } 763 764 return 0; 765 } 766 767 /* 768 * File format: 769 * 770 * struct group_descs { 771 * u32 nr_groups; 772 * struct group_desc { 773 * char name[]; 774 * u32 leader_idx; 775 * u32 nr_members; 776 * }[nr_groups]; 777 * }; 778 */ 779 static int write_group_desc(struct feat_fd *ff, 780 struct evlist *evlist) 781 { 782 u32 nr_groups = evlist->core.nr_groups; 783 struct evsel *evsel; 784 int ret; 785 786 ret = do_write(ff, &nr_groups, sizeof(nr_groups)); 787 if (ret < 0) 788 return ret; 789 790 evlist__for_each_entry(evlist, evsel) { 791 if (evsel__is_group_leader(evsel) && evsel->core.nr_members > 1) { 792 const char *name = evsel->group_name ?: "{anon_group}"; 793 u32 leader_idx = evsel->core.idx; 794 u32 nr_members = evsel->core.nr_members; 795 796 ret = do_write_string(ff, name); 797 if (ret < 0) 798 return ret; 799 800 ret = do_write(ff, &leader_idx, sizeof(leader_idx)); 801 if (ret < 0) 802 return ret; 803 804 ret = do_write(ff, &nr_members, sizeof(nr_members)); 805 if (ret < 0) 806 return ret; 807 } 808 } 809 return 0; 810 } 811 812 /* 813 * Return the CPU id as a raw string. 814 * 815 * Each architecture should provide a more precise id string that 816 * can be use to match the architecture's "mapfile". 817 */ 818 char * __weak get_cpuid_str(struct perf_pmu *pmu __maybe_unused) 819 { 820 return NULL; 821 } 822 823 /* Return zero when the cpuid from the mapfile.csv matches the 824 * cpuid string generated on this platform. 825 * Otherwise return non-zero. 826 */ 827 int __weak strcmp_cpuid_str(const char *mapcpuid, const char *cpuid) 828 { 829 regex_t re; 830 regmatch_t pmatch[1]; 831 int match; 832 833 if (regcomp(&re, mapcpuid, REG_EXTENDED) != 0) { 834 /* Warn unable to generate match particular string. */ 835 pr_info("Invalid regular expression %s\n", mapcpuid); 836 return 1; 837 } 838 839 match = !regexec(&re, cpuid, 1, pmatch, 0); 840 regfree(&re); 841 if (match) { 842 size_t match_len = (pmatch[0].rm_eo - pmatch[0].rm_so); 843 844 /* Verify the entire string matched. */ 845 if (match_len == strlen(cpuid)) 846 return 0; 847 } 848 return 1; 849 } 850 851 /* 852 * default get_cpuid(): nothing gets recorded 853 * actual implementation must be in arch/$(SRCARCH)/util/header.c 854 */ 855 int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused) 856 { 857 return ENOSYS; /* Not implemented */ 858 } 859 860 static int write_cpuid(struct feat_fd *ff, 861 struct evlist *evlist __maybe_unused) 862 { 863 char buffer[64]; 864 int ret; 865 866 ret = get_cpuid(buffer, sizeof(buffer)); 867 if (ret) 868 return -1; 869 870 return do_write_string(ff, buffer); 871 } 872 873 static int write_branch_stack(struct feat_fd *ff __maybe_unused, 874 struct evlist *evlist __maybe_unused) 875 { 876 return 0; 877 } 878 879 static int write_auxtrace(struct feat_fd *ff, 880 struct evlist *evlist __maybe_unused) 881 { 882 struct perf_session *session; 883 int err; 884 885 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__)) 886 return -1; 887 888 session = container_of(ff->ph, struct perf_session, header); 889 890 err = auxtrace_index__write(ff->fd, &session->auxtrace_index); 891 if (err < 0) 892 pr_err("Failed to write auxtrace index\n"); 893 return err; 894 } 895 896 static int write_clockid(struct feat_fd *ff, 897 struct evlist *evlist __maybe_unused) 898 { 899 return do_write(ff, &ff->ph->env.clock.clockid_res_ns, 900 sizeof(ff->ph->env.clock.clockid_res_ns)); 901 } 902 903 static int write_clock_data(struct feat_fd *ff, 904 struct evlist *evlist __maybe_unused) 905 { 906 u64 *data64; 907 u32 data32; 908 int ret; 909 910 /* version */ 911 data32 = 1; 912 913 ret = do_write(ff, &data32, sizeof(data32)); 914 if (ret < 0) 915 return ret; 916 917 /* clockid */ 918 data32 = ff->ph->env.clock.clockid; 919 920 ret = do_write(ff, &data32, sizeof(data32)); 921 if (ret < 0) 922 return ret; 923 924 /* TOD ref time */ 925 data64 = &ff->ph->env.clock.tod_ns; 926 927 ret = do_write(ff, data64, sizeof(*data64)); 928 if (ret < 0) 929 return ret; 930 931 /* clockid ref time */ 932 data64 = &ff->ph->env.clock.clockid_ns; 933 934 return do_write(ff, data64, sizeof(*data64)); 935 } 936 937 static int write_hybrid_topology(struct feat_fd *ff, 938 struct evlist *evlist __maybe_unused) 939 { 940 struct hybrid_topology *tp; 941 int ret; 942 u32 i; 943 944 tp = hybrid_topology__new(); 945 if (!tp) 946 return -ENOENT; 947 948 ret = do_write(ff, &tp->nr, sizeof(u32)); 949 if (ret < 0) 950 goto err; 951 952 for (i = 0; i < tp->nr; i++) { 953 struct hybrid_topology_node *n = &tp->nodes[i]; 954 955 ret = do_write_string(ff, n->pmu_name); 956 if (ret < 0) 957 goto err; 958 959 ret = do_write_string(ff, n->cpus); 960 if (ret < 0) 961 goto err; 962 } 963 964 ret = 0; 965 966 err: 967 hybrid_topology__delete(tp); 968 return ret; 969 } 970 971 static int write_dir_format(struct feat_fd *ff, 972 struct evlist *evlist __maybe_unused) 973 { 974 struct perf_session *session; 975 struct perf_data *data; 976 977 session = container_of(ff->ph, struct perf_session, header); 978 data = session->data; 979 980 if (WARN_ON(!perf_data__is_dir(data))) 981 return -1; 982 983 return do_write(ff, &data->dir.version, sizeof(data->dir.version)); 984 } 985 986 /* 987 * Check whether a CPU is online 988 * 989 * Returns: 990 * 1 -> if CPU is online 991 * 0 -> if CPU is offline 992 * -1 -> error case 993 */ 994 int is_cpu_online(unsigned int cpu) 995 { 996 char *str; 997 size_t strlen; 998 char buf[256]; 999 int status = -1; 1000 struct stat statbuf; 1001 1002 snprintf(buf, sizeof(buf), 1003 "/sys/devices/system/cpu/cpu%d", cpu); 1004 if (stat(buf, &statbuf) != 0) 1005 return 0; 1006 1007 /* 1008 * Check if /sys/devices/system/cpu/cpux/online file 1009 * exists. Some cases cpu0 won't have online file since 1010 * it is not expected to be turned off generally. 1011 * In kernels without CONFIG_HOTPLUG_CPU, this 1012 * file won't exist 1013 */ 1014 snprintf(buf, sizeof(buf), 1015 "/sys/devices/system/cpu/cpu%d/online", cpu); 1016 if (stat(buf, &statbuf) != 0) 1017 return 1; 1018 1019 /* 1020 * Read online file using sysfs__read_str. 1021 * If read or open fails, return -1. 1022 * If read succeeds, return value from file 1023 * which gets stored in "str" 1024 */ 1025 snprintf(buf, sizeof(buf), 1026 "devices/system/cpu/cpu%d/online", cpu); 1027 1028 if (sysfs__read_str(buf, &str, &strlen) < 0) 1029 return status; 1030 1031 status = atoi(str); 1032 1033 free(str); 1034 return status; 1035 } 1036 1037 #ifdef HAVE_LIBBPF_SUPPORT 1038 static int write_bpf_prog_info(struct feat_fd *ff, 1039 struct evlist *evlist __maybe_unused) 1040 { 1041 struct perf_env *env = &ff->ph->env; 1042 struct rb_root *root; 1043 struct rb_node *next; 1044 int ret; 1045 1046 down_read(&env->bpf_progs.lock); 1047 1048 ret = do_write(ff, &env->bpf_progs.infos_cnt, 1049 sizeof(env->bpf_progs.infos_cnt)); 1050 if (ret < 0) 1051 goto out; 1052 1053 root = &env->bpf_progs.infos; 1054 next = rb_first(root); 1055 while (next) { 1056 struct bpf_prog_info_node *node; 1057 size_t len; 1058 1059 node = rb_entry(next, struct bpf_prog_info_node, rb_node); 1060 next = rb_next(&node->rb_node); 1061 len = sizeof(struct perf_bpil) + 1062 node->info_linear->data_len; 1063 1064 /* before writing to file, translate address to offset */ 1065 bpil_addr_to_offs(node->info_linear); 1066 ret = do_write(ff, node->info_linear, len); 1067 /* 1068 * translate back to address even when do_write() fails, 1069 * so that this function never changes the data. 1070 */ 1071 bpil_offs_to_addr(node->info_linear); 1072 if (ret < 0) 1073 goto out; 1074 } 1075 out: 1076 up_read(&env->bpf_progs.lock); 1077 return ret; 1078 } 1079 1080 static int write_bpf_btf(struct feat_fd *ff, 1081 struct evlist *evlist __maybe_unused) 1082 { 1083 struct perf_env *env = &ff->ph->env; 1084 struct rb_root *root; 1085 struct rb_node *next; 1086 int ret; 1087 1088 down_read(&env->bpf_progs.lock); 1089 1090 ret = do_write(ff, &env->bpf_progs.btfs_cnt, 1091 sizeof(env->bpf_progs.btfs_cnt)); 1092 1093 if (ret < 0) 1094 goto out; 1095 1096 root = &env->bpf_progs.btfs; 1097 next = rb_first(root); 1098 while (next) { 1099 struct btf_node *node; 1100 1101 node = rb_entry(next, struct btf_node, rb_node); 1102 next = rb_next(&node->rb_node); 1103 ret = do_write(ff, &node->id, 1104 sizeof(u32) * 2 + node->data_size); 1105 if (ret < 0) 1106 goto out; 1107 } 1108 out: 1109 up_read(&env->bpf_progs.lock); 1110 return ret; 1111 } 1112 #endif // HAVE_LIBBPF_SUPPORT 1113 1114 static int cpu_cache_level__sort(const void *a, const void *b) 1115 { 1116 struct cpu_cache_level *cache_a = (struct cpu_cache_level *)a; 1117 struct cpu_cache_level *cache_b = (struct cpu_cache_level *)b; 1118 1119 return cache_a->level - cache_b->level; 1120 } 1121 1122 static bool cpu_cache_level__cmp(struct cpu_cache_level *a, struct cpu_cache_level *b) 1123 { 1124 if (a->level != b->level) 1125 return false; 1126 1127 if (a->line_size != b->line_size) 1128 return false; 1129 1130 if (a->sets != b->sets) 1131 return false; 1132 1133 if (a->ways != b->ways) 1134 return false; 1135 1136 if (strcmp(a->type, b->type)) 1137 return false; 1138 1139 if (strcmp(a->size, b->size)) 1140 return false; 1141 1142 if (strcmp(a->map, b->map)) 1143 return false; 1144 1145 return true; 1146 } 1147 1148 static int cpu_cache_level__read(struct cpu_cache_level *cache, u32 cpu, u16 level) 1149 { 1150 char path[PATH_MAX], file[PATH_MAX]; 1151 struct stat st; 1152 size_t len; 1153 1154 scnprintf(path, PATH_MAX, "devices/system/cpu/cpu%d/cache/index%d/", cpu, level); 1155 scnprintf(file, PATH_MAX, "%s/%s", sysfs__mountpoint(), path); 1156 1157 if (stat(file, &st)) 1158 return 1; 1159 1160 scnprintf(file, PATH_MAX, "%s/level", path); 1161 if (sysfs__read_int(file, (int *) &cache->level)) 1162 return -1; 1163 1164 scnprintf(file, PATH_MAX, "%s/coherency_line_size", path); 1165 if (sysfs__read_int(file, (int *) &cache->line_size)) 1166 return -1; 1167 1168 scnprintf(file, PATH_MAX, "%s/number_of_sets", path); 1169 if (sysfs__read_int(file, (int *) &cache->sets)) 1170 return -1; 1171 1172 scnprintf(file, PATH_MAX, "%s/ways_of_associativity", path); 1173 if (sysfs__read_int(file, (int *) &cache->ways)) 1174 return -1; 1175 1176 scnprintf(file, PATH_MAX, "%s/type", path); 1177 if (sysfs__read_str(file, &cache->type, &len)) 1178 return -1; 1179 1180 cache->type[len] = 0; 1181 cache->type = strim(cache->type); 1182 1183 scnprintf(file, PATH_MAX, "%s/size", path); 1184 if (sysfs__read_str(file, &cache->size, &len)) { 1185 zfree(&cache->type); 1186 return -1; 1187 } 1188 1189 cache->size[len] = 0; 1190 cache->size = strim(cache->size); 1191 1192 scnprintf(file, PATH_MAX, "%s/shared_cpu_list", path); 1193 if (sysfs__read_str(file, &cache->map, &len)) { 1194 zfree(&cache->size); 1195 zfree(&cache->type); 1196 return -1; 1197 } 1198 1199 cache->map[len] = 0; 1200 cache->map = strim(cache->map); 1201 return 0; 1202 } 1203 1204 static void cpu_cache_level__fprintf(FILE *out, struct cpu_cache_level *c) 1205 { 1206 fprintf(out, "L%d %-15s %8s [%s]\n", c->level, c->type, c->size, c->map); 1207 } 1208 1209 #define MAX_CACHE_LVL 4 1210 1211 static int build_caches(struct cpu_cache_level caches[], u32 *cntp) 1212 { 1213 u32 i, cnt = 0; 1214 u32 nr, cpu; 1215 u16 level; 1216 1217 nr = cpu__max_cpu().cpu; 1218 1219 for (cpu = 0; cpu < nr; cpu++) { 1220 for (level = 0; level < MAX_CACHE_LVL; level++) { 1221 struct cpu_cache_level c; 1222 int err; 1223 1224 err = cpu_cache_level__read(&c, cpu, level); 1225 if (err < 0) 1226 return err; 1227 1228 if (err == 1) 1229 break; 1230 1231 for (i = 0; i < cnt; i++) { 1232 if (cpu_cache_level__cmp(&c, &caches[i])) 1233 break; 1234 } 1235 1236 if (i == cnt) 1237 caches[cnt++] = c; 1238 else 1239 cpu_cache_level__free(&c); 1240 } 1241 } 1242 *cntp = cnt; 1243 return 0; 1244 } 1245 1246 static int write_cache(struct feat_fd *ff, 1247 struct evlist *evlist __maybe_unused) 1248 { 1249 u32 max_caches = cpu__max_cpu().cpu * MAX_CACHE_LVL; 1250 struct cpu_cache_level caches[max_caches]; 1251 u32 cnt = 0, i, version = 1; 1252 int ret; 1253 1254 ret = build_caches(caches, &cnt); 1255 if (ret) 1256 goto out; 1257 1258 qsort(&caches, cnt, sizeof(struct cpu_cache_level), cpu_cache_level__sort); 1259 1260 ret = do_write(ff, &version, sizeof(u32)); 1261 if (ret < 0) 1262 goto out; 1263 1264 ret = do_write(ff, &cnt, sizeof(u32)); 1265 if (ret < 0) 1266 goto out; 1267 1268 for (i = 0; i < cnt; i++) { 1269 struct cpu_cache_level *c = &caches[i]; 1270 1271 #define _W(v) \ 1272 ret = do_write(ff, &c->v, sizeof(u32)); \ 1273 if (ret < 0) \ 1274 goto out; 1275 1276 _W(level) 1277 _W(line_size) 1278 _W(sets) 1279 _W(ways) 1280 #undef _W 1281 1282 #define _W(v) \ 1283 ret = do_write_string(ff, (const char *) c->v); \ 1284 if (ret < 0) \ 1285 goto out; 1286 1287 _W(type) 1288 _W(size) 1289 _W(map) 1290 #undef _W 1291 } 1292 1293 out: 1294 for (i = 0; i < cnt; i++) 1295 cpu_cache_level__free(&caches[i]); 1296 return ret; 1297 } 1298 1299 static int write_stat(struct feat_fd *ff __maybe_unused, 1300 struct evlist *evlist __maybe_unused) 1301 { 1302 return 0; 1303 } 1304 1305 static int write_sample_time(struct feat_fd *ff, 1306 struct evlist *evlist) 1307 { 1308 int ret; 1309 1310 ret = do_write(ff, &evlist->first_sample_time, 1311 sizeof(evlist->first_sample_time)); 1312 if (ret < 0) 1313 return ret; 1314 1315 return do_write(ff, &evlist->last_sample_time, 1316 sizeof(evlist->last_sample_time)); 1317 } 1318 1319 1320 static int memory_node__read(struct memory_node *n, unsigned long idx) 1321 { 1322 unsigned int phys, size = 0; 1323 char path[PATH_MAX]; 1324 struct dirent *ent; 1325 DIR *dir; 1326 1327 #define for_each_memory(mem, dir) \ 1328 while ((ent = readdir(dir))) \ 1329 if (strcmp(ent->d_name, ".") && \ 1330 strcmp(ent->d_name, "..") && \ 1331 sscanf(ent->d_name, "memory%u", &mem) == 1) 1332 1333 scnprintf(path, PATH_MAX, 1334 "%s/devices/system/node/node%lu", 1335 sysfs__mountpoint(), idx); 1336 1337 dir = opendir(path); 1338 if (!dir) { 1339 pr_warning("failed: can't open memory sysfs data\n"); 1340 return -1; 1341 } 1342 1343 for_each_memory(phys, dir) { 1344 size = max(phys, size); 1345 } 1346 1347 size++; 1348 1349 n->set = bitmap_zalloc(size); 1350 if (!n->set) { 1351 closedir(dir); 1352 return -ENOMEM; 1353 } 1354 1355 n->node = idx; 1356 n->size = size; 1357 1358 rewinddir(dir); 1359 1360 for_each_memory(phys, dir) { 1361 set_bit(phys, n->set); 1362 } 1363 1364 closedir(dir); 1365 return 0; 1366 } 1367 1368 static int memory_node__sort(const void *a, const void *b) 1369 { 1370 const struct memory_node *na = a; 1371 const struct memory_node *nb = b; 1372 1373 return na->node - nb->node; 1374 } 1375 1376 static int build_mem_topology(struct memory_node *nodes, u64 size, u64 *cntp) 1377 { 1378 char path[PATH_MAX]; 1379 struct dirent *ent; 1380 DIR *dir; 1381 u64 cnt = 0; 1382 int ret = 0; 1383 1384 scnprintf(path, PATH_MAX, "%s/devices/system/node/", 1385 sysfs__mountpoint()); 1386 1387 dir = opendir(path); 1388 if (!dir) { 1389 pr_debug2("%s: couldn't read %s, does this arch have topology information?\n", 1390 __func__, path); 1391 return -1; 1392 } 1393 1394 while (!ret && (ent = readdir(dir))) { 1395 unsigned int idx; 1396 int r; 1397 1398 if (!strcmp(ent->d_name, ".") || 1399 !strcmp(ent->d_name, "..")) 1400 continue; 1401 1402 r = sscanf(ent->d_name, "node%u", &idx); 1403 if (r != 1) 1404 continue; 1405 1406 if (WARN_ONCE(cnt >= size, 1407 "failed to write MEM_TOPOLOGY, way too many nodes\n")) { 1408 closedir(dir); 1409 return -1; 1410 } 1411 1412 ret = memory_node__read(&nodes[cnt++], idx); 1413 } 1414 1415 *cntp = cnt; 1416 closedir(dir); 1417 1418 if (!ret) 1419 qsort(nodes, cnt, sizeof(nodes[0]), memory_node__sort); 1420 1421 return ret; 1422 } 1423 1424 #define MAX_MEMORY_NODES 2000 1425 1426 /* 1427 * The MEM_TOPOLOGY holds physical memory map for every 1428 * node in system. The format of data is as follows: 1429 * 1430 * 0 - version | for future changes 1431 * 8 - block_size_bytes | /sys/devices/system/memory/block_size_bytes 1432 * 16 - count | number of nodes 1433 * 1434 * For each node we store map of physical indexes for 1435 * each node: 1436 * 1437 * 32 - node id | node index 1438 * 40 - size | size of bitmap 1439 * 48 - bitmap | bitmap of memory indexes that belongs to node 1440 */ 1441 static int write_mem_topology(struct feat_fd *ff __maybe_unused, 1442 struct evlist *evlist __maybe_unused) 1443 { 1444 static struct memory_node nodes[MAX_MEMORY_NODES]; 1445 u64 bsize, version = 1, i, nr; 1446 int ret; 1447 1448 ret = sysfs__read_xll("devices/system/memory/block_size_bytes", 1449 (unsigned long long *) &bsize); 1450 if (ret) 1451 return ret; 1452 1453 ret = build_mem_topology(&nodes[0], MAX_MEMORY_NODES, &nr); 1454 if (ret) 1455 return ret; 1456 1457 ret = do_write(ff, &version, sizeof(version)); 1458 if (ret < 0) 1459 goto out; 1460 1461 ret = do_write(ff, &bsize, sizeof(bsize)); 1462 if (ret < 0) 1463 goto out; 1464 1465 ret = do_write(ff, &nr, sizeof(nr)); 1466 if (ret < 0) 1467 goto out; 1468 1469 for (i = 0; i < nr; i++) { 1470 struct memory_node *n = &nodes[i]; 1471 1472 #define _W(v) \ 1473 ret = do_write(ff, &n->v, sizeof(n->v)); \ 1474 if (ret < 0) \ 1475 goto out; 1476 1477 _W(node) 1478 _W(size) 1479 1480 #undef _W 1481 1482 ret = do_write_bitmap(ff, n->set, n->size); 1483 if (ret < 0) 1484 goto out; 1485 } 1486 1487 out: 1488 return ret; 1489 } 1490 1491 static int write_compressed(struct feat_fd *ff __maybe_unused, 1492 struct evlist *evlist __maybe_unused) 1493 { 1494 int ret; 1495 1496 ret = do_write(ff, &(ff->ph->env.comp_ver), sizeof(ff->ph->env.comp_ver)); 1497 if (ret) 1498 return ret; 1499 1500 ret = do_write(ff, &(ff->ph->env.comp_type), sizeof(ff->ph->env.comp_type)); 1501 if (ret) 1502 return ret; 1503 1504 ret = do_write(ff, &(ff->ph->env.comp_level), sizeof(ff->ph->env.comp_level)); 1505 if (ret) 1506 return ret; 1507 1508 ret = do_write(ff, &(ff->ph->env.comp_ratio), sizeof(ff->ph->env.comp_ratio)); 1509 if (ret) 1510 return ret; 1511 1512 return do_write(ff, &(ff->ph->env.comp_mmap_len), sizeof(ff->ph->env.comp_mmap_len)); 1513 } 1514 1515 static int __write_pmu_caps(struct feat_fd *ff, struct perf_pmu *pmu, 1516 bool write_pmu) 1517 { 1518 struct perf_pmu_caps *caps = NULL; 1519 int ret; 1520 1521 ret = do_write(ff, &pmu->nr_caps, sizeof(pmu->nr_caps)); 1522 if (ret < 0) 1523 return ret; 1524 1525 list_for_each_entry(caps, &pmu->caps, list) { 1526 ret = do_write_string(ff, caps->name); 1527 if (ret < 0) 1528 return ret; 1529 1530 ret = do_write_string(ff, caps->value); 1531 if (ret < 0) 1532 return ret; 1533 } 1534 1535 if (write_pmu) { 1536 ret = do_write_string(ff, pmu->name); 1537 if (ret < 0) 1538 return ret; 1539 } 1540 1541 return ret; 1542 } 1543 1544 static int write_cpu_pmu_caps(struct feat_fd *ff, 1545 struct evlist *evlist __maybe_unused) 1546 { 1547 struct perf_pmu *cpu_pmu = perf_pmu__find("cpu"); 1548 int ret; 1549 1550 if (!cpu_pmu) 1551 return -ENOENT; 1552 1553 ret = perf_pmu__caps_parse(cpu_pmu); 1554 if (ret < 0) 1555 return ret; 1556 1557 return __write_pmu_caps(ff, cpu_pmu, false); 1558 } 1559 1560 static int write_pmu_caps(struct feat_fd *ff, 1561 struct evlist *evlist __maybe_unused) 1562 { 1563 struct perf_pmu *pmu = NULL; 1564 int nr_pmu = 0; 1565 int ret; 1566 1567 while ((pmu = perf_pmu__scan(pmu))) { 1568 if (!pmu->name || !strcmp(pmu->name, "cpu") || 1569 perf_pmu__caps_parse(pmu) <= 0) 1570 continue; 1571 nr_pmu++; 1572 } 1573 1574 ret = do_write(ff, &nr_pmu, sizeof(nr_pmu)); 1575 if (ret < 0) 1576 return ret; 1577 1578 if (!nr_pmu) 1579 return 0; 1580 1581 /* 1582 * Write hybrid pmu caps first to maintain compatibility with 1583 * older perf tool. 1584 */ 1585 pmu = NULL; 1586 perf_pmu__for_each_hybrid_pmu(pmu) { 1587 ret = __write_pmu_caps(ff, pmu, true); 1588 if (ret < 0) 1589 return ret; 1590 } 1591 1592 pmu = NULL; 1593 while ((pmu = perf_pmu__scan(pmu))) { 1594 if (!pmu->name || !strcmp(pmu->name, "cpu") || 1595 !pmu->nr_caps || perf_pmu__is_hybrid(pmu->name)) 1596 continue; 1597 1598 ret = __write_pmu_caps(ff, pmu, true); 1599 if (ret < 0) 1600 return ret; 1601 } 1602 return 0; 1603 } 1604 1605 static void print_hostname(struct feat_fd *ff, FILE *fp) 1606 { 1607 fprintf(fp, "# hostname : %s\n", ff->ph->env.hostname); 1608 } 1609 1610 static void print_osrelease(struct feat_fd *ff, FILE *fp) 1611 { 1612 fprintf(fp, "# os release : %s\n", ff->ph->env.os_release); 1613 } 1614 1615 static void print_arch(struct feat_fd *ff, FILE *fp) 1616 { 1617 fprintf(fp, "# arch : %s\n", ff->ph->env.arch); 1618 } 1619 1620 static void print_cpudesc(struct feat_fd *ff, FILE *fp) 1621 { 1622 fprintf(fp, "# cpudesc : %s\n", ff->ph->env.cpu_desc); 1623 } 1624 1625 static void print_nrcpus(struct feat_fd *ff, FILE *fp) 1626 { 1627 fprintf(fp, "# nrcpus online : %u\n", ff->ph->env.nr_cpus_online); 1628 fprintf(fp, "# nrcpus avail : %u\n", ff->ph->env.nr_cpus_avail); 1629 } 1630 1631 static void print_version(struct feat_fd *ff, FILE *fp) 1632 { 1633 fprintf(fp, "# perf version : %s\n", ff->ph->env.version); 1634 } 1635 1636 static void print_cmdline(struct feat_fd *ff, FILE *fp) 1637 { 1638 int nr, i; 1639 1640 nr = ff->ph->env.nr_cmdline; 1641 1642 fprintf(fp, "# cmdline : "); 1643 1644 for (i = 0; i < nr; i++) { 1645 char *argv_i = strdup(ff->ph->env.cmdline_argv[i]); 1646 if (!argv_i) { 1647 fprintf(fp, "%s ", ff->ph->env.cmdline_argv[i]); 1648 } else { 1649 char *mem = argv_i; 1650 do { 1651 char *quote = strchr(argv_i, '\''); 1652 if (!quote) 1653 break; 1654 *quote++ = '\0'; 1655 fprintf(fp, "%s\\\'", argv_i); 1656 argv_i = quote; 1657 } while (1); 1658 fprintf(fp, "%s ", argv_i); 1659 free(mem); 1660 } 1661 } 1662 fputc('\n', fp); 1663 } 1664 1665 static void print_cpu_topology(struct feat_fd *ff, FILE *fp) 1666 { 1667 struct perf_header *ph = ff->ph; 1668 int cpu_nr = ph->env.nr_cpus_avail; 1669 int nr, i; 1670 char *str; 1671 1672 nr = ph->env.nr_sibling_cores; 1673 str = ph->env.sibling_cores; 1674 1675 for (i = 0; i < nr; i++) { 1676 fprintf(fp, "# sibling sockets : %s\n", str); 1677 str += strlen(str) + 1; 1678 } 1679 1680 if (ph->env.nr_sibling_dies) { 1681 nr = ph->env.nr_sibling_dies; 1682 str = ph->env.sibling_dies; 1683 1684 for (i = 0; i < nr; i++) { 1685 fprintf(fp, "# sibling dies : %s\n", str); 1686 str += strlen(str) + 1; 1687 } 1688 } 1689 1690 nr = ph->env.nr_sibling_threads; 1691 str = ph->env.sibling_threads; 1692 1693 for (i = 0; i < nr; i++) { 1694 fprintf(fp, "# sibling threads : %s\n", str); 1695 str += strlen(str) + 1; 1696 } 1697 1698 if (ph->env.nr_sibling_dies) { 1699 if (ph->env.cpu != NULL) { 1700 for (i = 0; i < cpu_nr; i++) 1701 fprintf(fp, "# CPU %d: Core ID %d, " 1702 "Die ID %d, Socket ID %d\n", 1703 i, ph->env.cpu[i].core_id, 1704 ph->env.cpu[i].die_id, 1705 ph->env.cpu[i].socket_id); 1706 } else 1707 fprintf(fp, "# Core ID, Die ID and Socket ID " 1708 "information is not available\n"); 1709 } else { 1710 if (ph->env.cpu != NULL) { 1711 for (i = 0; i < cpu_nr; i++) 1712 fprintf(fp, "# CPU %d: Core ID %d, " 1713 "Socket ID %d\n", 1714 i, ph->env.cpu[i].core_id, 1715 ph->env.cpu[i].socket_id); 1716 } else 1717 fprintf(fp, "# Core ID and Socket ID " 1718 "information is not available\n"); 1719 } 1720 } 1721 1722 static void print_clockid(struct feat_fd *ff, FILE *fp) 1723 { 1724 fprintf(fp, "# clockid frequency: %"PRIu64" MHz\n", 1725 ff->ph->env.clock.clockid_res_ns * 1000); 1726 } 1727 1728 static void print_clock_data(struct feat_fd *ff, FILE *fp) 1729 { 1730 struct timespec clockid_ns; 1731 char tstr[64], date[64]; 1732 struct timeval tod_ns; 1733 clockid_t clockid; 1734 struct tm ltime; 1735 u64 ref; 1736 1737 if (!ff->ph->env.clock.enabled) { 1738 fprintf(fp, "# reference time disabled\n"); 1739 return; 1740 } 1741 1742 /* Compute TOD time. */ 1743 ref = ff->ph->env.clock.tod_ns; 1744 tod_ns.tv_sec = ref / NSEC_PER_SEC; 1745 ref -= tod_ns.tv_sec * NSEC_PER_SEC; 1746 tod_ns.tv_usec = ref / NSEC_PER_USEC; 1747 1748 /* Compute clockid time. */ 1749 ref = ff->ph->env.clock.clockid_ns; 1750 clockid_ns.tv_sec = ref / NSEC_PER_SEC; 1751 ref -= clockid_ns.tv_sec * NSEC_PER_SEC; 1752 clockid_ns.tv_nsec = ref; 1753 1754 clockid = ff->ph->env.clock.clockid; 1755 1756 if (localtime_r(&tod_ns.tv_sec, <ime) == NULL) 1757 snprintf(tstr, sizeof(tstr), "<error>"); 1758 else { 1759 strftime(date, sizeof(date), "%F %T", <ime); 1760 scnprintf(tstr, sizeof(tstr), "%s.%06d", 1761 date, (int) tod_ns.tv_usec); 1762 } 1763 1764 fprintf(fp, "# clockid: %s (%u)\n", clockid_name(clockid), clockid); 1765 fprintf(fp, "# reference time: %s = %ld.%06d (TOD) = %ld.%09ld (%s)\n", 1766 tstr, (long) tod_ns.tv_sec, (int) tod_ns.tv_usec, 1767 (long) clockid_ns.tv_sec, clockid_ns.tv_nsec, 1768 clockid_name(clockid)); 1769 } 1770 1771 static void print_hybrid_topology(struct feat_fd *ff, FILE *fp) 1772 { 1773 int i; 1774 struct hybrid_node *n; 1775 1776 fprintf(fp, "# hybrid cpu system:\n"); 1777 for (i = 0; i < ff->ph->env.nr_hybrid_nodes; i++) { 1778 n = &ff->ph->env.hybrid_nodes[i]; 1779 fprintf(fp, "# %s cpu list : %s\n", n->pmu_name, n->cpus); 1780 } 1781 } 1782 1783 static void print_dir_format(struct feat_fd *ff, FILE *fp) 1784 { 1785 struct perf_session *session; 1786 struct perf_data *data; 1787 1788 session = container_of(ff->ph, struct perf_session, header); 1789 data = session->data; 1790 1791 fprintf(fp, "# directory data version : %"PRIu64"\n", data->dir.version); 1792 } 1793 1794 #ifdef HAVE_LIBBPF_SUPPORT 1795 static void print_bpf_prog_info(struct feat_fd *ff, FILE *fp) 1796 { 1797 struct perf_env *env = &ff->ph->env; 1798 struct rb_root *root; 1799 struct rb_node *next; 1800 1801 down_read(&env->bpf_progs.lock); 1802 1803 root = &env->bpf_progs.infos; 1804 next = rb_first(root); 1805 1806 while (next) { 1807 struct bpf_prog_info_node *node; 1808 1809 node = rb_entry(next, struct bpf_prog_info_node, rb_node); 1810 next = rb_next(&node->rb_node); 1811 1812 bpf_event__print_bpf_prog_info(&node->info_linear->info, 1813 env, fp); 1814 } 1815 1816 up_read(&env->bpf_progs.lock); 1817 } 1818 1819 static void print_bpf_btf(struct feat_fd *ff, FILE *fp) 1820 { 1821 struct perf_env *env = &ff->ph->env; 1822 struct rb_root *root; 1823 struct rb_node *next; 1824 1825 down_read(&env->bpf_progs.lock); 1826 1827 root = &env->bpf_progs.btfs; 1828 next = rb_first(root); 1829 1830 while (next) { 1831 struct btf_node *node; 1832 1833 node = rb_entry(next, struct btf_node, rb_node); 1834 next = rb_next(&node->rb_node); 1835 fprintf(fp, "# btf info of id %u\n", node->id); 1836 } 1837 1838 up_read(&env->bpf_progs.lock); 1839 } 1840 #endif // HAVE_LIBBPF_SUPPORT 1841 1842 static void free_event_desc(struct evsel *events) 1843 { 1844 struct evsel *evsel; 1845 1846 if (!events) 1847 return; 1848 1849 for (evsel = events; evsel->core.attr.size; evsel++) { 1850 zfree(&evsel->name); 1851 zfree(&evsel->core.id); 1852 } 1853 1854 free(events); 1855 } 1856 1857 static bool perf_attr_check(struct perf_event_attr *attr) 1858 { 1859 if (attr->__reserved_1 || attr->__reserved_2 || attr->__reserved_3) { 1860 pr_warning("Reserved bits are set unexpectedly. " 1861 "Please update perf tool.\n"); 1862 return false; 1863 } 1864 1865 if (attr->sample_type & ~(PERF_SAMPLE_MAX-1)) { 1866 pr_warning("Unknown sample type (0x%llx) is detected. " 1867 "Please update perf tool.\n", 1868 attr->sample_type); 1869 return false; 1870 } 1871 1872 if (attr->read_format & ~(PERF_FORMAT_MAX-1)) { 1873 pr_warning("Unknown read format (0x%llx) is detected. " 1874 "Please update perf tool.\n", 1875 attr->read_format); 1876 return false; 1877 } 1878 1879 if ((attr->sample_type & PERF_SAMPLE_BRANCH_STACK) && 1880 (attr->branch_sample_type & ~(PERF_SAMPLE_BRANCH_MAX-1))) { 1881 pr_warning("Unknown branch sample type (0x%llx) is detected. " 1882 "Please update perf tool.\n", 1883 attr->branch_sample_type); 1884 1885 return false; 1886 } 1887 1888 return true; 1889 } 1890 1891 static struct evsel *read_event_desc(struct feat_fd *ff) 1892 { 1893 struct evsel *evsel, *events = NULL; 1894 u64 *id; 1895 void *buf = NULL; 1896 u32 nre, sz, nr, i, j; 1897 size_t msz; 1898 1899 /* number of events */ 1900 if (do_read_u32(ff, &nre)) 1901 goto error; 1902 1903 if (do_read_u32(ff, &sz)) 1904 goto error; 1905 1906 /* buffer to hold on file attr struct */ 1907 buf = malloc(sz); 1908 if (!buf) 1909 goto error; 1910 1911 /* the last event terminates with evsel->core.attr.size == 0: */ 1912 events = calloc(nre + 1, sizeof(*events)); 1913 if (!events) 1914 goto error; 1915 1916 msz = sizeof(evsel->core.attr); 1917 if (sz < msz) 1918 msz = sz; 1919 1920 for (i = 0, evsel = events; i < nre; evsel++, i++) { 1921 evsel->core.idx = i; 1922 1923 /* 1924 * must read entire on-file attr struct to 1925 * sync up with layout. 1926 */ 1927 if (__do_read(ff, buf, sz)) 1928 goto error; 1929 1930 if (ff->ph->needs_swap) 1931 perf_event__attr_swap(buf); 1932 1933 memcpy(&evsel->core.attr, buf, msz); 1934 1935 if (!perf_attr_check(&evsel->core.attr)) 1936 goto error; 1937 1938 if (do_read_u32(ff, &nr)) 1939 goto error; 1940 1941 if (ff->ph->needs_swap) 1942 evsel->needs_swap = true; 1943 1944 evsel->name = do_read_string(ff); 1945 if (!evsel->name) 1946 goto error; 1947 1948 if (!nr) 1949 continue; 1950 1951 id = calloc(nr, sizeof(*id)); 1952 if (!id) 1953 goto error; 1954 evsel->core.ids = nr; 1955 evsel->core.id = id; 1956 1957 for (j = 0 ; j < nr; j++) { 1958 if (do_read_u64(ff, id)) 1959 goto error; 1960 id++; 1961 } 1962 } 1963 out: 1964 free(buf); 1965 return events; 1966 error: 1967 free_event_desc(events); 1968 events = NULL; 1969 goto out; 1970 } 1971 1972 static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val, 1973 void *priv __maybe_unused) 1974 { 1975 return fprintf(fp, ", %s = %s", name, val); 1976 } 1977 1978 static void print_event_desc(struct feat_fd *ff, FILE *fp) 1979 { 1980 struct evsel *evsel, *events; 1981 u32 j; 1982 u64 *id; 1983 1984 if (ff->events) 1985 events = ff->events; 1986 else 1987 events = read_event_desc(ff); 1988 1989 if (!events) { 1990 fprintf(fp, "# event desc: not available or unable to read\n"); 1991 return; 1992 } 1993 1994 for (evsel = events; evsel->core.attr.size; evsel++) { 1995 fprintf(fp, "# event : name = %s, ", evsel->name); 1996 1997 if (evsel->core.ids) { 1998 fprintf(fp, ", id = {"); 1999 for (j = 0, id = evsel->core.id; j < evsel->core.ids; j++, id++) { 2000 if (j) 2001 fputc(',', fp); 2002 fprintf(fp, " %"PRIu64, *id); 2003 } 2004 fprintf(fp, " }"); 2005 } 2006 2007 perf_event_attr__fprintf(fp, &evsel->core.attr, __desc_attr__fprintf, NULL); 2008 2009 fputc('\n', fp); 2010 } 2011 2012 free_event_desc(events); 2013 ff->events = NULL; 2014 } 2015 2016 static void print_total_mem(struct feat_fd *ff, FILE *fp) 2017 { 2018 fprintf(fp, "# total memory : %llu kB\n", ff->ph->env.total_mem); 2019 } 2020 2021 static void print_numa_topology(struct feat_fd *ff, FILE *fp) 2022 { 2023 int i; 2024 struct numa_node *n; 2025 2026 for (i = 0; i < ff->ph->env.nr_numa_nodes; i++) { 2027 n = &ff->ph->env.numa_nodes[i]; 2028 2029 fprintf(fp, "# node%u meminfo : total = %"PRIu64" kB," 2030 " free = %"PRIu64" kB\n", 2031 n->node, n->mem_total, n->mem_free); 2032 2033 fprintf(fp, "# node%u cpu list : ", n->node); 2034 cpu_map__fprintf(n->map, fp); 2035 } 2036 } 2037 2038 static void print_cpuid(struct feat_fd *ff, FILE *fp) 2039 { 2040 fprintf(fp, "# cpuid : %s\n", ff->ph->env.cpuid); 2041 } 2042 2043 static void print_branch_stack(struct feat_fd *ff __maybe_unused, FILE *fp) 2044 { 2045 fprintf(fp, "# contains samples with branch stack\n"); 2046 } 2047 2048 static void print_auxtrace(struct feat_fd *ff __maybe_unused, FILE *fp) 2049 { 2050 fprintf(fp, "# contains AUX area data (e.g. instruction trace)\n"); 2051 } 2052 2053 static void print_stat(struct feat_fd *ff __maybe_unused, FILE *fp) 2054 { 2055 fprintf(fp, "# contains stat data\n"); 2056 } 2057 2058 static void print_cache(struct feat_fd *ff, FILE *fp __maybe_unused) 2059 { 2060 int i; 2061 2062 fprintf(fp, "# CPU cache info:\n"); 2063 for (i = 0; i < ff->ph->env.caches_cnt; i++) { 2064 fprintf(fp, "# "); 2065 cpu_cache_level__fprintf(fp, &ff->ph->env.caches[i]); 2066 } 2067 } 2068 2069 static void print_compressed(struct feat_fd *ff, FILE *fp) 2070 { 2071 fprintf(fp, "# compressed : %s, level = %d, ratio = %d\n", 2072 ff->ph->env.comp_type == PERF_COMP_ZSTD ? "Zstd" : "Unknown", 2073 ff->ph->env.comp_level, ff->ph->env.comp_ratio); 2074 } 2075 2076 static void __print_pmu_caps(FILE *fp, int nr_caps, char **caps, char *pmu_name) 2077 { 2078 const char *delimiter = ""; 2079 int i; 2080 2081 if (!nr_caps) { 2082 fprintf(fp, "# %s pmu capabilities: not available\n", pmu_name); 2083 return; 2084 } 2085 2086 fprintf(fp, "# %s pmu capabilities: ", pmu_name); 2087 for (i = 0; i < nr_caps; i++) { 2088 fprintf(fp, "%s%s", delimiter, caps[i]); 2089 delimiter = ", "; 2090 } 2091 2092 fprintf(fp, "\n"); 2093 } 2094 2095 static void print_cpu_pmu_caps(struct feat_fd *ff, FILE *fp) 2096 { 2097 __print_pmu_caps(fp, ff->ph->env.nr_cpu_pmu_caps, 2098 ff->ph->env.cpu_pmu_caps, (char *)"cpu"); 2099 } 2100 2101 static void print_pmu_caps(struct feat_fd *ff, FILE *fp) 2102 { 2103 struct pmu_caps *pmu_caps; 2104 2105 for (int i = 0; i < ff->ph->env.nr_pmus_with_caps; i++) { 2106 pmu_caps = &ff->ph->env.pmu_caps[i]; 2107 __print_pmu_caps(fp, pmu_caps->nr_caps, pmu_caps->caps, 2108 pmu_caps->pmu_name); 2109 } 2110 } 2111 2112 static void print_pmu_mappings(struct feat_fd *ff, FILE *fp) 2113 { 2114 const char *delimiter = "# pmu mappings: "; 2115 char *str, *tmp; 2116 u32 pmu_num; 2117 u32 type; 2118 2119 pmu_num = ff->ph->env.nr_pmu_mappings; 2120 if (!pmu_num) { 2121 fprintf(fp, "# pmu mappings: not available\n"); 2122 return; 2123 } 2124 2125 str = ff->ph->env.pmu_mappings; 2126 2127 while (pmu_num) { 2128 type = strtoul(str, &tmp, 0); 2129 if (*tmp != ':') 2130 goto error; 2131 2132 str = tmp + 1; 2133 fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type); 2134 2135 delimiter = ", "; 2136 str += strlen(str) + 1; 2137 pmu_num--; 2138 } 2139 2140 fprintf(fp, "\n"); 2141 2142 if (!pmu_num) 2143 return; 2144 error: 2145 fprintf(fp, "# pmu mappings: unable to read\n"); 2146 } 2147 2148 static void print_group_desc(struct feat_fd *ff, FILE *fp) 2149 { 2150 struct perf_session *session; 2151 struct evsel *evsel; 2152 u32 nr = 0; 2153 2154 session = container_of(ff->ph, struct perf_session, header); 2155 2156 evlist__for_each_entry(session->evlist, evsel) { 2157 if (evsel__is_group_leader(evsel) && evsel->core.nr_members > 1) { 2158 fprintf(fp, "# group: %s{%s", evsel->group_name ?: "", evsel__name(evsel)); 2159 2160 nr = evsel->core.nr_members - 1; 2161 } else if (nr) { 2162 fprintf(fp, ",%s", evsel__name(evsel)); 2163 2164 if (--nr == 0) 2165 fprintf(fp, "}\n"); 2166 } 2167 } 2168 } 2169 2170 static void print_sample_time(struct feat_fd *ff, FILE *fp) 2171 { 2172 struct perf_session *session; 2173 char time_buf[32]; 2174 double d; 2175 2176 session = container_of(ff->ph, struct perf_session, header); 2177 2178 timestamp__scnprintf_usec(session->evlist->first_sample_time, 2179 time_buf, sizeof(time_buf)); 2180 fprintf(fp, "# time of first sample : %s\n", time_buf); 2181 2182 timestamp__scnprintf_usec(session->evlist->last_sample_time, 2183 time_buf, sizeof(time_buf)); 2184 fprintf(fp, "# time of last sample : %s\n", time_buf); 2185 2186 d = (double)(session->evlist->last_sample_time - 2187 session->evlist->first_sample_time) / NSEC_PER_MSEC; 2188 2189 fprintf(fp, "# sample duration : %10.3f ms\n", d); 2190 } 2191 2192 static void memory_node__fprintf(struct memory_node *n, 2193 unsigned long long bsize, FILE *fp) 2194 { 2195 char buf_map[100], buf_size[50]; 2196 unsigned long long size; 2197 2198 size = bsize * bitmap_weight(n->set, n->size); 2199 unit_number__scnprintf(buf_size, 50, size); 2200 2201 bitmap_scnprintf(n->set, n->size, buf_map, 100); 2202 fprintf(fp, "# %3" PRIu64 " [%s]: %s\n", n->node, buf_size, buf_map); 2203 } 2204 2205 static void print_mem_topology(struct feat_fd *ff, FILE *fp) 2206 { 2207 struct memory_node *nodes; 2208 int i, nr; 2209 2210 nodes = ff->ph->env.memory_nodes; 2211 nr = ff->ph->env.nr_memory_nodes; 2212 2213 fprintf(fp, "# memory nodes (nr %d, block size 0x%llx):\n", 2214 nr, ff->ph->env.memory_bsize); 2215 2216 for (i = 0; i < nr; i++) { 2217 memory_node__fprintf(&nodes[i], ff->ph->env.memory_bsize, fp); 2218 } 2219 } 2220 2221 static int __event_process_build_id(struct perf_record_header_build_id *bev, 2222 char *filename, 2223 struct perf_session *session) 2224 { 2225 int err = -1; 2226 struct machine *machine; 2227 u16 cpumode; 2228 struct dso *dso; 2229 enum dso_space_type dso_space; 2230 2231 machine = perf_session__findnew_machine(session, bev->pid); 2232 if (!machine) 2233 goto out; 2234 2235 cpumode = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 2236 2237 switch (cpumode) { 2238 case PERF_RECORD_MISC_KERNEL: 2239 dso_space = DSO_SPACE__KERNEL; 2240 break; 2241 case PERF_RECORD_MISC_GUEST_KERNEL: 2242 dso_space = DSO_SPACE__KERNEL_GUEST; 2243 break; 2244 case PERF_RECORD_MISC_USER: 2245 case PERF_RECORD_MISC_GUEST_USER: 2246 dso_space = DSO_SPACE__USER; 2247 break; 2248 default: 2249 goto out; 2250 } 2251 2252 dso = machine__findnew_dso(machine, filename); 2253 if (dso != NULL) { 2254 char sbuild_id[SBUILD_ID_SIZE]; 2255 struct build_id bid; 2256 size_t size = BUILD_ID_SIZE; 2257 2258 if (bev->header.misc & PERF_RECORD_MISC_BUILD_ID_SIZE) 2259 size = bev->size; 2260 2261 build_id__init(&bid, bev->data, size); 2262 dso__set_build_id(dso, &bid); 2263 dso->header_build_id = 1; 2264 2265 if (dso_space != DSO_SPACE__USER) { 2266 struct kmod_path m = { .name = NULL, }; 2267 2268 if (!kmod_path__parse_name(&m, filename) && m.kmod) 2269 dso__set_module_info(dso, &m, machine); 2270 2271 dso->kernel = dso_space; 2272 free(m.name); 2273 } 2274 2275 build_id__sprintf(&dso->bid, sbuild_id); 2276 pr_debug("build id event received for %s: %s [%zu]\n", 2277 dso->long_name, sbuild_id, size); 2278 dso__put(dso); 2279 } 2280 2281 err = 0; 2282 out: 2283 return err; 2284 } 2285 2286 static int perf_header__read_build_ids_abi_quirk(struct perf_header *header, 2287 int input, u64 offset, u64 size) 2288 { 2289 struct perf_session *session = container_of(header, struct perf_session, header); 2290 struct { 2291 struct perf_event_header header; 2292 u8 build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))]; 2293 char filename[0]; 2294 } old_bev; 2295 struct perf_record_header_build_id bev; 2296 char filename[PATH_MAX]; 2297 u64 limit = offset + size; 2298 2299 while (offset < limit) { 2300 ssize_t len; 2301 2302 if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev)) 2303 return -1; 2304 2305 if (header->needs_swap) 2306 perf_event_header__bswap(&old_bev.header); 2307 2308 len = old_bev.header.size - sizeof(old_bev); 2309 if (readn(input, filename, len) != len) 2310 return -1; 2311 2312 bev.header = old_bev.header; 2313 2314 /* 2315 * As the pid is the missing value, we need to fill 2316 * it properly. The header.misc value give us nice hint. 2317 */ 2318 bev.pid = HOST_KERNEL_ID; 2319 if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER || 2320 bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL) 2321 bev.pid = DEFAULT_GUEST_KERNEL_ID; 2322 2323 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id)); 2324 __event_process_build_id(&bev, filename, session); 2325 2326 offset += bev.header.size; 2327 } 2328 2329 return 0; 2330 } 2331 2332 static int perf_header__read_build_ids(struct perf_header *header, 2333 int input, u64 offset, u64 size) 2334 { 2335 struct perf_session *session = container_of(header, struct perf_session, header); 2336 struct perf_record_header_build_id bev; 2337 char filename[PATH_MAX]; 2338 u64 limit = offset + size, orig_offset = offset; 2339 int err = -1; 2340 2341 while (offset < limit) { 2342 ssize_t len; 2343 2344 if (readn(input, &bev, sizeof(bev)) != sizeof(bev)) 2345 goto out; 2346 2347 if (header->needs_swap) 2348 perf_event_header__bswap(&bev.header); 2349 2350 len = bev.header.size - sizeof(bev); 2351 if (readn(input, filename, len) != len) 2352 goto out; 2353 /* 2354 * The a1645ce1 changeset: 2355 * 2356 * "perf: 'perf kvm' tool for monitoring guest performance from host" 2357 * 2358 * Added a field to struct perf_record_header_build_id that broke the file 2359 * format. 2360 * 2361 * Since the kernel build-id is the first entry, process the 2362 * table using the old format if the well known 2363 * '[kernel.kallsyms]' string for the kernel build-id has the 2364 * first 4 characters chopped off (where the pid_t sits). 2365 */ 2366 if (memcmp(filename, "nel.kallsyms]", 13) == 0) { 2367 if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1) 2368 return -1; 2369 return perf_header__read_build_ids_abi_quirk(header, input, offset, size); 2370 } 2371 2372 __event_process_build_id(&bev, filename, session); 2373 2374 offset += bev.header.size; 2375 } 2376 err = 0; 2377 out: 2378 return err; 2379 } 2380 2381 /* Macro for features that simply need to read and store a string. */ 2382 #define FEAT_PROCESS_STR_FUN(__feat, __feat_env) \ 2383 static int process_##__feat(struct feat_fd *ff, void *data __maybe_unused) \ 2384 {\ 2385 free(ff->ph->env.__feat_env); \ 2386 ff->ph->env.__feat_env = do_read_string(ff); \ 2387 return ff->ph->env.__feat_env ? 0 : -ENOMEM; \ 2388 } 2389 2390 FEAT_PROCESS_STR_FUN(hostname, hostname); 2391 FEAT_PROCESS_STR_FUN(osrelease, os_release); 2392 FEAT_PROCESS_STR_FUN(version, version); 2393 FEAT_PROCESS_STR_FUN(arch, arch); 2394 FEAT_PROCESS_STR_FUN(cpudesc, cpu_desc); 2395 FEAT_PROCESS_STR_FUN(cpuid, cpuid); 2396 2397 static int process_tracing_data(struct feat_fd *ff, void *data) 2398 { 2399 ssize_t ret = trace_report(ff->fd, data, false); 2400 2401 return ret < 0 ? -1 : 0; 2402 } 2403 2404 static int process_build_id(struct feat_fd *ff, void *data __maybe_unused) 2405 { 2406 if (perf_header__read_build_ids(ff->ph, ff->fd, ff->offset, ff->size)) 2407 pr_debug("Failed to read buildids, continuing...\n"); 2408 return 0; 2409 } 2410 2411 static int process_nrcpus(struct feat_fd *ff, void *data __maybe_unused) 2412 { 2413 int ret; 2414 u32 nr_cpus_avail, nr_cpus_online; 2415 2416 ret = do_read_u32(ff, &nr_cpus_avail); 2417 if (ret) 2418 return ret; 2419 2420 ret = do_read_u32(ff, &nr_cpus_online); 2421 if (ret) 2422 return ret; 2423 ff->ph->env.nr_cpus_avail = (int)nr_cpus_avail; 2424 ff->ph->env.nr_cpus_online = (int)nr_cpus_online; 2425 return 0; 2426 } 2427 2428 static int process_total_mem(struct feat_fd *ff, void *data __maybe_unused) 2429 { 2430 u64 total_mem; 2431 int ret; 2432 2433 ret = do_read_u64(ff, &total_mem); 2434 if (ret) 2435 return -1; 2436 ff->ph->env.total_mem = (unsigned long long)total_mem; 2437 return 0; 2438 } 2439 2440 static struct evsel *evlist__find_by_index(struct evlist *evlist, int idx) 2441 { 2442 struct evsel *evsel; 2443 2444 evlist__for_each_entry(evlist, evsel) { 2445 if (evsel->core.idx == idx) 2446 return evsel; 2447 } 2448 2449 return NULL; 2450 } 2451 2452 static void evlist__set_event_name(struct evlist *evlist, struct evsel *event) 2453 { 2454 struct evsel *evsel; 2455 2456 if (!event->name) 2457 return; 2458 2459 evsel = evlist__find_by_index(evlist, event->core.idx); 2460 if (!evsel) 2461 return; 2462 2463 if (evsel->name) 2464 return; 2465 2466 evsel->name = strdup(event->name); 2467 } 2468 2469 static int 2470 process_event_desc(struct feat_fd *ff, void *data __maybe_unused) 2471 { 2472 struct perf_session *session; 2473 struct evsel *evsel, *events = read_event_desc(ff); 2474 2475 if (!events) 2476 return 0; 2477 2478 session = container_of(ff->ph, struct perf_session, header); 2479 2480 if (session->data->is_pipe) { 2481 /* Save events for reading later by print_event_desc, 2482 * since they can't be read again in pipe mode. */ 2483 ff->events = events; 2484 } 2485 2486 for (evsel = events; evsel->core.attr.size; evsel++) 2487 evlist__set_event_name(session->evlist, evsel); 2488 2489 if (!session->data->is_pipe) 2490 free_event_desc(events); 2491 2492 return 0; 2493 } 2494 2495 static int process_cmdline(struct feat_fd *ff, void *data __maybe_unused) 2496 { 2497 char *str, *cmdline = NULL, **argv = NULL; 2498 u32 nr, i, len = 0; 2499 2500 if (do_read_u32(ff, &nr)) 2501 return -1; 2502 2503 ff->ph->env.nr_cmdline = nr; 2504 2505 cmdline = zalloc(ff->size + nr + 1); 2506 if (!cmdline) 2507 return -1; 2508 2509 argv = zalloc(sizeof(char *) * (nr + 1)); 2510 if (!argv) 2511 goto error; 2512 2513 for (i = 0; i < nr; i++) { 2514 str = do_read_string(ff); 2515 if (!str) 2516 goto error; 2517 2518 argv[i] = cmdline + len; 2519 memcpy(argv[i], str, strlen(str) + 1); 2520 len += strlen(str) + 1; 2521 free(str); 2522 } 2523 ff->ph->env.cmdline = cmdline; 2524 ff->ph->env.cmdline_argv = (const char **) argv; 2525 return 0; 2526 2527 error: 2528 free(argv); 2529 free(cmdline); 2530 return -1; 2531 } 2532 2533 static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused) 2534 { 2535 u32 nr, i; 2536 char *str; 2537 struct strbuf sb; 2538 int cpu_nr = ff->ph->env.nr_cpus_avail; 2539 u64 size = 0; 2540 struct perf_header *ph = ff->ph; 2541 bool do_core_id_test = true; 2542 2543 ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu)); 2544 if (!ph->env.cpu) 2545 return -1; 2546 2547 if (do_read_u32(ff, &nr)) 2548 goto free_cpu; 2549 2550 ph->env.nr_sibling_cores = nr; 2551 size += sizeof(u32); 2552 if (strbuf_init(&sb, 128) < 0) 2553 goto free_cpu; 2554 2555 for (i = 0; i < nr; i++) { 2556 str = do_read_string(ff); 2557 if (!str) 2558 goto error; 2559 2560 /* include a NULL character at the end */ 2561 if (strbuf_add(&sb, str, strlen(str) + 1) < 0) 2562 goto error; 2563 size += string_size(str); 2564 free(str); 2565 } 2566 ph->env.sibling_cores = strbuf_detach(&sb, NULL); 2567 2568 if (do_read_u32(ff, &nr)) 2569 return -1; 2570 2571 ph->env.nr_sibling_threads = nr; 2572 size += sizeof(u32); 2573 2574 for (i = 0; i < nr; i++) { 2575 str = do_read_string(ff); 2576 if (!str) 2577 goto error; 2578 2579 /* include a NULL character at the end */ 2580 if (strbuf_add(&sb, str, strlen(str) + 1) < 0) 2581 goto error; 2582 size += string_size(str); 2583 free(str); 2584 } 2585 ph->env.sibling_threads = strbuf_detach(&sb, NULL); 2586 2587 /* 2588 * The header may be from old perf, 2589 * which doesn't include core id and socket id information. 2590 */ 2591 if (ff->size <= size) { 2592 zfree(&ph->env.cpu); 2593 return 0; 2594 } 2595 2596 /* On s390 the socket_id number is not related to the numbers of cpus. 2597 * The socket_id number might be higher than the numbers of cpus. 2598 * This depends on the configuration. 2599 * AArch64 is the same. 2600 */ 2601 if (ph->env.arch && (!strncmp(ph->env.arch, "s390", 4) 2602 || !strncmp(ph->env.arch, "aarch64", 7))) 2603 do_core_id_test = false; 2604 2605 for (i = 0; i < (u32)cpu_nr; i++) { 2606 if (do_read_u32(ff, &nr)) 2607 goto free_cpu; 2608 2609 ph->env.cpu[i].core_id = nr; 2610 size += sizeof(u32); 2611 2612 if (do_read_u32(ff, &nr)) 2613 goto free_cpu; 2614 2615 if (do_core_id_test && nr != (u32)-1 && nr > (u32)cpu_nr) { 2616 pr_debug("socket_id number is too big." 2617 "You may need to upgrade the perf tool.\n"); 2618 goto free_cpu; 2619 } 2620 2621 ph->env.cpu[i].socket_id = nr; 2622 size += sizeof(u32); 2623 } 2624 2625 /* 2626 * The header may be from old perf, 2627 * which doesn't include die information. 2628 */ 2629 if (ff->size <= size) 2630 return 0; 2631 2632 if (do_read_u32(ff, &nr)) 2633 return -1; 2634 2635 ph->env.nr_sibling_dies = nr; 2636 size += sizeof(u32); 2637 2638 for (i = 0; i < nr; i++) { 2639 str = do_read_string(ff); 2640 if (!str) 2641 goto error; 2642 2643 /* include a NULL character at the end */ 2644 if (strbuf_add(&sb, str, strlen(str) + 1) < 0) 2645 goto error; 2646 size += string_size(str); 2647 free(str); 2648 } 2649 ph->env.sibling_dies = strbuf_detach(&sb, NULL); 2650 2651 for (i = 0; i < (u32)cpu_nr; i++) { 2652 if (do_read_u32(ff, &nr)) 2653 goto free_cpu; 2654 2655 ph->env.cpu[i].die_id = nr; 2656 } 2657 2658 return 0; 2659 2660 error: 2661 strbuf_release(&sb); 2662 free_cpu: 2663 zfree(&ph->env.cpu); 2664 return -1; 2665 } 2666 2667 static int process_numa_topology(struct feat_fd *ff, void *data __maybe_unused) 2668 { 2669 struct numa_node *nodes, *n; 2670 u32 nr, i; 2671 char *str; 2672 2673 /* nr nodes */ 2674 if (do_read_u32(ff, &nr)) 2675 return -1; 2676 2677 nodes = zalloc(sizeof(*nodes) * nr); 2678 if (!nodes) 2679 return -ENOMEM; 2680 2681 for (i = 0; i < nr; i++) { 2682 n = &nodes[i]; 2683 2684 /* node number */ 2685 if (do_read_u32(ff, &n->node)) 2686 goto error; 2687 2688 if (do_read_u64(ff, &n->mem_total)) 2689 goto error; 2690 2691 if (do_read_u64(ff, &n->mem_free)) 2692 goto error; 2693 2694 str = do_read_string(ff); 2695 if (!str) 2696 goto error; 2697 2698 n->map = perf_cpu_map__new(str); 2699 if (!n->map) 2700 goto error; 2701 2702 free(str); 2703 } 2704 ff->ph->env.nr_numa_nodes = nr; 2705 ff->ph->env.numa_nodes = nodes; 2706 return 0; 2707 2708 error: 2709 free(nodes); 2710 return -1; 2711 } 2712 2713 static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused) 2714 { 2715 char *name; 2716 u32 pmu_num; 2717 u32 type; 2718 struct strbuf sb; 2719 2720 if (do_read_u32(ff, &pmu_num)) 2721 return -1; 2722 2723 if (!pmu_num) { 2724 pr_debug("pmu mappings not available\n"); 2725 return 0; 2726 } 2727 2728 ff->ph->env.nr_pmu_mappings = pmu_num; 2729 if (strbuf_init(&sb, 128) < 0) 2730 return -1; 2731 2732 while (pmu_num) { 2733 if (do_read_u32(ff, &type)) 2734 goto error; 2735 2736 name = do_read_string(ff); 2737 if (!name) 2738 goto error; 2739 2740 if (strbuf_addf(&sb, "%u:%s", type, name) < 0) 2741 goto error; 2742 /* include a NULL character at the end */ 2743 if (strbuf_add(&sb, "", 1) < 0) 2744 goto error; 2745 2746 if (!strcmp(name, "msr")) 2747 ff->ph->env.msr_pmu_type = type; 2748 2749 free(name); 2750 pmu_num--; 2751 } 2752 ff->ph->env.pmu_mappings = strbuf_detach(&sb, NULL); 2753 return 0; 2754 2755 error: 2756 strbuf_release(&sb); 2757 return -1; 2758 } 2759 2760 static int process_group_desc(struct feat_fd *ff, void *data __maybe_unused) 2761 { 2762 size_t ret = -1; 2763 u32 i, nr, nr_groups; 2764 struct perf_session *session; 2765 struct evsel *evsel, *leader = NULL; 2766 struct group_desc { 2767 char *name; 2768 u32 leader_idx; 2769 u32 nr_members; 2770 } *desc; 2771 2772 if (do_read_u32(ff, &nr_groups)) 2773 return -1; 2774 2775 ff->ph->env.nr_groups = nr_groups; 2776 if (!nr_groups) { 2777 pr_debug("group desc not available\n"); 2778 return 0; 2779 } 2780 2781 desc = calloc(nr_groups, sizeof(*desc)); 2782 if (!desc) 2783 return -1; 2784 2785 for (i = 0; i < nr_groups; i++) { 2786 desc[i].name = do_read_string(ff); 2787 if (!desc[i].name) 2788 goto out_free; 2789 2790 if (do_read_u32(ff, &desc[i].leader_idx)) 2791 goto out_free; 2792 2793 if (do_read_u32(ff, &desc[i].nr_members)) 2794 goto out_free; 2795 } 2796 2797 /* 2798 * Rebuild group relationship based on the group_desc 2799 */ 2800 session = container_of(ff->ph, struct perf_session, header); 2801 session->evlist->core.nr_groups = nr_groups; 2802 2803 i = nr = 0; 2804 evlist__for_each_entry(session->evlist, evsel) { 2805 if (evsel->core.idx == (int) desc[i].leader_idx) { 2806 evsel__set_leader(evsel, evsel); 2807 /* {anon_group} is a dummy name */ 2808 if (strcmp(desc[i].name, "{anon_group}")) { 2809 evsel->group_name = desc[i].name; 2810 desc[i].name = NULL; 2811 } 2812 evsel->core.nr_members = desc[i].nr_members; 2813 2814 if (i >= nr_groups || nr > 0) { 2815 pr_debug("invalid group desc\n"); 2816 goto out_free; 2817 } 2818 2819 leader = evsel; 2820 nr = evsel->core.nr_members - 1; 2821 i++; 2822 } else if (nr) { 2823 /* This is a group member */ 2824 evsel__set_leader(evsel, leader); 2825 2826 nr--; 2827 } 2828 } 2829 2830 if (i != nr_groups || nr != 0) { 2831 pr_debug("invalid group desc\n"); 2832 goto out_free; 2833 } 2834 2835 ret = 0; 2836 out_free: 2837 for (i = 0; i < nr_groups; i++) 2838 zfree(&desc[i].name); 2839 free(desc); 2840 2841 return ret; 2842 } 2843 2844 static int process_auxtrace(struct feat_fd *ff, void *data __maybe_unused) 2845 { 2846 struct perf_session *session; 2847 int err; 2848 2849 session = container_of(ff->ph, struct perf_session, header); 2850 2851 err = auxtrace_index__process(ff->fd, ff->size, session, 2852 ff->ph->needs_swap); 2853 if (err < 0) 2854 pr_err("Failed to process auxtrace index\n"); 2855 return err; 2856 } 2857 2858 static int process_cache(struct feat_fd *ff, void *data __maybe_unused) 2859 { 2860 struct cpu_cache_level *caches; 2861 u32 cnt, i, version; 2862 2863 if (do_read_u32(ff, &version)) 2864 return -1; 2865 2866 if (version != 1) 2867 return -1; 2868 2869 if (do_read_u32(ff, &cnt)) 2870 return -1; 2871 2872 caches = zalloc(sizeof(*caches) * cnt); 2873 if (!caches) 2874 return -1; 2875 2876 for (i = 0; i < cnt; i++) { 2877 struct cpu_cache_level c; 2878 2879 #define _R(v) \ 2880 if (do_read_u32(ff, &c.v))\ 2881 goto out_free_caches; \ 2882 2883 _R(level) 2884 _R(line_size) 2885 _R(sets) 2886 _R(ways) 2887 #undef _R 2888 2889 #define _R(v) \ 2890 c.v = do_read_string(ff); \ 2891 if (!c.v) \ 2892 goto out_free_caches; 2893 2894 _R(type) 2895 _R(size) 2896 _R(map) 2897 #undef _R 2898 2899 caches[i] = c; 2900 } 2901 2902 ff->ph->env.caches = caches; 2903 ff->ph->env.caches_cnt = cnt; 2904 return 0; 2905 out_free_caches: 2906 free(caches); 2907 return -1; 2908 } 2909 2910 static int process_sample_time(struct feat_fd *ff, void *data __maybe_unused) 2911 { 2912 struct perf_session *session; 2913 u64 first_sample_time, last_sample_time; 2914 int ret; 2915 2916 session = container_of(ff->ph, struct perf_session, header); 2917 2918 ret = do_read_u64(ff, &first_sample_time); 2919 if (ret) 2920 return -1; 2921 2922 ret = do_read_u64(ff, &last_sample_time); 2923 if (ret) 2924 return -1; 2925 2926 session->evlist->first_sample_time = first_sample_time; 2927 session->evlist->last_sample_time = last_sample_time; 2928 return 0; 2929 } 2930 2931 static int process_mem_topology(struct feat_fd *ff, 2932 void *data __maybe_unused) 2933 { 2934 struct memory_node *nodes; 2935 u64 version, i, nr, bsize; 2936 int ret = -1; 2937 2938 if (do_read_u64(ff, &version)) 2939 return -1; 2940 2941 if (version != 1) 2942 return -1; 2943 2944 if (do_read_u64(ff, &bsize)) 2945 return -1; 2946 2947 if (do_read_u64(ff, &nr)) 2948 return -1; 2949 2950 nodes = zalloc(sizeof(*nodes) * nr); 2951 if (!nodes) 2952 return -1; 2953 2954 for (i = 0; i < nr; i++) { 2955 struct memory_node n; 2956 2957 #define _R(v) \ 2958 if (do_read_u64(ff, &n.v)) \ 2959 goto out; \ 2960 2961 _R(node) 2962 _R(size) 2963 2964 #undef _R 2965 2966 if (do_read_bitmap(ff, &n.set, &n.size)) 2967 goto out; 2968 2969 nodes[i] = n; 2970 } 2971 2972 ff->ph->env.memory_bsize = bsize; 2973 ff->ph->env.memory_nodes = nodes; 2974 ff->ph->env.nr_memory_nodes = nr; 2975 ret = 0; 2976 2977 out: 2978 if (ret) 2979 free(nodes); 2980 return ret; 2981 } 2982 2983 static int process_clockid(struct feat_fd *ff, 2984 void *data __maybe_unused) 2985 { 2986 if (do_read_u64(ff, &ff->ph->env.clock.clockid_res_ns)) 2987 return -1; 2988 2989 return 0; 2990 } 2991 2992 static int process_clock_data(struct feat_fd *ff, 2993 void *_data __maybe_unused) 2994 { 2995 u32 data32; 2996 u64 data64; 2997 2998 /* version */ 2999 if (do_read_u32(ff, &data32)) 3000 return -1; 3001 3002 if (data32 != 1) 3003 return -1; 3004 3005 /* clockid */ 3006 if (do_read_u32(ff, &data32)) 3007 return -1; 3008 3009 ff->ph->env.clock.clockid = data32; 3010 3011 /* TOD ref time */ 3012 if (do_read_u64(ff, &data64)) 3013 return -1; 3014 3015 ff->ph->env.clock.tod_ns = data64; 3016 3017 /* clockid ref time */ 3018 if (do_read_u64(ff, &data64)) 3019 return -1; 3020 3021 ff->ph->env.clock.clockid_ns = data64; 3022 ff->ph->env.clock.enabled = true; 3023 return 0; 3024 } 3025 3026 static int process_hybrid_topology(struct feat_fd *ff, 3027 void *data __maybe_unused) 3028 { 3029 struct hybrid_node *nodes, *n; 3030 u32 nr, i; 3031 3032 /* nr nodes */ 3033 if (do_read_u32(ff, &nr)) 3034 return -1; 3035 3036 nodes = zalloc(sizeof(*nodes) * nr); 3037 if (!nodes) 3038 return -ENOMEM; 3039 3040 for (i = 0; i < nr; i++) { 3041 n = &nodes[i]; 3042 3043 n->pmu_name = do_read_string(ff); 3044 if (!n->pmu_name) 3045 goto error; 3046 3047 n->cpus = do_read_string(ff); 3048 if (!n->cpus) 3049 goto error; 3050 } 3051 3052 ff->ph->env.nr_hybrid_nodes = nr; 3053 ff->ph->env.hybrid_nodes = nodes; 3054 return 0; 3055 3056 error: 3057 for (i = 0; i < nr; i++) { 3058 free(nodes[i].pmu_name); 3059 free(nodes[i].cpus); 3060 } 3061 3062 free(nodes); 3063 return -1; 3064 } 3065 3066 static int process_dir_format(struct feat_fd *ff, 3067 void *_data __maybe_unused) 3068 { 3069 struct perf_session *session; 3070 struct perf_data *data; 3071 3072 session = container_of(ff->ph, struct perf_session, header); 3073 data = session->data; 3074 3075 if (WARN_ON(!perf_data__is_dir(data))) 3076 return -1; 3077 3078 return do_read_u64(ff, &data->dir.version); 3079 } 3080 3081 #ifdef HAVE_LIBBPF_SUPPORT 3082 static int process_bpf_prog_info(struct feat_fd *ff, void *data __maybe_unused) 3083 { 3084 struct bpf_prog_info_node *info_node; 3085 struct perf_env *env = &ff->ph->env; 3086 struct perf_bpil *info_linear; 3087 u32 count, i; 3088 int err = -1; 3089 3090 if (ff->ph->needs_swap) { 3091 pr_warning("interpreting bpf_prog_info from systems with endianness is not yet supported\n"); 3092 return 0; 3093 } 3094 3095 if (do_read_u32(ff, &count)) 3096 return -1; 3097 3098 down_write(&env->bpf_progs.lock); 3099 3100 for (i = 0; i < count; ++i) { 3101 u32 info_len, data_len; 3102 3103 info_linear = NULL; 3104 info_node = NULL; 3105 if (do_read_u32(ff, &info_len)) 3106 goto out; 3107 if (do_read_u32(ff, &data_len)) 3108 goto out; 3109 3110 if (info_len > sizeof(struct bpf_prog_info)) { 3111 pr_warning("detected invalid bpf_prog_info\n"); 3112 goto out; 3113 } 3114 3115 info_linear = malloc(sizeof(struct perf_bpil) + 3116 data_len); 3117 if (!info_linear) 3118 goto out; 3119 info_linear->info_len = sizeof(struct bpf_prog_info); 3120 info_linear->data_len = data_len; 3121 if (do_read_u64(ff, (u64 *)(&info_linear->arrays))) 3122 goto out; 3123 if (__do_read(ff, &info_linear->info, info_len)) 3124 goto out; 3125 if (info_len < sizeof(struct bpf_prog_info)) 3126 memset(((void *)(&info_linear->info)) + info_len, 0, 3127 sizeof(struct bpf_prog_info) - info_len); 3128 3129 if (__do_read(ff, info_linear->data, data_len)) 3130 goto out; 3131 3132 info_node = malloc(sizeof(struct bpf_prog_info_node)); 3133 if (!info_node) 3134 goto out; 3135 3136 /* after reading from file, translate offset to address */ 3137 bpil_offs_to_addr(info_linear); 3138 info_node->info_linear = info_linear; 3139 perf_env__insert_bpf_prog_info(env, info_node); 3140 } 3141 3142 up_write(&env->bpf_progs.lock); 3143 return 0; 3144 out: 3145 free(info_linear); 3146 free(info_node); 3147 up_write(&env->bpf_progs.lock); 3148 return err; 3149 } 3150 3151 static int process_bpf_btf(struct feat_fd *ff, void *data __maybe_unused) 3152 { 3153 struct perf_env *env = &ff->ph->env; 3154 struct btf_node *node = NULL; 3155 u32 count, i; 3156 int err = -1; 3157 3158 if (ff->ph->needs_swap) { 3159 pr_warning("interpreting btf from systems with endianness is not yet supported\n"); 3160 return 0; 3161 } 3162 3163 if (do_read_u32(ff, &count)) 3164 return -1; 3165 3166 down_write(&env->bpf_progs.lock); 3167 3168 for (i = 0; i < count; ++i) { 3169 u32 id, data_size; 3170 3171 if (do_read_u32(ff, &id)) 3172 goto out; 3173 if (do_read_u32(ff, &data_size)) 3174 goto out; 3175 3176 node = malloc(sizeof(struct btf_node) + data_size); 3177 if (!node) 3178 goto out; 3179 3180 node->id = id; 3181 node->data_size = data_size; 3182 3183 if (__do_read(ff, node->data, data_size)) 3184 goto out; 3185 3186 perf_env__insert_btf(env, node); 3187 node = NULL; 3188 } 3189 3190 err = 0; 3191 out: 3192 up_write(&env->bpf_progs.lock); 3193 free(node); 3194 return err; 3195 } 3196 #endif // HAVE_LIBBPF_SUPPORT 3197 3198 static int process_compressed(struct feat_fd *ff, 3199 void *data __maybe_unused) 3200 { 3201 if (do_read_u32(ff, &(ff->ph->env.comp_ver))) 3202 return -1; 3203 3204 if (do_read_u32(ff, &(ff->ph->env.comp_type))) 3205 return -1; 3206 3207 if (do_read_u32(ff, &(ff->ph->env.comp_level))) 3208 return -1; 3209 3210 if (do_read_u32(ff, &(ff->ph->env.comp_ratio))) 3211 return -1; 3212 3213 if (do_read_u32(ff, &(ff->ph->env.comp_mmap_len))) 3214 return -1; 3215 3216 return 0; 3217 } 3218 3219 static int __process_pmu_caps(struct feat_fd *ff, int *nr_caps, 3220 char ***caps, unsigned int *max_branches) 3221 { 3222 char *name, *value, *ptr; 3223 u32 nr_pmu_caps, i; 3224 3225 *nr_caps = 0; 3226 *caps = NULL; 3227 3228 if (do_read_u32(ff, &nr_pmu_caps)) 3229 return -1; 3230 3231 if (!nr_pmu_caps) 3232 return 0; 3233 3234 *caps = zalloc(sizeof(char *) * nr_pmu_caps); 3235 if (!*caps) 3236 return -1; 3237 3238 for (i = 0; i < nr_pmu_caps; i++) { 3239 name = do_read_string(ff); 3240 if (!name) 3241 goto error; 3242 3243 value = do_read_string(ff); 3244 if (!value) 3245 goto free_name; 3246 3247 if (asprintf(&ptr, "%s=%s", name, value) < 0) 3248 goto free_value; 3249 3250 (*caps)[i] = ptr; 3251 3252 if (!strcmp(name, "branches")) 3253 *max_branches = atoi(value); 3254 3255 free(value); 3256 free(name); 3257 } 3258 *nr_caps = nr_pmu_caps; 3259 return 0; 3260 3261 free_value: 3262 free(value); 3263 free_name: 3264 free(name); 3265 error: 3266 for (; i > 0; i--) 3267 free((*caps)[i - 1]); 3268 free(*caps); 3269 *caps = NULL; 3270 *nr_caps = 0; 3271 return -1; 3272 } 3273 3274 static int process_cpu_pmu_caps(struct feat_fd *ff, 3275 void *data __maybe_unused) 3276 { 3277 int ret = __process_pmu_caps(ff, &ff->ph->env.nr_cpu_pmu_caps, 3278 &ff->ph->env.cpu_pmu_caps, 3279 &ff->ph->env.max_branches); 3280 3281 if (!ret && !ff->ph->env.cpu_pmu_caps) 3282 pr_debug("cpu pmu capabilities not available\n"); 3283 return ret; 3284 } 3285 3286 static int process_pmu_caps(struct feat_fd *ff, void *data __maybe_unused) 3287 { 3288 struct pmu_caps *pmu_caps; 3289 u32 nr_pmu, i; 3290 int ret; 3291 int j; 3292 3293 if (do_read_u32(ff, &nr_pmu)) 3294 return -1; 3295 3296 if (!nr_pmu) { 3297 pr_debug("pmu capabilities not available\n"); 3298 return 0; 3299 } 3300 3301 pmu_caps = zalloc(sizeof(*pmu_caps) * nr_pmu); 3302 if (!pmu_caps) 3303 return -ENOMEM; 3304 3305 for (i = 0; i < nr_pmu; i++) { 3306 ret = __process_pmu_caps(ff, &pmu_caps[i].nr_caps, 3307 &pmu_caps[i].caps, 3308 &pmu_caps[i].max_branches); 3309 if (ret) 3310 goto err; 3311 3312 pmu_caps[i].pmu_name = do_read_string(ff); 3313 if (!pmu_caps[i].pmu_name) { 3314 ret = -1; 3315 goto err; 3316 } 3317 if (!pmu_caps[i].nr_caps) { 3318 pr_debug("%s pmu capabilities not available\n", 3319 pmu_caps[i].pmu_name); 3320 } 3321 } 3322 3323 ff->ph->env.nr_pmus_with_caps = nr_pmu; 3324 ff->ph->env.pmu_caps = pmu_caps; 3325 return 0; 3326 3327 err: 3328 for (i = 0; i < nr_pmu; i++) { 3329 for (j = 0; j < pmu_caps[i].nr_caps; j++) 3330 free(pmu_caps[i].caps[j]); 3331 free(pmu_caps[i].caps); 3332 free(pmu_caps[i].pmu_name); 3333 } 3334 3335 free(pmu_caps); 3336 return ret; 3337 } 3338 3339 #define FEAT_OPR(n, func, __full_only) \ 3340 [HEADER_##n] = { \ 3341 .name = __stringify(n), \ 3342 .write = write_##func, \ 3343 .print = print_##func, \ 3344 .full_only = __full_only, \ 3345 .process = process_##func, \ 3346 .synthesize = true \ 3347 } 3348 3349 #define FEAT_OPN(n, func, __full_only) \ 3350 [HEADER_##n] = { \ 3351 .name = __stringify(n), \ 3352 .write = write_##func, \ 3353 .print = print_##func, \ 3354 .full_only = __full_only, \ 3355 .process = process_##func \ 3356 } 3357 3358 /* feature_ops not implemented: */ 3359 #define print_tracing_data NULL 3360 #define print_build_id NULL 3361 3362 #define process_branch_stack NULL 3363 #define process_stat NULL 3364 3365 // Only used in util/synthetic-events.c 3366 const struct perf_header_feature_ops feat_ops[HEADER_LAST_FEATURE]; 3367 3368 const struct perf_header_feature_ops feat_ops[HEADER_LAST_FEATURE] = { 3369 FEAT_OPN(TRACING_DATA, tracing_data, false), 3370 FEAT_OPN(BUILD_ID, build_id, false), 3371 FEAT_OPR(HOSTNAME, hostname, false), 3372 FEAT_OPR(OSRELEASE, osrelease, false), 3373 FEAT_OPR(VERSION, version, false), 3374 FEAT_OPR(ARCH, arch, false), 3375 FEAT_OPR(NRCPUS, nrcpus, false), 3376 FEAT_OPR(CPUDESC, cpudesc, false), 3377 FEAT_OPR(CPUID, cpuid, false), 3378 FEAT_OPR(TOTAL_MEM, total_mem, false), 3379 FEAT_OPR(EVENT_DESC, event_desc, false), 3380 FEAT_OPR(CMDLINE, cmdline, false), 3381 FEAT_OPR(CPU_TOPOLOGY, cpu_topology, true), 3382 FEAT_OPR(NUMA_TOPOLOGY, numa_topology, true), 3383 FEAT_OPN(BRANCH_STACK, branch_stack, false), 3384 FEAT_OPR(PMU_MAPPINGS, pmu_mappings, false), 3385 FEAT_OPR(GROUP_DESC, group_desc, false), 3386 FEAT_OPN(AUXTRACE, auxtrace, false), 3387 FEAT_OPN(STAT, stat, false), 3388 FEAT_OPN(CACHE, cache, true), 3389 FEAT_OPR(SAMPLE_TIME, sample_time, false), 3390 FEAT_OPR(MEM_TOPOLOGY, mem_topology, true), 3391 FEAT_OPR(CLOCKID, clockid, false), 3392 FEAT_OPN(DIR_FORMAT, dir_format, false), 3393 #ifdef HAVE_LIBBPF_SUPPORT 3394 FEAT_OPR(BPF_PROG_INFO, bpf_prog_info, false), 3395 FEAT_OPR(BPF_BTF, bpf_btf, false), 3396 #endif 3397 FEAT_OPR(COMPRESSED, compressed, false), 3398 FEAT_OPR(CPU_PMU_CAPS, cpu_pmu_caps, false), 3399 FEAT_OPR(CLOCK_DATA, clock_data, false), 3400 FEAT_OPN(HYBRID_TOPOLOGY, hybrid_topology, true), 3401 FEAT_OPR(PMU_CAPS, pmu_caps, false), 3402 }; 3403 3404 struct header_print_data { 3405 FILE *fp; 3406 bool full; /* extended list of headers */ 3407 }; 3408 3409 static int perf_file_section__fprintf_info(struct perf_file_section *section, 3410 struct perf_header *ph, 3411 int feat, int fd, void *data) 3412 { 3413 struct header_print_data *hd = data; 3414 struct feat_fd ff; 3415 3416 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) { 3417 pr_debug("Failed to lseek to %" PRIu64 " offset for feature " 3418 "%d, continuing...\n", section->offset, feat); 3419 return 0; 3420 } 3421 if (feat >= HEADER_LAST_FEATURE) { 3422 pr_warning("unknown feature %d\n", feat); 3423 return 0; 3424 } 3425 if (!feat_ops[feat].print) 3426 return 0; 3427 3428 ff = (struct feat_fd) { 3429 .fd = fd, 3430 .ph = ph, 3431 }; 3432 3433 if (!feat_ops[feat].full_only || hd->full) 3434 feat_ops[feat].print(&ff, hd->fp); 3435 else 3436 fprintf(hd->fp, "# %s info available, use -I to display\n", 3437 feat_ops[feat].name); 3438 3439 return 0; 3440 } 3441 3442 int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full) 3443 { 3444 struct header_print_data hd; 3445 struct perf_header *header = &session->header; 3446 int fd = perf_data__fd(session->data); 3447 struct stat st; 3448 time_t stctime; 3449 int ret, bit; 3450 3451 hd.fp = fp; 3452 hd.full = full; 3453 3454 ret = fstat(fd, &st); 3455 if (ret == -1) 3456 return -1; 3457 3458 stctime = st.st_mtime; 3459 fprintf(fp, "# captured on : %s", ctime(&stctime)); 3460 3461 fprintf(fp, "# header version : %u\n", header->version); 3462 fprintf(fp, "# data offset : %" PRIu64 "\n", header->data_offset); 3463 fprintf(fp, "# data size : %" PRIu64 "\n", header->data_size); 3464 fprintf(fp, "# feat offset : %" PRIu64 "\n", header->feat_offset); 3465 3466 perf_header__process_sections(header, fd, &hd, 3467 perf_file_section__fprintf_info); 3468 3469 if (session->data->is_pipe) 3470 return 0; 3471 3472 fprintf(fp, "# missing features: "); 3473 for_each_clear_bit(bit, header->adds_features, HEADER_LAST_FEATURE) { 3474 if (bit) 3475 fprintf(fp, "%s ", feat_ops[bit].name); 3476 } 3477 3478 fprintf(fp, "\n"); 3479 return 0; 3480 } 3481 3482 struct header_fw { 3483 struct feat_writer fw; 3484 struct feat_fd *ff; 3485 }; 3486 3487 static int feat_writer_cb(struct feat_writer *fw, void *buf, size_t sz) 3488 { 3489 struct header_fw *h = container_of(fw, struct header_fw, fw); 3490 3491 return do_write(h->ff, buf, sz); 3492 } 3493 3494 static int do_write_feat(struct feat_fd *ff, int type, 3495 struct perf_file_section **p, 3496 struct evlist *evlist, 3497 struct feat_copier *fc) 3498 { 3499 int err; 3500 int ret = 0; 3501 3502 if (perf_header__has_feat(ff->ph, type)) { 3503 if (!feat_ops[type].write) 3504 return -1; 3505 3506 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__)) 3507 return -1; 3508 3509 (*p)->offset = lseek(ff->fd, 0, SEEK_CUR); 3510 3511 /* 3512 * Hook to let perf inject copy features sections from the input 3513 * file. 3514 */ 3515 if (fc && fc->copy) { 3516 struct header_fw h = { 3517 .fw.write = feat_writer_cb, 3518 .ff = ff, 3519 }; 3520 3521 /* ->copy() returns 0 if the feature was not copied */ 3522 err = fc->copy(fc, type, &h.fw); 3523 } else { 3524 err = 0; 3525 } 3526 if (!err) 3527 err = feat_ops[type].write(ff, evlist); 3528 if (err < 0) { 3529 pr_debug("failed to write feature %s\n", feat_ops[type].name); 3530 3531 /* undo anything written */ 3532 lseek(ff->fd, (*p)->offset, SEEK_SET); 3533 3534 return -1; 3535 } 3536 (*p)->size = lseek(ff->fd, 0, SEEK_CUR) - (*p)->offset; 3537 (*p)++; 3538 } 3539 return ret; 3540 } 3541 3542 static int perf_header__adds_write(struct perf_header *header, 3543 struct evlist *evlist, int fd, 3544 struct feat_copier *fc) 3545 { 3546 int nr_sections; 3547 struct feat_fd ff; 3548 struct perf_file_section *feat_sec, *p; 3549 int sec_size; 3550 u64 sec_start; 3551 int feat; 3552 int err; 3553 3554 ff = (struct feat_fd){ 3555 .fd = fd, 3556 .ph = header, 3557 }; 3558 3559 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS); 3560 if (!nr_sections) 3561 return 0; 3562 3563 feat_sec = p = calloc(nr_sections, sizeof(*feat_sec)); 3564 if (feat_sec == NULL) 3565 return -ENOMEM; 3566 3567 sec_size = sizeof(*feat_sec) * nr_sections; 3568 3569 sec_start = header->feat_offset; 3570 lseek(fd, sec_start + sec_size, SEEK_SET); 3571 3572 for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) { 3573 if (do_write_feat(&ff, feat, &p, evlist, fc)) 3574 perf_header__clear_feat(header, feat); 3575 } 3576 3577 lseek(fd, sec_start, SEEK_SET); 3578 /* 3579 * may write more than needed due to dropped feature, but 3580 * this is okay, reader will skip the missing entries 3581 */ 3582 err = do_write(&ff, feat_sec, sec_size); 3583 if (err < 0) 3584 pr_debug("failed to write feature section\n"); 3585 free(feat_sec); 3586 return err; 3587 } 3588 3589 int perf_header__write_pipe(int fd) 3590 { 3591 struct perf_pipe_file_header f_header; 3592 struct feat_fd ff; 3593 int err; 3594 3595 ff = (struct feat_fd){ .fd = fd }; 3596 3597 f_header = (struct perf_pipe_file_header){ 3598 .magic = PERF_MAGIC, 3599 .size = sizeof(f_header), 3600 }; 3601 3602 err = do_write(&ff, &f_header, sizeof(f_header)); 3603 if (err < 0) { 3604 pr_debug("failed to write perf pipe header\n"); 3605 return err; 3606 } 3607 3608 return 0; 3609 } 3610 3611 static int perf_session__do_write_header(struct perf_session *session, 3612 struct evlist *evlist, 3613 int fd, bool at_exit, 3614 struct feat_copier *fc) 3615 { 3616 struct perf_file_header f_header; 3617 struct perf_file_attr f_attr; 3618 struct perf_header *header = &session->header; 3619 struct evsel *evsel; 3620 struct feat_fd ff; 3621 u64 attr_offset; 3622 int err; 3623 3624 ff = (struct feat_fd){ .fd = fd}; 3625 lseek(fd, sizeof(f_header), SEEK_SET); 3626 3627 evlist__for_each_entry(session->evlist, evsel) { 3628 evsel->id_offset = lseek(fd, 0, SEEK_CUR); 3629 err = do_write(&ff, evsel->core.id, evsel->core.ids * sizeof(u64)); 3630 if (err < 0) { 3631 pr_debug("failed to write perf header\n"); 3632 return err; 3633 } 3634 } 3635 3636 attr_offset = lseek(ff.fd, 0, SEEK_CUR); 3637 3638 evlist__for_each_entry(evlist, evsel) { 3639 if (evsel->core.attr.size < sizeof(evsel->core.attr)) { 3640 /* 3641 * We are likely in "perf inject" and have read 3642 * from an older file. Update attr size so that 3643 * reader gets the right offset to the ids. 3644 */ 3645 evsel->core.attr.size = sizeof(evsel->core.attr); 3646 } 3647 f_attr = (struct perf_file_attr){ 3648 .attr = evsel->core.attr, 3649 .ids = { 3650 .offset = evsel->id_offset, 3651 .size = evsel->core.ids * sizeof(u64), 3652 } 3653 }; 3654 err = do_write(&ff, &f_attr, sizeof(f_attr)); 3655 if (err < 0) { 3656 pr_debug("failed to write perf header attribute\n"); 3657 return err; 3658 } 3659 } 3660 3661 if (!header->data_offset) 3662 header->data_offset = lseek(fd, 0, SEEK_CUR); 3663 header->feat_offset = header->data_offset + header->data_size; 3664 3665 if (at_exit) { 3666 err = perf_header__adds_write(header, evlist, fd, fc); 3667 if (err < 0) 3668 return err; 3669 } 3670 3671 f_header = (struct perf_file_header){ 3672 .magic = PERF_MAGIC, 3673 .size = sizeof(f_header), 3674 .attr_size = sizeof(f_attr), 3675 .attrs = { 3676 .offset = attr_offset, 3677 .size = evlist->core.nr_entries * sizeof(f_attr), 3678 }, 3679 .data = { 3680 .offset = header->data_offset, 3681 .size = header->data_size, 3682 }, 3683 /* event_types is ignored, store zeros */ 3684 }; 3685 3686 memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features)); 3687 3688 lseek(fd, 0, SEEK_SET); 3689 err = do_write(&ff, &f_header, sizeof(f_header)); 3690 if (err < 0) { 3691 pr_debug("failed to write perf header\n"); 3692 return err; 3693 } 3694 lseek(fd, header->data_offset + header->data_size, SEEK_SET); 3695 3696 return 0; 3697 } 3698 3699 int perf_session__write_header(struct perf_session *session, 3700 struct evlist *evlist, 3701 int fd, bool at_exit) 3702 { 3703 return perf_session__do_write_header(session, evlist, fd, at_exit, NULL); 3704 } 3705 3706 size_t perf_session__data_offset(const struct evlist *evlist) 3707 { 3708 struct evsel *evsel; 3709 size_t data_offset; 3710 3711 data_offset = sizeof(struct perf_file_header); 3712 evlist__for_each_entry(evlist, evsel) { 3713 data_offset += evsel->core.ids * sizeof(u64); 3714 } 3715 data_offset += evlist->core.nr_entries * sizeof(struct perf_file_attr); 3716 3717 return data_offset; 3718 } 3719 3720 int perf_session__inject_header(struct perf_session *session, 3721 struct evlist *evlist, 3722 int fd, 3723 struct feat_copier *fc) 3724 { 3725 return perf_session__do_write_header(session, evlist, fd, true, fc); 3726 } 3727 3728 static int perf_header__getbuffer64(struct perf_header *header, 3729 int fd, void *buf, size_t size) 3730 { 3731 if (readn(fd, buf, size) <= 0) 3732 return -1; 3733 3734 if (header->needs_swap) 3735 mem_bswap_64(buf, size); 3736 3737 return 0; 3738 } 3739 3740 int perf_header__process_sections(struct perf_header *header, int fd, 3741 void *data, 3742 int (*process)(struct perf_file_section *section, 3743 struct perf_header *ph, 3744 int feat, int fd, void *data)) 3745 { 3746 struct perf_file_section *feat_sec, *sec; 3747 int nr_sections; 3748 int sec_size; 3749 int feat; 3750 int err; 3751 3752 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS); 3753 if (!nr_sections) 3754 return 0; 3755 3756 feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec)); 3757 if (!feat_sec) 3758 return -1; 3759 3760 sec_size = sizeof(*feat_sec) * nr_sections; 3761 3762 lseek(fd, header->feat_offset, SEEK_SET); 3763 3764 err = perf_header__getbuffer64(header, fd, feat_sec, sec_size); 3765 if (err < 0) 3766 goto out_free; 3767 3768 for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) { 3769 err = process(sec++, header, feat, fd, data); 3770 if (err < 0) 3771 goto out_free; 3772 } 3773 err = 0; 3774 out_free: 3775 free(feat_sec); 3776 return err; 3777 } 3778 3779 static const int attr_file_abi_sizes[] = { 3780 [0] = PERF_ATTR_SIZE_VER0, 3781 [1] = PERF_ATTR_SIZE_VER1, 3782 [2] = PERF_ATTR_SIZE_VER2, 3783 [3] = PERF_ATTR_SIZE_VER3, 3784 [4] = PERF_ATTR_SIZE_VER4, 3785 0, 3786 }; 3787 3788 /* 3789 * In the legacy file format, the magic number is not used to encode endianness. 3790 * hdr_sz was used to encode endianness. But given that hdr_sz can vary based 3791 * on ABI revisions, we need to try all combinations for all endianness to 3792 * detect the endianness. 3793 */ 3794 static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph) 3795 { 3796 uint64_t ref_size, attr_size; 3797 int i; 3798 3799 for (i = 0 ; attr_file_abi_sizes[i]; i++) { 3800 ref_size = attr_file_abi_sizes[i] 3801 + sizeof(struct perf_file_section); 3802 if (hdr_sz != ref_size) { 3803 attr_size = bswap_64(hdr_sz); 3804 if (attr_size != ref_size) 3805 continue; 3806 3807 ph->needs_swap = true; 3808 } 3809 pr_debug("ABI%d perf.data file detected, need_swap=%d\n", 3810 i, 3811 ph->needs_swap); 3812 return 0; 3813 } 3814 /* could not determine endianness */ 3815 return -1; 3816 } 3817 3818 #define PERF_PIPE_HDR_VER0 16 3819 3820 static const size_t attr_pipe_abi_sizes[] = { 3821 [0] = PERF_PIPE_HDR_VER0, 3822 0, 3823 }; 3824 3825 /* 3826 * In the legacy pipe format, there is an implicit assumption that endianness 3827 * between host recording the samples, and host parsing the samples is the 3828 * same. This is not always the case given that the pipe output may always be 3829 * redirected into a file and analyzed on a different machine with possibly a 3830 * different endianness and perf_event ABI revisions in the perf tool itself. 3831 */ 3832 static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph) 3833 { 3834 u64 attr_size; 3835 int i; 3836 3837 for (i = 0 ; attr_pipe_abi_sizes[i]; i++) { 3838 if (hdr_sz != attr_pipe_abi_sizes[i]) { 3839 attr_size = bswap_64(hdr_sz); 3840 if (attr_size != hdr_sz) 3841 continue; 3842 3843 ph->needs_swap = true; 3844 } 3845 pr_debug("Pipe ABI%d perf.data file detected\n", i); 3846 return 0; 3847 } 3848 return -1; 3849 } 3850 3851 bool is_perf_magic(u64 magic) 3852 { 3853 if (!memcmp(&magic, __perf_magic1, sizeof(magic)) 3854 || magic == __perf_magic2 3855 || magic == __perf_magic2_sw) 3856 return true; 3857 3858 return false; 3859 } 3860 3861 static int check_magic_endian(u64 magic, uint64_t hdr_sz, 3862 bool is_pipe, struct perf_header *ph) 3863 { 3864 int ret; 3865 3866 /* check for legacy format */ 3867 ret = memcmp(&magic, __perf_magic1, sizeof(magic)); 3868 if (ret == 0) { 3869 ph->version = PERF_HEADER_VERSION_1; 3870 pr_debug("legacy perf.data format\n"); 3871 if (is_pipe) 3872 return try_all_pipe_abis(hdr_sz, ph); 3873 3874 return try_all_file_abis(hdr_sz, ph); 3875 } 3876 /* 3877 * the new magic number serves two purposes: 3878 * - unique number to identify actual perf.data files 3879 * - encode endianness of file 3880 */ 3881 ph->version = PERF_HEADER_VERSION_2; 3882 3883 /* check magic number with one endianness */ 3884 if (magic == __perf_magic2) 3885 return 0; 3886 3887 /* check magic number with opposite endianness */ 3888 if (magic != __perf_magic2_sw) 3889 return -1; 3890 3891 ph->needs_swap = true; 3892 3893 return 0; 3894 } 3895 3896 int perf_file_header__read(struct perf_file_header *header, 3897 struct perf_header *ph, int fd) 3898 { 3899 ssize_t ret; 3900 3901 lseek(fd, 0, SEEK_SET); 3902 3903 ret = readn(fd, header, sizeof(*header)); 3904 if (ret <= 0) 3905 return -1; 3906 3907 if (check_magic_endian(header->magic, 3908 header->attr_size, false, ph) < 0) { 3909 pr_debug("magic/endian check failed\n"); 3910 return -1; 3911 } 3912 3913 if (ph->needs_swap) { 3914 mem_bswap_64(header, offsetof(struct perf_file_header, 3915 adds_features)); 3916 } 3917 3918 if (header->size != sizeof(*header)) { 3919 /* Support the previous format */ 3920 if (header->size == offsetof(typeof(*header), adds_features)) 3921 bitmap_zero(header->adds_features, HEADER_FEAT_BITS); 3922 else 3923 return -1; 3924 } else if (ph->needs_swap) { 3925 /* 3926 * feature bitmap is declared as an array of unsigned longs -- 3927 * not good since its size can differ between the host that 3928 * generated the data file and the host analyzing the file. 3929 * 3930 * We need to handle endianness, but we don't know the size of 3931 * the unsigned long where the file was generated. Take a best 3932 * guess at determining it: try 64-bit swap first (ie., file 3933 * created on a 64-bit host), and check if the hostname feature 3934 * bit is set (this feature bit is forced on as of fbe96f2). 3935 * If the bit is not, undo the 64-bit swap and try a 32-bit 3936 * swap. If the hostname bit is still not set (e.g., older data 3937 * file), punt and fallback to the original behavior -- 3938 * clearing all feature bits and setting buildid. 3939 */ 3940 mem_bswap_64(&header->adds_features, 3941 BITS_TO_U64(HEADER_FEAT_BITS)); 3942 3943 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) { 3944 /* unswap as u64 */ 3945 mem_bswap_64(&header->adds_features, 3946 BITS_TO_U64(HEADER_FEAT_BITS)); 3947 3948 /* unswap as u32 */ 3949 mem_bswap_32(&header->adds_features, 3950 BITS_TO_U32(HEADER_FEAT_BITS)); 3951 } 3952 3953 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) { 3954 bitmap_zero(header->adds_features, HEADER_FEAT_BITS); 3955 set_bit(HEADER_BUILD_ID, header->adds_features); 3956 } 3957 } 3958 3959 memcpy(&ph->adds_features, &header->adds_features, 3960 sizeof(ph->adds_features)); 3961 3962 ph->data_offset = header->data.offset; 3963 ph->data_size = header->data.size; 3964 ph->feat_offset = header->data.offset + header->data.size; 3965 return 0; 3966 } 3967 3968 static int perf_file_section__process(struct perf_file_section *section, 3969 struct perf_header *ph, 3970 int feat, int fd, void *data) 3971 { 3972 struct feat_fd fdd = { 3973 .fd = fd, 3974 .ph = ph, 3975 .size = section->size, 3976 .offset = section->offset, 3977 }; 3978 3979 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) { 3980 pr_debug("Failed to lseek to %" PRIu64 " offset for feature " 3981 "%d, continuing...\n", section->offset, feat); 3982 return 0; 3983 } 3984 3985 if (feat >= HEADER_LAST_FEATURE) { 3986 pr_debug("unknown feature %d, continuing...\n", feat); 3987 return 0; 3988 } 3989 3990 if (!feat_ops[feat].process) 3991 return 0; 3992 3993 return feat_ops[feat].process(&fdd, data); 3994 } 3995 3996 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header, 3997 struct perf_header *ph, 3998 struct perf_data* data, 3999 bool repipe, int repipe_fd) 4000 { 4001 struct feat_fd ff = { 4002 .fd = repipe_fd, 4003 .ph = ph, 4004 }; 4005 ssize_t ret; 4006 4007 ret = perf_data__read(data, header, sizeof(*header)); 4008 if (ret <= 0) 4009 return -1; 4010 4011 if (check_magic_endian(header->magic, header->size, true, ph) < 0) { 4012 pr_debug("endian/magic failed\n"); 4013 return -1; 4014 } 4015 4016 if (ph->needs_swap) 4017 header->size = bswap_64(header->size); 4018 4019 if (repipe && do_write(&ff, header, sizeof(*header)) < 0) 4020 return -1; 4021 4022 return 0; 4023 } 4024 4025 static int perf_header__read_pipe(struct perf_session *session, int repipe_fd) 4026 { 4027 struct perf_header *header = &session->header; 4028 struct perf_pipe_file_header f_header; 4029 4030 if (perf_file_header__read_pipe(&f_header, header, session->data, 4031 session->repipe, repipe_fd) < 0) { 4032 pr_debug("incompatible file format\n"); 4033 return -EINVAL; 4034 } 4035 4036 return f_header.size == sizeof(f_header) ? 0 : -1; 4037 } 4038 4039 static int read_attr(int fd, struct perf_header *ph, 4040 struct perf_file_attr *f_attr) 4041 { 4042 struct perf_event_attr *attr = &f_attr->attr; 4043 size_t sz, left; 4044 size_t our_sz = sizeof(f_attr->attr); 4045 ssize_t ret; 4046 4047 memset(f_attr, 0, sizeof(*f_attr)); 4048 4049 /* read minimal guaranteed structure */ 4050 ret = readn(fd, attr, PERF_ATTR_SIZE_VER0); 4051 if (ret <= 0) { 4052 pr_debug("cannot read %d bytes of header attr\n", 4053 PERF_ATTR_SIZE_VER0); 4054 return -1; 4055 } 4056 4057 /* on file perf_event_attr size */ 4058 sz = attr->size; 4059 4060 if (ph->needs_swap) 4061 sz = bswap_32(sz); 4062 4063 if (sz == 0) { 4064 /* assume ABI0 */ 4065 sz = PERF_ATTR_SIZE_VER0; 4066 } else if (sz > our_sz) { 4067 pr_debug("file uses a more recent and unsupported ABI" 4068 " (%zu bytes extra)\n", sz - our_sz); 4069 return -1; 4070 } 4071 /* what we have not yet read and that we know about */ 4072 left = sz - PERF_ATTR_SIZE_VER0; 4073 if (left) { 4074 void *ptr = attr; 4075 ptr += PERF_ATTR_SIZE_VER0; 4076 4077 ret = readn(fd, ptr, left); 4078 } 4079 /* read perf_file_section, ids are read in caller */ 4080 ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids)); 4081 4082 return ret <= 0 ? -1 : 0; 4083 } 4084 4085 static int evsel__prepare_tracepoint_event(struct evsel *evsel, struct tep_handle *pevent) 4086 { 4087 struct tep_event *event; 4088 char bf[128]; 4089 4090 /* already prepared */ 4091 if (evsel->tp_format) 4092 return 0; 4093 4094 if (pevent == NULL) { 4095 pr_debug("broken or missing trace data\n"); 4096 return -1; 4097 } 4098 4099 event = tep_find_event(pevent, evsel->core.attr.config); 4100 if (event == NULL) { 4101 pr_debug("cannot find event format for %d\n", (int)evsel->core.attr.config); 4102 return -1; 4103 } 4104 4105 if (!evsel->name) { 4106 snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name); 4107 evsel->name = strdup(bf); 4108 if (evsel->name == NULL) 4109 return -1; 4110 } 4111 4112 evsel->tp_format = event; 4113 return 0; 4114 } 4115 4116 static int evlist__prepare_tracepoint_events(struct evlist *evlist, struct tep_handle *pevent) 4117 { 4118 struct evsel *pos; 4119 4120 evlist__for_each_entry(evlist, pos) { 4121 if (pos->core.attr.type == PERF_TYPE_TRACEPOINT && 4122 evsel__prepare_tracepoint_event(pos, pevent)) 4123 return -1; 4124 } 4125 4126 return 0; 4127 } 4128 4129 int perf_session__read_header(struct perf_session *session, int repipe_fd) 4130 { 4131 struct perf_data *data = session->data; 4132 struct perf_header *header = &session->header; 4133 struct perf_file_header f_header; 4134 struct perf_file_attr f_attr; 4135 u64 f_id; 4136 int nr_attrs, nr_ids, i, j, err; 4137 int fd = perf_data__fd(data); 4138 4139 session->evlist = evlist__new(); 4140 if (session->evlist == NULL) 4141 return -ENOMEM; 4142 4143 session->evlist->env = &header->env; 4144 session->machines.host.env = &header->env; 4145 4146 /* 4147 * We can read 'pipe' data event from regular file, 4148 * check for the pipe header regardless of source. 4149 */ 4150 err = perf_header__read_pipe(session, repipe_fd); 4151 if (!err || perf_data__is_pipe(data)) { 4152 data->is_pipe = true; 4153 return err; 4154 } 4155 4156 if (perf_file_header__read(&f_header, header, fd) < 0) 4157 return -EINVAL; 4158 4159 if (header->needs_swap && data->in_place_update) { 4160 pr_err("In-place update not supported when byte-swapping is required\n"); 4161 return -EINVAL; 4162 } 4163 4164 /* 4165 * Sanity check that perf.data was written cleanly; data size is 4166 * initialized to 0 and updated only if the on_exit function is run. 4167 * If data size is still 0 then the file contains only partial 4168 * information. Just warn user and process it as much as it can. 4169 */ 4170 if (f_header.data.size == 0) { 4171 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n" 4172 "Was the 'perf record' command properly terminated?\n", 4173 data->file.path); 4174 } 4175 4176 if (f_header.attr_size == 0) { 4177 pr_err("ERROR: The %s file's attr size field is 0 which is unexpected.\n" 4178 "Was the 'perf record' command properly terminated?\n", 4179 data->file.path); 4180 return -EINVAL; 4181 } 4182 4183 nr_attrs = f_header.attrs.size / f_header.attr_size; 4184 lseek(fd, f_header.attrs.offset, SEEK_SET); 4185 4186 for (i = 0; i < nr_attrs; i++) { 4187 struct evsel *evsel; 4188 off_t tmp; 4189 4190 if (read_attr(fd, header, &f_attr) < 0) 4191 goto out_errno; 4192 4193 if (header->needs_swap) { 4194 f_attr.ids.size = bswap_64(f_attr.ids.size); 4195 f_attr.ids.offset = bswap_64(f_attr.ids.offset); 4196 perf_event__attr_swap(&f_attr.attr); 4197 } 4198 4199 tmp = lseek(fd, 0, SEEK_CUR); 4200 evsel = evsel__new(&f_attr.attr); 4201 4202 if (evsel == NULL) 4203 goto out_delete_evlist; 4204 4205 evsel->needs_swap = header->needs_swap; 4206 /* 4207 * Do it before so that if perf_evsel__alloc_id fails, this 4208 * entry gets purged too at evlist__delete(). 4209 */ 4210 evlist__add(session->evlist, evsel); 4211 4212 nr_ids = f_attr.ids.size / sizeof(u64); 4213 /* 4214 * We don't have the cpu and thread maps on the header, so 4215 * for allocating the perf_sample_id table we fake 1 cpu and 4216 * hattr->ids threads. 4217 */ 4218 if (perf_evsel__alloc_id(&evsel->core, 1, nr_ids)) 4219 goto out_delete_evlist; 4220 4221 lseek(fd, f_attr.ids.offset, SEEK_SET); 4222 4223 for (j = 0; j < nr_ids; j++) { 4224 if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id))) 4225 goto out_errno; 4226 4227 perf_evlist__id_add(&session->evlist->core, &evsel->core, 0, j, f_id); 4228 } 4229 4230 lseek(fd, tmp, SEEK_SET); 4231 } 4232 4233 perf_header__process_sections(header, fd, &session->tevent, 4234 perf_file_section__process); 4235 4236 if (evlist__prepare_tracepoint_events(session->evlist, session->tevent.pevent)) 4237 goto out_delete_evlist; 4238 4239 return 0; 4240 out_errno: 4241 return -errno; 4242 4243 out_delete_evlist: 4244 evlist__delete(session->evlist); 4245 session->evlist = NULL; 4246 return -ENOMEM; 4247 } 4248 4249 int perf_event__process_feature(struct perf_session *session, 4250 union perf_event *event) 4251 { 4252 struct perf_tool *tool = session->tool; 4253 struct feat_fd ff = { .fd = 0 }; 4254 struct perf_record_header_feature *fe = (struct perf_record_header_feature *)event; 4255 int type = fe->header.type; 4256 u64 feat = fe->feat_id; 4257 int ret = 0; 4258 4259 if (type < 0 || type >= PERF_RECORD_HEADER_MAX) { 4260 pr_warning("invalid record type %d in pipe-mode\n", type); 4261 return 0; 4262 } 4263 if (feat == HEADER_RESERVED || feat >= HEADER_LAST_FEATURE) { 4264 pr_warning("invalid record type %d in pipe-mode\n", type); 4265 return -1; 4266 } 4267 4268 if (!feat_ops[feat].process) 4269 return 0; 4270 4271 ff.buf = (void *)fe->data; 4272 ff.size = event->header.size - sizeof(*fe); 4273 ff.ph = &session->header; 4274 4275 if (feat_ops[feat].process(&ff, NULL)) { 4276 ret = -1; 4277 goto out; 4278 } 4279 4280 if (!feat_ops[feat].print || !tool->show_feat_hdr) 4281 goto out; 4282 4283 if (!feat_ops[feat].full_only || 4284 tool->show_feat_hdr >= SHOW_FEAT_HEADER_FULL_INFO) { 4285 feat_ops[feat].print(&ff, stdout); 4286 } else { 4287 fprintf(stdout, "# %s info available, use -I to display\n", 4288 feat_ops[feat].name); 4289 } 4290 out: 4291 free_event_desc(ff.events); 4292 return ret; 4293 } 4294 4295 size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp) 4296 { 4297 struct perf_record_event_update *ev = &event->event_update; 4298 struct perf_record_event_update_scale *ev_scale; 4299 struct perf_record_event_update_cpus *ev_cpus; 4300 struct perf_cpu_map *map; 4301 size_t ret; 4302 4303 ret = fprintf(fp, "\n... id: %" PRI_lu64 "\n", ev->id); 4304 4305 switch (ev->type) { 4306 case PERF_EVENT_UPDATE__SCALE: 4307 ev_scale = (struct perf_record_event_update_scale *)ev->data; 4308 ret += fprintf(fp, "... scale: %f\n", ev_scale->scale); 4309 break; 4310 case PERF_EVENT_UPDATE__UNIT: 4311 ret += fprintf(fp, "... unit: %s\n", ev->data); 4312 break; 4313 case PERF_EVENT_UPDATE__NAME: 4314 ret += fprintf(fp, "... name: %s\n", ev->data); 4315 break; 4316 case PERF_EVENT_UPDATE__CPUS: 4317 ev_cpus = (struct perf_record_event_update_cpus *)ev->data; 4318 ret += fprintf(fp, "... "); 4319 4320 map = cpu_map__new_data(&ev_cpus->cpus); 4321 if (map) 4322 ret += cpu_map__fprintf(map, fp); 4323 else 4324 ret += fprintf(fp, "failed to get cpus\n"); 4325 break; 4326 default: 4327 ret += fprintf(fp, "... unknown type\n"); 4328 break; 4329 } 4330 4331 return ret; 4332 } 4333 4334 int perf_event__process_attr(struct perf_tool *tool __maybe_unused, 4335 union perf_event *event, 4336 struct evlist **pevlist) 4337 { 4338 u32 i, ids, n_ids; 4339 struct evsel *evsel; 4340 struct evlist *evlist = *pevlist; 4341 4342 if (evlist == NULL) { 4343 *pevlist = evlist = evlist__new(); 4344 if (evlist == NULL) 4345 return -ENOMEM; 4346 } 4347 4348 evsel = evsel__new(&event->attr.attr); 4349 if (evsel == NULL) 4350 return -ENOMEM; 4351 4352 evlist__add(evlist, evsel); 4353 4354 ids = event->header.size; 4355 ids -= (void *)&event->attr.id - (void *)event; 4356 n_ids = ids / sizeof(u64); 4357 /* 4358 * We don't have the cpu and thread maps on the header, so 4359 * for allocating the perf_sample_id table we fake 1 cpu and 4360 * hattr->ids threads. 4361 */ 4362 if (perf_evsel__alloc_id(&evsel->core, 1, n_ids)) 4363 return -ENOMEM; 4364 4365 for (i = 0; i < n_ids; i++) { 4366 perf_evlist__id_add(&evlist->core, &evsel->core, 0, i, event->attr.id[i]); 4367 } 4368 4369 return 0; 4370 } 4371 4372 int perf_event__process_event_update(struct perf_tool *tool __maybe_unused, 4373 union perf_event *event, 4374 struct evlist **pevlist) 4375 { 4376 struct perf_record_event_update *ev = &event->event_update; 4377 struct perf_record_event_update_scale *ev_scale; 4378 struct perf_record_event_update_cpus *ev_cpus; 4379 struct evlist *evlist; 4380 struct evsel *evsel; 4381 struct perf_cpu_map *map; 4382 4383 if (dump_trace) 4384 perf_event__fprintf_event_update(event, stdout); 4385 4386 if (!pevlist || *pevlist == NULL) 4387 return -EINVAL; 4388 4389 evlist = *pevlist; 4390 4391 evsel = evlist__id2evsel(evlist, ev->id); 4392 if (evsel == NULL) 4393 return -EINVAL; 4394 4395 switch (ev->type) { 4396 case PERF_EVENT_UPDATE__UNIT: 4397 free((char *)evsel->unit); 4398 evsel->unit = strdup(ev->data); 4399 break; 4400 case PERF_EVENT_UPDATE__NAME: 4401 free(evsel->name); 4402 evsel->name = strdup(ev->data); 4403 break; 4404 case PERF_EVENT_UPDATE__SCALE: 4405 ev_scale = (struct perf_record_event_update_scale *)ev->data; 4406 evsel->scale = ev_scale->scale; 4407 break; 4408 case PERF_EVENT_UPDATE__CPUS: 4409 ev_cpus = (struct perf_record_event_update_cpus *)ev->data; 4410 map = cpu_map__new_data(&ev_cpus->cpus); 4411 if (map) { 4412 perf_cpu_map__put(evsel->core.own_cpus); 4413 evsel->core.own_cpus = map; 4414 } else 4415 pr_err("failed to get event_update cpus\n"); 4416 default: 4417 break; 4418 } 4419 4420 return 0; 4421 } 4422 4423 int perf_event__process_tracing_data(struct perf_session *session, 4424 union perf_event *event) 4425 { 4426 ssize_t size_read, padding, size = event->tracing_data.size; 4427 int fd = perf_data__fd(session->data); 4428 char buf[BUFSIZ]; 4429 4430 /* 4431 * The pipe fd is already in proper place and in any case 4432 * we can't move it, and we'd screw the case where we read 4433 * 'pipe' data from regular file. The trace_report reads 4434 * data from 'fd' so we need to set it directly behind the 4435 * event, where the tracing data starts. 4436 */ 4437 if (!perf_data__is_pipe(session->data)) { 4438 off_t offset = lseek(fd, 0, SEEK_CUR); 4439 4440 /* setup for reading amidst mmap */ 4441 lseek(fd, offset + sizeof(struct perf_record_header_tracing_data), 4442 SEEK_SET); 4443 } 4444 4445 size_read = trace_report(fd, &session->tevent, 4446 session->repipe); 4447 padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read; 4448 4449 if (readn(fd, buf, padding) < 0) { 4450 pr_err("%s: reading input file", __func__); 4451 return -1; 4452 } 4453 if (session->repipe) { 4454 int retw = write(STDOUT_FILENO, buf, padding); 4455 if (retw <= 0 || retw != padding) { 4456 pr_err("%s: repiping tracing data padding", __func__); 4457 return -1; 4458 } 4459 } 4460 4461 if (size_read + padding != size) { 4462 pr_err("%s: tracing data size mismatch", __func__); 4463 return -1; 4464 } 4465 4466 evlist__prepare_tracepoint_events(session->evlist, session->tevent.pevent); 4467 4468 return size_read + padding; 4469 } 4470 4471 int perf_event__process_build_id(struct perf_session *session, 4472 union perf_event *event) 4473 { 4474 __event_process_build_id(&event->build_id, 4475 event->build_id.filename, 4476 session); 4477 return 0; 4478 } 4479