tools/perf/util/header.c

   1 #include <sys/types.h>
   2 #include <unistd.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <linux/list.h>
   6
   7 #include "util.h"
   8 #include "header.h"
   9 #include "../perf.h"
  10 #include "trace-event.h"
  11 #include "symbol.h"
  12
  13 /*
  14  * Create new perf.data header attribute:
  15  */
  16 struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr)
  17 {
  18         struct perf_header_attr *self = malloc(sizeof(*self));
  19
  20         if (!self)
  21                 die("nomem");
  22
  23         self->attr = *attr;
  24         self->ids = 0;
  25         self->size = 1;
  26         self->id = malloc(sizeof(u64));
  27
  28         if (!self->id)
  29                 die("nomem");
  30
  31         return self;
  32 }
  33
  34 void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
  35 {
  36         int pos = self->ids;
  37
  38         self->ids++;
  39         if (self->ids > self->size) {
  40                 self->size *= 2;
  41                 self->id = realloc(self->id, self->size * sizeof(u64));
  42                 if (!self->id)
  43                         die("nomem");
  44         }
  45         self->id[pos] = id;
  46 }
  47
  48 /*
  49  * Create new perf.data header:
  50  */
  51 struct perf_header *perf_header__new(void)
  52 {
  53         struct perf_header *self = calloc(sizeof(*self), 1);
  54
  55         if (!self)
  56                 die("nomem");
  57
  58         self->size = 1;
  59         self->attr = malloc(sizeof(void *));
  60
  61         if (!self->attr)
  62                 die("nomem");
  63
  64         return self;
  65 }
  66
  67 void perf_header__add_attr(struct perf_header *self,
  68                            struct perf_header_attr *attr)
  69 {
  70         int pos = self->attrs;
  71
  72         if (self->frozen)
  73                 die("frozen");
  74
  75         self->attrs++;
  76         if (self->attrs > self->size) {
  77                 self->size *= 2;
  78                 self->attr = realloc(self->attr, self->size * sizeof(void *));
  79                 if (!self->attr)
  80                         die("nomem");
  81         }
  82         self->attr[pos] = attr;
  83 }
  84
  85 #define MAX_EVENT_NAME 64
  86
  87 struct perf_trace_event_type {
  88         u64     event_id;
  89         char    name[MAX_EVENT_NAME];
  90 };
  91
  92 static int event_count;
  93 static struct perf_trace_event_type *events;
  94
  95 void perf_header__push_event(u64 id, const char *name)
  96 {
  97         if (strlen(name) > MAX_EVENT_NAME)
  98                 pr_warning("Event %s will be truncated\n", name);
  99
 100         if (!events) {
 101                 events = malloc(sizeof(struct perf_trace_event_type));
 102                 if (!events)
 103                         die("nomem");
 104         } else {
 105                 events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
 106                 if (!events)
 107                         die("nomem");
 108         }
 109         memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
 110         events[event_count].event_id = id;
 111         strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
 112         event_count++;
 113 }
 114
 115 char *perf_header__find_event(u64 id)
 116 {
 117         int i;
 118         for (i = 0 ; i < event_count; i++) {
 119                 if (events[i].event_id == id)
 120                         return events[i].name;
 121         }
 122         return NULL;
 123 }
 124
 125 static const char *__perf_magic = "PERFFILE";
 126
 127 #define PERF_MAGIC      (*(u64 *)__perf_magic)
 128
 129 struct perf_file_section {
 130         u64 offset;
 131         u64 size;
 132 };
 133
 134 struct perf_file_attr {
 135         struct perf_event_attr  attr;
 136         struct perf_file_section        ids;
 137 };
 138
 139 struct perf_file_header {
 140         u64                             magic;
 141         u64                             size;
 142         u64                             attr_size;
 143         struct perf_file_section        attrs;
 144         struct perf_file_section        data;
 145         struct perf_file_section        event_types;
 146         DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
 147 };
 148
 149 void perf_header__feat_trace_info(struct perf_header *header)
 150 {
 151         set_bit(HEADER_TRACE_INFO, header->adds_features);
 152 }
 153
 154 void perf_header__set_feat(struct perf_header *self, int feat)
 155 {
 156         set_bit(feat, self->adds_features);
 157 }
 158
 159 bool perf_header__has_feat(const struct perf_header *self, int feat)
 160 {
 161         return test_bit(feat, self->adds_features);
 162 }
 163
 164 static void do_write(int fd, void *buf, size_t size)
 165 {
 166         while (size) {
 167                 int ret = write(fd, buf, size);
 168
 169                 if (ret < 0)
 170                         die("failed to write");
 171
 172                 size -= ret;
 173                 buf += ret;
 174         }
 175 }
 176
 177 static bool write_buildid_table(int fd)
 178 {
 179         struct dso *pos;
 180         bool have_buildid = false;
 181
 182         list_for_each_entry(pos, &dsos, node) {
 183                 struct build_id_event b;
 184                 size_t len;
 185
 186                 if (filename__read_build_id(pos->long_name,
 187                                             &b.build_id,
 188                                             sizeof(b.build_id)) < 0)
 189                         continue;
 190                 have_buildid = true;
 191                 memset(&b.header, 0, sizeof(b.header));
 192                 len = strlen(pos->long_name) + 1;
 193                 len = ALIGN(len, 64);
 194                 b.header.size = sizeof(b) + len;
 195                 do_write(fd, &b, sizeof(b));
 196                 do_write(fd, pos->long_name, len);
 197         }
 198
 199         return have_buildid;
 200 }
 201
 202 static void
 203 perf_header__adds_write(struct perf_header *self, int fd, bool at_exit)
 204 {
 205         struct perf_file_section trace_sec;
 206         u64 cur_offset = lseek(fd, 0, SEEK_CUR);
 207         unsigned long *feat_mask = self->adds_features;
 208
 209         if (test_bit(HEADER_TRACE_INFO, feat_mask)) {
 210                 /* Write trace info */
 211                 trace_sec.offset = lseek(fd, sizeof(trace_sec), SEEK_CUR);
 212                 read_tracing_data(fd, attrs, nr_counters);
 213                 trace_sec.size = lseek(fd, 0, SEEK_CUR) - trace_sec.offset;
 214
 215                 /* Write trace info headers */
 216                 lseek(fd, cur_offset, SEEK_SET);
 217                 do_write(fd, &trace_sec, sizeof(trace_sec));
 218
 219                 /*
 220                  * Update cur_offset. So that other (future)
 221                  * features can set their own infos in this place. But if we are
 222                  * the only feature, at least that seeks to the place the data
 223                  * should begin.
 224                  */
 225                 cur_offset = lseek(fd, trace_sec.offset + trace_sec.size, SEEK_SET);
 226         }
 227
 228         if (at_exit) {
 229                 lseek(fd, self->data_offset + self->data_size, SEEK_SET);
 230                 if (write_buildid_table(fd))
 231                         perf_header__set_feat(self, HEADER_BUILD_ID);
 232                 lseek(fd, cur_offset, SEEK_SET);
 233         }
 234 };
 235
 236 void perf_header__write(struct perf_header *self, int fd, bool at_exit)
 237 {
 238         struct perf_file_header f_header;
 239         struct perf_file_attr   f_attr;
 240         struct perf_header_attr *attr;
 241         int i;
 242
 243         lseek(fd, sizeof(f_header), SEEK_SET);
 244
 245
 246         for (i = 0; i < self->attrs; i++) {
 247                 attr = self->attr[i];
 248
 249                 attr->id_offset = lseek(fd, 0, SEEK_CUR);
 250                 do_write(fd, attr->id, attr->ids * sizeof(u64));
 251         }
 252
 253
 254         self->attr_offset = lseek(fd, 0, SEEK_CUR);
 255
 256         for (i = 0; i < self->attrs; i++) {
 257                 attr = self->attr[i];
 258
 259                 f_attr = (struct perf_file_attr){
 260                         .attr = attr->attr,
 261                         .ids  = {
 262                                 .offset = attr->id_offset,
 263                                 .size   = attr->ids * sizeof(u64),
 264                         }
 265                 };
 266                 do_write(fd, &f_attr, sizeof(f_attr));
 267         }
 268
 269         self->event_offset = lseek(fd, 0, SEEK_CUR);
 270         self->event_size = event_count * sizeof(struct perf_trace_event_type);
 271         if (events)
 272                 do_write(fd, events, self->event_size);
 273
 274         perf_header__adds_write(self, fd, at_exit);
 275
 276         self->data_offset = lseek(fd, 0, SEEK_CUR);
 277
 278         f_header = (struct perf_file_header){
 279                 .magic     = PERF_MAGIC,
 280                 .size      = sizeof(f_header),
 281                 .attr_size = sizeof(f_attr),
 282                 .attrs = {
 283                         .offset = self->attr_offset,
 284                         .size   = self->attrs * sizeof(f_attr),
 285                 },
 286                 .data = {
 287                         .offset = self->data_offset,
 288                         .size   = self->data_size,
 289                 },
 290                 .event_types = {
 291                         .offset = self->event_offset,
 292                         .size   = self->event_size,
 293                 },
 294         };
 295
 296         memcpy(&f_header.adds_features, &self->adds_features, sizeof(self->adds_features));
 297
 298         lseek(fd, 0, SEEK_SET);
 299         do_write(fd, &f_header, sizeof(f_header));
 300         lseek(fd, self->data_offset + self->data_size, SEEK_SET);
 301
 302         self->frozen = 1;
 303 }
 304
 305 static void do_read(int fd, void *buf, size_t size)
 306 {
 307         while (size) {
 308                 int ret = read(fd, buf, size);
 309
 310                 if (ret < 0)
 311                         die("failed to read");
 312                 if (ret == 0)
 313                         die("failed to read: missing data");
 314
 315                 size -= ret;
 316                 buf += ret;
 317         }
 318 }
 319
 320 static void perf_header__adds_read(struct perf_header *self, int fd)
 321 {
 322         const unsigned long *feat_mask = self->adds_features;
 323
 324         if (test_bit(HEADER_TRACE_INFO, feat_mask)) {
 325                 struct perf_file_section trace_sec;
 326
 327                 do_read(fd, &trace_sec, sizeof(trace_sec));
 328                 lseek(fd, trace_sec.offset, SEEK_SET);
 329                 trace_report(fd);
 330                 lseek(fd, trace_sec.offset + trace_sec.size, SEEK_SET);
 331         }
 332 };
 333
 334 struct perf_header *perf_header__read(int fd)
 335 {
 336         struct perf_header      *self = perf_header__new();
 337         struct perf_file_header f_header;
 338         struct perf_file_attr   f_attr;
 339         u64                     f_id;
 340
 341         int nr_attrs, nr_ids, i, j;
 342
 343         lseek(fd, 0, SEEK_SET);
 344         do_read(fd, &f_header, sizeof(f_header));
 345
 346         if (f_header.magic      != PERF_MAGIC           ||
 347             f_header.attr_size  != sizeof(f_attr))
 348                 die("incompatible file format");
 349
 350         if (f_header.size != sizeof(f_header)) {
 351                 /* Support the previous format */
 352                 if (f_header.size == offsetof(typeof(f_header), adds_features))
 353                         bitmap_zero(f_header.adds_features, HEADER_FEAT_BITS);
 354                 else
 355                         die("incompatible file format");
 356         }
 357         nr_attrs = f_header.attrs.size / sizeof(f_attr);
 358         lseek(fd, f_header.attrs.offset, SEEK_SET);
 359
 360         for (i = 0; i < nr_attrs; i++) {
 361                 struct perf_header_attr *attr;
 362                 off_t tmp;
 363
 364                 do_read(fd, &f_attr, sizeof(f_attr));
 365                 tmp = lseek(fd, 0, SEEK_CUR);
 366
 367                 attr = perf_header_attr__new(&f_attr.attr);
 368
 369                 nr_ids = f_attr.ids.size / sizeof(u64);
 370                 lseek(fd, f_attr.ids.offset, SEEK_SET);
 371
 372                 for (j = 0; j < nr_ids; j++) {
 373                         do_read(fd, &f_id, sizeof(f_id));
 374
 375                         perf_header_attr__add_id(attr, f_id);
 376                 }
 377                 perf_header__add_attr(self, attr);
 378                 lseek(fd, tmp, SEEK_SET);
 379         }
 380
 381         if (f_header.event_types.size) {
 382                 lseek(fd, f_header.event_types.offset, SEEK_SET);
 383                 events = malloc(f_header.event_types.size);
 384                 if (!events)
 385                         die("nomem");
 386                 do_read(fd, events, f_header.event_types.size);
 387                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
 388         }
 389
 390         memcpy(&self->adds_features, &f_header.adds_features, sizeof(f_header.adds_features));
 391
 392         perf_header__adds_read(self, fd);
 393
 394         self->event_offset = f_header.event_types.offset;
 395         self->event_size   = f_header.event_types.size;
 396
 397         self->data_offset = f_header.data.offset;
 398         self->data_size   = f_header.data.size;
 399
 400         lseek(fd, self->data_offset, SEEK_SET);
 401
 402         self->frozen = 1;
 403
 404         return self;
 405 }
 406
 407 u64 perf_header__sample_type(struct perf_header *header)
 408 {
 409         u64 type = 0;
 410         int i;
 411
 412         for (i = 0; i < header->attrs; i++) {
 413                 struct perf_header_attr *attr = header->attr[i];
 414
 415                 if (!type)
 416                         type = attr->attr.sample_type;
 417                 else if (type != attr->attr.sample_type)
 418                         die("non matching sample_type");
 419         }
 420
 421         return type;
 422 }
 423
 424 struct perf_event_attr *
 425 perf_header__find_attr(u64 id, struct perf_header *header)
 426 {
 427         int i;
 428
 429         for (i = 0; i < header->attrs; i++) {
 430                 struct perf_header_attr *attr = header->attr[i];
 431                 int j;
 432
 433                 for (j = 0; j < attr->ids; j++) {
 434                         if (attr->id[j] == id)
 435                                 return &attr->attr;
 436                 }
 437         }
 438
 439         return NULL;
 440 }