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