SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 void perf_header__set_feat(struct perf_header *self, int feat)
 153 {
 154         set_bit(feat, self->adds_features);
 155 }
 156
 157 bool perf_header__has_feat(const struct perf_header *self, int feat)
 158 {
 159         return test_bit(feat, self->adds_features);
 160 }
 161
 162 static void do_write(int fd, void *buf, size_t size)
 163 {
 164         while (size) {
 165                 int ret = write(fd, buf, size);
 166
 167                 if (ret < 0)
 168                         die("failed to write");
 169
 170                 size -= ret;
 171                 buf += ret;
 172         }
 173 }
 174
 175 static void perf_header__adds_write(struct perf_header *self, int fd)
 176 {
 177         struct perf_file_section trace_sec;
 178         u64 cur_offset = lseek(fd, 0, SEEK_CUR);
 179         unsigned long *feat_mask = self->adds_features;
 180
 181         if (test_bit(HEADER_TRACE_INFO, feat_mask)) {
 182                 /* Write trace info */
 183                 trace_sec.offset = lseek(fd, sizeof(trace_sec), SEEK_CUR);
 184                 read_tracing_data(fd, attrs, nr_counters);
 185                 trace_sec.size = lseek(fd, 0, SEEK_CUR) - trace_sec.offset;
 186
 187                 /* Write trace info headers */
 188                 lseek(fd, cur_offset, SEEK_SET);
 189                 do_write(fd, &trace_sec, sizeof(trace_sec));
 190
 191                 /*
 192                  * Update cur_offset. So that other (future)
 193                  * features can set their own infos in this place. But if we are
 194                  * the only feature, at least that seeks to the place the data
 195                  * should begin.
 196                  */
 197                 cur_offset = lseek(fd, trace_sec.offset + trace_sec.size, SEEK_SET);
 198         }
 199 };
 200
 201 void perf_header__write(struct perf_header *self, int fd)
 202 {
 203         struct perf_file_header f_header;
 204         struct perf_file_attr   f_attr;
 205         struct perf_header_attr *attr;
 206         int i;
 207
 208         lseek(fd, sizeof(f_header), SEEK_SET);
 209
 210
 211         for (i = 0; i < self->attrs; i++) {
 212                 attr = self->attr[i];
 213
 214                 attr->id_offset = lseek(fd, 0, SEEK_CUR);
 215                 do_write(fd, attr->id, attr->ids * sizeof(u64));
 216         }
 217
 218
 219         self->attr_offset = lseek(fd, 0, SEEK_CUR);
 220
 221         for (i = 0; i < self->attrs; i++) {
 222                 attr = self->attr[i];
 223
 224                 f_attr = (struct perf_file_attr){
 225                         .attr = attr->attr,
 226                         .ids  = {
 227                                 .offset = attr->id_offset,
 228                                 .size   = attr->ids * sizeof(u64),
 229                         }
 230                 };
 231                 do_write(fd, &f_attr, sizeof(f_attr));
 232         }
 233
 234         self->event_offset = lseek(fd, 0, SEEK_CUR);
 235         self->event_size = event_count * sizeof(struct perf_trace_event_type);
 236         if (events)
 237                 do_write(fd, events, self->event_size);
 238
 239         perf_header__adds_write(self, fd);
 240
 241         self->data_offset = lseek(fd, 0, SEEK_CUR);
 242
 243         f_header = (struct perf_file_header){
 244                 .magic     = PERF_MAGIC,
 245                 .size      = sizeof(f_header),
 246                 .attr_size = sizeof(f_attr),
 247                 .attrs = {
 248                         .offset = self->attr_offset,
 249                         .size   = self->attrs * sizeof(f_attr),
 250                 },
 251                 .data = {
 252                         .offset = self->data_offset,
 253                         .size   = self->data_size,
 254                 },
 255                 .event_types = {
 256                         .offset = self->event_offset,
 257                         .size   = self->event_size,
 258                 },
 259         };
 260
 261         memcpy(&f_header.adds_features, &self->adds_features, sizeof(self->adds_features));
 262
 263         lseek(fd, 0, SEEK_SET);
 264         do_write(fd, &f_header, sizeof(f_header));
 265         lseek(fd, self->data_offset + self->data_size, SEEK_SET);
 266
 267         self->frozen = 1;
 268 }
 269
 270 static void do_read(int fd, void *buf, size_t size)
 271 {
 272         while (size) {
 273                 int ret = read(fd, buf, size);
 274
 275                 if (ret < 0)
 276                         die("failed to read");
 277                 if (ret == 0)
 278                         die("failed to read: missing data");
 279
 280                 size -= ret;
 281                 buf += ret;
 282         }
 283 }
 284
 285 static void perf_header__adds_read(struct perf_header *self, int fd)
 286 {
 287         const unsigned long *feat_mask = self->adds_features;
 288
 289         if (test_bit(HEADER_TRACE_INFO, feat_mask)) {
 290                 struct perf_file_section trace_sec;
 291
 292                 do_read(fd, &trace_sec, sizeof(trace_sec));
 293                 lseek(fd, trace_sec.offset, SEEK_SET);
 294                 trace_report(fd);
 295                 lseek(fd, trace_sec.offset + trace_sec.size, SEEK_SET);
 296         }
 297 };
 298
 299 struct perf_header *perf_header__read(int fd)
 300 {
 301         struct perf_header      *self = perf_header__new();
 302         struct perf_file_header f_header;
 303         struct perf_file_attr   f_attr;
 304         u64                     f_id;
 305
 306         int nr_attrs, nr_ids, i, j;
 307
 308         lseek(fd, 0, SEEK_SET);
 309         do_read(fd, &f_header, sizeof(f_header));
 310
 311         if (f_header.magic      != PERF_MAGIC           ||
 312             f_header.attr_size  != sizeof(f_attr))
 313                 die("incompatible file format");
 314
 315         if (f_header.size != sizeof(f_header)) {
 316                 /* Support the previous format */
 317                 if (f_header.size == offsetof(typeof(f_header), adds_features))
 318                         bitmap_zero(f_header.adds_features, HEADER_FEAT_BITS);
 319                 else
 320                         die("incompatible file format");
 321         }
 322         nr_attrs = f_header.attrs.size / sizeof(f_attr);
 323         lseek(fd, f_header.attrs.offset, SEEK_SET);
 324
 325         for (i = 0; i < nr_attrs; i++) {
 326                 struct perf_header_attr *attr;
 327                 off_t tmp;
 328
 329                 do_read(fd, &f_attr, sizeof(f_attr));
 330                 tmp = lseek(fd, 0, SEEK_CUR);
 331
 332                 attr = perf_header_attr__new(&f_attr.attr);
 333
 334                 nr_ids = f_attr.ids.size / sizeof(u64);
 335                 lseek(fd, f_attr.ids.offset, SEEK_SET);
 336
 337                 for (j = 0; j < nr_ids; j++) {
 338                         do_read(fd, &f_id, sizeof(f_id));
 339
 340                         perf_header_attr__add_id(attr, f_id);
 341                 }
 342                 perf_header__add_attr(self, attr);
 343                 lseek(fd, tmp, SEEK_SET);
 344         }
 345
 346         if (f_header.event_types.size) {
 347                 lseek(fd, f_header.event_types.offset, SEEK_SET);
 348                 events = malloc(f_header.event_types.size);
 349                 if (!events)
 350                         die("nomem");
 351                 do_read(fd, events, f_header.event_types.size);
 352                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
 353         }
 354
 355         memcpy(&self->adds_features, &f_header.adds_features, sizeof(f_header.adds_features));
 356
 357         perf_header__adds_read(self, fd);
 358
 359         self->event_offset = f_header.event_types.offset;
 360         self->event_size   = f_header.event_types.size;
 361
 362         self->data_offset = f_header.data.offset;
 363         self->data_size   = f_header.data.size;
 364
 365         lseek(fd, self->data_offset, SEEK_SET);
 366
 367         self->frozen = 1;
 368
 369         return self;
 370 }
 371
 372 u64 perf_header__sample_type(struct perf_header *header)
 373 {
 374         u64 type = 0;
 375         int i;
 376
 377         for (i = 0; i < header->attrs; i++) {
 378                 struct perf_header_attr *attr = header->attr[i];
 379
 380                 if (!type)
 381                         type = attr->attr.sample_type;
 382                 else if (type != attr->attr.sample_type)
 383                         die("non matching sample_type");
 384         }
 385
 386         return type;
 387 }
 388
 389 struct perf_event_attr *
 390 perf_header__find_attr(u64 id, struct perf_header *header)
 391 {
 392         int i;
 393
 394         for (i = 0; i < header->attrs; i++) {
 395                 struct perf_header_attr *attr = header->attr[i];
 396                 int j;
 397
 398                 for (j = 0; j < attr->ids; j++) {
 399                         if (attr->id[j] == id)
 400                                 return &attr->attr;
 401                 }
 402         }
 403
 404         return NULL;
 405 }