1 /* 2 * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com> 3 * 4 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; version 2 of the License (not later!) 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 * 19 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 20 */ 21 #define _LARGEFILE64_SOURCE 22 23 #include <dirent.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <getopt.h> 28 #include <stdarg.h> 29 #include <sys/types.h> 30 #include <sys/stat.h> 31 #include <sys/wait.h> 32 #include <sys/mman.h> 33 #include <pthread.h> 34 #include <fcntl.h> 35 #include <unistd.h> 36 #include <ctype.h> 37 #include <errno.h> 38 39 #include "../perf.h" 40 #include "util.h" 41 #include "trace-event.h" 42 43 static int input_fd; 44 45 static int read_page; 46 47 int file_bigendian; 48 int host_bigendian; 49 static int long_size; 50 51 static unsigned long page_size; 52 53 static int read_or_die(void *data, int size) 54 { 55 int r; 56 57 r = read(input_fd, data, size); 58 if (r != size) 59 die("reading input file (size expected=%d received=%d)", 60 size, r); 61 return r; 62 } 63 64 static unsigned int read4(void) 65 { 66 unsigned int data; 67 68 read_or_die(&data, 4); 69 return __data2host4(data); 70 } 71 72 static unsigned long long read8(void) 73 { 74 unsigned long long data; 75 76 read_or_die(&data, 8); 77 return __data2host8(data); 78 } 79 80 static char *read_string(void) 81 { 82 char buf[BUFSIZ]; 83 char *str = NULL; 84 int size = 0; 85 int i; 86 s64 r; 87 88 for (;;) { 89 r = read(input_fd, buf, BUFSIZ); 90 if (r < 0) 91 die("reading input file"); 92 93 if (!r) 94 die("no data"); 95 96 for (i = 0; i < r; i++) { 97 if (!buf[i]) 98 break; 99 } 100 if (i < r) 101 break; 102 103 if (str) { 104 size += BUFSIZ; 105 str = realloc(str, size); 106 if (!str) 107 die("malloc of size %d", size); 108 memcpy(str + (size - BUFSIZ), buf, BUFSIZ); 109 } else { 110 size = BUFSIZ; 111 str = malloc_or_die(size); 112 memcpy(str, buf, size); 113 } 114 } 115 116 /* trailing \0: */ 117 i++; 118 119 /* move the file descriptor to the end of the string */ 120 r = lseek64(input_fd, -(r - i), SEEK_CUR); 121 if (r < 0) 122 die("lseek"); 123 124 if (str) { 125 size += i; 126 str = realloc(str, size); 127 if (!str) 128 die("malloc of size %d", size); 129 memcpy(str + (size - i), buf, i); 130 } else { 131 size = i; 132 str = malloc_or_die(i); 133 memcpy(str, buf, i); 134 } 135 136 return str; 137 } 138 139 static void read_proc_kallsyms(void) 140 { 141 unsigned int size; 142 char *buf; 143 144 size = read4(); 145 if (!size) 146 return; 147 148 buf = malloc_or_die(size + 1); 149 read_or_die(buf, size); 150 buf[size] = '\0'; 151 152 parse_proc_kallsyms(buf, size); 153 154 free(buf); 155 } 156 157 static void read_ftrace_printk(void) 158 { 159 unsigned int size; 160 char *buf; 161 162 size = read4(); 163 if (!size) 164 return; 165 166 buf = malloc_or_die(size); 167 read_or_die(buf, size); 168 169 parse_ftrace_printk(buf, size); 170 171 free(buf); 172 } 173 174 static void read_header_files(void) 175 { 176 unsigned long long size; 177 char *header_page; 178 char *header_event; 179 char buf[BUFSIZ]; 180 181 read_or_die(buf, 12); 182 183 if (memcmp(buf, "header_page", 12) != 0) 184 die("did not read header page"); 185 186 size = read8(); 187 header_page = malloc_or_die(size); 188 read_or_die(header_page, size); 189 parse_header_page(header_page, size); 190 free(header_page); 191 192 /* 193 * The size field in the page is of type long, 194 * use that instead, since it represents the kernel. 195 */ 196 long_size = header_page_size_size; 197 198 read_or_die(buf, 13); 199 if (memcmp(buf, "header_event", 13) != 0) 200 die("did not read header event"); 201 202 size = read8(); 203 header_event = malloc_or_die(size); 204 read_or_die(header_event, size); 205 free(header_event); 206 } 207 208 static void read_ftrace_file(unsigned long long size) 209 { 210 char *buf; 211 212 buf = malloc_or_die(size); 213 read_or_die(buf, size); 214 parse_ftrace_file(buf, size); 215 free(buf); 216 } 217 218 static void read_event_file(char *sys, unsigned long long size) 219 { 220 char *buf; 221 222 buf = malloc_or_die(size); 223 read_or_die(buf, size); 224 parse_event_file(buf, size, sys); 225 free(buf); 226 } 227 228 static void read_ftrace_files(void) 229 { 230 unsigned long long size; 231 int count; 232 int i; 233 234 count = read4(); 235 236 for (i = 0; i < count; i++) { 237 size = read8(); 238 read_ftrace_file(size); 239 } 240 } 241 242 static void read_event_files(void) 243 { 244 unsigned long long size; 245 char *sys; 246 int systems; 247 int count; 248 int i,x; 249 250 systems = read4(); 251 252 for (i = 0; i < systems; i++) { 253 sys = read_string(); 254 255 count = read4(); 256 for (x=0; x < count; x++) { 257 size = read8(); 258 read_event_file(sys, size); 259 } 260 } 261 } 262 263 struct cpu_data { 264 unsigned long long offset; 265 unsigned long long size; 266 unsigned long long timestamp; 267 struct record *next; 268 char *page; 269 int cpu; 270 int index; 271 int page_size; 272 }; 273 274 static struct cpu_data *cpu_data; 275 276 static void update_cpu_data_index(int cpu) 277 { 278 cpu_data[cpu].offset += page_size; 279 cpu_data[cpu].size -= page_size; 280 cpu_data[cpu].index = 0; 281 } 282 283 static void get_next_page(int cpu) 284 { 285 off64_t save_seek; 286 off64_t ret; 287 288 if (!cpu_data[cpu].page) 289 return; 290 291 if (read_page) { 292 if (cpu_data[cpu].size <= page_size) { 293 free(cpu_data[cpu].page); 294 cpu_data[cpu].page = NULL; 295 return; 296 } 297 298 update_cpu_data_index(cpu); 299 300 /* other parts of the code may expect the pointer to not move */ 301 save_seek = lseek64(input_fd, 0, SEEK_CUR); 302 303 ret = lseek64(input_fd, cpu_data[cpu].offset, SEEK_SET); 304 if (ret < 0) 305 die("failed to lseek"); 306 ret = read(input_fd, cpu_data[cpu].page, page_size); 307 if (ret < 0) 308 die("failed to read page"); 309 310 /* reset the file pointer back */ 311 lseek64(input_fd, save_seek, SEEK_SET); 312 313 return; 314 } 315 316 munmap(cpu_data[cpu].page, page_size); 317 cpu_data[cpu].page = NULL; 318 319 if (cpu_data[cpu].size <= page_size) 320 return; 321 322 update_cpu_data_index(cpu); 323 324 cpu_data[cpu].page = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE, 325 input_fd, cpu_data[cpu].offset); 326 if (cpu_data[cpu].page == MAP_FAILED) 327 die("failed to mmap cpu %d at offset 0x%llx", 328 cpu, cpu_data[cpu].offset); 329 } 330 331 static unsigned int type_len4host(unsigned int type_len_ts) 332 { 333 if (file_bigendian) 334 return (type_len_ts >> 27) & ((1 << 5) - 1); 335 else 336 return type_len_ts & ((1 << 5) - 1); 337 } 338 339 static unsigned int ts4host(unsigned int type_len_ts) 340 { 341 if (file_bigendian) 342 return type_len_ts & ((1 << 27) - 1); 343 else 344 return type_len_ts >> 5; 345 } 346 347 static int calc_index(void *ptr, int cpu) 348 { 349 return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page; 350 } 351 352 struct record *trace_peek_data(int cpu) 353 { 354 struct record *data; 355 void *page = cpu_data[cpu].page; 356 int idx = cpu_data[cpu].index; 357 void *ptr = page + idx; 358 unsigned long long extend; 359 unsigned int type_len_ts; 360 unsigned int type_len; 361 unsigned int delta; 362 unsigned int length = 0; 363 364 if (cpu_data[cpu].next) 365 return cpu_data[cpu].next; 366 367 if (!page) 368 return NULL; 369 370 if (!idx) { 371 /* FIXME: handle header page */ 372 if (header_page_ts_size != 8) 373 die("expected a long long type for timestamp"); 374 cpu_data[cpu].timestamp = data2host8(ptr); 375 ptr += 8; 376 switch (header_page_size_size) { 377 case 4: 378 cpu_data[cpu].page_size = data2host4(ptr); 379 ptr += 4; 380 break; 381 case 8: 382 cpu_data[cpu].page_size = data2host8(ptr); 383 ptr += 8; 384 break; 385 default: 386 die("bad long size"); 387 } 388 ptr = cpu_data[cpu].page + header_page_data_offset; 389 } 390 391 read_again: 392 idx = calc_index(ptr, cpu); 393 394 if (idx >= cpu_data[cpu].page_size) { 395 get_next_page(cpu); 396 return trace_peek_data(cpu); 397 } 398 399 type_len_ts = data2host4(ptr); 400 ptr += 4; 401 402 type_len = type_len4host(type_len_ts); 403 delta = ts4host(type_len_ts); 404 405 switch (type_len) { 406 case RINGBUF_TYPE_PADDING: 407 if (!delta) 408 die("error, hit unexpected end of page"); 409 length = data2host4(ptr); 410 ptr += 4; 411 length *= 4; 412 ptr += length; 413 goto read_again; 414 415 case RINGBUF_TYPE_TIME_EXTEND: 416 extend = data2host4(ptr); 417 ptr += 4; 418 extend <<= TS_SHIFT; 419 extend += delta; 420 cpu_data[cpu].timestamp += extend; 421 goto read_again; 422 423 case RINGBUF_TYPE_TIME_STAMP: 424 ptr += 12; 425 break; 426 case 0: 427 length = data2host4(ptr); 428 ptr += 4; 429 die("here! length=%d", length); 430 break; 431 default: 432 length = type_len * 4; 433 break; 434 } 435 436 cpu_data[cpu].timestamp += delta; 437 438 data = malloc_or_die(sizeof(*data)); 439 memset(data, 0, sizeof(*data)); 440 441 data->ts = cpu_data[cpu].timestamp; 442 data->size = length; 443 data->data = ptr; 444 ptr += length; 445 446 cpu_data[cpu].index = calc_index(ptr, cpu); 447 cpu_data[cpu].next = data; 448 449 return data; 450 } 451 452 struct record *trace_read_data(int cpu) 453 { 454 struct record *data; 455 456 data = trace_peek_data(cpu); 457 cpu_data[cpu].next = NULL; 458 459 return data; 460 } 461 462 void trace_report(int fd) 463 { 464 char buf[BUFSIZ]; 465 char test[] = { 23, 8, 68 }; 466 char *version; 467 int show_version = 0; 468 int show_funcs = 0; 469 int show_printk = 0; 470 471 input_fd = fd; 472 473 read_or_die(buf, 3); 474 if (memcmp(buf, test, 3) != 0) 475 die("no trace data in the file"); 476 477 read_or_die(buf, 7); 478 if (memcmp(buf, "tracing", 7) != 0) 479 die("not a trace file (missing 'tracing' tag)"); 480 481 version = read_string(); 482 if (show_version) 483 printf("version = %s\n", version); 484 free(version); 485 486 read_or_die(buf, 1); 487 file_bigendian = buf[0]; 488 host_bigendian = bigendian(); 489 490 read_or_die(buf, 1); 491 long_size = buf[0]; 492 493 page_size = read4(); 494 495 read_header_files(); 496 497 read_ftrace_files(); 498 read_event_files(); 499 read_proc_kallsyms(); 500 read_ftrace_printk(); 501 502 if (show_funcs) { 503 print_funcs(); 504 return; 505 } 506 if (show_printk) { 507 print_printk(); 508 return; 509 } 510 511 return; 512 } 513