tools/perf/util/header.c

   1 #include "util.h"
   2 #include <sys/types.h>
   3 #include <byteswap.h>
   4 #include <unistd.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <linux/list.h>
   8 #include <linux/kernel.h>
   9 #include <linux/bitops.h>
  10 #include <sys/utsname.h>
  11
  12 #include "evlist.h"
  13 #include "evsel.h"
  14 #include "header.h"
  15 #include "../perf.h"
  16 #include "trace-event.h"
  17 #include "session.h"
  18 #include "symbol.h"
  19 #include "debug.h"
  20 #include "cpumap.h"
  21 #include "pmu.h"
  22 #include "vdso.h"
  23 #include "strbuf.h"
  24 #include "build-id.h"
  25 #include "data.h"
  26
  27 static bool no_buildid_cache = false;
  28
  29 static u32 header_argc;
  30 static const char **header_argv;
  31
  32 /*
  33  * magic2 = "PERFILE2"
  34  * must be a numerical value to let the endianness
  35  * determine the memory layout. That way we are able
  36  * to detect endianness when reading the perf.data file
  37  * back.
  38  *
  39  * we check for legacy (PERFFILE) format.
  40  */
  41 static const char *__perf_magic1 = "PERFFILE";
  42 static const u64 __perf_magic2    = 0x32454c4946524550ULL;
  43 static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
  44
  45 #define PERF_MAGIC      __perf_magic2
  46
  47 struct perf_file_attr {
  48         struct perf_event_attr  attr;
  49         struct perf_file_section        ids;
  50 };
  51
  52 void perf_header__set_feat(struct perf_header *header, int feat)
  53 {
  54         set_bit(feat, header->adds_features);
  55 }
  56
  57 void perf_header__clear_feat(struct perf_header *header, int feat)
  58 {
  59         clear_bit(feat, header->adds_features);
  60 }
  61
  62 bool perf_header__has_feat(const struct perf_header *header, int feat)
  63 {
  64         return test_bit(feat, header->adds_features);
  65 }
  66
  67 static int do_write(int fd, const void *buf, size_t size)
  68 {
  69         while (size) {
  70                 int ret = write(fd, buf, size);
  71
  72                 if (ret < 0)
  73                         return -errno;
  74
  75                 size -= ret;
  76                 buf += ret;
  77         }
  78
  79         return 0;
  80 }
  81
  82 #define NAME_ALIGN 64
  83
  84 static int write_padded(int fd, const void *bf, size_t count,
  85                         size_t count_aligned)
  86 {
  87         static const char zero_buf[NAME_ALIGN];
  88         int err = do_write(fd, bf, count);
  89
  90         if (!err)
  91                 err = do_write(fd, zero_buf, count_aligned - count);
  92
  93         return err;
  94 }
  95
  96 static int do_write_string(int fd, const char *str)
  97 {
  98         u32 len, olen;
  99         int ret;
 100
 101         olen = strlen(str) + 1;
 102         len = PERF_ALIGN(olen, NAME_ALIGN);
 103
 104         /* write len, incl. \0 */
 105         ret = do_write(fd, &len, sizeof(len));
 106         if (ret < 0)
 107                 return ret;
 108
 109         return write_padded(fd, str, olen, len);
 110 }
 111
 112 static char *do_read_string(int fd, struct perf_header *ph)
 113 {
 114         ssize_t sz, ret;
 115         u32 len;
 116         char *buf;
 117
 118         sz = readn(fd, &len, sizeof(len));
 119         if (sz < (ssize_t)sizeof(len))
 120                 return NULL;
 121
 122         if (ph->needs_swap)
 123                 len = bswap_32(len);
 124
 125         buf = malloc(len);
 126         if (!buf)
 127                 return NULL;
 128
 129         ret = readn(fd, buf, len);
 130         if (ret == (ssize_t)len) {
 131                 /*
 132                  * strings are padded by zeroes
 133                  * thus the actual strlen of buf
 134                  * may be less than len
 135                  */
 136                 return buf;
 137         }
 138
 139         free(buf);
 140         return NULL;
 141 }
 142
 143 int
 144 perf_header__set_cmdline(int argc, const char **argv)
 145 {
 146         int i;
 147
 148         /*
 149          * If header_argv has already been set, do not override it.
 150          * This allows a command to set the cmdline, parse args and
 151          * then call another builtin function that implements a
 152          * command -- e.g, cmd_kvm calling cmd_record.
 153          */
 154         if (header_argv)
 155                 return 0;
 156
 157         header_argc = (u32)argc;
 158
 159         /* do not include NULL termination */
 160         header_argv = calloc(argc, sizeof(char *));
 161         if (!header_argv)
 162                 return -ENOMEM;
 163
 164         /*
 165          * must copy argv contents because it gets moved
 166          * around during option parsing
 167          */
 168         for (i = 0; i < argc ; i++)
 169                 header_argv[i] = argv[i];
 170
 171         return 0;
 172 }
 173
 174 #define dsos__for_each_with_build_id(pos, head) \
 175         list_for_each_entry(pos, head, node)    \
 176                 if (!pos->has_build_id)         \
 177                         continue;               \
 178                 else
 179
 180 static int write_buildid(const char *name, size_t name_len, u8 *build_id,
 181                          pid_t pid, u16 misc, int fd)
 182 {
 183         int err;
 184         struct build_id_event b;
 185         size_t len;
 186
 187         len = name_len + 1;
 188         len = PERF_ALIGN(len, NAME_ALIGN);
 189
 190         memset(&b, 0, sizeof(b));
 191         memcpy(&b.build_id, build_id, BUILD_ID_SIZE);
 192         b.pid = pid;
 193         b.header.misc = misc;
 194         b.header.size = sizeof(b) + len;
 195
 196         err = do_write(fd, &b, sizeof(b));
 197         if (err < 0)
 198                 return err;
 199
 200         return write_padded(fd, name, name_len + 1, len);
 201 }
 202
 203 static int __dsos__write_buildid_table(struct list_head *head,
 204                                        struct machine *machine,
 205                                        pid_t pid, u16 misc, int fd)
 206 {
 207         char nm[PATH_MAX];
 208         struct dso *pos;
 209
 210         dsos__for_each_with_build_id(pos, head) {
 211                 int err;
 212                 const char *name;
 213                 size_t name_len;
 214
 215                 if (!pos->hit)
 216                         continue;
 217
 218                 if (is_vdso_map(pos->short_name)) {
 219                         name = (char *) VDSO__MAP_NAME;
 220                         name_len = sizeof(VDSO__MAP_NAME) + 1;
 221                 } else if (dso__is_kcore(pos)) {
 222                         machine__mmap_name(machine, nm, sizeof(nm));
 223                         name = nm;
 224                         name_len = strlen(nm) + 1;
 225                 } else {
 226                         name = pos->long_name;
 227                         name_len = pos->long_name_len + 1;
 228                 }
 229
 230                 err = write_buildid(name, name_len, pos->build_id,
 231                                     pid, misc, fd);
 232                 if (err)
 233                         return err;
 234         }
 235
 236         return 0;
 237 }
 238
 239 static int machine__write_buildid_table(struct machine *machine, int fd)
 240 {
 241         int err;
 242         u16 kmisc = PERF_RECORD_MISC_KERNEL,
 243             umisc = PERF_RECORD_MISC_USER;
 244
 245         if (!machine__is_host(machine)) {
 246                 kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
 247                 umisc = PERF_RECORD_MISC_GUEST_USER;
 248         }
 249
 250         err = __dsos__write_buildid_table(&machine->kernel_dsos, machine,
 251                                           machine->pid, kmisc, fd);
 252         if (err == 0)
 253                 err = __dsos__write_buildid_table(&machine->user_dsos, machine,
 254                                                   machine->pid, umisc, fd);
 255         return err;
 256 }
 257
 258 static int dsos__write_buildid_table(struct perf_header *header, int fd)
 259 {
 260         struct perf_session *session = container_of(header,
 261                         struct perf_session, header);
 262         struct rb_node *nd;
 263         int err = machine__write_buildid_table(&session->machines.host, fd);
 264
 265         if (err)
 266                 return err;
 267
 268         for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) {
 269                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
 270                 err = machine__write_buildid_table(pos, fd);
 271                 if (err)
 272                         break;
 273         }
 274         return err;
 275 }
 276
 277 int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
 278                           const char *name, bool is_kallsyms, bool is_vdso)
 279 {
 280         const size_t size = PATH_MAX;
 281         char *realname, *filename = zalloc(size),
 282              *linkname = zalloc(size), *targetname;
 283         int len, err = -1;
 284         bool slash = is_kallsyms || is_vdso;
 285
 286         if (is_kallsyms) {
 287                 if (symbol_conf.kptr_restrict) {
 288                         pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
 289                         err = 0;
 290                         goto out_free;
 291                 }
 292                 realname = (char *) name;
 293         } else
 294                 realname = realpath(name, NULL);
 295
 296         if (realname == NULL || filename == NULL || linkname == NULL)
 297                 goto out_free;
 298
 299         len = scnprintf(filename, size, "%s%s%s",
 300                        debugdir, slash ? "/" : "",
 301                        is_vdso ? VDSO__MAP_NAME : realname);
 302         if (mkdir_p(filename, 0755))
 303                 goto out_free;
 304
 305         snprintf(filename + len, size - len, "/%s", sbuild_id);
 306
 307         if (access(filename, F_OK)) {
 308                 if (is_kallsyms) {
 309                          if (copyfile("/proc/kallsyms", filename))
 310                                 goto out_free;
 311                 } else if (link(realname, filename) && copyfile(name, filename))
 312                         goto out_free;
 313         }
 314
 315         len = scnprintf(linkname, size, "%s/.build-id/%.2s",
 316                        debugdir, sbuild_id);
 317
 318         if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
 319                 goto out_free;
 320
 321         snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
 322         targetname = filename + strlen(debugdir) - 5;
 323         memcpy(targetname, "../..", 5);
 324
 325         if (symlink(targetname, linkname) == 0)
 326                 err = 0;
 327 out_free:
 328         if (!is_kallsyms)
 329                 free(realname);
 330         free(filename);
 331         free(linkname);
 332         return err;
 333 }
 334
 335 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
 336                                  const char *name, const char *debugdir,
 337                                  bool is_kallsyms, bool is_vdso)
 338 {
 339         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 340
 341         build_id__sprintf(build_id, build_id_size, sbuild_id);
 342
 343         return build_id_cache__add_s(sbuild_id, debugdir, name,
 344                                      is_kallsyms, is_vdso);
 345 }
 346
 347 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
 348 {
 349         const size_t size = PATH_MAX;
 350         char *filename = zalloc(size),
 351              *linkname = zalloc(size);
 352         int err = -1;
 353
 354         if (filename == NULL || linkname == NULL)
 355                 goto out_free;
 356
 357         snprintf(linkname, size, "%s/.build-id/%.2s/%s",
 358                  debugdir, sbuild_id, sbuild_id + 2);
 359
 360         if (access(linkname, F_OK))
 361                 goto out_free;
 362
 363         if (readlink(linkname, filename, size - 1) < 0)
 364                 goto out_free;
 365
 366         if (unlink(linkname))
 367                 goto out_free;
 368
 369         /*
 370          * Since the link is relative, we must make it absolute:
 371          */
 372         snprintf(linkname, size, "%s/.build-id/%.2s/%s",
 373                  debugdir, sbuild_id, filename);
 374
 375         if (unlink(linkname))
 376                 goto out_free;
 377
 378         err = 0;
 379 out_free:
 380         free(filename);
 381         free(linkname);
 382         return err;
 383 }
 384
 385 static int dso__cache_build_id(struct dso *dso, struct machine *machine,
 386                                const char *debugdir)
 387 {
 388         bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
 389         bool is_vdso = is_vdso_map(dso->short_name);
 390         const char *name = dso->long_name;
 391         char nm[PATH_MAX];
 392
 393         if (dso__is_kcore(dso)) {
 394                 is_kallsyms = true;
 395                 machine__mmap_name(machine, nm, sizeof(nm));
 396                 name = nm;
 397         }
 398         return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id), name,
 399                                      debugdir, is_kallsyms, is_vdso);
 400 }
 401
 402 static int __dsos__cache_build_ids(struct list_head *head,
 403                                    struct machine *machine, const char *debugdir)
 404 {
 405         struct dso *pos;
 406         int err = 0;
 407
 408         dsos__for_each_with_build_id(pos, head)
 409                 if (dso__cache_build_id(pos, machine, debugdir))
 410                         err = -1;
 411
 412         return err;
 413 }
 414
 415 static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
 416 {
 417         int ret = __dsos__cache_build_ids(&machine->kernel_dsos, machine,
 418                                           debugdir);
 419         ret |= __dsos__cache_build_ids(&machine->user_dsos, machine, debugdir);
 420         return ret;
 421 }
 422
 423 static int perf_session__cache_build_ids(struct perf_session *session)
 424 {
 425         struct rb_node *nd;
 426         int ret;
 427         char debugdir[PATH_MAX];
 428
 429         snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
 430
 431         if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
 432                 return -1;
 433
 434         ret = machine__cache_build_ids(&session->machines.host, debugdir);
 435
 436         for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) {
 437                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
 438                 ret |= machine__cache_build_ids(pos, debugdir);
 439         }
 440         return ret ? -1 : 0;
 441 }
 442
 443 static bool machine__read_build_ids(struct machine *machine, bool with_hits)
 444 {
 445         bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
 446         ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits);
 447         return ret;
 448 }
 449
 450 static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
 451 {
 452         struct rb_node *nd;
 453         bool ret = machine__read_build_ids(&session->machines.host, with_hits);
 454
 455         for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) {
 456                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
 457                 ret |= machine__read_build_ids(pos, with_hits);
 458         }
 459
 460         return ret;
 461 }
 462
 463 static int write_tracing_data(int fd, struct perf_header *h __maybe_unused,
 464                             struct perf_evlist *evlist)
 465 {
 466         return read_tracing_data(fd, &evlist->entries);
 467 }
 468
 469
 470 static int write_build_id(int fd, struct perf_header *h,
 471                           struct perf_evlist *evlist __maybe_unused)
 472 {
 473         struct perf_session *session;
 474         int err;
 475
 476         session = container_of(h, struct perf_session, header);
 477
 478         if (!perf_session__read_build_ids(session, true))
 479                 return -1;
 480
 481         err = dsos__write_buildid_table(h, fd);
 482         if (err < 0) {
 483                 pr_debug("failed to write buildid table\n");
 484                 return err;
 485         }
 486         if (!no_buildid_cache)
 487                 perf_session__cache_build_ids(session);
 488
 489         return 0;
 490 }
 491
 492 static int write_hostname(int fd, struct perf_header *h __maybe_unused,
 493                           struct perf_evlist *evlist __maybe_unused)
 494 {
 495         struct utsname uts;
 496         int ret;
 497
 498         ret = uname(&uts);
 499         if (ret < 0)
 500                 return -1;
 501
 502         return do_write_string(fd, uts.nodename);
 503 }
 504
 505 static int write_osrelease(int fd, struct perf_header *h __maybe_unused,
 506                            struct perf_evlist *evlist __maybe_unused)
 507 {
 508         struct utsname uts;
 509         int ret;
 510
 511         ret = uname(&uts);
 512         if (ret < 0)
 513                 return -1;
 514
 515         return do_write_string(fd, uts.release);
 516 }
 517
 518 static int write_arch(int fd, struct perf_header *h __maybe_unused,
 519                       struct perf_evlist *evlist __maybe_unused)
 520 {
 521         struct utsname uts;
 522         int ret;
 523
 524         ret = uname(&uts);
 525         if (ret < 0)
 526                 return -1;
 527
 528         return do_write_string(fd, uts.machine);
 529 }
 530
 531 static int write_version(int fd, struct perf_header *h __maybe_unused,
 532                          struct perf_evlist *evlist __maybe_unused)
 533 {
 534         return do_write_string(fd, perf_version_string);
 535 }
 536
 537 static int write_cpudesc(int fd, struct perf_header *h __maybe_unused,
 538                        struct perf_evlist *evlist __maybe_unused)
 539 {
 540 #ifndef CPUINFO_PROC
 541 #define CPUINFO_PROC NULL
 542 #endif
 543         FILE *file;
 544         char *buf = NULL;
 545         char *s, *p;
 546         const char *search = CPUINFO_PROC;
 547         size_t len = 0;
 548         int ret = -1;
 549
 550         if (!search)
 551                 return -1;
 552
 553         file = fopen("/proc/cpuinfo", "r");
 554         if (!file)
 555                 return -1;
 556
 557         while (getline(&buf, &len, file) > 0) {
 558                 ret = strncmp(buf, search, strlen(search));
 559                 if (!ret)
 560                         break;
 561         }
 562
 563         if (ret)
 564                 goto done;
 565
 566         s = buf;
 567
 568         p = strchr(buf, ':');
 569         if (p && *(p+1) == ' ' && *(p+2))
 570                 s = p + 2;
 571         p = strchr(s, '\n');
 572         if (p)
 573                 *p = '\0';
 574
 575         /* squash extra space characters (branding string) */
 576         p = s;
 577         while (*p) {
 578                 if (isspace(*p)) {
 579                         char *r = p + 1;
 580                         char *q = r;
 581                         *p = ' ';
 582                         while (*q && isspace(*q))
 583                                 q++;
 584                         if (q != (p+1))
 585                                 while ((*r++ = *q++));
 586                 }
 587                 p++;
 588         }
 589         ret = do_write_string(fd, s);
 590 done:
 591         free(buf);
 592         fclose(file);
 593         return ret;
 594 }
 595
 596 static int write_nrcpus(int fd, struct perf_header *h __maybe_unused,
 597                         struct perf_evlist *evlist __maybe_unused)
 598 {
 599         long nr;
 600         u32 nrc, nra;
 601         int ret;
 602
 603         nr = sysconf(_SC_NPROCESSORS_CONF);
 604         if (nr < 0)
 605                 return -1;
 606
 607         nrc = (u32)(nr & UINT_MAX);
 608
 609         nr = sysconf(_SC_NPROCESSORS_ONLN);
 610         if (nr < 0)
 611                 return -1;
 612
 613         nra = (u32)(nr & UINT_MAX);
 614
 615         ret = do_write(fd, &nrc, sizeof(nrc));
 616         if (ret < 0)
 617                 return ret;
 618
 619         return do_write(fd, &nra, sizeof(nra));
 620 }
 621
 622 static int write_event_desc(int fd, struct perf_header *h __maybe_unused,
 623                             struct perf_evlist *evlist)
 624 {
 625         struct perf_evsel *evsel;
 626         u32 nre, nri, sz;
 627         int ret;
 628
 629         nre = evlist->nr_entries;
 630
 631         /*
 632          * write number of events
 633          */
 634         ret = do_write(fd, &nre, sizeof(nre));
 635         if (ret < 0)
 636                 return ret;
 637
 638         /*
 639          * size of perf_event_attr struct
 640          */
 641         sz = (u32)sizeof(evsel->attr);
 642         ret = do_write(fd, &sz, sizeof(sz));
 643         if (ret < 0)
 644                 return ret;
 645
 646         evlist__for_each(evlist, evsel) {
 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                 zfree(&tp->core_siblings[i]);
 803
 804         for (i = 0 ; i < tp->thread_sib; i++)
 805                 zfree(&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 %31s %"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         evlist__for_each(evlist, evsel) {
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                 zfree(&evsel->name);
1235                 zfree(&evsel->id);
1236         }
1237
1238         free(events);
1239 }
1240
1241 static struct perf_evsel *
1242 read_event_desc(struct perf_header *ph, int fd)
1243 {
1244         struct perf_evsel *evsel, *events = NULL;
1245         u64 *id;
1246         void *buf = NULL;
1247         u32 nre, sz, nr, i, j;
1248         ssize_t ret;
1249         size_t msz;
1250
1251         /* number of events */
1252         ret = readn(fd, &nre, sizeof(nre));
1253         if (ret != (ssize_t)sizeof(nre))
1254                 goto error;
1255
1256         if (ph->needs_swap)
1257                 nre = bswap_32(nre);
1258
1259         ret = readn(fd, &sz, sizeof(sz));
1260         if (ret != (ssize_t)sizeof(sz))
1261                 goto error;
1262
1263         if (ph->needs_swap)
1264                 sz = bswap_32(sz);
1265
1266         /* buffer to hold on file attr struct */
1267         buf = malloc(sz);
1268         if (!buf)
1269                 goto error;
1270
1271         /* the last event terminates with evsel->attr.size == 0: */
1272         events = calloc(nre + 1, sizeof(*events));
1273         if (!events)
1274                 goto error;
1275
1276         msz = sizeof(evsel->attr);
1277         if (sz < msz)
1278                 msz = sz;
1279
1280         for (i = 0, evsel = events; i < nre; evsel++, i++) {
1281                 evsel->idx = i;
1282
1283                 /*
1284                  * must read entire on-file attr struct to
1285                  * sync up with layout.
1286                  */
1287                 ret = readn(fd, buf, sz);
1288                 if (ret != (ssize_t)sz)
1289                         goto error;
1290
1291                 if (ph->needs_swap)
1292                         perf_event__attr_swap(buf);
1293
1294                 memcpy(&evsel->attr, buf, msz);
1295
1296                 ret = readn(fd, &nr, sizeof(nr));
1297                 if (ret != (ssize_t)sizeof(nr))
1298                         goto error;
1299
1300                 if (ph->needs_swap) {
1301                         nr = bswap_32(nr);
1302                         evsel->needs_swap = true;
1303                 }
1304
1305                 evsel->name = do_read_string(fd, ph);
1306
1307                 if (!nr)
1308                         continue;
1309
1310                 id = calloc(nr, sizeof(*id));
1311                 if (!id)
1312                         goto error;
1313                 evsel->ids = nr;
1314                 evsel->id = id;
1315
1316                 for (j = 0 ; j < nr; j++) {
1317                         ret = readn(fd, id, sizeof(*id));
1318                         if (ret != (ssize_t)sizeof(*id))
1319                                 goto error;
1320                         if (ph->needs_swap)
1321                                 *id = bswap_64(*id);
1322                         id++;
1323                 }
1324         }
1325 out:
1326         free(buf);
1327         return events;
1328 error:
1329         if (events)
1330                 free_event_desc(events);
1331         events = NULL;
1332         goto out;
1333 }
1334
1335 static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
1336 {
1337         struct perf_evsel *evsel, *events = read_event_desc(ph, fd);
1338         u32 j;
1339         u64 *id;
1340
1341         if (!events) {
1342                 fprintf(fp, "# event desc: not available or unable to read\n");
1343                 return;
1344         }
1345
1346         for (evsel = events; evsel->attr.size; evsel++) {
1347                 fprintf(fp, "# event : name = %s, ", evsel->name);
1348
1349                 fprintf(fp, "type = %d, config = 0x%"PRIx64
1350                             ", config1 = 0x%"PRIx64", config2 = 0x%"PRIx64,
1351                                 evsel->attr.type,
1352                                 (u64)evsel->attr.config,
1353                                 (u64)evsel->attr.config1,
1354                                 (u64)evsel->attr.config2);
1355
1356                 fprintf(fp, ", excl_usr = %d, excl_kern = %d",
1357                                 evsel->attr.exclude_user,
1358                                 evsel->attr.exclude_kernel);
1359
1360                 fprintf(fp, ", excl_host = %d, excl_guest = %d",
1361                                 evsel->attr.exclude_host,
1362                                 evsel->attr.exclude_guest);
1363
1364                 fprintf(fp, ", precise_ip = %d", evsel->attr.precise_ip);
1365
1366                 fprintf(fp, ", attr_mmap2 = %d", evsel->attr.mmap2);
1367                 fprintf(fp, ", attr_mmap  = %d", evsel->attr.mmap);
1368                 fprintf(fp, ", attr_mmap_data = %d", evsel->attr.mmap_data);
1369                 if (evsel->ids) {
1370                         fprintf(fp, ", id = {");
1371                         for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) {
1372                                 if (j)
1373                                         fputc(',', fp);
1374                                 fprintf(fp, " %"PRIu64, *id);
1375                         }
1376                         fprintf(fp, " }");
1377                 }
1378
1379                 fputc('\n', fp);
1380         }
1381
1382         free_event_desc(events);
1383 }
1384
1385 static void print_total_mem(struct perf_header *ph, int fd __maybe_unused,
1386                             FILE *fp)
1387 {
1388         fprintf(fp, "# total memory : %Lu kB\n", ph->env.total_mem);
1389 }
1390
1391 static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused,
1392                                 FILE *fp)
1393 {
1394         u32 nr, c, i;
1395         char *str, *tmp;
1396         uint64_t mem_total, mem_free;
1397
1398         /* nr nodes */
1399         nr = ph->env.nr_numa_nodes;
1400         str = ph->env.numa_nodes;
1401
1402         for (i = 0; i < nr; i++) {
1403                 /* node number */
1404                 c = strtoul(str, &tmp, 0);
1405                 if (*tmp != ':')
1406                         goto error;
1407
1408                 str = tmp + 1;
1409                 mem_total = strtoull(str, &tmp, 0);
1410                 if (*tmp != ':')
1411                         goto error;
1412
1413                 str = tmp + 1;
1414                 mem_free = strtoull(str, &tmp, 0);
1415                 if (*tmp != ':')
1416                         goto error;
1417
1418                 fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
1419                             " free = %"PRIu64" kB\n",
1420                         c, mem_total, mem_free);
1421
1422                 str = tmp + 1;
1423                 fprintf(fp, "# node%u cpu list : %s\n", c, str);
1424
1425                 str += strlen(str) + 1;
1426         }
1427         return;
1428 error:
1429         fprintf(fp, "# numa topology : not available\n");
1430 }
1431
1432 static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
1433 {
1434         fprintf(fp, "# cpuid : %s\n", ph->env.cpuid);
1435 }
1436
1437 static void print_branch_stack(struct perf_header *ph __maybe_unused,
1438                                int fd __maybe_unused, FILE *fp)
1439 {
1440         fprintf(fp, "# contains samples with branch stack\n");
1441 }
1442
1443 static void print_pmu_mappings(struct perf_header *ph, int fd __maybe_unused,
1444                                FILE *fp)
1445 {
1446         const char *delimiter = "# pmu mappings: ";
1447         char *str, *tmp;
1448         u32 pmu_num;
1449         u32 type;
1450
1451         pmu_num = ph->env.nr_pmu_mappings;
1452         if (!pmu_num) {
1453                 fprintf(fp, "# pmu mappings: not available\n");
1454                 return;
1455         }
1456
1457         str = ph->env.pmu_mappings;
1458
1459         while (pmu_num) {
1460                 type = strtoul(str, &tmp, 0);
1461                 if (*tmp != ':')
1462                         goto error;
1463
1464                 str = tmp + 1;
1465                 fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
1466
1467                 delimiter = ", ";
1468                 str += strlen(str) + 1;
1469                 pmu_num--;
1470         }
1471
1472         fprintf(fp, "\n");
1473
1474         if (!pmu_num)
1475                 return;
1476 error:
1477         fprintf(fp, "# pmu mappings: unable to read\n");
1478 }
1479
1480 static void print_group_desc(struct perf_header *ph, int fd __maybe_unused,
1481                              FILE *fp)
1482 {
1483         struct perf_session *session;
1484         struct perf_evsel *evsel;
1485         u32 nr = 0;
1486
1487         session = container_of(ph, struct perf_session, header);
1488
1489         evlist__for_each(session->evlist, evsel) {
1490                 if (perf_evsel__is_group_leader(evsel) &&
1491                     evsel->nr_members > 1) {
1492                         fprintf(fp, "# group: %s{%s", evsel->group_name ?: "",
1493                                 perf_evsel__name(evsel));
1494
1495                         nr = evsel->nr_members - 1;
1496                 } else if (nr) {
1497                         fprintf(fp, ",%s", perf_evsel__name(evsel));
1498
1499                         if (--nr == 0)
1500                                 fprintf(fp, "}\n");
1501                 }
1502         }
1503 }
1504
1505 static int __event_process_build_id(struct build_id_event *bev,
1506                                     char *filename,
1507                                     struct perf_session *session)
1508 {
1509         int err = -1;
1510         struct list_head *head;
1511         struct machine *machine;
1512         u16 misc;
1513         struct dso *dso;
1514         enum dso_kernel_type dso_type;
1515
1516         machine = perf_session__findnew_machine(session, bev->pid);
1517         if (!machine)
1518                 goto out;
1519
1520         misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1521
1522         switch (misc) {
1523         case PERF_RECORD_MISC_KERNEL:
1524                 dso_type = DSO_TYPE_KERNEL;
1525                 head = &machine->kernel_dsos;
1526                 break;
1527         case PERF_RECORD_MISC_GUEST_KERNEL:
1528                 dso_type = DSO_TYPE_GUEST_KERNEL;
1529                 head = &machine->kernel_dsos;
1530                 break;
1531         case PERF_RECORD_MISC_USER:
1532         case PERF_RECORD_MISC_GUEST_USER:
1533                 dso_type = DSO_TYPE_USER;
1534                 head = &machine->user_dsos;
1535                 break;
1536         default:
1537                 goto out;
1538         }
1539
1540         dso = __dsos__findnew(head, filename);
1541         if (dso != NULL) {
1542                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1543
1544                 dso__set_build_id(dso, &bev->build_id);
1545
1546                 if (filename[0] == '[')
1547                         dso->kernel = dso_type;
1548
1549                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
1550                                   sbuild_id);
1551                 pr_debug("build id event received for %s: %s\n",
1552                          dso->long_name, sbuild_id);
1553         }
1554
1555         err = 0;
1556 out:
1557         return err;
1558 }
1559
1560 static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
1561                                                  int input, u64 offset, u64 size)
1562 {
1563         struct perf_session *session = container_of(header, struct perf_session, header);
1564         struct {
1565                 struct perf_event_header   header;
1566                 u8                         build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
1567                 char                       filename[0];
1568         } old_bev;
1569         struct build_id_event bev;
1570         char filename[PATH_MAX];
1571         u64 limit = offset + size;
1572
1573         while (offset < limit) {
1574                 ssize_t len;
1575
1576                 if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
1577                         return -1;
1578
1579                 if (header->needs_swap)
1580                         perf_event_header__bswap(&old_bev.header);
1581
1582                 len = old_bev.header.size - sizeof(old_bev);
1583                 if (readn(input, filename, len) != len)
1584                         return -1;
1585
1586                 bev.header = old_bev.header;
1587
1588                 /*
1589                  * As the pid is the missing value, we need to fill
1590                  * it properly. The header.misc value give us nice hint.
1591                  */
1592                 bev.pid = HOST_KERNEL_ID;
1593                 if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
1594                     bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
1595                         bev.pid = DEFAULT_GUEST_KERNEL_ID;
1596
1597                 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
1598                 __event_process_build_id(&bev, filename, session);
1599
1600                 offset += bev.header.size;
1601         }
1602
1603         return 0;
1604 }
1605
1606 static int perf_header__read_build_ids(struct perf_header *header,
1607                                        int input, u64 offset, u64 size)
1608 {
1609         struct perf_session *session = container_of(header, struct perf_session, header);
1610         struct build_id_event bev;
1611         char filename[PATH_MAX];
1612         u64 limit = offset + size, orig_offset = offset;
1613         int err = -1;
1614
1615         while (offset < limit) {
1616                 ssize_t len;
1617
1618                 if (readn(input, &bev, sizeof(bev)) != sizeof(bev))
1619                         goto out;
1620
1621                 if (header->needs_swap)
1622                         perf_event_header__bswap(&bev.header);
1623
1624                 len = bev.header.size - sizeof(bev);
1625                 if (readn(input, filename, len) != len)
1626                         goto out;
1627                 /*
1628                  * The a1645ce1 changeset:
1629                  *
1630                  * "perf: 'perf kvm' tool for monitoring guest performance from host"
1631                  *
1632                  * Added a field to struct build_id_event that broke the file
1633                  * format.
1634                  *
1635                  * Since the kernel build-id is the first entry, process the
1636                  * table using the old format if the well known
1637                  * '[kernel.kallsyms]' string for the kernel build-id has the
1638                  * first 4 characters chopped off (where the pid_t sits).
1639                  */
1640                 if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
1641                         if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
1642                                 return -1;
1643                         return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
1644                 }
1645
1646                 __event_process_build_id(&bev, filename, session);
1647
1648                 offset += bev.header.size;
1649         }
1650         err = 0;
1651 out:
1652         return err;
1653 }
1654
1655 static int process_tracing_data(struct perf_file_section *section __maybe_unused,
1656                                 struct perf_header *ph __maybe_unused,
1657                                 int fd, void *data)
1658 {
1659         ssize_t ret = trace_report(fd, data, false);
1660         return ret < 0 ? -1 : 0;
1661 }
1662
1663 static int process_build_id(struct perf_file_section *section,
1664                             struct perf_header *ph, int fd,
1665                             void *data __maybe_unused)
1666 {
1667         if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
1668                 pr_debug("Failed to read buildids, continuing...\n");
1669         return 0;
1670 }
1671
1672 static int process_hostname(struct perf_file_section *section __maybe_unused,
1673                             struct perf_header *ph, int fd,
1674                             void *data __maybe_unused)
1675 {
1676         ph->env.hostname = do_read_string(fd, ph);
1677         return ph->env.hostname ? 0 : -ENOMEM;
1678 }
1679
1680 static int process_osrelease(struct perf_file_section *section __maybe_unused,
1681                              struct perf_header *ph, int fd,
1682                              void *data __maybe_unused)
1683 {
1684         ph->env.os_release = do_read_string(fd, ph);
1685         return ph->env.os_release ? 0 : -ENOMEM;
1686 }
1687
1688 static int process_version(struct perf_file_section *section __maybe_unused,
1689                            struct perf_header *ph, int fd,
1690                            void *data __maybe_unused)
1691 {
1692         ph->env.version = do_read_string(fd, ph);
1693         return ph->env.version ? 0 : -ENOMEM;
1694 }
1695
1696 static int process_arch(struct perf_file_section *section __maybe_unused,
1697                         struct perf_header *ph, int fd,
1698                         void *data __maybe_unused)
1699 {
1700         ph->env.arch = do_read_string(fd, ph);
1701         return ph->env.arch ? 0 : -ENOMEM;
1702 }
1703
1704 static int process_nrcpus(struct perf_file_section *section __maybe_unused,
1705                           struct perf_header *ph, int fd,
1706                           void *data __maybe_unused)
1707 {
1708         ssize_t ret;
1709         u32 nr;
1710
1711         ret = readn(fd, &nr, sizeof(nr));
1712         if (ret != sizeof(nr))
1713                 return -1;
1714
1715         if (ph->needs_swap)
1716                 nr = bswap_32(nr);
1717
1718         ph->env.nr_cpus_online = nr;
1719
1720         ret = readn(fd, &nr, sizeof(nr));
1721         if (ret != sizeof(nr))
1722                 return -1;
1723
1724         if (ph->needs_swap)
1725                 nr = bswap_32(nr);
1726
1727         ph->env.nr_cpus_avail = nr;
1728         return 0;
1729 }
1730
1731 static int process_cpudesc(struct perf_file_section *section __maybe_unused,
1732                            struct perf_header *ph, int fd,
1733                            void *data __maybe_unused)
1734 {
1735         ph->env.cpu_desc = do_read_string(fd, ph);
1736         return ph->env.cpu_desc ? 0 : -ENOMEM;
1737 }
1738
1739 static int process_cpuid(struct perf_file_section *section __maybe_unused,
1740                          struct perf_header *ph,  int fd,
1741                          void *data __maybe_unused)
1742 {
1743         ph->env.cpuid = do_read_string(fd, ph);
1744         return ph->env.cpuid ? 0 : -ENOMEM;
1745 }
1746
1747 static int process_total_mem(struct perf_file_section *section __maybe_unused,
1748                              struct perf_header *ph, int fd,
1749                              void *data __maybe_unused)
1750 {
1751         uint64_t mem;
1752         ssize_t ret;
1753
1754         ret = readn(fd, &mem, sizeof(mem));
1755         if (ret != sizeof(mem))
1756                 return -1;
1757
1758         if (ph->needs_swap)
1759                 mem = bswap_64(mem);
1760
1761         ph->env.total_mem = mem;
1762         return 0;
1763 }
1764
1765 static struct perf_evsel *
1766 perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
1767 {
1768         struct perf_evsel *evsel;
1769
1770         evlist__for_each(evlist, evsel) {
1771                 if (evsel->idx == idx)
1772                         return evsel;
1773         }
1774
1775         return NULL;
1776 }
1777
1778 static void
1779 perf_evlist__set_event_name(struct perf_evlist *evlist,
1780                             struct perf_evsel *event)
1781 {
1782         struct perf_evsel *evsel;
1783
1784         if (!event->name)
1785                 return;
1786
1787         evsel = perf_evlist__find_by_index(evlist, event->idx);
1788         if (!evsel)
1789                 return;
1790
1791         if (evsel->name)
1792                 return;
1793
1794         evsel->name = strdup(event->name);
1795 }
1796
1797 static int
1798 process_event_desc(struct perf_file_section *section __maybe_unused,
1799                    struct perf_header *header, int fd,
1800                    void *data __maybe_unused)
1801 {
1802         struct perf_session *session;
1803         struct perf_evsel *evsel, *events = read_event_desc(header, fd);
1804
1805         if (!events)
1806                 return 0;
1807
1808         session = container_of(header, struct perf_session, header);
1809         for (evsel = events; evsel->attr.size; evsel++)
1810                 perf_evlist__set_event_name(session->evlist, evsel);
1811
1812         free_event_desc(events);
1813
1814         return 0;
1815 }
1816
1817 static int process_cmdline(struct perf_file_section *section __maybe_unused,
1818                            struct perf_header *ph, int fd,
1819                            void *data __maybe_unused)
1820 {
1821         ssize_t ret;
1822         char *str;
1823         u32 nr, i;
1824         struct strbuf sb;
1825
1826         ret = readn(fd, &nr, sizeof(nr));
1827         if (ret != sizeof(nr))
1828                 return -1;
1829
1830         if (ph->needs_swap)
1831                 nr = bswap_32(nr);
1832
1833         ph->env.nr_cmdline = nr;
1834         strbuf_init(&sb, 128);
1835
1836         for (i = 0; i < nr; i++) {
1837                 str = do_read_string(fd, ph);
1838                 if (!str)
1839                         goto error;
1840
1841                 /* include a NULL character at the end */
1842                 strbuf_add(&sb, str, strlen(str) + 1);
1843                 free(str);
1844         }
1845         ph->env.cmdline = strbuf_detach(&sb, NULL);
1846         return 0;
1847
1848 error:
1849         strbuf_release(&sb);
1850         return -1;
1851 }
1852
1853 static int process_cpu_topology(struct perf_file_section *section __maybe_unused,
1854                                 struct perf_header *ph, int fd,
1855                                 void *data __maybe_unused)
1856 {
1857         ssize_t ret;
1858         u32 nr, i;
1859         char *str;
1860         struct strbuf sb;
1861
1862         ret = readn(fd, &nr, sizeof(nr));
1863         if (ret != sizeof(nr))
1864                 return -1;
1865
1866         if (ph->needs_swap)
1867                 nr = bswap_32(nr);
1868
1869         ph->env.nr_sibling_cores = nr;
1870         strbuf_init(&sb, 128);
1871
1872         for (i = 0; i < nr; i++) {
1873                 str = do_read_string(fd, ph);
1874                 if (!str)
1875                         goto error;
1876
1877                 /* include a NULL character at the end */
1878                 strbuf_add(&sb, str, strlen(str) + 1);
1879                 free(str);
1880         }
1881         ph->env.sibling_cores = strbuf_detach(&sb, NULL);
1882
1883         ret = readn(fd, &nr, sizeof(nr));
1884         if (ret != sizeof(nr))
1885                 return -1;
1886
1887         if (ph->needs_swap)
1888                 nr = bswap_32(nr);
1889
1890         ph->env.nr_sibling_threads = nr;
1891
1892         for (i = 0; i < nr; i++) {
1893                 str = do_read_string(fd, ph);
1894                 if (!str)
1895                         goto error;
1896
1897                 /* include a NULL character at the end */
1898                 strbuf_add(&sb, str, strlen(str) + 1);
1899                 free(str);
1900         }
1901         ph->env.sibling_threads = strbuf_detach(&sb, NULL);
1902         return 0;
1903
1904 error:
1905         strbuf_release(&sb);
1906         return -1;
1907 }
1908
1909 static int process_numa_topology(struct perf_file_section *section __maybe_unused,
1910                                  struct perf_header *ph, int fd,
1911                                  void *data __maybe_unused)
1912 {
1913         ssize_t ret;
1914         u32 nr, node, i;
1915         char *str;
1916         uint64_t mem_total, mem_free;
1917         struct strbuf sb;
1918
1919         /* nr nodes */
1920         ret = readn(fd, &nr, sizeof(nr));
1921         if (ret != sizeof(nr))
1922                 goto error;
1923
1924         if (ph->needs_swap)
1925                 nr = bswap_32(nr);
1926
1927         ph->env.nr_numa_nodes = nr;
1928         strbuf_init(&sb, 256);
1929
1930         for (i = 0; i < nr; i++) {
1931                 /* node number */
1932                 ret = readn(fd, &node, sizeof(node));
1933                 if (ret != sizeof(node))
1934                         goto error;
1935
1936                 ret = readn(fd, &mem_total, sizeof(u64));
1937                 if (ret != sizeof(u64))
1938                         goto error;
1939
1940                 ret = readn(fd, &mem_free, sizeof(u64));
1941                 if (ret != sizeof(u64))
1942                         goto error;
1943
1944                 if (ph->needs_swap) {
1945                         node = bswap_32(node);
1946                         mem_total = bswap_64(mem_total);
1947                         mem_free = bswap_64(mem_free);
1948                 }
1949
1950                 strbuf_addf(&sb, "%u:%"PRIu64":%"PRIu64":",
1951                             node, mem_total, mem_free);
1952
1953                 str = do_read_string(fd, ph);
1954                 if (!str)
1955                         goto error;
1956
1957                 /* include a NULL character at the end */
1958                 strbuf_add(&sb, str, strlen(str) + 1);
1959                 free(str);
1960         }
1961         ph->env.numa_nodes = strbuf_detach(&sb, NULL);
1962         return 0;
1963
1964 error:
1965         strbuf_release(&sb);
1966         return -1;
1967 }
1968
1969 static int process_pmu_mappings(struct perf_file_section *section __maybe_unused,
1970                                 struct perf_header *ph, int fd,
1971                                 void *data __maybe_unused)
1972 {
1973         ssize_t ret;
1974         char *name;
1975         u32 pmu_num;
1976         u32 type;
1977         struct strbuf sb;
1978
1979         ret = readn(fd, &pmu_num, sizeof(pmu_num));
1980         if (ret != sizeof(pmu_num))
1981                 return -1;
1982
1983         if (ph->needs_swap)
1984                 pmu_num = bswap_32(pmu_num);
1985
1986         if (!pmu_num) {
1987                 pr_debug("pmu mappings not available\n");
1988                 return 0;
1989         }
1990
1991         ph->env.nr_pmu_mappings = pmu_num;
1992         strbuf_init(&sb, 128);
1993
1994         while (pmu_num) {
1995                 if (readn(fd, &type, sizeof(type)) != sizeof(type))
1996                         goto error;
1997                 if (ph->needs_swap)
1998                         type = bswap_32(type);
1999
2000                 name = do_read_string(fd, ph);
2001                 if (!name)
2002                         goto error;
2003
2004                 strbuf_addf(&sb, "%u:%s", type, name);
2005                 /* include a NULL character at the end */
2006                 strbuf_add(&sb, "", 1);
2007
2008                 free(name);
2009                 pmu_num--;
2010         }
2011         ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
2012         return 0;
2013
2014 error:
2015         strbuf_release(&sb);
2016         return -1;
2017 }
2018
2019 static int process_group_desc(struct perf_file_section *section __maybe_unused,
2020                               struct perf_header *ph, int fd,
2021                               void *data __maybe_unused)
2022 {
2023         size_t ret = -1;
2024         u32 i, nr, nr_groups;
2025         struct perf_session *session;
2026         struct perf_evsel *evsel, *leader = NULL;
2027         struct group_desc {
2028                 char *name;
2029                 u32 leader_idx;
2030                 u32 nr_members;
2031         } *desc;
2032
2033         if (readn(fd, &nr_groups, sizeof(nr_groups)) != sizeof(nr_groups))
2034                 return -1;
2035
2036         if (ph->needs_swap)
2037                 nr_groups = bswap_32(nr_groups);
2038
2039         ph->env.nr_groups = nr_groups;
2040         if (!nr_groups) {
2041                 pr_debug("group desc not available\n");
2042                 return 0;
2043         }
2044
2045         desc = calloc(nr_groups, sizeof(*desc));
2046         if (!desc)
2047                 return -1;
2048
2049         for (i = 0; i < nr_groups; i++) {
2050                 desc[i].name = do_read_string(fd, ph);
2051                 if (!desc[i].name)
2052                         goto out_free;
2053
2054                 if (readn(fd, &desc[i].leader_idx, sizeof(u32)) != sizeof(u32))
2055                         goto out_free;
2056
2057                 if (readn(fd, &desc[i].nr_members, sizeof(u32)) != sizeof(u32))
2058                         goto out_free;
2059
2060                 if (ph->needs_swap) {
2061                         desc[i].leader_idx = bswap_32(desc[i].leader_idx);
2062                         desc[i].nr_members = bswap_32(desc[i].nr_members);
2063                 }
2064         }
2065
2066         /*
2067          * Rebuild group relationship based on the group_desc
2068          */
2069         session = container_of(ph, struct perf_session, header);
2070         session->evlist->nr_groups = nr_groups;
2071
2072         i = nr = 0;
2073         evlist__for_each(session->evlist, evsel) {
2074                 if (evsel->idx == (int) desc[i].leader_idx) {
2075                         evsel->leader = evsel;
2076                         /* {anon_group} is a dummy name */
2077                         if (strcmp(desc[i].name, "{anon_group}")) {
2078                                 evsel->group_name = desc[i].name;
2079                                 desc[i].name = NULL;
2080                         }
2081                         evsel->nr_members = desc[i].nr_members;
2082
2083                         if (i >= nr_groups || nr > 0) {
2084                                 pr_debug("invalid group desc\n");
2085                                 goto out_free;
2086                         }
2087
2088                         leader = evsel;
2089                         nr = evsel->nr_members - 1;
2090                         i++;
2091                 } else if (nr) {
2092                         /* This is a group member */
2093                         evsel->leader = leader;
2094
2095                         nr--;
2096                 }
2097         }
2098
2099         if (i != nr_groups || nr != 0) {
2100                 pr_debug("invalid group desc\n");
2101                 goto out_free;
2102         }
2103
2104         ret = 0;
2105 out_free:
2106         for (i = 0; i < nr_groups; i++)
2107                 zfree(&desc[i].name);
2108         free(desc);
2109
2110         return ret;
2111 }
2112
2113 struct feature_ops {
2114         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
2115         void (*print)(struct perf_header *h, int fd, FILE *fp);
2116         int (*process)(struct perf_file_section *section,
2117                        struct perf_header *h, int fd, void *data);
2118         const char *name;
2119         bool full_only;
2120 };
2121
2122 #define FEAT_OPA(n, func) \
2123         [n] = { .name = #n, .write = write_##func, .print = print_##func }
2124 #define FEAT_OPP(n, func) \
2125         [n] = { .name = #n, .write = write_##func, .print = print_##func, \
2126                 .process = process_##func }
2127 #define FEAT_OPF(n, func) \
2128         [n] = { .name = #n, .write = write_##func, .print = print_##func, \
2129                 .process = process_##func, .full_only = true }
2130
2131 /* feature_ops not implemented: */
2132 #define print_tracing_data      NULL
2133 #define print_build_id          NULL
2134
2135 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
2136         FEAT_OPP(HEADER_TRACING_DATA,   tracing_data),
2137         FEAT_OPP(HEADER_BUILD_ID,       build_id),
2138         FEAT_OPP(HEADER_HOSTNAME,       hostname),
2139         FEAT_OPP(HEADER_OSRELEASE,      osrelease),
2140         FEAT_OPP(HEADER_VERSION,        version),
2141         FEAT_OPP(HEADER_ARCH,           arch),
2142         FEAT_OPP(HEADER_NRCPUS,         nrcpus),
2143         FEAT_OPP(HEADER_CPUDESC,        cpudesc),
2144         FEAT_OPP(HEADER_CPUID,          cpuid),
2145         FEAT_OPP(HEADER_TOTAL_MEM,      total_mem),
2146         FEAT_OPP(HEADER_EVENT_DESC,     event_desc),
2147         FEAT_OPP(HEADER_CMDLINE,        cmdline),
2148         FEAT_OPF(HEADER_CPU_TOPOLOGY,   cpu_topology),
2149         FEAT_OPF(HEADER_NUMA_TOPOLOGY,  numa_topology),
2150         FEAT_OPA(HEADER_BRANCH_STACK,   branch_stack),
2151         FEAT_OPP(HEADER_PMU_MAPPINGS,   pmu_mappings),
2152         FEAT_OPP(HEADER_GROUP_DESC,     group_desc),
2153 };
2154
2155 struct header_print_data {
2156         FILE *fp;
2157         bool full; /* extended list of headers */
2158 };
2159
2160 static int perf_file_section__fprintf_info(struct perf_file_section *section,
2161                                            struct perf_header *ph,
2162                                            int feat, int fd, void *data)
2163 {
2164         struct header_print_data *hd = data;
2165
2166         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
2167                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
2168                                 "%d, continuing...\n", section->offset, feat);
2169                 return 0;
2170         }
2171         if (feat >= HEADER_LAST_FEATURE) {
2172                 pr_warning("unknown feature %d\n", feat);
2173                 return 0;
2174         }
2175         if (!feat_ops[feat].print)
2176                 return 0;
2177
2178         if (!feat_ops[feat].full_only || hd->full)
2179                 feat_ops[feat].print(ph, fd, hd->fp);
2180         else
2181                 fprintf(hd->fp, "# %s info available, use -I to display\n",
2182                         feat_ops[feat].name);
2183
2184         return 0;
2185 }
2186
2187 int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
2188 {
2189         struct header_print_data hd;
2190         struct perf_header *header = &session->header;
2191         int fd = perf_data_file__fd(session->file);
2192         hd.fp = fp;
2193         hd.full = full;
2194
2195         perf_header__process_sections(header, fd, &hd,
2196                                       perf_file_section__fprintf_info);
2197         return 0;
2198 }
2199
2200 static int do_write_feat(int fd, struct perf_header *h, int type,
2201                          struct perf_file_section **p,
2202                          struct perf_evlist *evlist)
2203 {
2204         int err;
2205         int ret = 0;
2206
2207         if (perf_header__has_feat(h, type)) {
2208                 if (!feat_ops[type].write)
2209                         return -1;
2210
2211                 (*p)->offset = lseek(fd, 0, SEEK_CUR);
2212
2213                 err = feat_ops[type].write(fd, h, evlist);
2214                 if (err < 0) {
2215                         pr_debug("failed to write feature %d\n", type);
2216
2217                         /* undo anything written */
2218                         lseek(fd, (*p)->offset, SEEK_SET);
2219
2220                         return -1;
2221                 }
2222                 (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
2223                 (*p)++;
2224         }
2225         return ret;
2226 }
2227
2228 static int perf_header__adds_write(struct perf_header *header,
2229                                    struct perf_evlist *evlist, int fd)
2230 {
2231         int nr_sections;
2232         struct perf_file_section *feat_sec, *p;
2233         int sec_size;
2234         u64 sec_start;
2235         int feat;
2236         int err;
2237
2238         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
2239         if (!nr_sections)
2240                 return 0;
2241
2242         feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));
2243         if (feat_sec == NULL)
2244                 return -ENOMEM;
2245
2246         sec_size = sizeof(*feat_sec) * nr_sections;
2247
2248         sec_start = header->feat_offset;
2249         lseek(fd, sec_start + sec_size, SEEK_SET);
2250
2251         for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
2252                 if (do_write_feat(fd, header, feat, &p, evlist))
2253                         perf_header__clear_feat(header, feat);
2254         }
2255
2256         lseek(fd, sec_start, SEEK_SET);
2257         /*
2258          * may write more than needed due to dropped feature, but
2259          * this is okay, reader will skip the mising entries
2260          */
2261         err = do_write(fd, feat_sec, sec_size);
2262         if (err < 0)
2263                 pr_debug("failed to write feature section\n");
2264         free(feat_sec);
2265         return err;
2266 }
2267
2268 int perf_header__write_pipe(int fd)
2269 {
2270         struct perf_pipe_file_header f_header;
2271         int err;
2272
2273         f_header = (struct perf_pipe_file_header){
2274                 .magic     = PERF_MAGIC,
2275                 .size      = sizeof(f_header),
2276         };
2277
2278         err = do_write(fd, &f_header, sizeof(f_header));
2279         if (err < 0) {
2280                 pr_debug("failed to write perf pipe header\n");
2281                 return err;
2282         }
2283
2284         return 0;
2285 }
2286
2287 int perf_session__write_header(struct perf_session *session,
2288                                struct perf_evlist *evlist,
2289                                int fd, bool at_exit)
2290 {
2291         struct perf_file_header f_header;
2292         struct perf_file_attr   f_attr;
2293         struct perf_header *header = &session->header;
2294         struct perf_evsel *evsel;
2295         u64 attr_offset;
2296         int err;
2297
2298         lseek(fd, sizeof(f_header), SEEK_SET);
2299
2300         evlist__for_each(session->evlist, evsel) {
2301                 evsel->id_offset = lseek(fd, 0, SEEK_CUR);
2302                 err = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
2303                 if (err < 0) {
2304                         pr_debug("failed to write perf header\n");
2305                         return err;
2306                 }
2307         }
2308
2309         attr_offset = lseek(fd, 0, SEEK_CUR);
2310
2311         evlist__for_each(evlist, evsel) {
2312                 f_attr = (struct perf_file_attr){
2313                         .attr = evsel->attr,
2314                         .ids  = {
2315                                 .offset = evsel->id_offset,
2316                                 .size   = evsel->ids * sizeof(u64),
2317                         }
2318                 };
2319                 err = do_write(fd, &f_attr, sizeof(f_attr));
2320                 if (err < 0) {
2321                         pr_debug("failed to write perf header attribute\n");
2322                         return err;
2323                 }
2324         }
2325
2326         if (!header->data_offset)
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         ssize_t 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         ssize_t 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,
2654                                         perf_data_file__fd(session->file),
2655                                         session->repipe) < 0) {
2656                 pr_debug("incompatible file format\n");
2657                 return -EINVAL;
2658         }
2659
2660         return 0;
2661 }
2662
2663 static int read_attr(int fd, struct perf_header *ph,
2664                      struct perf_file_attr *f_attr)
2665 {
2666         struct perf_event_attr *attr = &f_attr->attr;
2667         size_t sz, left;
2668         size_t our_sz = sizeof(f_attr->attr);
2669         ssize_t ret;
2670
2671         memset(f_attr, 0, sizeof(*f_attr));
2672
2673         /* read minimal guaranteed structure */
2674         ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
2675         if (ret <= 0) {
2676                 pr_debug("cannot read %d bytes of header attr\n",
2677                          PERF_ATTR_SIZE_VER0);
2678                 return -1;
2679         }
2680
2681         /* on file perf_event_attr size */
2682         sz = attr->size;
2683
2684         if (ph->needs_swap)
2685                 sz = bswap_32(sz);
2686
2687         if (sz == 0) {
2688                 /* assume ABI0 */
2689                 sz =  PERF_ATTR_SIZE_VER0;
2690         } else if (sz > our_sz) {
2691                 pr_debug("file uses a more recent and unsupported ABI"
2692                          " (%zu bytes extra)\n", sz - our_sz);
2693                 return -1;
2694         }
2695         /* what we have not yet read and that we know about */
2696         left = sz - PERF_ATTR_SIZE_VER0;
2697         if (left) {
2698                 void *ptr = attr;
2699                 ptr += PERF_ATTR_SIZE_VER0;
2700
2701                 ret = readn(fd, ptr, left);
2702         }
2703         /* read perf_file_section, ids are read in caller */
2704         ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));
2705
2706         return ret <= 0 ? -1 : 0;
2707 }
2708
2709 static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
2710                                                 struct pevent *pevent)
2711 {
2712         struct event_format *event;
2713         char bf[128];
2714
2715         /* already prepared */
2716         if (evsel->tp_format)
2717                 return 0;
2718
2719         if (pevent == NULL) {
2720                 pr_debug("broken or missing trace data\n");
2721                 return -1;
2722         }
2723
2724         event = pevent_find_event(pevent, evsel->attr.config);
2725         if (event == NULL)
2726                 return -1;
2727
2728         if (!evsel->name) {
2729                 snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
2730                 evsel->name = strdup(bf);
2731                 if (evsel->name == NULL)
2732                         return -1;
2733         }
2734
2735         evsel->tp_format = event;
2736         return 0;
2737 }
2738
2739 static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist,
2740                                                   struct pevent *pevent)
2741 {
2742         struct perf_evsel *pos;
2743
2744         evlist__for_each(evlist, pos) {
2745                 if (pos->attr.type == PERF_TYPE_TRACEPOINT &&
2746                     perf_evsel__prepare_tracepoint_event(pos, pevent))
2747                         return -1;
2748         }
2749
2750         return 0;
2751 }
2752
2753 int perf_session__read_header(struct perf_session *session)
2754 {
2755         struct perf_data_file *file = session->file;
2756         struct perf_header *header = &session->header;
2757         struct perf_file_header f_header;
2758         struct perf_file_attr   f_attr;
2759         u64                     f_id;
2760         int nr_attrs, nr_ids, i, j;
2761         int fd = perf_data_file__fd(file);
2762
2763         session->evlist = perf_evlist__new();
2764         if (session->evlist == NULL)
2765                 return -ENOMEM;
2766
2767         if (perf_data_file__is_pipe(file))
2768                 return perf_header__read_pipe(session);
2769
2770         if (perf_file_header__read(&f_header, header, fd) < 0)
2771                 return -EINVAL;
2772
2773         /*
2774          * Sanity check that perf.data was written cleanly; data size is
2775          * initialized to 0 and updated only if the on_exit function is run.
2776          * If data size is still 0 then the file contains only partial
2777          * information.  Just warn user and process it as much as it can.
2778          */
2779         if (f_header.data.size == 0) {
2780                 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
2781                            "Was the 'perf record' command properly terminated?\n",
2782                            file->path);
2783         }
2784
2785         nr_attrs = f_header.attrs.size / f_header.attr_size;
2786         lseek(fd, f_header.attrs.offset, SEEK_SET);
2787
2788         for (i = 0; i < nr_attrs; i++) {
2789                 struct perf_evsel *evsel;
2790                 off_t tmp;
2791
2792                 if (read_attr(fd, header, &f_attr) < 0)
2793                         goto out_errno;
2794
2795                 if (header->needs_swap)
2796                         perf_event__attr_swap(&f_attr.attr);
2797
2798                 tmp = lseek(fd, 0, SEEK_CUR);
2799                 evsel = perf_evsel__new(&f_attr.attr);
2800
2801                 if (evsel == NULL)
2802                         goto out_delete_evlist;
2803
2804                 evsel->needs_swap = header->needs_swap;
2805                 /*
2806                  * Do it before so that if perf_evsel__alloc_id fails, this
2807                  * entry gets purged too at perf_evlist__delete().
2808                  */
2809                 perf_evlist__add(session->evlist, evsel);
2810
2811                 nr_ids = f_attr.ids.size / sizeof(u64);
2812                 /*
2813                  * We don't have the cpu and thread maps on the header, so
2814                  * for allocating the perf_sample_id table we fake 1 cpu and
2815                  * hattr->ids threads.
2816                  */
2817                 if (perf_evsel__alloc_id(evsel, 1, nr_ids))
2818                         goto out_delete_evlist;
2819
2820                 lseek(fd, f_attr.ids.offset, SEEK_SET);
2821
2822                 for (j = 0; j < nr_ids; j++) {
2823                         if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
2824                                 goto out_errno;
2825
2826                         perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
2827                 }
2828
2829                 lseek(fd, tmp, SEEK_SET);
2830         }
2831
2832         symbol_conf.nr_events = nr_attrs;
2833
2834         perf_header__process_sections(header, fd, &session->tevent,
2835                                       perf_file_section__process);
2836
2837         if (perf_evlist__prepare_tracepoint_events(session->evlist,
2838                                                    session->tevent.pevent))
2839                 goto out_delete_evlist;
2840
2841         return 0;
2842 out_errno:
2843         return -errno;
2844
2845 out_delete_evlist:
2846         perf_evlist__delete(session->evlist);
2847         session->evlist = NULL;
2848         return -ENOMEM;
2849 }
2850
2851 int perf_event__synthesize_attr(struct perf_tool *tool,
2852                                 struct perf_event_attr *attr, u32 ids, u64 *id,
2853                                 perf_event__handler_t process)
2854 {
2855         union perf_event *ev;
2856         size_t size;
2857         int err;
2858
2859         size = sizeof(struct perf_event_attr);
2860         size = PERF_ALIGN(size, sizeof(u64));
2861         size += sizeof(struct perf_event_header);
2862         size += ids * sizeof(u64);
2863
2864         ev = malloc(size);
2865
2866         if (ev == NULL)
2867                 return -ENOMEM;
2868
2869         ev->attr.attr = *attr;
2870         memcpy(ev->attr.id, id, ids * sizeof(u64));
2871
2872         ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
2873         ev->attr.header.size = (u16)size;
2874
2875         if (ev->attr.header.size == size)
2876                 err = process(tool, ev, NULL, NULL);
2877         else
2878                 err = -E2BIG;
2879
2880         free(ev);
2881
2882         return err;
2883 }
2884
2885 int perf_event__synthesize_attrs(struct perf_tool *tool,
2886                                    struct perf_session *session,
2887                                    perf_event__handler_t process)
2888 {
2889         struct perf_evsel *evsel;
2890         int err = 0;
2891
2892         evlist__for_each(session->evlist, evsel) {
2893                 err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids,
2894                                                   evsel->id, process);
2895                 if (err) {
2896                         pr_debug("failed to create perf header attribute\n");
2897                         return err;
2898                 }
2899         }
2900
2901         return err;
2902 }
2903
2904 int perf_event__process_attr(struct perf_tool *tool __maybe_unused,
2905                              union perf_event *event,
2906                              struct perf_evlist **pevlist)
2907 {
2908         u32 i, ids, n_ids;
2909         struct perf_evsel *evsel;
2910         struct perf_evlist *evlist = *pevlist;
2911
2912         if (evlist == NULL) {
2913                 *pevlist = evlist = perf_evlist__new();
2914                 if (evlist == NULL)
2915                         return -ENOMEM;
2916         }
2917
2918         evsel = perf_evsel__new(&event->attr.attr);
2919         if (evsel == NULL)
2920                 return -ENOMEM;
2921
2922         perf_evlist__add(evlist, evsel);
2923
2924         ids = event->header.size;
2925         ids -= (void *)&event->attr.id - (void *)event;
2926         n_ids = ids / sizeof(u64);
2927         /*
2928          * We don't have the cpu and thread maps on the header, so
2929          * for allocating the perf_sample_id table we fake 1 cpu and
2930          * hattr->ids threads.
2931          */
2932         if (perf_evsel__alloc_id(evsel, 1, n_ids))
2933                 return -ENOMEM;
2934
2935         for (i = 0; i < n_ids; i++) {
2936                 perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]);
2937         }
2938
2939         symbol_conf.nr_events = evlist->nr_entries;
2940
2941         return 0;
2942 }
2943
2944 int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
2945                                         struct perf_evlist *evlist,
2946                                         perf_event__handler_t process)
2947 {
2948         union perf_event ev;
2949         struct tracing_data *tdata;
2950         ssize_t size = 0, aligned_size = 0, padding;
2951         int err __maybe_unused = 0;
2952
2953         /*
2954          * We are going to store the size of the data followed
2955          * by the data contents. Since the fd descriptor is a pipe,
2956          * we cannot seek back to store the size of the data once
2957          * we know it. Instead we:
2958          *
2959          * - write the tracing data to the temp file
2960          * - get/write the data size to pipe
2961          * - write the tracing data from the temp file
2962          *   to the pipe
2963          */
2964         tdata = tracing_data_get(&evlist->entries, fd, true);
2965         if (!tdata)
2966                 return -1;
2967
2968         memset(&ev, 0, sizeof(ev));
2969
2970         ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
2971         size = tdata->size;
2972         aligned_size = PERF_ALIGN(size, sizeof(u64));
2973         padding = aligned_size - size;
2974         ev.tracing_data.header.size = sizeof(ev.tracing_data);
2975         ev.tracing_data.size = aligned_size;
2976
2977         process(tool, &ev, NULL, NULL);
2978
2979         /*
2980          * The put function will copy all the tracing data
2981          * stored in temp file to the pipe.
2982          */
2983         tracing_data_put(tdata);
2984
2985         write_padded(fd, NULL, 0, padding);
2986
2987         return aligned_size;
2988 }
2989
2990 int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused,
2991                                      union perf_event *event,
2992                                      struct perf_session *session)
2993 {
2994         ssize_t size_read, padding, size = event->tracing_data.size;
2995         int fd = perf_data_file__fd(session->file);
2996         off_t offset = lseek(fd, 0, SEEK_CUR);
2997         char buf[BUFSIZ];
2998
2999         /* setup for reading amidst mmap */
3000         lseek(fd, offset + sizeof(struct tracing_data_event),
3001               SEEK_SET);
3002
3003         size_read = trace_report(fd, &session->tevent,
3004                                  session->repipe);
3005         padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
3006
3007         if (readn(fd, buf, padding) < 0) {
3008                 pr_err("%s: reading input file", __func__);
3009                 return -1;
3010         }
3011         if (session->repipe) {
3012                 int retw = write(STDOUT_FILENO, buf, padding);
3013                 if (retw <= 0 || retw != padding) {
3014                         pr_err("%s: repiping tracing data padding", __func__);
3015                         return -1;
3016                 }
3017         }
3018
3019         if (size_read + padding != size) {
3020                 pr_err("%s: tracing data size mismatch", __func__);
3021                 return -1;
3022         }
3023
3024         perf_evlist__prepare_tracepoint_events(session->evlist,
3025                                                session->tevent.pevent);
3026
3027         return size_read + padding;
3028 }
3029
3030 int perf_event__synthesize_build_id(struct perf_tool *tool,
3031                                     struct dso *pos, u16 misc,
3032                                     perf_event__handler_t process,
3033                                     struct machine *machine)
3034 {
3035         union perf_event ev;
3036         size_t len;
3037         int err = 0;
3038
3039         if (!pos->hit)
3040                 return err;
3041
3042         memset(&ev, 0, sizeof(ev));
3043
3044         len = pos->long_name_len + 1;
3045         len = PERF_ALIGN(len, NAME_ALIGN);
3046         memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
3047         ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
3048         ev.build_id.header.misc = misc;
3049         ev.build_id.pid = machine->pid;
3050         ev.build_id.header.size = sizeof(ev.build_id) + len;
3051         memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
3052
3053         err = process(tool, &ev, NULL, machine);
3054
3055         return err;
3056 }
3057
3058 int perf_event__process_build_id(struct perf_tool *tool __maybe_unused,
3059                                  union perf_event *event,
3060                                  struct perf_session *session)
3061 {
3062         __event_process_build_id(&event->build_id,
3063                                  event->build_id.filename,
3064                                  session);
3065         return 0;
3066 }
3067
3068 void disable_buildid_cache(void)
3069 {
3070         no_buildid_cache = true;
3071 }