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

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