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