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