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