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