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

   1 /*
   2  * Copyright (C) 2008,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 #define _GNU_SOURCE
  22 #include <dirent.h>
  23 #include <mntent.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/wait.h>
  31 #include <pthread.h>
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34 #include <ctype.h>
  35 #include <errno.h>
  36 #include <stdbool.h>
  37 #include <linux/kernel.h>
  38
  39 #include "../perf.h"
  40 #include "trace-event.h"
  41 #include "debugfs.h"
  42
  43 #define VERSION "0.5"
  44
  45 #define _STR(x) #x
  46 #define STR(x) _STR(x)
  47 #define MAX_PATH 256
  48
  49 #define TRACE_CTRL      "tracing_on"
  50 #define TRACE           "trace"
  51 #define AVAILABLE       "available_tracers"
  52 #define CURRENT         "current_tracer"
  53 #define ITER_CTRL       "trace_options"
  54 #define MAX_LATENCY     "tracing_max_latency"
  55
  56 unsigned int page_size;
  57
  58 static const char *output_file = "trace.info";
  59 static int output_fd;
  60
  61 struct event_list {
  62         struct event_list *next;
  63         const char *event;
  64 };
  65
  66 struct events {
  67         struct events *sibling;
  68         struct events *children;
  69         struct events *next;
  70         char *name;
  71 };
  72
  73
  74
  75 static void die(const char *fmt, ...)
  76 {
  77         va_list ap;
  78         int ret = errno;
  79
  80         if (errno)
  81                 perror("trace-cmd");
  82         else
  83                 ret = -1;
  84
  85         va_start(ap, fmt);
  86         fprintf(stderr, "  ");
  87         vfprintf(stderr, fmt, ap);
  88         va_end(ap);
  89
  90         fprintf(stderr, "\n");
  91         exit(ret);
  92 }
  93
  94 void *malloc_or_die(unsigned int size)
  95 {
  96         void *data;
  97
  98         data = malloc(size);
  99         if (!data)
 100                 die("malloc");
 101         return data;
 102 }
 103
 104 static const char *find_debugfs(void)
 105 {
 106         const char *path = debugfs_mount(NULL);
 107
 108         if (!path)
 109                 die("Your kernel not support debugfs filesystem");
 110
 111         return path;
 112 }
 113
 114 /*
 115  * Finds the path to the debugfs/tracing
 116  * Allocates the string and stores it.
 117  */
 118 static const char *find_tracing_dir(void)
 119 {
 120         static char *tracing;
 121         static int tracing_found;
 122         const char *debugfs;
 123
 124         if (tracing_found)
 125                 return tracing;
 126
 127         debugfs = find_debugfs();
 128
 129         tracing = malloc_or_die(strlen(debugfs) + 9);
 130
 131         sprintf(tracing, "%s/tracing", debugfs);
 132
 133         tracing_found = 1;
 134         return tracing;
 135 }
 136
 137 static char *get_tracing_file(const char *name)
 138 {
 139         const char *tracing;
 140         char *file;
 141
 142         tracing = find_tracing_dir();
 143         if (!tracing)
 144                 return NULL;
 145
 146         file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
 147
 148         sprintf(file, "%s/%s", tracing, name);
 149         return file;
 150 }
 151
 152 static void put_tracing_file(char *file)
 153 {
 154         free(file);
 155 }
 156
 157 static ssize_t calc_data_size;
 158
 159 static ssize_t write_or_die(const void *buf, size_t len)
 160 {
 161         int ret;
 162
 163         if (calc_data_size) {
 164                 calc_data_size += len;
 165                 return len;
 166         }
 167
 168         ret = write(output_fd, buf, len);
 169         if (ret < 0)
 170                 die("writing to '%s'", output_file);
 171
 172         return ret;
 173 }
 174
 175 int bigendian(void)
 176 {
 177         unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
 178         unsigned int *ptr;
 179
 180         ptr = (unsigned int *)(void *)str;
 181         return *ptr == 0x01020304;
 182 }
 183
 184 static unsigned long long copy_file_fd(int fd)
 185 {
 186         unsigned long long size = 0;
 187         char buf[BUFSIZ];
 188         int r;
 189
 190         do {
 191                 r = read(fd, buf, BUFSIZ);
 192                 if (r > 0) {
 193                         size += r;
 194                         write_or_die(buf, r);
 195                 }
 196         } while (r > 0);
 197
 198         return size;
 199 }
 200
 201 static unsigned long long copy_file(const char *file)
 202 {
 203         unsigned long long size = 0;
 204         int fd;
 205
 206         fd = open(file, O_RDONLY);
 207         if (fd < 0)
 208                 die("Can't read '%s'", file);
 209         size = copy_file_fd(fd);
 210         close(fd);
 211
 212         return size;
 213 }
 214
 215 static unsigned long get_size_fd(int fd)
 216 {
 217         unsigned long long size = 0;
 218         char buf[BUFSIZ];
 219         int r;
 220
 221         do {
 222                 r = read(fd, buf, BUFSIZ);
 223                 if (r > 0)
 224                         size += r;
 225         } while (r > 0);
 226
 227         lseek(fd, 0, SEEK_SET);
 228
 229         return size;
 230 }
 231
 232 static unsigned long get_size(const char *file)
 233 {
 234         unsigned long long size = 0;
 235         int fd;
 236
 237         fd = open(file, O_RDONLY);
 238         if (fd < 0)
 239                 die("Can't read '%s'", file);
 240         size = get_size_fd(fd);
 241         close(fd);
 242
 243         return size;
 244 }
 245
 246 static void read_header_files(void)
 247 {
 248         unsigned long long size, check_size;
 249         char *path;
 250         int fd;
 251
 252         path = get_tracing_file("events/header_page");
 253         fd = open(path, O_RDONLY);
 254         if (fd < 0)
 255                 die("can't read '%s'", path);
 256
 257         /* unfortunately, you can not stat debugfs files for size */
 258         size = get_size_fd(fd);
 259
 260         write_or_die("header_page", 12);
 261         write_or_die(&size, 8);
 262         check_size = copy_file_fd(fd);
 263         close(fd);
 264
 265         if (size != check_size)
 266                 die("wrong size for '%s' size=%lld read=%lld",
 267                     path, size, check_size);
 268         put_tracing_file(path);
 269
 270         path = get_tracing_file("events/header_event");
 271         fd = open(path, O_RDONLY);
 272         if (fd < 0)
 273                 die("can't read '%s'", path);
 274
 275         size = get_size_fd(fd);
 276
 277         write_or_die("header_event", 13);
 278         write_or_die(&size, 8);
 279         check_size = copy_file_fd(fd);
 280         if (size != check_size)
 281                 die("wrong size for '%s'", path);
 282         put_tracing_file(path);
 283         close(fd);
 284 }
 285
 286 static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
 287 {
 288         while (tps) {
 289                 if (!strcmp(sys, tps->name))
 290                         return true;
 291                 tps = tps->next;
 292         }
 293
 294         return false;
 295 }
 296
 297 static void copy_event_system(const char *sys, struct tracepoint_path *tps)
 298 {
 299         unsigned long long size, check_size;
 300         struct dirent *dent;
 301         struct stat st;
 302         char *format;
 303         DIR *dir;
 304         int count = 0;
 305         int ret;
 306
 307         dir = opendir(sys);
 308         if (!dir)
 309                 die("can't read directory '%s'", sys);
 310
 311         while ((dent = readdir(dir))) {
 312                 if (dent->d_type != DT_DIR ||
 313                     strcmp(dent->d_name, ".") == 0 ||
 314                     strcmp(dent->d_name, "..") == 0 ||
 315                     !name_in_tp_list(dent->d_name, tps))
 316                         continue;
 317                 format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
 318                 sprintf(format, "%s/%s/format", sys, dent->d_name);
 319                 ret = stat(format, &st);
 320                 free(format);
 321                 if (ret < 0)
 322                         continue;
 323                 count++;
 324         }
 325
 326         write_or_die(&count, 4);
 327
 328         rewinddir(dir);
 329         while ((dent = readdir(dir))) {
 330                 if (dent->d_type != DT_DIR ||
 331                     strcmp(dent->d_name, ".") == 0 ||
 332                     strcmp(dent->d_name, "..") == 0 ||
 333                     !name_in_tp_list(dent->d_name, tps))
 334                         continue;
 335                 format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
 336                 sprintf(format, "%s/%s/format", sys, dent->d_name);
 337                 ret = stat(format, &st);
 338
 339                 if (ret >= 0) {
 340                         /* unfortunately, you can not stat debugfs files for size */
 341                         size = get_size(format);
 342                         write_or_die(&size, 8);
 343                         check_size = copy_file(format);
 344                         if (size != check_size)
 345                                 die("error in size of file '%s'", format);
 346                 }
 347
 348                 free(format);
 349         }
 350         closedir(dir);
 351 }
 352
 353 static void read_ftrace_files(struct tracepoint_path *tps)
 354 {
 355         char *path;
 356
 357         path = get_tracing_file("events/ftrace");
 358
 359         copy_event_system(path, tps);
 360
 361         put_tracing_file(path);
 362 }
 363
 364 static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
 365 {
 366         while (tps) {
 367                 if (!strcmp(sys, tps->system))
 368                         return true;
 369                 tps = tps->next;
 370         }
 371
 372         return false;
 373 }
 374
 375 static void read_event_files(struct tracepoint_path *tps)
 376 {
 377         struct dirent *dent;
 378         struct stat st;
 379         char *path;
 380         char *sys;
 381         DIR *dir;
 382         int count = 0;
 383         int ret;
 384
 385         path = get_tracing_file("events");
 386
 387         dir = opendir(path);
 388         if (!dir)
 389                 die("can't read directory '%s'", path);
 390
 391         while ((dent = readdir(dir))) {
 392                 if (dent->d_type != DT_DIR ||
 393                     strcmp(dent->d_name, ".") == 0 ||
 394                     strcmp(dent->d_name, "..") == 0 ||
 395                     strcmp(dent->d_name, "ftrace") == 0 ||
 396                     !system_in_tp_list(dent->d_name, tps))
 397                         continue;
 398                 count++;
 399         }
 400
 401         write_or_die(&count, 4);
 402
 403         rewinddir(dir);
 404         while ((dent = readdir(dir))) {
 405                 if (dent->d_type != DT_DIR ||
 406                     strcmp(dent->d_name, ".") == 0 ||
 407                     strcmp(dent->d_name, "..") == 0 ||
 408                     strcmp(dent->d_name, "ftrace") == 0 ||
 409                     !system_in_tp_list(dent->d_name, tps))
 410                         continue;
 411                 sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
 412                 sprintf(sys, "%s/%s", path, dent->d_name);
 413                 ret = stat(sys, &st);
 414                 if (ret >= 0) {
 415                         write_or_die(dent->d_name, strlen(dent->d_name) + 1);
 416                         copy_event_system(sys, tps);
 417                 }
 418                 free(sys);
 419         }
 420
 421         closedir(dir);
 422         put_tracing_file(path);
 423 }
 424
 425 static void read_proc_kallsyms(void)
 426 {
 427         unsigned int size, check_size;
 428         const char *path = "/proc/kallsyms";
 429         struct stat st;
 430         int ret;
 431
 432         ret = stat(path, &st);
 433         if (ret < 0) {
 434                 /* not found */
 435                 size = 0;
 436                 write_or_die(&size, 4);
 437                 return;
 438         }
 439         size = get_size(path);
 440         write_or_die(&size, 4);
 441         check_size = copy_file(path);
 442         if (size != check_size)
 443                 die("error in size of file '%s'", path);
 444
 445 }
 446
 447 static void read_ftrace_printk(void)
 448 {
 449         unsigned int size, check_size;
 450         char *path;
 451         struct stat st;
 452         int ret;
 453
 454         path = get_tracing_file("printk_formats");
 455         ret = stat(path, &st);
 456         if (ret < 0) {
 457                 /* not found */
 458                 size = 0;
 459                 write_or_die(&size, 4);
 460                 goto out;
 461         }
 462         size = get_size(path);
 463         write_or_die(&size, 4);
 464         check_size = copy_file(path);
 465         if (size != check_size)
 466                 die("error in size of file '%s'", path);
 467 out:
 468         put_tracing_file(path);
 469 }
 470
 471 static struct tracepoint_path *
 472 get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
 473 {
 474         struct tracepoint_path path, *ppath = &path;
 475         int i, nr_tracepoints = 0;
 476
 477         for (i = 0; i < nb_events; i++) {
 478                 if (pattrs[i].type != PERF_TYPE_TRACEPOINT)
 479                         continue;
 480                 ++nr_tracepoints;
 481                 ppath->next = tracepoint_id_to_path(pattrs[i].config);
 482                 if (!ppath->next)
 483                         die("%s\n", "No memory to alloc tracepoints list");
 484                 ppath = ppath->next;
 485         }
 486
 487         return nr_tracepoints > 0 ? path.next : NULL;
 488 }
 489
 490 bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events)
 491 {
 492         int i;
 493
 494         for (i = 0; i < nb_events; i++)
 495                 if (pattrs[i].type == PERF_TYPE_TRACEPOINT)
 496                         return true;
 497
 498         return false;
 499 }
 500
 501 int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
 502 {
 503         char buf[BUFSIZ];
 504         struct tracepoint_path *tps = get_tracepoints_path(pattrs, nb_events);
 505
 506         /*
 507          * What? No tracepoints? No sense writing anything here, bail out.
 508          */
 509         if (tps == NULL)
 510                 return -1;
 511
 512         output_fd = fd;
 513
 514         buf[0] = 23;
 515         buf[1] = 8;
 516         buf[2] = 68;
 517         memcpy(buf + 3, "tracing", 7);
 518
 519         write_or_die(buf, 10);
 520
 521         write_or_die(VERSION, strlen(VERSION) + 1);
 522
 523         /* save endian */
 524         if (bigendian())
 525                 buf[0] = 1;
 526         else
 527                 buf[0] = 0;
 528
 529         write_or_die(buf, 1);
 530
 531         /* save size of long */
 532         buf[0] = sizeof(long);
 533         write_or_die(buf, 1);
 534
 535         /* save page_size */
 536         page_size = sysconf(_SC_PAGESIZE);
 537         write_or_die(&page_size, 4);
 538
 539         read_header_files();
 540         read_ftrace_files(tps);
 541         read_event_files(tps);
 542         read_proc_kallsyms();
 543         read_ftrace_printk();
 544
 545         return 0;
 546 }
 547
 548 ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
 549                                int nb_events)
 550 {
 551         ssize_t size;
 552         int err = 0;
 553
 554         calc_data_size = 1;
 555         err = read_tracing_data(fd, pattrs, nb_events);
 556         size = calc_data_size - 1;
 557         calc_data_size = 0;
 558
 559         if (err < 0)
 560                 return err;
 561
 562         return size;
 563 }