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