tools/perf/util/header.c

   1 #include "util.h"
   2 #include <sys/types.h>
   3 #include <byteswap.h>
   4 #include <unistd.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <linux/list.h>
   8 #include <linux/kernel.h>
   9 #include <linux/bitops.h>
  10 #include <sys/utsname.h>
  11
  12 #include "evlist.h"
  13 #include "evsel.h"
  14 #include "header.h"
  15 #include "../perf.h"
  16 #include "trace-event.h"
  17 #include "session.h"
  18 #include "symbol.h"
  19 #include "debug.h"
  20 #include "cpumap.h"
  21 #include "pmu.h"
  22 #include "vdso.h"
  23 #include "strbuf.h"
  24 #include "build-id.h"
  25 #include "data.h"
  26
  27 static u32 header_argc;
  28 static const char **header_argv;
  29
  30 /*
  31  * magic2 = "PERFILE2"
  32  * must be a numerical value to let the endianness
  33  * determine the memory layout. That way we are able
  34  * to detect endianness when reading the perf.data file
  35  * back.
  36  *
  37  * we check for legacy (PERFFILE) format.
  38  */
  39 static const char *__perf_magic1 = "PERFFILE";
  40 static const u64 __perf_magic2    = 0x32454c4946524550ULL;
  41 static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
  42
  43 #define PERF_MAGIC      __perf_magic2
  44
  45 struct perf_file_attr {
  46         struct perf_event_attr  attr;
  47         struct perf_file_section        ids;
  48 };
  49
  50 void perf_header__set_feat(struct perf_header *header, int feat)
  51 {
  52         set_bit(feat, header->adds_features);
  53 }
  54
  55 void perf_header__clear_feat(struct perf_header *header, int feat)
  56 {
  57         clear_bit(feat, header->adds_features);
  58 }
  59
  60 bool perf_header__has_feat(const struct perf_header *header, int feat)
  61 {
  62         return test_bit(feat, header->adds_features);
  63 }
  64
  65 static int do_write(int fd, const void *buf, size_t size)
  66 {
  67         while (size) {
  68                 int ret = write(fd, buf, size);
  69
  70                 if (ret < 0)
  71                         return -errno;
  72
  73                 size -= ret;
  74                 buf += ret;
  75         }
  76
  77         return 0;
  78 }
  79
  80 int write_padded(int fd, const void *bf, size_t count, size_t count_aligned)
  81 {
  82         static const char zero_buf[NAME_ALIGN];
  83         int err = do_write(fd, bf, count);
  84
  85         if (!err)
  86                 err = do_write(fd, zero_buf, count_aligned - count);
  87
  88         return err;
  89 }
  90
  91 #define string_size(str)                                                \
  92         (PERF_ALIGN((strlen(str) + 1), NAME_ALIGN) + sizeof(u32))
  93
  94 static int do_write_string(int fd, const char *str)
  95 {
  96         u32 len, olen;
  97         int ret;
  98
  99         olen = strlen(str) + 1;
 100         len = PERF_ALIGN(olen, NAME_ALIGN);
 101
 102         /* write len, incl. \0 */
 103         ret = do_write(fd, &len, sizeof(len));
 104         if (ret < 0)
 105                 return ret;
 106
 107         return write_padded(fd, str, olen, len);
 108 }
 109
 110 static char *do_read_string(int fd, struct perf_header *ph)
 111 {
 112         ssize_t sz, ret;
 113         u32 len;
 114         char *buf;
 115
 116         sz = readn(fd, &len, sizeof(len));
 117         if (sz < (ssize_t)sizeof(len))
 118                 return NULL;
 119
 120         if (ph->needs_swap)
 121                 len = bswap_32(len);
 122
 123         buf = malloc(len);
 124         if (!buf)
 125                 return NULL;
 126
 127         ret = readn(fd, buf, len);
 128         if (ret == (ssize_t)len) {
 129                 /*
 130                  * strings are padded by zeroes
 131                  * thus the actual strlen of buf
 132                  * may be less than len
 133                  */
 134                 return buf;
 135         }
 136
 137         free(buf);
 138         return NULL;
 139 }
 140
 141 int
 142 perf_header__set_cmdline(int argc, const char **argv)
 143 {
 144         int i;
 145
 146         /*
 147          * If header_argv has already been set, do not override it.
 148          * This allows a command to set the cmdline, parse args and
 149          * then call another builtin function that implements a
 150          * command -- e.g, cmd_kvm calling cmd_record.
 151          */
 152         if (header_argv)
 153                 return 0;
 154
 155         header_argc = (u32)argc;
 156
 157         /* do not include NULL termination */
 158         header_argv = calloc(argc, sizeof(char *));
 159         if (!header_argv)
 160                 return -ENOMEM;
 161
 162         /*
 163          * must copy argv contents because it gets moved
 164          * around during option parsing
 165          */
 166         for (i = 0; i < argc ; i++)
 167                 header_argv[i] = argv[i];
 168
 169         return 0;
 170 }
 171
 172 static int write_tracing_data(int fd, struct perf_header *h __maybe_unused,
 173                             struct perf_evlist *evlist)
 174 {
 175         return read_tracing_data(fd, &evlist->entries);
 176 }
 177
 178
 179 static int write_build_id(int fd, struct perf_header *h,
 180                           struct perf_evlist *evlist __maybe_unused)
 181 {
 182         struct perf_session *session;
 183         int err;
 184
 185         session = container_of(h, struct perf_session, header);
 186
 187         if (!perf_session__read_build_ids(session, true))
 188                 return -1;
 189
 190         err = perf_session__write_buildid_table(session, fd);
 191         if (err < 0) {
 192                 pr_debug("failed to write buildid table\n");
 193                 return err;
 194         }
 195         perf_session__cache_build_ids(session);
 196
 197         return 0;
 198 }
 199
 200 static int write_hostname(int fd, struct perf_header *h __maybe_unused,
 201                           struct perf_evlist *evlist __maybe_unused)
 202 {
 203         struct utsname uts;
 204         int ret;
 205
 206         ret = uname(&uts);
 207         if (ret < 0)
 208                 return -1;
 209
 210         return do_write_string(fd, uts.nodename);
 211 }
 212
 213 static int write_osrelease(int fd, struct perf_header *h __maybe_unused,
 214                            struct perf_evlist *evlist __maybe_unused)
 215 {
 216         struct utsname uts;
 217         int ret;
 218
 219         ret = uname(&uts);
 220         if (ret < 0)
 221                 return -1;
 222
 223         return do_write_string(fd, uts.release);
 224 }
 225
 226 static int write_arch(int fd, struct perf_header *h __maybe_unused,
 227                       struct perf_evlist *evlist __maybe_unused)
 228 {
 229         struct utsname uts;
 230         int ret;
 231
 232         ret = uname(&uts);
 233         if (ret < 0)
 234                 return -1;
 235
 236         return do_write_string(fd, uts.machine);
 237 }
 238
 239 static int write_version(int fd, struct perf_header *h __maybe_unused,
 240                          struct perf_evlist *evlist __maybe_unused)
 241 {
 242         return do_write_string(fd, perf_version_string);
 243 }
 244
 245 static int __write_cpudesc(int fd, const char *cpuinfo_proc)
 246 {
 247         FILE *file;
 248         char *buf = NULL;
 249         char *s, *p;
 250         const char *search = cpuinfo_proc;
 251         size_t len = 0;
 252         int ret = -1;
 253
 254         if (!search)
 255                 return -1;
 256
 257         file = fopen("/proc/cpuinfo", "r");
 258         if (!file)
 259                 return -1;
 260
 261         while (getline(&buf, &len, file) > 0) {
 262                 ret = strncmp(buf, search, strlen(search));
 263                 if (!ret)
 264                         break;
 265         }
 266
 267         if (ret) {
 268                 ret = -1;
 269                 goto done;
 270         }
 271
 272         s = buf;
 273
 274         p = strchr(buf, ':');
 275         if (p && *(p+1) == ' ' && *(p+2))
 276                 s = p + 2;
 277         p = strchr(s, '\n');
 278         if (p)
 279                 *p = '\0';
 280
 281         /* squash extra space characters (branding string) */
 282         p = s;
 283         while (*p) {
 284                 if (isspace(*p)) {
 285                         char *r = p + 1;
 286                         char *q = r;
 287                         *p = ' ';
 288                         while (*q && isspace(*q))
 289                                 q++;
 290                         if (q != (p+1))
 291                                 while ((*r++ = *q++));
 292                 }
 293                 p++;
 294         }
 295         ret = do_write_string(fd, s);
 296 done:
 297         free(buf);
 298         fclose(file);
 299         return ret;
 300 }
 301
 302 static int write_cpudesc(int fd, struct perf_header *h __maybe_unused,
 303                        struct perf_evlist *evlist __maybe_unused)
 304 {
 305 #ifndef CPUINFO_PROC
 306 #define CPUINFO_PROC {"model name", }
 307 #endif
 308         const char *cpuinfo_procs[] = CPUINFO_PROC;
 309         unsigned int i;
 310
 311         for (i = 0; i < ARRAY_SIZE(cpuinfo_procs); i++) {
 312                 int ret;
 313                 ret = __write_cpudesc(fd, cpuinfo_procs[i]);
 314                 if (ret >= 0)
 315                         return ret;
 316         }
 317         return -1;
 318 }
 319
 320
 321 static int write_nrcpus(int fd, struct perf_header *h __maybe_unused,
 322                         struct perf_evlist *evlist __maybe_unused)
 323 {
 324         long nr;
 325         u32 nrc, nra;
 326         int ret;
 327
 328         nr = sysconf(_SC_NPROCESSORS_CONF);
 329         if (nr < 0)
 330                 return -1;
 331
 332         nrc = (u32)(nr & UINT_MAX);
 333
 334         nr = sysconf(_SC_NPROCESSORS_ONLN);
 335         if (nr < 0)
 336                 return -1;
 337
 338         nra = (u32)(nr & UINT_MAX);
 339
 340         ret = do_write(fd, &nrc, sizeof(nrc));
 341         if (ret < 0)
 342                 return ret;
 343
 344         return do_write(fd, &nra, sizeof(nra));
 345 }
 346
 347 static int write_event_desc(int fd, struct perf_header *h __maybe_unused,
 348                             struct perf_evlist *evlist)
 349 {
 350         struct perf_evsel *evsel;
 351         u32 nre, nri, sz;
 352         int ret;
 353
 354         nre = evlist->nr_entries;
 355
 356         /*
 357          * write number of events
 358          */
 359         ret = do_write(fd, &nre, sizeof(nre));
 360         if (ret < 0)
 361                 return ret;
 362
 363         /*
 364          * size of perf_event_attr struct
 365          */
 366         sz = (u32)sizeof(evsel->attr);
 367         ret = do_write(fd, &sz, sizeof(sz));
 368         if (ret < 0)
 369                 return ret;
 370
 371         evlist__for_each(evlist, evsel) {
 372                 ret = do_write(fd, &evsel->attr, sz);
 373                 if (ret < 0)
 374                         return ret;
 375                 /*
 376                  * write number of unique id per event
 377                  * there is one id per instance of an event
 378                  *
 379                  * copy into an nri to be independent of the
 380                  * type of ids,
 381                  */
 382                 nri = evsel->ids;
 383                 ret = do_write(fd, &nri, sizeof(nri));
 384                 if (ret < 0)
 385                         return ret;
 386
 387                 /*
 388                  * write event string as passed on cmdline
 389                  */
 390                 ret = do_write_string(fd, perf_evsel__name(evsel));
 391                 if (ret < 0)
 392                         return ret;
 393                 /*
 394                  * write unique ids for this event
 395                  */
 396                 ret = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
 397                 if (ret < 0)
 398                         return ret;
 399         }
 400         return 0;
 401 }
 402
 403 static int write_cmdline(int fd, struct perf_header *h __maybe_unused,
 404                          struct perf_evlist *evlist __maybe_unused)
 405 {
 406         char buf[MAXPATHLEN];
 407         char proc[32];
 408         u32 i, n;
 409         int ret;
 410
 411         /*
 412          * actual atual path to perf binary
 413          */
 414         sprintf(proc, "/proc/%d/exe", getpid());
 415         ret = readlink(proc, buf, sizeof(buf));
 416         if (ret <= 0)
 417                 return -1;
 418
 419         /* readlink() does not add null termination */
 420         buf[ret] = '\0';
 421
 422         /* account for binary path */
 423         n = header_argc + 1;
 424
 425         ret = do_write(fd, &n, sizeof(n));
 426         if (ret < 0)
 427                 return ret;
 428
 429         ret = do_write_string(fd, buf);
 430         if (ret < 0)
 431                 return ret;
 432
 433         for (i = 0 ; i < header_argc; i++) {
 434                 ret = do_write_string(fd, header_argv[i]);
 435                 if (ret < 0)
 436                         return ret;
 437         }
 438         return 0;
 439 }
 440
 441 #define CORE_SIB_FMT \
 442         "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list"
 443 #define THRD_SIB_FMT \
 444         "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list"
 445
 446 struct cpu_topo {
 447         u32 cpu_nr;
 448         u32 core_sib;
 449         u32 thread_sib;
 450         char **core_siblings;
 451         char **thread_siblings;
 452         int *core_id;
 453         int *phy_pkg_id;
 454 };
 455
 456 static int build_cpu_topo(struct cpu_topo *tp, int cpu)
 457 {
 458         FILE *fp;
 459         char filename[MAXPATHLEN];
 460         char *buf = NULL, *p;
 461         size_t len = 0;
 462         ssize_t sret;
 463         u32 i = 0;
 464         int ret = -1;
 465
 466         sprintf(filename, CORE_SIB_FMT, cpu);
 467         fp = fopen(filename, "r");
 468         if (!fp)
 469                 goto try_threads;
 470
 471         sret = getline(&buf, &len, fp);
 472         fclose(fp);
 473         if (sret <= 0)
 474                 goto try_threads;
 475
 476         p = strchr(buf, '\n');
 477         if (p)
 478                 *p = '\0';
 479
 480         for (i = 0; i < tp->core_sib; i++) {
 481                 if (!strcmp(buf, tp->core_siblings[i]))
 482                         break;
 483         }
 484         if (i == tp->core_sib) {
 485                 tp->core_siblings[i] = buf;
 486                 tp->core_sib++;
 487                 buf = NULL;
 488                 len = 0;
 489         }
 490         ret = 0;
 491
 492 try_threads:
 493         sprintf(filename, THRD_SIB_FMT, cpu);
 494         fp = fopen(filename, "r");
 495         if (!fp)
 496                 goto done;
 497
 498         if (getline(&buf, &len, fp) <= 0)
 499                 goto done;
 500
 501         p = strchr(buf, '\n');
 502         if (p)
 503                 *p = '\0';
 504
 505         for (i = 0; i < tp->thread_sib; i++) {
 506                 if (!strcmp(buf, tp->thread_siblings[i]))
 507                         break;
 508         }
 509         if (i == tp->thread_sib) {
 510                 tp->thread_siblings[i] = buf;
 511                 tp->thread_sib++;
 512                 buf = NULL;
 513         }
 514         ret = 0;
 515 done:
 516         tp->core_id[cpu] = cpu_map__get_core_id(cpu);
 517         tp->phy_pkg_id[cpu] = cpu_map__get_socket_id(cpu);
 518
 519         if(fp)
 520                 fclose(fp);
 521         free(buf);
 522         return ret;
 523 }
 524
 525 static void free_cpu_topo(struct cpu_topo *tp)
 526 {
 527         u32 i;
 528
 529         if (!tp)
 530                 return;
 531
 532         for (i = 0 ; i < tp->core_sib; i++)
 533                 zfree(&tp->core_siblings[i]);
 534
 535         for (i = 0 ; i < tp->thread_sib; i++)
 536                 zfree(&tp->thread_siblings[i]);
 537
 538         free(tp);
 539 }
 540
 541 static struct cpu_topo *build_cpu_topology(void)
 542 {
 543         struct cpu_topo *tp;
 544         void *addr;
 545         u32 nr, i;
 546         size_t sz, sz_id;
 547         long ncpus;
 548         int ret = -1;
 549
 550         ncpus = sysconf(_SC_NPROCESSORS_CONF);
 551         if (ncpus < 0)
 552                 return NULL;
 553
 554         nr = (u32)(ncpus & UINT_MAX);
 555
 556         sz = nr * sizeof(char *);
 557         sz_id = nr * sizeof(int);
 558
 559         addr = calloc(1, sizeof(*tp) + 2 * sz + 2 * sz_id);
 560         if (!addr)
 561                 return NULL;
 562
 563         tp = addr;
 564         tp->cpu_nr = nr;
 565         addr += sizeof(*tp);
 566         tp->core_siblings = addr;
 567         addr += sz;
 568         tp->thread_siblings = addr;
 569         addr += sz;
 570         tp->core_id = addr;
 571         addr += sz_id;
 572         tp->phy_pkg_id = addr;
 573
 574         for (i = 0; i < nr; i++) {
 575                 ret = build_cpu_topo(tp, i);
 576                 if (ret < 0)
 577                         break;
 578         }
 579         if (ret) {
 580                 free_cpu_topo(tp);
 581                 tp = NULL;
 582         }
 583         return tp;
 584 }
 585
 586 static int write_cpu_topology(int fd, struct perf_header *h __maybe_unused,
 587                           struct perf_evlist *evlist __maybe_unused)
 588 {
 589         struct cpu_topo *tp;
 590         u32 i;
 591         int ret;
 592
 593         tp = build_cpu_topology();
 594         if (!tp)
 595                 return -1;
 596
 597         ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib));
 598         if (ret < 0)
 599                 goto done;
 600
 601         for (i = 0; i < tp->core_sib; i++) {
 602                 ret = do_write_string(fd, tp->core_siblings[i]);
 603                 if (ret < 0)
 604                         goto done;
 605         }
 606         ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib));
 607         if (ret < 0)
 608                 goto done;
 609
 610         for (i = 0; i < tp->thread_sib; i++) {
 611                 ret = do_write_string(fd, tp->thread_siblings[i]);
 612                 if (ret < 0)
 613                         break;
 614         }
 615
 616         for (i = 0; i < tp->cpu_nr; i++) {
 617                 ret = do_write(fd, &tp->core_id[i], sizeof(int));
 618                 if (ret < 0)
 619                         return ret;
 620                 ret = do_write(fd, &tp->phy_pkg_id[i], sizeof(int));
 621                 if (ret < 0)
 622                         return ret;
 623         }
 624 done:
 625         free_cpu_topo(tp);
 626         return ret;
 627 }
 628
 629
 630
 631 static int write_total_mem(int fd, struct perf_header *h __maybe_unused,
 632                           struct perf_evlist *evlist __maybe_unused)
 633 {
 634         char *buf = NULL;
 635         FILE *fp;
 636         size_t len = 0;
 637         int ret = -1, n;
 638         uint64_t mem;
 639
 640         fp = fopen("/proc/meminfo", "r");
 641         if (!fp)
 642                 return -1;
 643
 644         while (getline(&buf, &len, fp) > 0) {
 645                 ret = strncmp(buf, "MemTotal:", 9);
 646                 if (!ret)
 647                         break;
 648         }
 649         if (!ret) {
 650                 n = sscanf(buf, "%*s %"PRIu64, &mem);
 651                 if (n == 1)
 652                         ret = do_write(fd, &mem, sizeof(mem));
 653         } else
 654                 ret = -1;
 655         free(buf);
 656         fclose(fp);
 657         return ret;
 658 }
 659
 660 static int write_topo_node(int fd, int node)
 661 {
 662         char str[MAXPATHLEN];
 663         char field[32];
 664         char *buf = NULL, *p;
 665         size_t len = 0;
 666         FILE *fp;
 667         u64 mem_total, mem_free, mem;
 668         int ret = -1;
 669
 670         sprintf(str, "/sys/devices/system/node/node%d/meminfo", node);
 671         fp = fopen(str, "r");
 672         if (!fp)
 673                 return -1;
 674
 675         while (getline(&buf, &len, fp) > 0) {
 676                 /* skip over invalid lines */
 677                 if (!strchr(buf, ':'))
 678                         continue;
 679                 if (sscanf(buf, "%*s %*d %31s %"PRIu64, field, &mem) != 2)
 680                         goto done;
 681                 if (!strcmp(field, "MemTotal:"))
 682                         mem_total = mem;
 683                 if (!strcmp(field, "MemFree:"))
 684                         mem_free = mem;
 685         }
 686
 687         fclose(fp);
 688         fp = NULL;
 689
 690         ret = do_write(fd, &mem_total, sizeof(u64));
 691         if (ret)
 692                 goto done;
 693
 694         ret = do_write(fd, &mem_free, sizeof(u64));
 695         if (ret)
 696                 goto done;
 697
 698         ret = -1;
 699         sprintf(str, "/sys/devices/system/node/node%d/cpulist", node);
 700
 701         fp = fopen(str, "r");
 702         if (!fp)
 703                 goto done;
 704
 705         if (getline(&buf, &len, fp) <= 0)
 706                 goto done;
 707
 708         p = strchr(buf, '\n');
 709         if (p)
 710                 *p = '\0';
 711
 712         ret = do_write_string(fd, buf);
 713 done:
 714         free(buf);
 715         if (fp)
 716                 fclose(fp);
 717         return ret;
 718 }
 719
 720 static int write_numa_topology(int fd, struct perf_header *h __maybe_unused,
 721                           struct perf_evlist *evlist __maybe_unused)
 722 {
 723         char *buf = NULL;
 724         size_t len = 0;
 725         FILE *fp;
 726         struct cpu_map *node_map = NULL;
 727         char *c;
 728         u32 nr, i, j;
 729         int ret = -1;
 730
 731         fp = fopen("/sys/devices/system/node/online", "r");
 732         if (!fp)
 733                 return -1;
 734
 735         if (getline(&buf, &len, fp) <= 0)
 736                 goto done;
 737
 738         c = strchr(buf, '\n');
 739         if (c)
 740                 *c = '\0';
 741
 742         node_map = cpu_map__new(buf);
 743         if (!node_map)
 744                 goto done;
 745
 746         nr = (u32)node_map->nr;
 747
 748         ret = do_write(fd, &nr, sizeof(nr));
 749         if (ret < 0)
 750                 goto done;
 751
 752         for (i = 0; i < nr; i++) {
 753                 j = (u32)node_map->map[i];
 754                 ret = do_write(fd, &j, sizeof(j));
 755                 if (ret < 0)
 756                         break;
 757
 758                 ret = write_topo_node(fd, i);
 759                 if (ret < 0)
 760                         break;
 761         }
 762 done:
 763         free(buf);
 764         fclose(fp);
 765         free(node_map);
 766         return ret;
 767 }
 768
 769 /*
 770  * File format:
 771  *
 772  * struct pmu_mappings {
 773  *      u32     pmu_num;
 774  *      struct pmu_map {
 775  *              u32     type;
 776  *              char    name[];
 777  *      }[pmu_num];
 778  * };
 779  */
 780
 781 static int write_pmu_mappings(int fd, struct perf_header *h __maybe_unused,
 782                               struct perf_evlist *evlist __maybe_unused)
 783 {
 784         struct perf_pmu *pmu = NULL;
 785         off_t offset = lseek(fd, 0, SEEK_CUR);
 786         __u32 pmu_num = 0;
 787         int ret;
 788
 789         /* write real pmu_num later */
 790         ret = do_write(fd, &pmu_num, sizeof(pmu_num));
 791         if (ret < 0)
 792                 return ret;
 793
 794         while ((pmu = perf_pmu__scan(pmu))) {
 795                 if (!pmu->name)
 796                         continue;
 797                 pmu_num++;
 798
 799                 ret = do_write(fd, &pmu->type, sizeof(pmu->type));
 800                 if (ret < 0)
 801                         return ret;
 802
 803                 ret = do_write_string(fd, pmu->name);
 804                 if (ret < 0)
 805                         return ret;
 806         }
 807
 808         if (pwrite(fd, &pmu_num, sizeof(pmu_num), offset) != sizeof(pmu_num)) {
 809                 /* discard all */
 810                 lseek(fd, offset, SEEK_SET);
 811                 return -1;
 812         }
 813
 814         return 0;
 815 }
 816
 817 /*
 818  * File format:
 819  *
 820  * struct group_descs {
 821  *      u32     nr_groups;
 822  *      struct group_desc {
 823  *              char    name[];
 824  *              u32     leader_idx;
 825  *              u32     nr_members;
 826  *      }[nr_groups];
 827  * };
 828  */
 829 static int write_group_desc(int fd, struct perf_header *h __maybe_unused,
 830                             struct perf_evlist *evlist)
 831 {
 832         u32 nr_groups = evlist->nr_groups;
 833         struct perf_evsel *evsel;
 834         int ret;
 835
 836         ret = do_write(fd, &nr_groups, sizeof(nr_groups));
 837         if (ret < 0)
 838                 return ret;
 839
 840         evlist__for_each(evlist, evsel) {
 841                 if (perf_evsel__is_group_leader(evsel) &&
 842                     evsel->nr_members > 1) {
 843                         const char *name = evsel->group_name ?: "{anon_group}";
 844                         u32 leader_idx = evsel->idx;
 845                         u32 nr_members = evsel->nr_members;
 846
 847                         ret = do_write_string(fd, name);
 848                         if (ret < 0)
 849                                 return ret;
 850
 851                         ret = do_write(fd, &leader_idx, sizeof(leader_idx));
 852                         if (ret < 0)
 853                                 return ret;
 854
 855                         ret = do_write(fd, &nr_members, sizeof(nr_members));
 856                         if (ret < 0)
 857                                 return ret;
 858                 }
 859         }
 860         return 0;
 861 }
 862
 863 /*
 864  * default get_cpuid(): nothing gets recorded
 865  * actual implementation must be in arch/$(ARCH)/util/header.c
 866  */
 867 int __attribute__ ((weak)) get_cpuid(char *buffer __maybe_unused,
 868                                      size_t sz __maybe_unused)
 869 {
 870         return -1;
 871 }
 872
 873 static int write_cpuid(int fd, struct perf_header *h __maybe_unused,
 874                        struct perf_evlist *evlist __maybe_unused)
 875 {
 876         char buffer[64];
 877         int ret;
 878
 879         ret = get_cpuid(buffer, sizeof(buffer));
 880         if (!ret)
 881                 goto write_it;
 882
 883         return -1;
 884 write_it:
 885         return do_write_string(fd, buffer);
 886 }
 887
 888 static int write_branch_stack(int fd __maybe_unused,
 889                               struct perf_header *h __maybe_unused,
 890                        struct perf_evlist *evlist __maybe_unused)
 891 {
 892         return 0;
 893 }
 894
 895 static int write_auxtrace(int fd, struct perf_header *h,
 896                           struct perf_evlist *evlist __maybe_unused)
 897 {
 898         struct perf_session *session;
 899         int err;
 900
 901         session = container_of(h, struct perf_session, header);
 902
 903         err = auxtrace_index__write(fd, &session->auxtrace_index);
 904         if (err < 0)
 905                 pr_err("Failed to write auxtrace index\n");
 906         return err;
 907 }
 908
 909 static void print_hostname(struct perf_header *ph, int fd __maybe_unused,
 910                            FILE *fp)
 911 {
 912         fprintf(fp, "# hostname : %s\n", ph->env.hostname);
 913 }
 914
 915 static void print_osrelease(struct perf_header *ph, int fd __maybe_unused,
 916                             FILE *fp)
 917 {
 918         fprintf(fp, "# os release : %s\n", ph->env.os_release);
 919 }
 920
 921 static void print_arch(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
 922 {
 923         fprintf(fp, "# arch : %s\n", ph->env.arch);
 924 }
 925
 926 static void print_cpudesc(struct perf_header *ph, int fd __maybe_unused,
 927                           FILE *fp)
 928 {
 929         fprintf(fp, "# cpudesc : %s\n", ph->env.cpu_desc);
 930 }
 931
 932 static void print_nrcpus(struct perf_header *ph, int fd __maybe_unused,
 933                          FILE *fp)
 934 {
 935         fprintf(fp, "# nrcpus online : %u\n", ph->env.nr_cpus_online);
 936         fprintf(fp, "# nrcpus avail : %u\n", ph->env.nr_cpus_avail);
 937 }
 938
 939 static void print_version(struct perf_header *ph, int fd __maybe_unused,
 940                           FILE *fp)
 941 {
 942         fprintf(fp, "# perf version : %s\n", ph->env.version);
 943 }
 944
 945 static void print_cmdline(struct perf_header *ph, int fd __maybe_unused,
 946                           FILE *fp)
 947 {
 948         int nr, i;
 949
 950         nr = ph->env.nr_cmdline;
 951
 952         fprintf(fp, "# cmdline : ");
 953
 954         for (i = 0; i < nr; i++)
 955                 fprintf(fp, "%s ", ph->env.cmdline_argv[i]);
 956         fputc('\n', fp);
 957 }
 958
 959 static void print_cpu_topology(struct perf_header *ph, int fd __maybe_unused,
 960                                FILE *fp)
 961 {
 962         int nr, i;
 963         char *str;
 964         int cpu_nr = ph->env.nr_cpus_online;
 965
 966         nr = ph->env.nr_sibling_cores;
 967         str = ph->env.sibling_cores;
 968
 969         for (i = 0; i < nr; i++) {
 970                 fprintf(fp, "# sibling cores   : %s\n", str);
 971                 str += strlen(str) + 1;
 972         }
 973
 974         nr = ph->env.nr_sibling_threads;
 975         str = ph->env.sibling_threads;
 976
 977         for (i = 0; i < nr; i++) {
 978                 fprintf(fp, "# sibling threads : %s\n", str);
 979                 str += strlen(str) + 1;
 980         }
 981
 982         if (ph->env.cpu != NULL) {
 983                 for (i = 0; i < cpu_nr; i++)
 984                         fprintf(fp, "# CPU %d: Core ID %d, Socket ID %d\n", i,
 985                                 ph->env.cpu[i].core_id, ph->env.cpu[i].socket_id);
 986         } else
 987                 fprintf(fp, "# Core ID and Socket ID information is not available\n");
 988 }
 989
 990 static void free_event_desc(struct perf_evsel *events)
 991 {
 992         struct perf_evsel *evsel;
 993
 994         if (!events)
 995                 return;
 996
 997         for (evsel = events; evsel->attr.size; evsel++) {
 998                 zfree(&evsel->name);
 999                 zfree(&evsel->id);
1000         }
1001
1002         free(events);
1003 }
1004
1005 static struct perf_evsel *
1006 read_event_desc(struct perf_header *ph, int fd)
1007 {
1008         struct perf_evsel *evsel, *events = NULL;
1009         u64 *id;
1010         void *buf = NULL;
1011         u32 nre, sz, nr, i, j;
1012         ssize_t ret;
1013         size_t msz;
1014
1015         /* number of events */
1016         ret = readn(fd, &nre, sizeof(nre));
1017         if (ret != (ssize_t)sizeof(nre))
1018                 goto error;
1019
1020         if (ph->needs_swap)
1021                 nre = bswap_32(nre);
1022
1023         ret = readn(fd, &sz, sizeof(sz));
1024         if (ret != (ssize_t)sizeof(sz))
1025                 goto error;
1026
1027         if (ph->needs_swap)
1028                 sz = bswap_32(sz);
1029
1030         /* buffer to hold on file attr struct */
1031         buf = malloc(sz);
1032         if (!buf)
1033                 goto error;
1034
1035         /* the last event terminates with evsel->attr.size == 0: */
1036         events = calloc(nre + 1, sizeof(*events));
1037         if (!events)
1038                 goto error;
1039
1040         msz = sizeof(evsel->attr);
1041         if (sz < msz)
1042                 msz = sz;
1043
1044         for (i = 0, evsel = events; i < nre; evsel++, i++) {
1045                 evsel->idx = i;
1046
1047                 /*
1048                  * must read entire on-file attr struct to
1049                  * sync up with layout.
1050                  */
1051                 ret = readn(fd, buf, sz);
1052                 if (ret != (ssize_t)sz)
1053                         goto error;
1054
1055                 if (ph->needs_swap)
1056                         perf_event__attr_swap(buf);
1057
1058                 memcpy(&evsel->attr, buf, msz);
1059
1060                 ret = readn(fd, &nr, sizeof(nr));
1061                 if (ret != (ssize_t)sizeof(nr))
1062                         goto error;
1063
1064                 if (ph->needs_swap) {
1065                         nr = bswap_32(nr);
1066                         evsel->needs_swap = true;
1067                 }
1068
1069                 evsel->name = do_read_string(fd, ph);
1070
1071                 if (!nr)
1072                         continue;
1073
1074                 id = calloc(nr, sizeof(*id));
1075                 if (!id)
1076                         goto error;
1077                 evsel->ids = nr;
1078                 evsel->id = id;
1079
1080                 for (j = 0 ; j < nr; j++) {
1081                         ret = readn(fd, id, sizeof(*id));
1082                         if (ret != (ssize_t)sizeof(*id))
1083                                 goto error;
1084                         if (ph->needs_swap)
1085                                 *id = bswap_64(*id);
1086                         id++;
1087                 }
1088         }
1089 out:
1090         free(buf);
1091         return events;
1092 error:
1093         free_event_desc(events);
1094         events = NULL;
1095         goto out;
1096 }
1097
1098 static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
1099                                 void *priv __attribute__((unused)))
1100 {
1101         return fprintf(fp, ", %s = %s", name, val);
1102 }
1103
1104 static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
1105 {
1106         struct perf_evsel *evsel, *events = read_event_desc(ph, fd);
1107         u32 j;
1108         u64 *id;
1109
1110         if (!events) {
1111                 fprintf(fp, "# event desc: not available or unable to read\n");
1112                 return;
1113         }
1114
1115         for (evsel = events; evsel->attr.size; evsel++) {
1116                 fprintf(fp, "# event : name = %s, ", evsel->name);
1117
1118                 if (evsel->ids) {
1119                         fprintf(fp, ", id = {");
1120                         for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) {
1121                                 if (j)
1122                                         fputc(',', fp);
1123                                 fprintf(fp, " %"PRIu64, *id);
1124                         }
1125                         fprintf(fp, " }");
1126                 }
1127
1128                 perf_event_attr__fprintf(fp, &evsel->attr, __desc_attr__fprintf, NULL);
1129
1130                 fputc('\n', fp);
1131         }
1132
1133         free_event_desc(events);
1134 }
1135
1136 static void print_total_mem(struct perf_header *ph, int fd __maybe_unused,
1137                             FILE *fp)
1138 {
1139         fprintf(fp, "# total memory : %Lu kB\n", ph->env.total_mem);
1140 }
1141
1142 static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused,
1143                                 FILE *fp)
1144 {
1145         u32 nr, c, i;
1146         char *str, *tmp;
1147         uint64_t mem_total, mem_free;
1148
1149         /* nr nodes */
1150         nr = ph->env.nr_numa_nodes;
1151         str = ph->env.numa_nodes;
1152
1153         for (i = 0; i < nr; i++) {
1154                 /* node number */
1155                 c = strtoul(str, &tmp, 0);
1156                 if (*tmp != ':')
1157                         goto error;
1158
1159                 str = tmp + 1;
1160                 mem_total = strtoull(str, &tmp, 0);
1161                 if (*tmp != ':')
1162                         goto error;
1163
1164                 str = tmp + 1;
1165                 mem_free = strtoull(str, &tmp, 0);
1166                 if (*tmp != ':')
1167                         goto error;
1168
1169                 fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
1170                             " free = %"PRIu64" kB\n",
1171                         c, mem_total, mem_free);
1172
1173                 str = tmp + 1;
1174                 fprintf(fp, "# node%u cpu list : %s\n", c, str);
1175
1176                 str += strlen(str) + 1;
1177         }
1178         return;
1179 error:
1180         fprintf(fp, "# numa topology : not available\n");
1181 }
1182
1183 static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
1184 {
1185         fprintf(fp, "# cpuid : %s\n", ph->env.cpuid);
1186 }
1187
1188 static void print_branch_stack(struct perf_header *ph __maybe_unused,
1189                                int fd __maybe_unused, FILE *fp)
1190 {
1191         fprintf(fp, "# contains samples with branch stack\n");
1192 }
1193
1194 static void print_auxtrace(struct perf_header *ph __maybe_unused,
1195                            int fd __maybe_unused, FILE *fp)
1196 {
1197         fprintf(fp, "# contains AUX area data (e.g. instruction trace)\n");
1198 }
1199
1200 static void print_pmu_mappings(struct perf_header *ph, int fd __maybe_unused,
1201                                FILE *fp)
1202 {
1203         const char *delimiter = "# pmu mappings: ";
1204         char *str, *tmp;
1205         u32 pmu_num;
1206         u32 type;
1207
1208         pmu_num = ph->env.nr_pmu_mappings;
1209         if (!pmu_num) {
1210                 fprintf(fp, "# pmu mappings: not available\n");
1211                 return;
1212         }
1213
1214         str = ph->env.pmu_mappings;
1215
1216         while (pmu_num) {
1217                 type = strtoul(str, &tmp, 0);
1218                 if (*tmp != ':')
1219                         goto error;
1220
1221                 str = tmp + 1;
1222                 fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
1223
1224                 delimiter = ", ";
1225                 str += strlen(str) + 1;
1226                 pmu_num--;
1227         }
1228
1229         fprintf(fp, "\n");
1230
1231         if (!pmu_num)
1232                 return;
1233 error:
1234         fprintf(fp, "# pmu mappings: unable to read\n");
1235 }
1236
1237 static void print_group_desc(struct perf_header *ph, int fd __maybe_unused,
1238                              FILE *fp)
1239 {
1240         struct perf_session *session;
1241         struct perf_evsel *evsel;
1242         u32 nr = 0;
1243
1244         session = container_of(ph, struct perf_session, header);
1245
1246         evlist__for_each(session->evlist, evsel) {
1247                 if (perf_evsel__is_group_leader(evsel) &&
1248                     evsel->nr_members > 1) {
1249                         fprintf(fp, "# group: %s{%s", evsel->group_name ?: "",
1250                                 perf_evsel__name(evsel));
1251
1252                         nr = evsel->nr_members - 1;
1253                 } else if (nr) {
1254                         fprintf(fp, ",%s", perf_evsel__name(evsel));
1255
1256                         if (--nr == 0)
1257                                 fprintf(fp, "}\n");
1258                 }
1259         }
1260 }
1261
1262 static int __event_process_build_id(struct build_id_event *bev,
1263                                     char *filename,
1264                                     struct perf_session *session)
1265 {
1266         int err = -1;
1267         struct machine *machine;
1268         u16 cpumode;
1269         struct dso *dso;
1270         enum dso_kernel_type dso_type;
1271
1272         machine = perf_session__findnew_machine(session, bev->pid);
1273         if (!machine)
1274                 goto out;
1275
1276         cpumode = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1277
1278         switch (cpumode) {
1279         case PERF_RECORD_MISC_KERNEL:
1280                 dso_type = DSO_TYPE_KERNEL;
1281                 break;
1282         case PERF_RECORD_MISC_GUEST_KERNEL:
1283                 dso_type = DSO_TYPE_GUEST_KERNEL;
1284                 break;
1285         case PERF_RECORD_MISC_USER:
1286         case PERF_RECORD_MISC_GUEST_USER:
1287                 dso_type = DSO_TYPE_USER;
1288                 break;
1289         default:
1290                 goto out;
1291         }
1292
1293         dso = machine__findnew_dso(machine, filename);
1294         if (dso != NULL) {
1295                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1296
1297                 dso__set_build_id(dso, &bev->build_id);
1298
1299                 if (!is_kernel_module(filename, cpumode))
1300                         dso->kernel = dso_type;
1301
1302                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
1303                                   sbuild_id);
1304                 pr_debug("build id event received for %s: %s\n",
1305                          dso->long_name, sbuild_id);
1306                 dso__put(dso);
1307         }
1308
1309         err = 0;
1310 out:
1311         return err;
1312 }
1313
1314 static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
1315                                                  int input, u64 offset, u64 size)
1316 {
1317         struct perf_session *session = container_of(header, struct perf_session, header);
1318         struct {
1319                 struct perf_event_header   header;
1320                 u8                         build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
1321                 char                       filename[0];
1322         } old_bev;
1323         struct build_id_event bev;
1324         char filename[PATH_MAX];
1325         u64 limit = offset + size;
1326
1327         while (offset < limit) {
1328                 ssize_t len;
1329
1330                 if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
1331                         return -1;
1332
1333                 if (header->needs_swap)
1334                         perf_event_header__bswap(&old_bev.header);
1335
1336                 len = old_bev.header.size - sizeof(old_bev);
1337                 if (readn(input, filename, len) != len)
1338                         return -1;
1339
1340                 bev.header = old_bev.header;
1341
1342                 /*
1343                  * As the pid is the missing value, we need to fill
1344                  * it properly. The header.misc value give us nice hint.
1345                  */
1346                 bev.pid = HOST_KERNEL_ID;
1347                 if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
1348                     bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
1349                         bev.pid = DEFAULT_GUEST_KERNEL_ID;
1350
1351                 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
1352                 __event_process_build_id(&bev, filename, session);
1353
1354                 offset += bev.header.size;
1355         }
1356
1357         return 0;
1358 }
1359
1360 static int perf_header__read_build_ids(struct perf_header *header,
1361                                        int input, u64 offset, u64 size)
1362 {
1363         struct perf_session *session = container_of(header, struct perf_session, header);
1364         struct build_id_event bev;
1365         char filename[PATH_MAX];
1366         u64 limit = offset + size, orig_offset = offset;
1367         int err = -1;
1368
1369         while (offset < limit) {
1370                 ssize_t len;
1371
1372                 if (readn(input, &bev, sizeof(bev)) != sizeof(bev))
1373                         goto out;
1374
1375                 if (header->needs_swap)
1376                         perf_event_header__bswap(&bev.header);
1377
1378                 len = bev.header.size - sizeof(bev);
1379                 if (readn(input, filename, len) != len)
1380                         goto out;
1381                 /*
1382                  * The a1645ce1 changeset:
1383                  *
1384                  * "perf: 'perf kvm' tool for monitoring guest performance from host"
1385                  *
1386                  * Added a field to struct build_id_event that broke the file
1387                  * format.
1388                  *
1389                  * Since the kernel build-id is the first entry, process the
1390                  * table using the old format if the well known
1391                  * '[kernel.kallsyms]' string for the kernel build-id has the
1392                  * first 4 characters chopped off (where the pid_t sits).
1393                  */
1394                 if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
1395                         if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
1396                                 return -1;
1397                         return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
1398                 }
1399
1400                 __event_process_build_id(&bev, filename, session);
1401
1402                 offset += bev.header.size;
1403         }
1404         err = 0;
1405 out:
1406         return err;
1407 }
1408
1409 static int process_tracing_data(struct perf_file_section *section __maybe_unused,
1410                                 struct perf_header *ph __maybe_unused,
1411                                 int fd, void *data)
1412 {
1413         ssize_t ret = trace_report(fd, data, false);
1414         return ret < 0 ? -1 : 0;
1415 }
1416
1417 static int process_build_id(struct perf_file_section *section,
1418                             struct perf_header *ph, int fd,
1419                             void *data __maybe_unused)
1420 {
1421         if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
1422                 pr_debug("Failed to read buildids, continuing...\n");
1423         return 0;
1424 }
1425
1426 static int process_hostname(struct perf_file_section *section __maybe_unused,
1427                             struct perf_header *ph, int fd,
1428                             void *data __maybe_unused)
1429 {
1430         ph->env.hostname = do_read_string(fd, ph);
1431         return ph->env.hostname ? 0 : -ENOMEM;
1432 }
1433
1434 static int process_osrelease(struct perf_file_section *section __maybe_unused,
1435                              struct perf_header *ph, int fd,
1436                              void *data __maybe_unused)
1437 {
1438         ph->env.os_release = do_read_string(fd, ph);
1439         return ph->env.os_release ? 0 : -ENOMEM;
1440 }
1441
1442 static int process_version(struct perf_file_section *section __maybe_unused,
1443                            struct perf_header *ph, int fd,
1444                            void *data __maybe_unused)
1445 {
1446         ph->env.version = do_read_string(fd, ph);
1447         return ph->env.version ? 0 : -ENOMEM;
1448 }
1449
1450 static int process_arch(struct perf_file_section *section __maybe_unused,
1451                         struct perf_header *ph, int fd,
1452                         void *data __maybe_unused)
1453 {
1454         ph->env.arch = do_read_string(fd, ph);
1455         return ph->env.arch ? 0 : -ENOMEM;
1456 }
1457
1458 static int process_nrcpus(struct perf_file_section *section __maybe_unused,
1459                           struct perf_header *ph, int fd,
1460                           void *data __maybe_unused)
1461 {
1462         ssize_t ret;
1463         u32 nr;
1464
1465         ret = readn(fd, &nr, sizeof(nr));
1466         if (ret != sizeof(nr))
1467                 return -1;
1468
1469         if (ph->needs_swap)
1470                 nr = bswap_32(nr);
1471
1472         ph->env.nr_cpus_online = nr;
1473
1474         ret = readn(fd, &nr, sizeof(nr));
1475         if (ret != sizeof(nr))
1476                 return -1;
1477
1478         if (ph->needs_swap)
1479                 nr = bswap_32(nr);
1480
1481         ph->env.nr_cpus_avail = nr;
1482         return 0;
1483 }
1484
1485 static int process_cpudesc(struct perf_file_section *section __maybe_unused,
1486                            struct perf_header *ph, int fd,
1487                            void *data __maybe_unused)
1488 {
1489         ph->env.cpu_desc = do_read_string(fd, ph);
1490         return ph->env.cpu_desc ? 0 : -ENOMEM;
1491 }
1492
1493 static int process_cpuid(struct perf_file_section *section __maybe_unused,
1494                          struct perf_header *ph,  int fd,
1495                          void *data __maybe_unused)
1496 {
1497         ph->env.cpuid = do_read_string(fd, ph);
1498         return ph->env.cpuid ? 0 : -ENOMEM;
1499 }
1500
1501 static int process_total_mem(struct perf_file_section *section __maybe_unused,
1502                              struct perf_header *ph, int fd,
1503                              void *data __maybe_unused)
1504 {
1505         uint64_t mem;
1506         ssize_t ret;
1507
1508         ret = readn(fd, &mem, sizeof(mem));
1509         if (ret != sizeof(mem))
1510                 return -1;
1511
1512         if (ph->needs_swap)
1513                 mem = bswap_64(mem);
1514
1515         ph->env.total_mem = mem;
1516         return 0;
1517 }
1518
1519 static struct perf_evsel *
1520 perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
1521 {
1522         struct perf_evsel *evsel;
1523
1524         evlist__for_each(evlist, evsel) {
1525                 if (evsel->idx == idx)
1526                         return evsel;
1527         }
1528
1529         return NULL;
1530 }
1531
1532 static void
1533 perf_evlist__set_event_name(struct perf_evlist *evlist,
1534                             struct perf_evsel *event)
1535 {
1536         struct perf_evsel *evsel;
1537
1538         if (!event->name)
1539                 return;
1540
1541         evsel = perf_evlist__find_by_index(evlist, event->idx);
1542         if (!evsel)
1543                 return;
1544
1545         if (evsel->name)
1546                 return;
1547
1548         evsel->name = strdup(event->name);
1549 }
1550
1551 static int
1552 process_event_desc(struct perf_file_section *section __maybe_unused,
1553                    struct perf_header *header, int fd,
1554                    void *data __maybe_unused)
1555 {
1556         struct perf_session *session;
1557         struct perf_evsel *evsel, *events = read_event_desc(header, fd);
1558
1559         if (!events)
1560                 return 0;
1561
1562         session = container_of(header, struct perf_session, header);
1563         for (evsel = events; evsel->attr.size; evsel++)
1564                 perf_evlist__set_event_name(session->evlist, evsel);
1565
1566         free_event_desc(events);
1567
1568         return 0;
1569 }
1570
1571 static int process_cmdline(struct perf_file_section *section,
1572                            struct perf_header *ph, int fd,
1573                            void *data __maybe_unused)
1574 {
1575         ssize_t ret;
1576         char *str, *cmdline = NULL, **argv = NULL;
1577         u32 nr, i, len = 0;
1578
1579         ret = readn(fd, &nr, sizeof(nr));
1580         if (ret != sizeof(nr))
1581                 return -1;
1582
1583         if (ph->needs_swap)
1584                 nr = bswap_32(nr);
1585
1586         ph->env.nr_cmdline = nr;
1587
1588         cmdline = zalloc(section->size + nr + 1);
1589         if (!cmdline)
1590                 return -1;
1591
1592         argv = zalloc(sizeof(char *) * (nr + 1));
1593         if (!argv)
1594                 goto error;
1595
1596         for (i = 0; i < nr; i++) {
1597                 str = do_read_string(fd, ph);
1598                 if (!str)
1599                         goto error;
1600
1601                 argv[i] = cmdline + len;
1602                 memcpy(argv[i], str, strlen(str) + 1);
1603                 len += strlen(str) + 1;
1604                 free(str);
1605         }
1606         ph->env.cmdline = cmdline;
1607         ph->env.cmdline_argv = (const char **) argv;
1608         return 0;
1609
1610 error:
1611         free(argv);
1612         free(cmdline);
1613         return -1;
1614 }
1615
1616 static int process_cpu_topology(struct perf_file_section *section,
1617                                 struct perf_header *ph, int fd,
1618                                 void *data __maybe_unused)
1619 {
1620         ssize_t ret;
1621         u32 nr, i;
1622         char *str;
1623         struct strbuf sb;
1624         int cpu_nr = ph->env.nr_cpus_online;
1625         u64 size = 0;
1626
1627         ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu));
1628         if (!ph->env.cpu)
1629                 return -1;
1630
1631         ret = readn(fd, &nr, sizeof(nr));
1632         if (ret != sizeof(nr))
1633                 goto free_cpu;
1634
1635         if (ph->needs_swap)
1636                 nr = bswap_32(nr);
1637
1638         ph->env.nr_sibling_cores = nr;
1639         size += sizeof(u32);
1640         strbuf_init(&sb, 128);
1641
1642         for (i = 0; i < nr; i++) {
1643                 str = do_read_string(fd, ph);
1644                 if (!str)
1645                         goto error;
1646
1647                 /* include a NULL character at the end */
1648                 strbuf_add(&sb, str, strlen(str) + 1);
1649                 size += string_size(str);
1650                 free(str);
1651         }
1652         ph->env.sibling_cores = strbuf_detach(&sb, NULL);
1653
1654         ret = readn(fd, &nr, sizeof(nr));
1655         if (ret != sizeof(nr))
1656                 return -1;
1657
1658         if (ph->needs_swap)
1659                 nr = bswap_32(nr);
1660
1661         ph->env.nr_sibling_threads = nr;
1662         size += sizeof(u32);
1663
1664         for (i = 0; i < nr; i++) {
1665                 str = do_read_string(fd, ph);
1666                 if (!str)
1667                         goto error;
1668
1669                 /* include a NULL character at the end */
1670                 strbuf_add(&sb, str, strlen(str) + 1);
1671                 size += string_size(str);
1672                 free(str);
1673         }
1674         ph->env.sibling_threads = strbuf_detach(&sb, NULL);
1675
1676         /*
1677          * The header may be from old perf,
1678          * which doesn't include core id and socket id information.
1679          */
1680         if (section->size <= size) {
1681                 zfree(&ph->env.cpu);
1682                 return 0;
1683         }
1684
1685         for (i = 0; i < (u32)cpu_nr; i++) {
1686                 ret = readn(fd, &nr, sizeof(nr));
1687                 if (ret != sizeof(nr))
1688                         goto free_cpu;
1689
1690                 if (ph->needs_swap)
1691                         nr = bswap_32(nr);
1692
1693                 if (nr > (u32)cpu_nr) {
1694                         pr_debug("core_id number is too big."
1695                                  "You may need to upgrade the perf tool.\n");
1696                         goto free_cpu;
1697                 }
1698                 ph->env.cpu[i].core_id = nr;
1699
1700                 ret = readn(fd, &nr, sizeof(nr));
1701                 if (ret != sizeof(nr))
1702                         goto free_cpu;
1703
1704                 if (ph->needs_swap)
1705                         nr = bswap_32(nr);
1706
1707                 if (nr > (u32)cpu_nr) {
1708                         pr_debug("socket_id number is too big."
1709                                  "You may need to upgrade the perf tool.\n");
1710                         goto free_cpu;
1711                 }
1712
1713                 ph->env.cpu[i].socket_id = nr;
1714         }
1715
1716         return 0;
1717
1718 error:
1719         strbuf_release(&sb);
1720 free_cpu:
1721         zfree(&ph->env.cpu);
1722         return -1;
1723 }
1724
1725 static int process_numa_topology(struct perf_file_section *section __maybe_unused,
1726                                  struct perf_header *ph, int fd,
1727                                  void *data __maybe_unused)
1728 {
1729         ssize_t ret;
1730         u32 nr, node, i;
1731         char *str;
1732         uint64_t mem_total, mem_free;
1733         struct strbuf sb;
1734
1735         /* nr nodes */
1736         ret = readn(fd, &nr, sizeof(nr));
1737         if (ret != sizeof(nr))
1738                 goto error;
1739
1740         if (ph->needs_swap)
1741                 nr = bswap_32(nr);
1742
1743         ph->env.nr_numa_nodes = nr;
1744         strbuf_init(&sb, 256);
1745
1746         for (i = 0; i < nr; i++) {
1747                 /* node number */
1748                 ret = readn(fd, &node, sizeof(node));
1749                 if (ret != sizeof(node))
1750                         goto error;
1751
1752                 ret = readn(fd, &mem_total, sizeof(u64));
1753                 if (ret != sizeof(u64))
1754                         goto error;
1755
1756                 ret = readn(fd, &mem_free, sizeof(u64));
1757                 if (ret != sizeof(u64))
1758                         goto error;
1759
1760                 if (ph->needs_swap) {
1761                         node = bswap_32(node);
1762                         mem_total = bswap_64(mem_total);
1763                         mem_free = bswap_64(mem_free);
1764                 }
1765
1766                 strbuf_addf(&sb, "%u:%"PRIu64":%"PRIu64":",
1767                             node, mem_total, mem_free);
1768
1769                 str = do_read_string(fd, ph);
1770                 if (!str)
1771                         goto error;
1772
1773                 /* include a NULL character at the end */
1774                 strbuf_add(&sb, str, strlen(str) + 1);
1775                 free(str);
1776         }
1777         ph->env.numa_nodes = strbuf_detach(&sb, NULL);
1778         return 0;
1779
1780 error:
1781         strbuf_release(&sb);
1782         return -1;
1783 }
1784
1785 static int process_pmu_mappings(struct perf_file_section *section __maybe_unused,
1786                                 struct perf_header *ph, int fd,
1787                                 void *data __maybe_unused)
1788 {
1789         ssize_t ret;
1790         char *name;
1791         u32 pmu_num;
1792         u32 type;
1793         struct strbuf sb;
1794
1795         ret = readn(fd, &pmu_num, sizeof(pmu_num));
1796         if (ret != sizeof(pmu_num))
1797                 return -1;
1798
1799         if (ph->needs_swap)
1800                 pmu_num = bswap_32(pmu_num);
1801
1802         if (!pmu_num) {
1803                 pr_debug("pmu mappings not available\n");
1804                 return 0;
1805         }
1806
1807         ph->env.nr_pmu_mappings = pmu_num;
1808         strbuf_init(&sb, 128);
1809
1810         while (pmu_num) {
1811                 if (readn(fd, &type, sizeof(type)) != sizeof(type))
1812                         goto error;
1813                 if (ph->needs_swap)
1814                         type = bswap_32(type);
1815
1816                 name = do_read_string(fd, ph);
1817                 if (!name)
1818                         goto error;
1819
1820                 strbuf_addf(&sb, "%u:%s", type, name);
1821                 /* include a NULL character at the end */
1822                 strbuf_add(&sb, "", 1);
1823
1824                 free(name);
1825                 pmu_num--;
1826         }
1827         ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
1828         return 0;
1829
1830 error:
1831         strbuf_release(&sb);
1832         return -1;
1833 }
1834
1835 static int process_group_desc(struct perf_file_section *section __maybe_unused,
1836                               struct perf_header *ph, int fd,
1837                               void *data __maybe_unused)
1838 {
1839         size_t ret = -1;
1840         u32 i, nr, nr_groups;
1841         struct perf_session *session;
1842         struct perf_evsel *evsel, *leader = NULL;
1843         struct group_desc {
1844                 char *name;
1845                 u32 leader_idx;
1846                 u32 nr_members;
1847         } *desc;
1848
1849         if (readn(fd, &nr_groups, sizeof(nr_groups)) != sizeof(nr_groups))
1850                 return -1;
1851
1852         if (ph->needs_swap)
1853                 nr_groups = bswap_32(nr_groups);
1854
1855         ph->env.nr_groups = nr_groups;
1856         if (!nr_groups) {
1857                 pr_debug("group desc not available\n");
1858                 return 0;
1859         }
1860
1861         desc = calloc(nr_groups, sizeof(*desc));
1862         if (!desc)
1863                 return -1;
1864
1865         for (i = 0; i < nr_groups; i++) {
1866                 desc[i].name = do_read_string(fd, ph);
1867                 if (!desc[i].name)
1868                         goto out_free;
1869
1870                 if (readn(fd, &desc[i].leader_idx, sizeof(u32)) != sizeof(u32))
1871                         goto out_free;
1872
1873                 if (readn(fd, &desc[i].nr_members, sizeof(u32)) != sizeof(u32))
1874                         goto out_free;
1875
1876                 if (ph->needs_swap) {
1877                         desc[i].leader_idx = bswap_32(desc[i].leader_idx);
1878                         desc[i].nr_members = bswap_32(desc[i].nr_members);
1879                 }
1880         }
1881
1882         /*
1883          * Rebuild group relationship based on the group_desc
1884          */
1885         session = container_of(ph, struct perf_session, header);
1886         session->evlist->nr_groups = nr_groups;
1887
1888         i = nr = 0;
1889         evlist__for_each(session->evlist, evsel) {
1890                 if (evsel->idx == (int) desc[i].leader_idx) {
1891                         evsel->leader = evsel;
1892                         /* {anon_group} is a dummy name */
1893                         if (strcmp(desc[i].name, "{anon_group}")) {
1894                                 evsel->group_name = desc[i].name;
1895                                 desc[i].name = NULL;
1896                         }
1897                         evsel->nr_members = desc[i].nr_members;
1898
1899                         if (i >= nr_groups || nr > 0) {
1900                                 pr_debug("invalid group desc\n");
1901                                 goto out_free;
1902                         }
1903
1904                         leader = evsel;
1905                         nr = evsel->nr_members - 1;
1906                         i++;
1907                 } else if (nr) {
1908                         /* This is a group member */
1909                         evsel->leader = leader;
1910
1911                         nr--;
1912                 }
1913         }
1914
1915         if (i != nr_groups || nr != 0) {
1916                 pr_debug("invalid group desc\n");
1917                 goto out_free;
1918         }
1919
1920         ret = 0;
1921 out_free:
1922         for (i = 0; i < nr_groups; i++)
1923                 zfree(&desc[i].name);
1924         free(desc);
1925
1926         return ret;
1927 }
1928
1929 static int process_auxtrace(struct perf_file_section *section,
1930                             struct perf_header *ph, int fd,
1931                             void *data __maybe_unused)
1932 {
1933         struct perf_session *session;
1934         int err;
1935
1936         session = container_of(ph, struct perf_session, header);
1937
1938         err = auxtrace_index__process(fd, section->size, session,
1939                                       ph->needs_swap);
1940         if (err < 0)
1941                 pr_err("Failed to process auxtrace index\n");
1942         return err;
1943 }
1944
1945 struct feature_ops {
1946         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
1947         void (*print)(struct perf_header *h, int fd, FILE *fp);
1948         int (*process)(struct perf_file_section *section,
1949                        struct perf_header *h, int fd, void *data);
1950         const char *name;
1951         bool full_only;
1952 };
1953
1954 #define FEAT_OPA(n, func) \
1955         [n] = { .name = #n, .write = write_##func, .print = print_##func }
1956 #define FEAT_OPP(n, func) \
1957         [n] = { .name = #n, .write = write_##func, .print = print_##func, \
1958                 .process = process_##func }
1959 #define FEAT_OPF(n, func) \
1960         [n] = { .name = #n, .write = write_##func, .print = print_##func, \
1961                 .process = process_##func, .full_only = true }
1962
1963 /* feature_ops not implemented: */
1964 #define print_tracing_data      NULL
1965 #define print_build_id          NULL
1966
1967 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
1968         FEAT_OPP(HEADER_TRACING_DATA,   tracing_data),
1969         FEAT_OPP(HEADER_BUILD_ID,       build_id),
1970         FEAT_OPP(HEADER_HOSTNAME,       hostname),
1971         FEAT_OPP(HEADER_OSRELEASE,      osrelease),
1972         FEAT_OPP(HEADER_VERSION,        version),
1973         FEAT_OPP(HEADER_ARCH,           arch),
1974         FEAT_OPP(HEADER_NRCPUS,         nrcpus),
1975         FEAT_OPP(HEADER_CPUDESC,        cpudesc),
1976         FEAT_OPP(HEADER_CPUID,          cpuid),
1977         FEAT_OPP(HEADER_TOTAL_MEM,      total_mem),
1978         FEAT_OPP(HEADER_EVENT_DESC,     event_desc),
1979         FEAT_OPP(HEADER_CMDLINE,        cmdline),
1980         FEAT_OPF(HEADER_CPU_TOPOLOGY,   cpu_topology),
1981         FEAT_OPF(HEADER_NUMA_TOPOLOGY,  numa_topology),
1982         FEAT_OPA(HEADER_BRANCH_STACK,   branch_stack),
1983         FEAT_OPP(HEADER_PMU_MAPPINGS,   pmu_mappings),
1984         FEAT_OPP(HEADER_GROUP_DESC,     group_desc),
1985         FEAT_OPP(HEADER_AUXTRACE,       auxtrace),
1986 };
1987
1988 struct header_print_data {
1989         FILE *fp;
1990         bool full; /* extended list of headers */
1991 };
1992
1993 static int perf_file_section__fprintf_info(struct perf_file_section *section,
1994                                            struct perf_header *ph,
1995                                            int feat, int fd, void *data)
1996 {
1997         struct header_print_data *hd = data;
1998
1999         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
2000                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
2001                                 "%d, continuing...\n", section->offset, feat);
2002                 return 0;
2003         }
2004         if (feat >= HEADER_LAST_FEATURE) {
2005                 pr_warning("unknown feature %d\n", feat);
2006                 return 0;
2007         }
2008         if (!feat_ops[feat].print)
2009                 return 0;
2010
2011         if (!feat_ops[feat].full_only || hd->full)
2012                 feat_ops[feat].print(ph, fd, hd->fp);
2013         else
2014                 fprintf(hd->fp, "# %s info available, use -I to display\n",
2015                         feat_ops[feat].name);
2016
2017         return 0;
2018 }
2019
2020 int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
2021 {
2022         struct header_print_data hd;
2023         struct perf_header *header = &session->header;
2024         int fd = perf_data_file__fd(session->file);
2025         hd.fp = fp;
2026         hd.full = full;
2027
2028         perf_header__process_sections(header, fd, &hd,
2029                                       perf_file_section__fprintf_info);
2030         return 0;
2031 }
2032
2033 static int do_write_feat(int fd, struct perf_header *h, int type,
2034                          struct perf_file_section **p,
2035                          struct perf_evlist *evlist)
2036 {
2037         int err;
2038         int ret = 0;
2039
2040         if (perf_header__has_feat(h, type)) {
2041                 if (!feat_ops[type].write)
2042                         return -1;
2043
2044                 (*p)->offset = lseek(fd, 0, SEEK_CUR);
2045
2046                 err = feat_ops[type].write(fd, h, evlist);
2047                 if (err < 0) {
2048                         pr_debug("failed to write feature %d\n", type);
2049
2050                         /* undo anything written */
2051                         lseek(fd, (*p)->offset, SEEK_SET);
2052
2053                         return -1;
2054                 }
2055                 (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
2056                 (*p)++;
2057         }
2058         return ret;
2059 }
2060
2061 static int perf_header__adds_write(struct perf_header *header,
2062                                    struct perf_evlist *evlist, int fd)
2063 {
2064         int nr_sections;
2065         struct perf_file_section *feat_sec, *p;
2066         int sec_size;
2067         u64 sec_start;
2068         int feat;
2069         int err;
2070
2071         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
2072         if (!nr_sections)
2073                 return 0;
2074
2075         feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));
2076         if (feat_sec == NULL)
2077                 return -ENOMEM;
2078
2079         sec_size = sizeof(*feat_sec) * nr_sections;
2080
2081         sec_start = header->feat_offset;
2082         lseek(fd, sec_start + sec_size, SEEK_SET);
2083
2084         for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
2085                 if (do_write_feat(fd, header, feat, &p, evlist))
2086                         perf_header__clear_feat(header, feat);
2087         }
2088
2089         lseek(fd, sec_start, SEEK_SET);
2090         /*
2091          * may write more than needed due to dropped feature, but
2092          * this is okay, reader will skip the mising entries
2093          */
2094         err = do_write(fd, feat_sec, sec_size);
2095         if (err < 0)
2096                 pr_debug("failed to write feature section\n");
2097         free(feat_sec);
2098         return err;
2099 }
2100
2101 int perf_header__write_pipe(int fd)
2102 {
2103         struct perf_pipe_file_header f_header;
2104         int err;
2105
2106         f_header = (struct perf_pipe_file_header){
2107                 .magic     = PERF_MAGIC,
2108                 .size      = sizeof(f_header),
2109         };
2110
2111         err = do_write(fd, &f_header, sizeof(f_header));
2112         if (err < 0) {
2113                 pr_debug("failed to write perf pipe header\n");
2114                 return err;
2115         }
2116
2117         return 0;
2118 }
2119
2120 int perf_session__write_header(struct perf_session *session,
2121                                struct perf_evlist *evlist,
2122                                int fd, bool at_exit)
2123 {
2124         struct perf_file_header f_header;
2125         struct perf_file_attr   f_attr;
2126         struct perf_header *header = &session->header;
2127         struct perf_evsel *evsel;
2128         u64 attr_offset;
2129         int err;
2130
2131         lseek(fd, sizeof(f_header), SEEK_SET);
2132
2133         evlist__for_each(session->evlist, evsel) {
2134                 evsel->id_offset = lseek(fd, 0, SEEK_CUR);
2135                 err = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
2136                 if (err < 0) {
2137                         pr_debug("failed to write perf header\n");
2138                         return err;
2139                 }
2140         }
2141
2142         attr_offset = lseek(fd, 0, SEEK_CUR);
2143
2144         evlist__for_each(evlist, evsel) {
2145                 f_attr = (struct perf_file_attr){
2146                         .attr = evsel->attr,
2147                         .ids  = {
2148                                 .offset = evsel->id_offset,
2149                                 .size   = evsel->ids * sizeof(u64),
2150                         }
2151                 };
2152                 err = do_write(fd, &f_attr, sizeof(f_attr));
2153                 if (err < 0) {
2154                         pr_debug("failed to write perf header attribute\n");
2155                         return err;
2156                 }
2157         }
2158
2159         if (!header->data_offset)
2160                 header->data_offset = lseek(fd, 0, SEEK_CUR);
2161         header->feat_offset = header->data_offset + header->data_size;
2162
2163         if (at_exit) {
2164                 err = perf_header__adds_write(header, evlist, fd);
2165                 if (err < 0)
2166                         return err;
2167         }
2168
2169         f_header = (struct perf_file_header){
2170                 .magic     = PERF_MAGIC,
2171                 .size      = sizeof(f_header),
2172                 .attr_size = sizeof(f_attr),
2173                 .attrs = {
2174                         .offset = attr_offset,
2175                         .size   = evlist->nr_entries * sizeof(f_attr),
2176                 },
2177                 .data = {
2178                         .offset = header->data_offset,
2179                         .size   = header->data_size,
2180                 },
2181                 /* event_types is ignored, store zeros */
2182         };
2183
2184         memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
2185
2186         lseek(fd, 0, SEEK_SET);
2187         err = do_write(fd, &f_header, sizeof(f_header));
2188         if (err < 0) {
2189                 pr_debug("failed to write perf header\n");
2190                 return err;
2191         }
2192         lseek(fd, header->data_offset + header->data_size, SEEK_SET);
2193
2194         return 0;
2195 }
2196
2197 static int perf_header__getbuffer64(struct perf_header *header,
2198                                     int fd, void *buf, size_t size)
2199 {
2200         if (readn(fd, buf, size) <= 0)
2201                 return -1;
2202
2203         if (header->needs_swap)
2204                 mem_bswap_64(buf, size);
2205
2206         return 0;
2207 }
2208
2209 int perf_header__process_sections(struct perf_header *header, int fd,
2210                                   void *data,
2211                                   int (*process)(struct perf_file_section *section,
2212                                                  struct perf_header *ph,
2213                                                  int feat, int fd, void *data))
2214 {
2215         struct perf_file_section *feat_sec, *sec;
2216         int nr_sections;
2217         int sec_size;
2218         int feat;
2219         int err;
2220
2221         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
2222         if (!nr_sections)
2223                 return 0;
2224
2225         feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec));
2226         if (!feat_sec)
2227                 return -1;
2228
2229         sec_size = sizeof(*feat_sec) * nr_sections;
2230
2231         lseek(fd, header->feat_offset, SEEK_SET);
2232
2233         err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
2234         if (err < 0)
2235                 goto out_free;
2236
2237         for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
2238                 err = process(sec++, header, feat, fd, data);
2239                 if (err < 0)
2240                         goto out_free;
2241         }
2242         err = 0;
2243 out_free:
2244         free(feat_sec);
2245         return err;
2246 }
2247
2248 static const int attr_file_abi_sizes[] = {
2249         [0] = PERF_ATTR_SIZE_VER0,
2250         [1] = PERF_ATTR_SIZE_VER1,
2251         [2] = PERF_ATTR_SIZE_VER2,
2252         [3] = PERF_ATTR_SIZE_VER3,
2253         [4] = PERF_ATTR_SIZE_VER4,
2254         0,
2255 };
2256
2257 /*
2258  * In the legacy file format, the magic number is not used to encode endianness.
2259  * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
2260  * on ABI revisions, we need to try all combinations for all endianness to
2261  * detect the endianness.
2262  */
2263 static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph)
2264 {
2265         uint64_t ref_size, attr_size;
2266         int i;
2267
2268         for (i = 0 ; attr_file_abi_sizes[i]; i++) {
2269                 ref_size = attr_file_abi_sizes[i]
2270                          + sizeof(struct perf_file_section);
2271                 if (hdr_sz != ref_size) {
2272                         attr_size = bswap_64(hdr_sz);
2273                         if (attr_size != ref_size)
2274                                 continue;
2275
2276                         ph->needs_swap = true;
2277                 }
2278                 pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
2279                          i,
2280                          ph->needs_swap);
2281                 return 0;
2282         }
2283         /* could not determine endianness */
2284         return -1;
2285 }
2286
2287 #define PERF_PIPE_HDR_VER0      16
2288
2289 static const size_t attr_pipe_abi_sizes[] = {
2290         [0] = PERF_PIPE_HDR_VER0,
2291         0,
2292 };
2293
2294 /*
2295  * In the legacy pipe format, there is an implicit assumption that endiannesss
2296  * between host recording the samples, and host parsing the samples is the
2297  * same. This is not always the case given that the pipe output may always be
2298  * redirected into a file and analyzed on a different machine with possibly a
2299  * different endianness and perf_event ABI revsions in the perf tool itself.
2300  */
2301 static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph)
2302 {
2303         u64 attr_size;
2304         int i;
2305
2306         for (i = 0 ; attr_pipe_abi_sizes[i]; i++) {
2307                 if (hdr_sz != attr_pipe_abi_sizes[i]) {
2308                         attr_size = bswap_64(hdr_sz);
2309                         if (attr_size != hdr_sz)
2310                                 continue;
2311
2312                         ph->needs_swap = true;
2313                 }
2314                 pr_debug("Pipe ABI%d perf.data file detected\n", i);
2315                 return 0;
2316         }
2317         return -1;
2318 }
2319
2320 bool is_perf_magic(u64 magic)
2321 {
2322         if (!memcmp(&magic, __perf_magic1, sizeof(magic))
2323                 || magic == __perf_magic2
2324                 || magic == __perf_magic2_sw)
2325                 return true;
2326
2327         return false;
2328 }
2329
2330 static int check_magic_endian(u64 magic, uint64_t hdr_sz,
2331                               bool is_pipe, struct perf_header *ph)
2332 {
2333         int ret;
2334
2335         /* check for legacy format */
2336         ret = memcmp(&magic, __perf_magic1, sizeof(magic));
2337         if (ret == 0) {
2338                 ph->version = PERF_HEADER_VERSION_1;
2339                 pr_debug("legacy perf.data format\n");
2340                 if (is_pipe)
2341                         return try_all_pipe_abis(hdr_sz, ph);
2342
2343                 return try_all_file_abis(hdr_sz, ph);
2344         }
2345         /*
2346          * the new magic number serves two purposes:
2347          * - unique number to identify actual perf.data files
2348          * - encode endianness of file
2349          */
2350         ph->version = PERF_HEADER_VERSION_2;
2351
2352         /* check magic number with one endianness */
2353         if (magic == __perf_magic2)
2354                 return 0;
2355
2356         /* check magic number with opposite endianness */
2357         if (magic != __perf_magic2_sw)
2358                 return -1;
2359
2360         ph->needs_swap = true;
2361
2362         return 0;
2363 }
2364
2365 int perf_file_header__read(struct perf_file_header *header,
2366                            struct perf_header *ph, int fd)
2367 {
2368         ssize_t ret;
2369
2370         lseek(fd, 0, SEEK_SET);
2371
2372         ret = readn(fd, header, sizeof(*header));
2373         if (ret <= 0)
2374                 return -1;
2375
2376         if (check_magic_endian(header->magic,
2377                                header->attr_size, false, ph) < 0) {
2378                 pr_debug("magic/endian check failed\n");
2379                 return -1;
2380         }
2381
2382         if (ph->needs_swap) {
2383                 mem_bswap_64(header, offsetof(struct perf_file_header,
2384                              adds_features));
2385         }
2386
2387         if (header->size != sizeof(*header)) {
2388                 /* Support the previous format */
2389                 if (header->size == offsetof(typeof(*header), adds_features))
2390                         bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
2391                 else
2392                         return -1;
2393         } else if (ph->needs_swap) {
2394                 /*
2395                  * feature bitmap is declared as an array of unsigned longs --
2396                  * not good since its size can differ between the host that
2397                  * generated the data file and the host analyzing the file.
2398                  *
2399                  * We need to handle endianness, but we don't know the size of
2400                  * the unsigned long where the file was generated. Take a best
2401                  * guess at determining it: try 64-bit swap first (ie., file
2402                  * created on a 64-bit host), and check if the hostname feature
2403                  * bit is set (this feature bit is forced on as of fbe96f2).
2404                  * If the bit is not, undo the 64-bit swap and try a 32-bit
2405                  * swap. If the hostname bit is still not set (e.g., older data
2406                  * file), punt and fallback to the original behavior --
2407                  * clearing all feature bits and setting buildid.
2408                  */
2409                 mem_bswap_64(&header->adds_features,
2410                             BITS_TO_U64(HEADER_FEAT_BITS));
2411
2412                 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
2413                         /* unswap as u64 */
2414                         mem_bswap_64(&header->adds_features,
2415                                     BITS_TO_U64(HEADER_FEAT_BITS));
2416
2417                         /* unswap as u32 */
2418                         mem_bswap_32(&header->adds_features,
2419                                     BITS_TO_U32(HEADER_FEAT_BITS));
2420                 }
2421
2422                 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
2423                         bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
2424                         set_bit(HEADER_BUILD_ID, header->adds_features);
2425                 }
2426         }
2427
2428         memcpy(&ph->adds_features, &header->adds_features,
2429                sizeof(ph->adds_features));
2430
2431         ph->data_offset  = header->data.offset;
2432         ph->data_size    = header->data.size;
2433         ph->feat_offset  = header->data.offset + header->data.size;
2434         return 0;
2435 }
2436
2437 static int perf_file_section__process(struct perf_file_section *section,
2438                                       struct perf_header *ph,
2439                                       int feat, int fd, void *data)
2440 {
2441         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
2442                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
2443                           "%d, continuing...\n", section->offset, feat);
2444                 return 0;
2445         }
2446
2447         if (feat >= HEADER_LAST_FEATURE) {
2448                 pr_debug("unknown feature %d, continuing...\n", feat);
2449                 return 0;
2450         }
2451
2452         if (!feat_ops[feat].process)
2453                 return 0;
2454
2455         return feat_ops[feat].process(section, ph, fd, data);
2456 }
2457
2458 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
2459                                        struct perf_header *ph, int fd,
2460                                        bool repipe)
2461 {
2462         ssize_t ret;
2463
2464         ret = readn(fd, header, sizeof(*header));
2465         if (ret <= 0)
2466                 return -1;
2467
2468         if (check_magic_endian(header->magic, header->size, true, ph) < 0) {
2469                 pr_debug("endian/magic failed\n");
2470                 return -1;
2471         }
2472
2473         if (ph->needs_swap)
2474                 header->size = bswap_64(header->size);
2475
2476         if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
2477                 return -1;
2478
2479         return 0;
2480 }
2481
2482 static int perf_header__read_pipe(struct perf_session *session)
2483 {
2484         struct perf_header *header = &session->header;
2485         struct perf_pipe_file_header f_header;
2486
2487         if (perf_file_header__read_pipe(&f_header, header,
2488                                         perf_data_file__fd(session->file),
2489                                         session->repipe) < 0) {
2490                 pr_debug("incompatible file format\n");
2491                 return -EINVAL;
2492         }
2493
2494         return 0;
2495 }
2496
2497 static int read_attr(int fd, struct perf_header *ph,
2498                      struct perf_file_attr *f_attr)
2499 {
2500         struct perf_event_attr *attr = &f_attr->attr;
2501         size_t sz, left;
2502         size_t our_sz = sizeof(f_attr->attr);
2503         ssize_t ret;
2504
2505         memset(f_attr, 0, sizeof(*f_attr));
2506
2507         /* read minimal guaranteed structure */
2508         ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
2509         if (ret <= 0) {
2510                 pr_debug("cannot read %d bytes of header attr\n",
2511                          PERF_ATTR_SIZE_VER0);
2512                 return -1;
2513         }
2514
2515         /* on file perf_event_attr size */
2516         sz = attr->size;
2517
2518         if (ph->needs_swap)
2519                 sz = bswap_32(sz);
2520
2521         if (sz == 0) {
2522                 /* assume ABI0 */
2523                 sz =  PERF_ATTR_SIZE_VER0;
2524         } else if (sz > our_sz) {
2525                 pr_debug("file uses a more recent and unsupported ABI"
2526                          " (%zu bytes extra)\n", sz - our_sz);
2527                 return -1;
2528         }
2529         /* what we have not yet read and that we know about */
2530         left = sz - PERF_ATTR_SIZE_VER0;
2531         if (left) {
2532                 void *ptr = attr;
2533                 ptr += PERF_ATTR_SIZE_VER0;
2534
2535                 ret = readn(fd, ptr, left);
2536         }
2537         /* read perf_file_section, ids are read in caller */
2538         ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));
2539
2540         return ret <= 0 ? -1 : 0;
2541 }
2542
2543 static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
2544                                                 struct pevent *pevent)
2545 {
2546         struct event_format *event;
2547         char bf[128];
2548
2549         /* already prepared */
2550         if (evsel->tp_format)
2551                 return 0;
2552
2553         if (pevent == NULL) {
2554                 pr_debug("broken or missing trace data\n");
2555                 return -1;
2556         }
2557
2558         event = pevent_find_event(pevent, evsel->attr.config);
2559         if (event == NULL)
2560                 return -1;
2561
2562         if (!evsel->name) {
2563                 snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
2564                 evsel->name = strdup(bf);
2565                 if (evsel->name == NULL)
2566                         return -1;
2567         }
2568
2569         evsel->tp_format = event;
2570         return 0;
2571 }
2572
2573 static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist,
2574                                                   struct pevent *pevent)
2575 {
2576         struct perf_evsel *pos;
2577
2578         evlist__for_each(evlist, pos) {
2579                 if (pos->attr.type == PERF_TYPE_TRACEPOINT &&
2580                     perf_evsel__prepare_tracepoint_event(pos, pevent))
2581                         return -1;
2582         }
2583
2584         return 0;
2585 }
2586
2587 int perf_session__read_header(struct perf_session *session)
2588 {
2589         struct perf_data_file *file = session->file;
2590         struct perf_header *header = &session->header;
2591         struct perf_file_header f_header;
2592         struct perf_file_attr   f_attr;
2593         u64                     f_id;
2594         int nr_attrs, nr_ids, i, j;
2595         int fd = perf_data_file__fd(file);
2596
2597         session->evlist = perf_evlist__new();
2598         if (session->evlist == NULL)
2599                 return -ENOMEM;
2600
2601         session->evlist->env = &header->env;
2602         if (perf_data_file__is_pipe(file))
2603                 return perf_header__read_pipe(session);
2604
2605         if (perf_file_header__read(&f_header, header, fd) < 0)
2606                 return -EINVAL;
2607
2608         /*
2609          * Sanity check that perf.data was written cleanly; data size is
2610          * initialized to 0 and updated only if the on_exit function is run.
2611          * If data size is still 0 then the file contains only partial
2612          * information.  Just warn user and process it as much as it can.
2613          */
2614         if (f_header.data.size == 0) {
2615                 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
2616                            "Was the 'perf record' command properly terminated?\n",
2617                            file->path);
2618         }
2619
2620         nr_attrs = f_header.attrs.size / f_header.attr_size;
2621         lseek(fd, f_header.attrs.offset, SEEK_SET);
2622
2623         for (i = 0; i < nr_attrs; i++) {
2624                 struct perf_evsel *evsel;
2625                 off_t tmp;
2626
2627                 if (read_attr(fd, header, &f_attr) < 0)
2628                         goto out_errno;
2629
2630                 if (header->needs_swap) {
2631                         f_attr.ids.size   = bswap_64(f_attr.ids.size);
2632                         f_attr.ids.offset = bswap_64(f_attr.ids.offset);
2633                         perf_event__attr_swap(&f_attr.attr);
2634                 }
2635
2636                 tmp = lseek(fd, 0, SEEK_CUR);
2637                 evsel = perf_evsel__new(&f_attr.attr);
2638
2639                 if (evsel == NULL)
2640                         goto out_delete_evlist;
2641
2642                 evsel->needs_swap = header->needs_swap;
2643                 /*
2644                  * Do it before so that if perf_evsel__alloc_id fails, this
2645                  * entry gets purged too at perf_evlist__delete().
2646                  */
2647                 perf_evlist__add(session->evlist, evsel);
2648
2649                 nr_ids = f_attr.ids.size / sizeof(u64);
2650                 /*
2651                  * We don't have the cpu and thread maps on the header, so
2652                  * for allocating the perf_sample_id table we fake 1 cpu and
2653                  * hattr->ids threads.
2654                  */
2655                 if (perf_evsel__alloc_id(evsel, 1, nr_ids))
2656                         goto out_delete_evlist;
2657
2658                 lseek(fd, f_attr.ids.offset, SEEK_SET);
2659
2660                 for (j = 0; j < nr_ids; j++) {
2661                         if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
2662                                 goto out_errno;
2663
2664                         perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
2665                 }
2666
2667                 lseek(fd, tmp, SEEK_SET);
2668         }
2669
2670         symbol_conf.nr_events = nr_attrs;
2671
2672         perf_header__process_sections(header, fd, &session->tevent,
2673                                       perf_file_section__process);
2674
2675         if (perf_evlist__prepare_tracepoint_events(session->evlist,
2676                                                    session->tevent.pevent))
2677                 goto out_delete_evlist;
2678
2679         return 0;
2680 out_errno:
2681         return -errno;
2682
2683 out_delete_evlist:
2684         perf_evlist__delete(session->evlist);
2685         session->evlist = NULL;
2686         return -ENOMEM;
2687 }
2688
2689 int perf_event__synthesize_attr(struct perf_tool *tool,
2690                                 struct perf_event_attr *attr, u32 ids, u64 *id,
2691                                 perf_event__handler_t process)
2692 {
2693         union perf_event *ev;
2694         size_t size;
2695         int err;
2696
2697         size = sizeof(struct perf_event_attr);
2698         size = PERF_ALIGN(size, sizeof(u64));
2699         size += sizeof(struct perf_event_header);
2700         size += ids * sizeof(u64);
2701
2702         ev = malloc(size);
2703
2704         if (ev == NULL)
2705                 return -ENOMEM;
2706
2707         ev->attr.attr = *attr;
2708         memcpy(ev->attr.id, id, ids * sizeof(u64));
2709
2710         ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
2711         ev->attr.header.size = (u16)size;
2712
2713         if (ev->attr.header.size == size)
2714                 err = process(tool, ev, NULL, NULL);
2715         else
2716                 err = -E2BIG;
2717
2718         free(ev);
2719
2720         return err;
2721 }
2722
2723 int perf_event__synthesize_attrs(struct perf_tool *tool,
2724                                    struct perf_session *session,
2725                                    perf_event__handler_t process)
2726 {
2727         struct perf_evsel *evsel;
2728         int err = 0;
2729
2730         evlist__for_each(session->evlist, evsel) {
2731                 err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids,
2732                                                   evsel->id, process);
2733                 if (err) {
2734                         pr_debug("failed to create perf header attribute\n");
2735                         return err;
2736                 }
2737         }
2738
2739         return err;
2740 }
2741
2742 int perf_event__process_attr(struct perf_tool *tool __maybe_unused,
2743                              union perf_event *event,
2744                              struct perf_evlist **pevlist)
2745 {
2746         u32 i, ids, n_ids;
2747         struct perf_evsel *evsel;
2748         struct perf_evlist *evlist = *pevlist;
2749
2750         if (evlist == NULL) {
2751                 *pevlist = evlist = perf_evlist__new();
2752                 if (evlist == NULL)
2753                         return -ENOMEM;
2754         }
2755
2756         evsel = perf_evsel__new(&event->attr.attr);
2757         if (evsel == NULL)
2758                 return -ENOMEM;
2759
2760         perf_evlist__add(evlist, evsel);
2761
2762         ids = event->header.size;
2763         ids -= (void *)&event->attr.id - (void *)event;
2764         n_ids = ids / sizeof(u64);
2765         /*
2766          * We don't have the cpu and thread maps on the header, so
2767          * for allocating the perf_sample_id table we fake 1 cpu and
2768          * hattr->ids threads.
2769          */
2770         if (perf_evsel__alloc_id(evsel, 1, n_ids))
2771                 return -ENOMEM;
2772
2773         for (i = 0; i < n_ids; i++) {
2774                 perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]);
2775         }
2776
2777         symbol_conf.nr_events = evlist->nr_entries;
2778
2779         return 0;
2780 }
2781
2782 int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
2783                                         struct perf_evlist *evlist,
2784                                         perf_event__handler_t process)
2785 {
2786         union perf_event ev;
2787         struct tracing_data *tdata;
2788         ssize_t size = 0, aligned_size = 0, padding;
2789         int err __maybe_unused = 0;
2790
2791         /*
2792          * We are going to store the size of the data followed
2793          * by the data contents. Since the fd descriptor is a pipe,
2794          * we cannot seek back to store the size of the data once
2795          * we know it. Instead we:
2796          *
2797          * - write the tracing data to the temp file
2798          * - get/write the data size to pipe
2799          * - write the tracing data from the temp file
2800          *   to the pipe
2801          */
2802         tdata = tracing_data_get(&evlist->entries, fd, true);
2803         if (!tdata)
2804                 return -1;
2805
2806         memset(&ev, 0, sizeof(ev));
2807
2808         ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
2809         size = tdata->size;
2810         aligned_size = PERF_ALIGN(size, sizeof(u64));
2811         padding = aligned_size - size;
2812         ev.tracing_data.header.size = sizeof(ev.tracing_data);
2813         ev.tracing_data.size = aligned_size;
2814
2815         process(tool, &ev, NULL, NULL);
2816
2817         /*
2818          * The put function will copy all the tracing data
2819          * stored in temp file to the pipe.
2820          */
2821         tracing_data_put(tdata);
2822
2823         write_padded(fd, NULL, 0, padding);
2824
2825         return aligned_size;
2826 }
2827
2828 int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused,
2829                                      union perf_event *event,
2830                                      struct perf_session *session)
2831 {
2832         ssize_t size_read, padding, size = event->tracing_data.size;
2833         int fd = perf_data_file__fd(session->file);
2834         off_t offset = lseek(fd, 0, SEEK_CUR);
2835         char buf[BUFSIZ];
2836
2837         /* setup for reading amidst mmap */
2838         lseek(fd, offset + sizeof(struct tracing_data_event),
2839               SEEK_SET);
2840
2841         size_read = trace_report(fd, &session->tevent,
2842                                  session->repipe);
2843         padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
2844
2845         if (readn(fd, buf, padding) < 0) {
2846                 pr_err("%s: reading input file", __func__);
2847                 return -1;
2848         }
2849         if (session->repipe) {
2850                 int retw = write(STDOUT_FILENO, buf, padding);
2851                 if (retw <= 0 || retw != padding) {
2852                         pr_err("%s: repiping tracing data padding", __func__);
2853                         return -1;
2854                 }
2855         }
2856
2857         if (size_read + padding != size) {
2858                 pr_err("%s: tracing data size mismatch", __func__);
2859                 return -1;
2860         }
2861
2862         perf_evlist__prepare_tracepoint_events(session->evlist,
2863                                                session->tevent.pevent);
2864
2865         return size_read + padding;
2866 }
2867
2868 int perf_event__synthesize_build_id(struct perf_tool *tool,
2869                                     struct dso *pos, u16 misc,
2870                                     perf_event__handler_t process,
2871                                     struct machine *machine)
2872 {
2873         union perf_event ev;
2874         size_t len;
2875         int err = 0;
2876
2877         if (!pos->hit)
2878                 return err;
2879
2880         memset(&ev, 0, sizeof(ev));
2881
2882         len = pos->long_name_len + 1;
2883         len = PERF_ALIGN(len, NAME_ALIGN);
2884         memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
2885         ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
2886         ev.build_id.header.misc = misc;
2887         ev.build_id.pid = machine->pid;
2888         ev.build_id.header.size = sizeof(ev.build_id) + len;
2889         memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
2890
2891         err = process(tool, &ev, NULL, machine);
2892
2893         return err;
2894 }
2895
2896 int perf_event__process_build_id(struct perf_tool *tool __maybe_unused,
2897                                  union perf_event *event,
2898                                  struct perf_session *session)
2899 {
2900         __event_process_build_id(&event->build_id,
2901                                  event->build_id.filename,
2902                                  session);
2903         return 0;
2904 }