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