Pileus Git - ~andy/linux/blob - tools/perf/util/header.c

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