tools/perf/util/header.c

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