tools/perf/util/header.c

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