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 #include <dirent.h> 22 #include <stdio.h> 23 #include <stdlib.h> 24 #include <string.h> 25 #include <stdarg.h> 26 #include <sys/types.h> 27 #include <sys/stat.h> 28 #include <sys/wait.h> 29 #include <sys/mman.h> 30 #include <pthread.h> 31 #include <fcntl.h> 32 #include <unistd.h> 33 #include <errno.h> 34 35 #include "../perf.h" 36 #include "util.h" 37 #include "trace-event.h" 38 #include "debug.h" 39 40 static int input_fd; 41 42 static ssize_t trace_data_size; 43 static bool repipe; 44 45 static int __do_read(int fd, void *buf, int size) 46 { 47 int rsize = size; 48 49 while (size) { 50 int ret = read(fd, buf, size); 51 52 if (ret <= 0) 53 return -1; 54 55 if (repipe) { 56 int retw = write(STDOUT_FILENO, buf, ret); 57 58 if (retw <= 0 || retw != ret) { 59 pr_debug("repiping input file"); 60 return -1; 61 } 62 } 63 64 size -= ret; 65 buf += ret; 66 } 67 68 return rsize; 69 } 70 71 static int do_read(void *data, int size) 72 { 73 int r; 74 75 r = __do_read(input_fd, data, size); 76 if (r <= 0) { 77 pr_debug("reading input file (size expected=%d received=%d)", 78 size, r); 79 return -1; 80 } 81 82 trace_data_size += r; 83 84 return r; 85 } 86 87 /* If it fails, the next read will report it */ 88 static void skip(int size) 89 { 90 char buf[BUFSIZ]; 91 int r; 92 93 while (size) { 94 r = size > BUFSIZ ? BUFSIZ : size; 95 do_read(buf, r); 96 size -= r; 97 }; 98 } 99 100 static unsigned int read4(struct pevent *pevent) 101 { 102 unsigned int data; 103 104 if (do_read(&data, 4) < 0) 105 return 0; 106 return __data2host4(pevent, data); 107 } 108 109 static unsigned long long read8(struct pevent *pevent) 110 { 111 unsigned long long data; 112 113 if (do_read(&data, 8) < 0) 114 return 0; 115 return __data2host8(pevent, data); 116 } 117 118 static char *read_string(void) 119 { 120 char buf[BUFSIZ]; 121 char *str = NULL; 122 int size = 0; 123 off_t r; 124 char c; 125 126 for (;;) { 127 r = read(input_fd, &c, 1); 128 if (r < 0) { 129 pr_debug("reading input file"); 130 goto out; 131 } 132 133 if (!r) { 134 pr_debug("no data"); 135 goto out; 136 } 137 138 if (repipe) { 139 int retw = write(STDOUT_FILENO, &c, 1); 140 141 if (retw <= 0 || retw != r) { 142 pr_debug("repiping input file string"); 143 goto out; 144 } 145 } 146 147 buf[size++] = c; 148 149 if (!c) 150 break; 151 } 152 153 trace_data_size += size; 154 155 str = malloc(size); 156 if (str) 157 memcpy(str, buf, size); 158 out: 159 return str; 160 } 161 162 static int read_proc_kallsyms(struct pevent *pevent) 163 { 164 unsigned int size; 165 166 size = read4(pevent); 167 if (!size) 168 return 0; 169 /* 170 * Just skip it, now that we configure libtraceevent to use the 171 * tools/perf/ symbol resolver. 172 * 173 * We need to skip it so that we can continue parsing old perf.data 174 * files, that contains this /proc/kallsyms payload. 175 * 176 * Newer perf.data files will have just the 4-bytes zeros "kallsyms 177 * payload", so that older tools can continue reading it and interpret 178 * it as "no kallsyms payload is present". 179 */ 180 lseek(input_fd, size, SEEK_CUR); 181 trace_data_size += size; 182 return 0; 183 } 184 185 static int read_ftrace_printk(struct pevent *pevent) 186 { 187 unsigned int size; 188 char *buf; 189 190 /* it can have 0 size */ 191 size = read4(pevent); 192 if (!size) 193 return 0; 194 195 buf = malloc(size); 196 if (buf == NULL) 197 return -1; 198 199 if (do_read(buf, size) < 0) { 200 free(buf); 201 return -1; 202 } 203 204 parse_ftrace_printk(pevent, buf, size); 205 206 free(buf); 207 return 0; 208 } 209 210 static int read_header_files(struct pevent *pevent) 211 { 212 unsigned long long size; 213 char *header_page; 214 char buf[BUFSIZ]; 215 int ret = 0; 216 217 if (do_read(buf, 12) < 0) 218 return -1; 219 220 if (memcmp(buf, "header_page", 12) != 0) { 221 pr_debug("did not read header page"); 222 return -1; 223 } 224 225 size = read8(pevent); 226 227 header_page = malloc(size); 228 if (header_page == NULL) 229 return -1; 230 231 if (do_read(header_page, size) < 0) { 232 pr_debug("did not read header page"); 233 free(header_page); 234 return -1; 235 } 236 237 if (!pevent_parse_header_page(pevent, header_page, size, 238 pevent_get_long_size(pevent))) { 239 /* 240 * The commit field in the page is of type long, 241 * use that instead, since it represents the kernel. 242 */ 243 pevent_set_long_size(pevent, pevent->header_page_size_size); 244 } 245 free(header_page); 246 247 if (do_read(buf, 13) < 0) 248 return -1; 249 250 if (memcmp(buf, "header_event", 13) != 0) { 251 pr_debug("did not read header event"); 252 return -1; 253 } 254 255 size = read8(pevent); 256 skip(size); 257 258 return ret; 259 } 260 261 static int read_ftrace_file(struct pevent *pevent, unsigned long long size) 262 { 263 char *buf; 264 265 buf = malloc(size); 266 if (buf == NULL) 267 return -1; 268 269 if (do_read(buf, size) < 0) { 270 free(buf); 271 return -1; 272 } 273 274 parse_ftrace_file(pevent, buf, size); 275 free(buf); 276 return 0; 277 } 278 279 static int read_event_file(struct pevent *pevent, char *sys, 280 unsigned long long size) 281 { 282 char *buf; 283 284 buf = malloc(size); 285 if (buf == NULL) 286 return -1; 287 288 if (do_read(buf, size) < 0) { 289 free(buf); 290 return -1; 291 } 292 293 parse_event_file(pevent, buf, size, sys); 294 free(buf); 295 return 0; 296 } 297 298 static int read_ftrace_files(struct pevent *pevent) 299 { 300 unsigned long long size; 301 int count; 302 int i; 303 int ret; 304 305 count = read4(pevent); 306 307 for (i = 0; i < count; i++) { 308 size = read8(pevent); 309 ret = read_ftrace_file(pevent, size); 310 if (ret) 311 return ret; 312 } 313 return 0; 314 } 315 316 static int read_event_files(struct pevent *pevent) 317 { 318 unsigned long long size; 319 char *sys; 320 int systems; 321 int count; 322 int i,x; 323 int ret; 324 325 systems = read4(pevent); 326 327 for (i = 0; i < systems; i++) { 328 sys = read_string(); 329 if (sys == NULL) 330 return -1; 331 332 count = read4(pevent); 333 334 for (x=0; x < count; x++) { 335 size = read8(pevent); 336 ret = read_event_file(pevent, sys, size); 337 if (ret) 338 return ret; 339 } 340 } 341 return 0; 342 } 343 344 ssize_t trace_report(int fd, struct trace_event *tevent, bool __repipe) 345 { 346 char buf[BUFSIZ]; 347 char test[] = { 23, 8, 68 }; 348 char *version; 349 int show_version = 0; 350 int show_funcs = 0; 351 int show_printk = 0; 352 ssize_t size = -1; 353 int file_bigendian; 354 int host_bigendian; 355 int file_long_size; 356 int file_page_size; 357 struct pevent *pevent = NULL; 358 int err; 359 360 repipe = __repipe; 361 input_fd = fd; 362 363 if (do_read(buf, 3) < 0) 364 return -1; 365 if (memcmp(buf, test, 3) != 0) { 366 pr_debug("no trace data in the file"); 367 return -1; 368 } 369 370 if (do_read(buf, 7) < 0) 371 return -1; 372 if (memcmp(buf, "tracing", 7) != 0) { 373 pr_debug("not a trace file (missing 'tracing' tag)"); 374 return -1; 375 } 376 377 version = read_string(); 378 if (version == NULL) 379 return -1; 380 if (show_version) 381 printf("version = %s\n", version); 382 free(version); 383 384 if (do_read(buf, 1) < 0) 385 return -1; 386 file_bigendian = buf[0]; 387 host_bigendian = bigendian(); 388 389 if (trace_event__init(tevent)) { 390 pr_debug("trace_event__init failed"); 391 goto out; 392 } 393 394 pevent = tevent->pevent; 395 396 pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT); 397 pevent_set_file_bigendian(pevent, file_bigendian); 398 pevent_set_host_bigendian(pevent, host_bigendian); 399 400 if (do_read(buf, 1) < 0) 401 goto out; 402 file_long_size = buf[0]; 403 404 file_page_size = read4(pevent); 405 if (!file_page_size) 406 goto out; 407 408 pevent_set_long_size(pevent, file_long_size); 409 pevent_set_page_size(pevent, file_page_size); 410 411 err = read_header_files(pevent); 412 if (err) 413 goto out; 414 err = read_ftrace_files(pevent); 415 if (err) 416 goto out; 417 err = read_event_files(pevent); 418 if (err) 419 goto out; 420 err = read_proc_kallsyms(pevent); 421 if (err) 422 goto out; 423 err = read_ftrace_printk(pevent); 424 if (err) 425 goto out; 426 427 size = trace_data_size; 428 repipe = false; 429 430 if (show_funcs) { 431 pevent_print_funcs(pevent); 432 } else if (show_printk) { 433 pevent_print_printk(pevent); 434 } 435 436 pevent = NULL; 437 438 out: 439 if (pevent) 440 trace_event__cleanup(tevent); 441 return size; 442 } 443