tools/perf/util/header.c

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