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 9 /* 10 * Create new perf.data header attribute: 11 */ 12 struct perf_header_attr *perf_header_attr__new(struct perf_counter_attr *attr) 13 { 14 struct perf_header_attr *self = malloc(sizeof(*self)); 15 16 if (!self) 17 die("nomem"); 18 19 self->attr = *attr; 20 self->ids = 0; 21 self->size = 1; 22 self->id = malloc(sizeof(u64)); 23 24 if (!self->id) 25 die("nomem"); 26 27 return self; 28 } 29 30 void perf_header_attr__add_id(struct perf_header_attr *self, u64 id) 31 { 32 int pos = self->ids; 33 34 self->ids++; 35 if (self->ids > self->size) { 36 self->size *= 2; 37 self->id = realloc(self->id, self->size * sizeof(u64)); 38 if (!self->id) 39 die("nomem"); 40 } 41 self->id[pos] = id; 42 } 43 44 /* 45 * Create new perf.data header: 46 */ 47 struct perf_header *perf_header__new(void) 48 { 49 struct perf_header *self = malloc(sizeof(*self)); 50 51 if (!self) 52 die("nomem"); 53 54 self->frozen = 0; 55 56 self->attrs = 0; 57 self->size = 1; 58 self->attr = malloc(sizeof(void *)); 59 60 if (!self->attr) 61 die("nomem"); 62 63 self->data_offset = 0; 64 self->data_size = 0; 65 66 return self; 67 } 68 69 void perf_header__add_attr(struct perf_header *self, 70 struct perf_header_attr *attr) 71 { 72 int pos = self->attrs; 73 74 if (self->frozen) 75 die("frozen"); 76 77 self->attrs++; 78 if (self->attrs > self->size) { 79 self->size *= 2; 80 self->attr = realloc(self->attr, self->size * sizeof(void *)); 81 if (!self->attr) 82 die("nomem"); 83 } 84 self->attr[pos] = attr; 85 } 86 87 #define MAX_EVENT_NAME 64 88 89 struct perf_trace_event_type { 90 u64 event_id; 91 char name[MAX_EVENT_NAME]; 92 }; 93 94 static int event_count; 95 static struct perf_trace_event_type *events; 96 97 void perf_header__push_event(u64 id, const char *name) 98 { 99 if (strlen(name) > MAX_EVENT_NAME) 100 printf("Event %s will be truncated\n", name); 101 102 if (!events) { 103 events = malloc(sizeof(struct perf_trace_event_type)); 104 if (!events) 105 die("nomem"); 106 } else { 107 events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type)); 108 if (!events) 109 die("nomem"); 110 } 111 memset(&events[event_count], 0, sizeof(struct perf_trace_event_type)); 112 events[event_count].event_id = id; 113 strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1); 114 event_count++; 115 } 116 117 char *perf_header__find_event(u64 id) 118 { 119 int i; 120 for (i = 0 ; i < event_count; i++) { 121 if (events[i].event_id == id) 122 return events[i].name; 123 } 124 return NULL; 125 } 126 127 static const char *__perf_magic = "PERFFILE"; 128 129 #define PERF_MAGIC (*(u64 *)__perf_magic) 130 131 struct perf_file_section { 132 u64 offset; 133 u64 size; 134 }; 135 136 struct perf_file_attr { 137 struct perf_counter_attr attr; 138 struct perf_file_section ids; 139 }; 140 141 struct perf_file_header { 142 u64 magic; 143 u64 size; 144 u64 attr_size; 145 struct perf_file_section attrs; 146 struct perf_file_section data; 147 struct perf_file_section event_types; 148 }; 149 150 static void do_write(int fd, void *buf, size_t size) 151 { 152 while (size) { 153 int ret = write(fd, buf, size); 154 155 if (ret < 0) 156 die("failed to write"); 157 158 size -= ret; 159 buf += ret; 160 } 161 } 162 163 void perf_header__write(struct perf_header *self, int fd) 164 { 165 struct perf_file_header f_header; 166 struct perf_file_attr f_attr; 167 struct perf_header_attr *attr; 168 int i; 169 170 lseek(fd, sizeof(f_header), SEEK_SET); 171 172 173 for (i = 0; i < self->attrs; i++) { 174 attr = self->attr[i]; 175 176 attr->id_offset = lseek(fd, 0, SEEK_CUR); 177 do_write(fd, attr->id, attr->ids * sizeof(u64)); 178 } 179 180 181 self->attr_offset = lseek(fd, 0, SEEK_CUR); 182 183 for (i = 0; i < self->attrs; i++) { 184 attr = self->attr[i]; 185 186 f_attr = (struct perf_file_attr){ 187 .attr = attr->attr, 188 .ids = { 189 .offset = attr->id_offset, 190 .size = attr->ids * sizeof(u64), 191 } 192 }; 193 do_write(fd, &f_attr, sizeof(f_attr)); 194 } 195 196 self->event_offset = lseek(fd, 0, SEEK_CUR); 197 self->event_size = event_count * sizeof(struct perf_trace_event_type); 198 if (events) 199 do_write(fd, events, self->event_size); 200 201 202 self->data_offset = lseek(fd, 0, SEEK_CUR); 203 204 f_header = (struct perf_file_header){ 205 .magic = PERF_MAGIC, 206 .size = sizeof(f_header), 207 .attr_size = sizeof(f_attr), 208 .attrs = { 209 .offset = self->attr_offset, 210 .size = self->attrs * sizeof(f_attr), 211 }, 212 .data = { 213 .offset = self->data_offset, 214 .size = self->data_size, 215 }, 216 .event_types = { 217 .offset = self->event_offset, 218 .size = self->event_size, 219 }, 220 }; 221 222 lseek(fd, 0, SEEK_SET); 223 do_write(fd, &f_header, sizeof(f_header)); 224 lseek(fd, self->data_offset + self->data_size, SEEK_SET); 225 226 self->frozen = 1; 227 } 228 229 static void do_read(int fd, void *buf, size_t size) 230 { 231 while (size) { 232 int ret = read(fd, buf, size); 233 234 if (ret < 0) 235 die("failed to read"); 236 if (ret == 0) 237 die("failed to read: missing data"); 238 239 size -= ret; 240 buf += ret; 241 } 242 } 243 244 struct perf_header *perf_header__read(int fd) 245 { 246 struct perf_header *self = perf_header__new(); 247 struct perf_file_header f_header; 248 struct perf_file_attr f_attr; 249 u64 f_id; 250 251 int nr_attrs, nr_ids, i, j; 252 253 lseek(fd, 0, SEEK_SET); 254 do_read(fd, &f_header, sizeof(f_header)); 255 256 if (f_header.magic != PERF_MAGIC || 257 f_header.size != sizeof(f_header) || 258 f_header.attr_size != sizeof(f_attr)) 259 die("incompatible file format"); 260 261 nr_attrs = f_header.attrs.size / sizeof(f_attr); 262 lseek(fd, f_header.attrs.offset, SEEK_SET); 263 264 for (i = 0; i < nr_attrs; i++) { 265 struct perf_header_attr *attr; 266 off_t tmp; 267 268 do_read(fd, &f_attr, sizeof(f_attr)); 269 tmp = lseek(fd, 0, SEEK_CUR); 270 271 attr = perf_header_attr__new(&f_attr.attr); 272 273 nr_ids = f_attr.ids.size / sizeof(u64); 274 lseek(fd, f_attr.ids.offset, SEEK_SET); 275 276 for (j = 0; j < nr_ids; j++) { 277 do_read(fd, &f_id, sizeof(f_id)); 278 279 perf_header_attr__add_id(attr, f_id); 280 } 281 perf_header__add_attr(self, attr); 282 lseek(fd, tmp, SEEK_SET); 283 } 284 285 if (f_header.event_types.size) { 286 lseek(fd, f_header.event_types.offset, SEEK_SET); 287 events = malloc(f_header.event_types.size); 288 if (!events) 289 die("nomem"); 290 do_read(fd, events, f_header.event_types.size); 291 event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type); 292 } 293 self->event_offset = f_header.event_types.offset; 294 self->event_size = f_header.event_types.size; 295 296 self->data_offset = f_header.data.offset; 297 self->data_size = f_header.data.size; 298 299 lseek(fd, self->data_offset, SEEK_SET); 300 301 self->frozen = 1; 302 303 return self; 304 } 305 306 u64 perf_header__sample_type(struct perf_header *header) 307 { 308 u64 type = 0; 309 int i; 310 311 for (i = 0; i < header->attrs; i++) { 312 struct perf_header_attr *attr = header->attr[i]; 313 314 if (!type) 315 type = attr->attr.sample_type; 316 else if (type != attr->attr.sample_type) 317 die("non matching sample_type"); 318 } 319 320 return type; 321 } 322 323 struct perf_counter_attr * 324 perf_header__find_attr(u64 id, struct perf_header *header) 325 { 326 int i; 327 328 for (i = 0; i < header->attrs; i++) { 329 struct perf_header_attr *attr = header->attr[i]; 330 int j; 331 332 for (j = 0; j < attr->ids; j++) { 333 if (attr->id[j] == id) 334 return &attr->attr; 335 } 336 } 337 338 return NULL; 339 } 340