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