tools/perf/util/header.c

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