tools/perf/util/trace-event-read.c

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