1 files changed, 237 insertions, 105 deletions

diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 7d26659b806..b01a9537977 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -2,11 +2,15 @@
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <linux/list.h>
 
 #include "util.h"
 #include "header.h"
 #include "../perf.h"
 #include "trace-event.h"
+#include "symbol.h"
+#include "data_map.h"
+#include "debug.h"
 
 /*
  * Create new perf.data header attribute:
@@ -15,32 +19,43 @@ struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr)
 {
         struct perf_header_attr *self = malloc(sizeof(*self));
 
-        if (!self)
-                die("nomem");
-
-        self->attr = *attr;
-        self->ids = 0;
-        self->size = 1;
-        self->id = malloc(sizeof(u64));
-
-        if (!self->id)
-                die("nomem");
+        if (self != NULL) {
+                self->attr = *attr;
+                self->ids  = 0;
+                self->size = 1;
+                self->id   = malloc(sizeof(u64));
+                if (self->id == NULL) {
+                        free(self);
+                        self = NULL;
+                }
+        }
 
         return self;
 }
 
-void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
+void perf_header_attr__delete(struct perf_header_attr *self)
+{
+        free(self->id);
+        free(self);
+}
+
+int perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
 {
         int pos = self->ids;
 
         self->ids++;
         if (self->ids > self->size) {
-                self->size *= 2;
-                self->id = realloc(self->id, self->size * sizeof(u64));
-                if (!self->id)
-                        die("nomem");
+                int nsize = self->size * 2;
+                u64 *nid = realloc(self->id, nsize * sizeof(u64));
+
+                if (nid == NULL)
+                        return -1;
+
+                self->size = nsize;
+                self->id = nid;
         }
         self->id[pos] = id;
+        return 0;
 }
 
 /*
@@ -50,34 +65,41 @@ struct perf_header *perf_header__new(void)
 {
         struct perf_header *self = calloc(sizeof(*self), 1);
 
-        if (!self)
-                die("nomem");
-
-        self->size = 1;
-        self->attr = malloc(sizeof(void *));
+        if (self != NULL) {
+                self->size = 1;
+                self->attr = malloc(sizeof(void *));
 
-        if (!self->attr)
-                die("nomem");
+                if (self->attr == NULL) {
+                        free(self);
+                        self = NULL;
+                }
+        }
 
         return self;
 }
 
-void perf_header__add_attr(struct perf_header *self,
-                           struct perf_header_attr *attr)
+int perf_header__add_attr(struct perf_header *self,
+                          struct perf_header_attr *attr)
 {
         int pos = self->attrs;
 
         if (self->frozen)
-                die("frozen");
+                return -1;
 
         self->attrs++;
         if (self->attrs > self->size) {
-                self->size *= 2;
-                self->attr = realloc(self->attr, self->size * sizeof(void *));
-                if (!self->attr)
-                        die("nomem");
+                int nsize = self->size * 2;
+                struct perf_header_attr **nattr;
+
+                nattr = realloc(self->attr, nsize * sizeof(void *));
+                if (nattr == NULL)
+                        return -1;
+
+                self->size = nsize;
+                self->attr = nattr;
         }
         self->attr[pos] = attr;
+        return 0;
 }
 
 #define MAX_EVENT_NAME 64
@@ -124,71 +146,110 @@ static const char *__perf_magic = "PERFFILE";
 
 #define PERF_MAGIC      (*(u64 *)__perf_magic)
 
-struct perf_file_section {
-        u64 offset;
-        u64 size;
-};
-
 struct perf_file_attr {
         struct perf_event_attr  attr;
         struct perf_file_section        ids;
 };
 
-struct perf_file_header {
-        u64                             magic;
-        u64                             size;
-        u64                             attr_size;
-        struct perf_file_section        attrs;
-        struct perf_file_section        data;
-        struct perf_file_section        event_types;
-        DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
-};
+void perf_header__set_feat(struct perf_header *self, int feat)
+{
+        set_bit(feat, self->adds_features);
+}
 
-void perf_header__feat_trace_info(struct perf_header *header)
+bool perf_header__has_feat(const struct perf_header *self, int feat)
 {
-        set_bit(HEADER_TRACE_INFO, header->adds_features);
+        return test_bit(feat, self->adds_features);
 }
 
-static void do_write(int fd, void *buf, size_t size)
+static int do_write(int fd, const void *buf, size_t size)
 {
         while (size) {
                 int ret = write(fd, buf, size);
 
                 if (ret < 0)
-                        die("failed to write");
+                        return -1;
 
                 size -= ret;
                 buf += ret;
         }
+
+        return 0;
+}
+
+static int write_buildid_table(int fd, struct list_head *id_head)
+{
+        struct build_id_list *iter, *next;
+
+        list_for_each_entry_safe(iter, next, id_head, list) {
+                struct build_id_event *b = &iter->event;
+
+                if (do_write(fd, b, sizeof(*b)) < 0 ||
+                    do_write(fd, iter->dso_name, iter->len) < 0)
+                        return -1;
+                list_del(&iter->list);
+                free(iter);
+        }
+
+        return 0;
 }
 
-static void perf_header__adds_write(struct perf_header *self, int fd)
+static void
+perf_header__adds_write(struct perf_header *self, int fd)
 {
-        struct perf_file_section trace_sec;
-        u64 cur_offset = lseek(fd, 0, SEEK_CUR);
-        unsigned long *feat_mask = self->adds_features;
+        LIST_HEAD(id_list);
+        int nr_sections;
+        struct perf_file_section *feat_sec;
+        int sec_size;
+        u64 sec_start;
+        int idx = 0;
+
+        if (fetch_build_id_table(&id_list))
+                perf_header__set_feat(self, HEADER_BUILD_ID);
+
+        nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
+        if (!nr_sections)
+                return;
+
+        feat_sec = calloc(sizeof(*feat_sec), nr_sections);
+        if (!feat_sec)
+                die("No memory");
+
+        sec_size = sizeof(*feat_sec) * nr_sections;
+
+        sec_start = self->data_offset + self->data_size;
+        lseek(fd, sec_start + sec_size, SEEK_SET);
+
+        if (perf_header__has_feat(self, HEADER_TRACE_INFO)) {
+                struct perf_file_section *trace_sec;
+
+                trace_sec = &feat_sec[idx++];
 
-        if (test_bit(HEADER_TRACE_INFO, feat_mask)) {
                 /* Write trace info */
-                trace_sec.offset = lseek(fd, sizeof(trace_sec), SEEK_CUR);
+                trace_sec->offset = lseek(fd, 0, SEEK_CUR);
                 read_tracing_data(fd, attrs, nr_counters);
-                trace_sec.size = lseek(fd, 0, SEEK_CUR) - trace_sec.offset;
-
-                /* Write trace info headers */
-                lseek(fd, cur_offset, SEEK_SET);
-                do_write(fd, &trace_sec, sizeof(trace_sec));
-
-                /*
-                 * Update cur_offset. So that other (future)
-                 * features can set their own infos in this place. But if we are
-                 * the only feature, at least that seeks to the place the data
-                 * should begin.
-                 */
-                cur_offset = lseek(fd, trace_sec.offset + trace_sec.size, SEEK_SET);
+                trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
         }
-};
 
-void perf_header__write(struct perf_header *self, int fd)
+
+        if (perf_header__has_feat(self, HEADER_BUILD_ID)) {
+                struct perf_file_section *buildid_sec;
+
+                buildid_sec = &feat_sec[idx++];
+
+                /* Write build-ids */
+                buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
+                if (write_buildid_table(fd, &id_list) < 0)
+                        die("failed to write buildid table");
+                buildid_sec->size = lseek(fd, 0, SEEK_CUR) - buildid_sec->offset;
+        }
+
+        lseek(fd, sec_start, SEEK_SET);
+        if (do_write(fd, feat_sec, sec_size) < 0)
+                die("failed to write feature section");
+        free(feat_sec);
+}
+
+void perf_header__write(struct perf_header *self, int fd, bool at_exit)
 {
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
@@ -202,7 +263,8 @@ void perf_header__write(struct perf_header *self, int fd)
                 attr = self->attr[i];
 
                 attr->id_offset = lseek(fd, 0, SEEK_CUR);
-                do_write(fd, attr->id, attr->ids * sizeof(u64));
+                if (do_write(fd, attr->id, attr->ids * sizeof(u64)) < 0)
+                        die("failed to write perf header");
         }
 
 
@@ -218,18 +280,21 @@ void perf_header__write(struct perf_header *self, int fd)
                                 .size   = attr->ids * sizeof(u64),
                         }
                 };
-                do_write(fd, &f_attr, sizeof(f_attr));
+                if (do_write(fd, &f_attr, sizeof(f_attr)) < 0)
+                        die("failed to write perf header attribute");
         }
 
         self->event_offset = lseek(fd, 0, SEEK_CUR);
         self->event_size = event_count * sizeof(struct perf_trace_event_type);
         if (events)
-                do_write(fd, events, self->event_size);
-
-        perf_header__adds_write(self, fd);
+                if (do_write(fd, events, self->event_size) < 0)
+                        die("failed to write perf header events");
 
         self->data_offset = lseek(fd, 0, SEEK_CUR);
 
+        if (at_exit)
+                perf_header__adds_write(self, fd);
+
         f_header = (struct perf_file_header){
                 .magic     = PERF_MAGIC,
                 .size      = sizeof(f_header),
@@ -251,7 +316,8 @@ void perf_header__write(struct perf_header *self, int fd)
         memcpy(&f_header.adds_features, &self->adds_features, sizeof(self->adds_features));
 
         lseek(fd, 0, SEEK_SET);
-        do_write(fd, &f_header, sizeof(f_header));
+        if (do_write(fd, &f_header, sizeof(f_header)) < 0)
+                die("failed to write perf header");
         lseek(fd, self->data_offset + self->data_size, SEEK_SET);
 
         self->frozen = 1;
@@ -272,43 +338,112 @@ static void do_read(int fd, void *buf, size_t size)
         }
 }
 
-static void perf_header__adds_read(struct perf_header *self, int fd)
+int perf_header__process_sections(struct perf_header *self, int fd,
+                                  int (*process)(struct perf_file_section *self,
+                                                 int feat, int fd))
 {
-        const unsigned long *feat_mask = self->adds_features;
+        struct perf_file_section *feat_sec;
+        int nr_sections;
+        int sec_size;
+        int idx = 0;
+        int err = 0, feat = 1;
 
-        if (test_bit(HEADER_TRACE_INFO, feat_mask)) {
-                struct perf_file_section trace_sec;
+        nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
+        if (!nr_sections)
+                return 0;
 
-                do_read(fd, &trace_sec, sizeof(trace_sec));
-                lseek(fd, trace_sec.offset, SEEK_SET);
-                trace_report(fd);
-                lseek(fd, trace_sec.offset + trace_sec.size, SEEK_SET);
+        feat_sec = calloc(sizeof(*feat_sec), nr_sections);
+        if (!feat_sec)
+                return -1;
+
+        sec_size = sizeof(*feat_sec) * nr_sections;
+
+        lseek(fd, self->data_offset + self->data_size, SEEK_SET);
+
+        do_read(fd, feat_sec, sec_size);
+
+        while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
+                if (perf_header__has_feat(self, feat)) {
+                        struct perf_file_section *sec = &feat_sec[idx++];
+
+                        err = process(sec, feat, fd);
+                        if (err < 0)
+                                break;
+                }
+                ++feat;
         }
+
+        free(feat_sec);
+        return err;
 };
 
+int perf_file_header__read(struct perf_file_header *self,
+                           struct perf_header *ph, int fd)
+{
+        lseek(fd, 0, SEEK_SET);
+        do_read(fd, self, sizeof(*self));
+
+        if (self->magic     != PERF_MAGIC ||
+            self->attr_size != sizeof(struct perf_file_attr))
+                return -1;
+
+        if (self->size != sizeof(*self)) {
+                /* Support the previous format */
+                if (self->size == offsetof(typeof(*self), adds_features))
+                        bitmap_zero(self->adds_features, HEADER_FEAT_BITS);
+                else
+                        return -1;
+        }
+
+        memcpy(&ph->adds_features, &self->adds_features,
+               sizeof(self->adds_features));
+
+        ph->event_offset = self->event_types.offset;
+        ph->event_size   = self->event_types.size;
+        ph->data_offset  = self->data.offset;
+        ph->data_size    = self->data.size;
+        return 0;
+}
+
+static int perf_file_section__process(struct perf_file_section *self,
+                                      int feat, int fd)
+{
+        if (lseek(fd, self->offset, SEEK_SET) < 0) {
+                pr_debug("Failed to lseek to %Ld offset for feature %d, "
+                         "continuing...\n", self->offset, feat);
+                return 0;
+        }
+
+        switch (feat) {
+        case HEADER_TRACE_INFO:
+                trace_report(fd);
+                break;
+
+        case HEADER_BUILD_ID:
+                if (perf_header__read_build_ids(fd, self->offset, self->size))
+                        pr_debug("Failed to read buildids, continuing...\n");
+                break;
+        default:
+                pr_debug("unknown feature %d, continuing...\n", feat);
+        }
+
+        return 0;
+}
+
 struct perf_header *perf_header__read(int fd)
 {
         struct perf_header      *self = perf_header__new();
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         u64                     f_id;
-
         int nr_attrs, nr_ids, i, j;
 
-        lseek(fd, 0, SEEK_SET);
-        do_read(fd, &f_header, sizeof(f_header));
+        if (self == NULL)
+                die("nomem");
 
-        if (f_header.magic      != PERF_MAGIC           ||
-            f_header.attr_size  != sizeof(f_attr))
+        if (perf_file_header__read(&f_header, self, fd) < 0)
                 die("incompatible file format");
 
-        if (f_header.size != sizeof(f_header)) {
-                /* Support the previous format */
-                if (f_header.size == offsetof(typeof(f_header), adds_features))
-                        bitmap_zero(f_header.adds_features, HEADER_FEAT_BITS);
-                else
-                        die("incompatible file format");
-        }
         nr_attrs = f_header.attrs.size / sizeof(f_attr);
         lseek(fd, f_header.attrs.offset, SEEK_SET);
 
@@ -320,6 +455,8 @@ struct perf_header *perf_header__read(int fd)
                 tmp = lseek(fd, 0, SEEK_CUR);
 
                 attr = perf_header_attr__new(&f_attr.attr);
+                if (attr == NULL)
+                         die("nomem");
 
                 nr_ids = f_attr.ids.size / sizeof(u64);
                 lseek(fd, f_attr.ids.offset, SEEK_SET);
@@ -327,9 +464,12 @@ struct perf_header *perf_header__read(int fd)
                 for (j = 0; j < nr_ids; j++) {
                         do_read(fd, &f_id, sizeof(f_id));
 
-                        perf_header_attr__add_id(attr, f_id);
+                        if (perf_header_attr__add_id(attr, f_id) < 0)
+                                die("nomem");
                 }
-                perf_header__add_attr(self, attr);
+                if (perf_header__add_attr(self, attr) < 0)
+                         die("nomem");
+
                 lseek(fd, tmp, SEEK_SET);
         }
 
@@ -342,15 +482,7 @@ struct perf_header *perf_header__read(int fd)
                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
         }
 
-        memcpy(&self->adds_features, &f_header.adds_features, sizeof(f_header.adds_features));
-
-        perf_header__adds_read(self, fd);
-
-        self->event_offset = f_header.event_types.offset;
-        self->event_size   = f_header.event_types.size;
-
-        self->data_offset = f_header.data.offset;
-        self->data_size   = f_header.data.size;
+        perf_header__process_sections(self, fd, perf_file_section__process);
 
         lseek(fd, self->data_offset, SEEK_SET);