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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2008,2009, Steven Rostedt <srostedt@redhat.com>
   4  */
   5 #include <dirent.h>
   6 #include <mntent.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <stdarg.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <sys/wait.h>
  14 #include <fcntl.h>
  15 #include <unistd.h>
  16 #include <errno.h>
  17 #include <stdbool.h>
  18 #include <linux/list.h>
  19 #include <linux/kernel.h>
  20 #include <linux/zalloc.h>
  21 #include <internal/lib.h> // page_size
  22 #include <sys/param.h>
  23
  24 #include "trace-event.h"
  25 #include "tracepoint.h"
  26 #include <api/fs/tracing_path.h>
  27 #include "evsel.h"
  28 #include "debug.h"
  29 #include "util.h"
  30
  31 #define VERSION "0.6"
  32 #define MAX_EVENT_LENGTH 512
  33
  34 static int output_fd;
  35
  36 struct tracepoint_path {
  37         char *system;
  38         char *name;
  39         struct tracepoint_path *next;
  40 };
  41
  42 /* unfortunately, you can not stat debugfs or proc files for size */
  43 static int record_file(const char *file, ssize_t hdr_sz)
  44 {
  45         unsigned long long size = 0;
  46         char buf[BUFSIZ], *sizep;
  47         off_t hdr_pos = lseek(output_fd, 0, SEEK_CUR);
  48         int r, fd;
  49         int err = -EIO;
  50
  51         fd = open(file, O_RDONLY);
  52         if (fd < 0) {
  53                 pr_debug("Can't read '%s'", file);
  54                 return -errno;
  55         }
  56
  57         /* put in zeros for file size, then fill true size later */
  58         if (hdr_sz) {
  59                 if (write(output_fd, &size, hdr_sz) != hdr_sz)
  60                         goto out;
  61         }
  62
  63         do {
  64                 r = read(fd, buf, BUFSIZ);
  65                 if (r > 0) {
  66                         size += r;
  67                         if (write(output_fd, buf, r) != r)
  68                                 goto out;
  69                 }
  70         } while (r > 0);
  71
  72         /* ugh, handle big-endian hdr_size == 4 */
  73         sizep = (char*)&size;
  74         if (host_is_bigendian())
  75                 sizep += sizeof(u64) - hdr_sz;
  76
  77         if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0) {
  78                 pr_debug("writing file size failed\n");
  79                 goto out;
  80         }
  81
  82         err = 0;
  83 out:
  84         close(fd);
  85         return err;
  86 }
  87
  88 static int record_header_files(void)
  89 {
  90         char *path = get_events_file("header_page");
  91         struct stat st;
  92         int err = -EIO;
  93
  94         if (!path) {
  95                 pr_debug("can't get tracing/events/header_page");
  96                 return -ENOMEM;
  97         }
  98
  99         if (stat(path, &st) < 0) {
 100                 pr_debug("can't read '%s'", path);
 101                 goto out;
 102         }
 103
 104         if (write(output_fd, "header_page", 12) != 12) {
 105                 pr_debug("can't write header_page\n");
 106                 goto out;
 107         }
 108
 109         if (record_file(path, 8) < 0) {
 110                 pr_debug("can't record header_page file\n");
 111                 goto out;
 112         }
 113
 114         put_events_file(path);
 115
 116         path = get_events_file("header_event");
 117         if (!path) {
 118                 pr_debug("can't get tracing/events/header_event");
 119                 err = -ENOMEM;
 120                 goto out;
 121         }
 122
 123         if (stat(path, &st) < 0) {
 124                 pr_debug("can't read '%s'", path);
 125                 goto out;
 126         }
 127
 128         if (write(output_fd, "header_event", 13) != 13) {
 129                 pr_debug("can't write header_event\n");
 130                 goto out;
 131         }
 132
 133         if (record_file(path, 8) < 0) {
 134                 pr_debug("can't record header_event file\n");
 135                 goto out;
 136         }
 137
 138         err = 0;
 139 out:
 140         put_events_file(path);
 141         return err;
 142 }
 143
 144 static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
 145 {
 146         while (tps) {
 147                 if (!strcmp(sys, tps->name))
 148                         return true;
 149                 tps = tps->next;
 150         }
 151
 152         return false;
 153 }
 154
 155 #define for_each_event_tps(dir, dent, tps)                      \
 156         while ((dent = readdir(dir)))                           \
 157                 if (dent->d_type == DT_DIR &&                   \
 158                     (strcmp(dent->d_name, ".")) &&              \
 159                     (strcmp(dent->d_name, "..")))               \
 160
 161 static int copy_event_system(const char *sys, struct tracepoint_path *tps)
 162 {
 163         struct dirent *dent;
 164         struct stat st;
 165         char *format;
 166         DIR *dir;
 167         int count = 0;
 168         int ret;
 169         int err;
 170
 171         dir = opendir(sys);
 172         if (!dir) {
 173                 pr_debug("can't read directory '%s'", sys);
 174                 return -errno;
 175         }
 176
 177         for_each_event_tps(dir, dent, tps) {
 178                 if (!name_in_tp_list(dent->d_name, tps))
 179                         continue;
 180
 181                 if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
 182                         err = -ENOMEM;
 183                         goto out;
 184                 }
 185                 ret = stat(format, &st);
 186                 free(format);
 187                 if (ret < 0)
 188                         continue;
 189                 count++;
 190         }
 191
 192         if (write(output_fd, &count, 4) != 4) {
 193                 err = -EIO;
 194                 pr_debug("can't write count\n");
 195                 goto out;
 196         }
 197
 198         rewinddir(dir);
 199         for_each_event_tps(dir, dent, tps) {
 200                 if (!name_in_tp_list(dent->d_name, tps))
 201                         continue;
 202
 203                 if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
 204                         err = -ENOMEM;
 205                         goto out;
 206                 }
 207                 ret = stat(format, &st);
 208
 209                 if (ret >= 0) {
 210                         err = record_file(format, 8);
 211                         if (err) {
 212                                 free(format);
 213                                 goto out;
 214                         }
 215                 }
 216                 free(format);
 217         }
 218         err = 0;
 219 out:
 220         closedir(dir);
 221         return err;
 222 }
 223
 224 static int record_ftrace_files(struct tracepoint_path *tps)
 225 {
 226         char *path;
 227         int ret;
 228
 229         path = get_events_file("ftrace");
 230         if (!path) {
 231                 pr_debug("can't get tracing/events/ftrace");
 232                 return -ENOMEM;
 233         }
 234
 235         ret = copy_event_system(path, tps);
 236
 237         put_tracing_file(path);
 238
 239         return ret;
 240 }
 241
 242 static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
 243 {
 244         while (tps) {
 245                 if (!strcmp(sys, tps->system))
 246                         return true;
 247                 tps = tps->next;
 248         }
 249
 250         return false;
 251 }
 252
 253 static int record_event_files(struct tracepoint_path *tps)
 254 {
 255         struct dirent *dent;
 256         struct stat st;
 257         char *path;
 258         char *sys;
 259         DIR *dir;
 260         int count = 0;
 261         int ret;
 262         int err;
 263
 264         path = get_tracing_file("events");
 265         if (!path) {
 266                 pr_debug("can't get tracing/events");
 267                 return -ENOMEM;
 268         }
 269
 270         dir = opendir(path);
 271         if (!dir) {
 272                 err = -errno;
 273                 pr_debug("can't read directory '%s'", path);
 274                 goto out;
 275         }
 276
 277         for_each_event_tps(dir, dent, tps) {
 278                 if (strcmp(dent->d_name, "ftrace") == 0 ||
 279                     !system_in_tp_list(dent->d_name, tps))
 280                         continue;
 281
 282                 count++;
 283         }
 284
 285         if (write(output_fd, &count, 4) != 4) {
 286                 err = -EIO;
 287                 pr_debug("can't write count\n");
 288                 goto out;
 289         }
 290
 291         rewinddir(dir);
 292         for_each_event_tps(dir, dent, tps) {
 293                 if (strcmp(dent->d_name, "ftrace") == 0 ||
 294                     !system_in_tp_list(dent->d_name, tps))
 295                         continue;
 296
 297                 if (asprintf(&sys, "%s/%s", path, dent->d_name) < 0) {
 298                         err = -ENOMEM;
 299                         goto out;
 300                 }
 301                 ret = stat(sys, &st);
 302                 if (ret >= 0) {
 303                         ssize_t size = strlen(dent->d_name) + 1;
 304
 305                         if (write(output_fd, dent->d_name, size) != size ||
 306                             copy_event_system(sys, tps) < 0) {
 307                                 err = -EIO;
 308                                 free(sys);
 309                                 goto out;
 310                         }
 311                 }
 312                 free(sys);
 313         }
 314         err = 0;
 315 out:
 316         if (dir)
 317                 closedir(dir);
 318         put_tracing_file(path);
 319
 320         return err;
 321 }
 322
 323 static int record_proc_kallsyms(void)
 324 {
 325         unsigned long long size = 0;
 326         /*
 327          * Just to keep older perf.data file parsers happy, record a zero
 328          * sized kallsyms file, i.e. do the same thing that was done when
 329          * /proc/kallsyms (or something specified via --kallsyms, in a
 330          * different path) couldn't be read.
 331          */
 332         return write(output_fd, &size, 4) != 4 ? -EIO : 0;
 333 }
 334
 335 static int record_ftrace_printk(void)
 336 {
 337         unsigned int size;
 338         char *path;
 339         struct stat st;
 340         int ret, err = 0;
 341
 342         path = get_tracing_file("printk_formats");
 343         if (!path) {
 344                 pr_debug("can't get tracing/printk_formats");
 345                 return -ENOMEM;
 346         }
 347
 348         ret = stat(path, &st);
 349         if (ret < 0) {
 350                 /* not found */
 351                 size = 0;
 352                 if (write(output_fd, &size, 4) != 4)
 353                         err = -EIO;
 354                 goto out;
 355         }
 356         err = record_file(path, 4);
 357
 358 out:
 359         put_tracing_file(path);
 360         return err;
 361 }
 362
 363 static int record_saved_cmdline(void)
 364 {
 365         unsigned long long size;
 366         char *path;
 367         struct stat st;
 368         int ret, err = 0;
 369
 370         path = get_tracing_file("saved_cmdlines");
 371         if (!path) {
 372                 pr_debug("can't get tracing/saved_cmdline");
 373                 return -ENOMEM;
 374         }
 375
 376         ret = stat(path, &st);
 377         if (ret < 0) {
 378                 /* not found */
 379                 size = 0;
 380                 if (write(output_fd, &size, 8) != 8)
 381                         err = -EIO;
 382                 goto out;
 383         }
 384         err = record_file(path, 8);
 385
 386 out:
 387         put_tracing_file(path);
 388         return err;
 389 }
 390
 391 static void
 392 put_tracepoints_path(struct tracepoint_path *tps)
 393 {
 394         while (tps) {
 395                 struct tracepoint_path *t = tps;
 396
 397                 tps = tps->next;
 398                 zfree(&t->name);
 399                 zfree(&t->system);
 400                 free(t);
 401         }
 402 }
 403
 404 static struct tracepoint_path *tracepoint_id_to_path(u64 config)
 405 {
 406         struct tracepoint_path *path = NULL;
 407         DIR *sys_dir, *evt_dir;
 408         struct dirent *sys_dirent, *evt_dirent;
 409         char id_buf[24];
 410         int fd;
 411         u64 id;
 412         char evt_path[MAXPATHLEN];
 413         char *dir_path;
 414
 415         sys_dir = tracing_events__opendir();
 416         if (!sys_dir)
 417                 return NULL;
 418
 419         for_each_subsystem(sys_dir, sys_dirent) {
 420                 dir_path = get_events_file(sys_dirent->d_name);
 421                 if (!dir_path)
 422                         continue;
 423                 evt_dir = opendir(dir_path);
 424                 if (!evt_dir)
 425                         goto next;
 426
 427                 for_each_event(dir_path, evt_dir, evt_dirent) {
 428
 429                         scnprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
 430                                   evt_dirent->d_name);
 431                         fd = open(evt_path, O_RDONLY);
 432                         if (fd < 0)
 433                                 continue;
 434                         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
 435                                 close(fd);
 436                                 continue;
 437                         }
 438                         close(fd);
 439                         id = atoll(id_buf);
 440                         if (id == config) {
 441                                 put_events_file(dir_path);
 442                                 closedir(evt_dir);
 443                                 closedir(sys_dir);
 444                                 path = zalloc(sizeof(*path));
 445                                 if (!path)
 446                                         return NULL;
 447                                 if (asprintf(&path->system, "%.*s",
 448                                              MAX_EVENT_LENGTH, sys_dirent->d_name) < 0) {
 449                                         free(path);
 450                                         return NULL;
 451                                 }
 452                                 if (asprintf(&path->name, "%.*s",
 453                                              MAX_EVENT_LENGTH, evt_dirent->d_name) < 0) {
 454                                         zfree(&path->system);
 455                                         free(path);
 456                                         return NULL;
 457                                 }
 458                                 return path;
 459                         }
 460                 }
 461                 closedir(evt_dir);
 462 next:
 463                 put_events_file(dir_path);
 464         }
 465
 466         closedir(sys_dir);
 467         return NULL;
 468 }
 469
 470 char *tracepoint_id_to_name(u64 config)
 471 {
 472         struct tracepoint_path *path = tracepoint_id_to_path(config);
 473         char *buf = NULL;
 474
 475         if (path && asprintf(&buf, "%s:%s", path->system, path->name) < 0)
 476                 buf = NULL;
 477
 478         put_tracepoints_path(path);
 479         return buf;
 480 }
 481
 482 static struct tracepoint_path *tracepoint_name_to_path(const char *name)
 483 {
 484         struct tracepoint_path *path = zalloc(sizeof(*path));
 485         char *str = strchr(name, ':');
 486
 487         if (path == NULL || str == NULL) {
 488                 free(path);
 489                 return NULL;
 490         }
 491
 492         path->system = strndup(name, str - name);
 493         path->name = strdup(str+1);
 494
 495         if (path->system == NULL || path->name == NULL) {
 496                 zfree(&path->system);
 497                 zfree(&path->name);
 498                 zfree(&path);
 499         }
 500
 501         return path;
 502 }
 503
 504 static struct tracepoint_path *
 505 get_tracepoints_path(struct list_head *pattrs)
 506 {
 507         struct tracepoint_path path, *ppath = &path;
 508         struct evsel *pos;
 509         int nr_tracepoints = 0;
 510
 511         list_for_each_entry(pos, pattrs, core.node) {
 512                 if (pos->core.attr.type != PERF_TYPE_TRACEPOINT)
 513                         continue;
 514                 ++nr_tracepoints;
 515
 516                 if (pos->name) {
 517                         ppath->next = tracepoint_name_to_path(pos->name);
 518                         if (ppath->next)
 519                                 goto next;
 520
 521                         if (strchr(pos->name, ':') == NULL)
 522                                 goto try_id;
 523
 524                         goto error;
 525                 }
 526
 527 try_id:
 528                 ppath->next = tracepoint_id_to_path(pos->core.attr.config);
 529                 if (!ppath->next) {
 530 error:
 531                         pr_debug("No memory to alloc tracepoints list\n");
 532                         put_tracepoints_path(path.next);
 533                         return NULL;
 534                 }
 535 next:
 536                 ppath = ppath->next;
 537         }
 538
 539         return nr_tracepoints > 0 ? path.next : NULL;
 540 }
 541
 542 bool have_tracepoints(struct list_head *pattrs)
 543 {
 544         struct evsel *pos;
 545
 546         list_for_each_entry(pos, pattrs, core.node)
 547                 if (pos->core.attr.type == PERF_TYPE_TRACEPOINT)
 548                         return true;
 549
 550         return false;
 551 }
 552
 553 static int tracing_data_header(void)
 554 {
 555         char buf[20];
 556         ssize_t size;
 557
 558         /* just guessing this is someone's birthday.. ;) */
 559         buf[0] = 23;
 560         buf[1] = 8;
 561         buf[2] = 68;
 562         memcpy(buf + 3, "tracing", 7);
 563
 564         if (write(output_fd, buf, 10) != 10)
 565                 return -1;
 566
 567         size = strlen(VERSION) + 1;
 568         if (write(output_fd, VERSION, size) != size)
 569                 return -1;
 570
 571         /* save endian */
 572         if (host_is_bigendian())
 573                 buf[0] = 1;
 574         else
 575                 buf[0] = 0;
 576
 577         if (write(output_fd, buf, 1) != 1)
 578                 return -1;
 579
 580         /* save size of long */
 581         buf[0] = sizeof(long);
 582         if (write(output_fd, buf, 1) != 1)
 583                 return -1;
 584
 585         /* save page_size */
 586         if (write(output_fd, &page_size, 4) != 4)
 587                 return -1;
 588
 589         return 0;
 590 }
 591
 592 struct tracing_data *tracing_data_get(struct list_head *pattrs,
 593                                       int fd, bool temp)
 594 {
 595         struct tracepoint_path *tps;
 596         struct tracing_data *tdata;
 597         int err;
 598
 599         output_fd = fd;
 600
 601         tps = get_tracepoints_path(pattrs);
 602         if (!tps)
 603                 return NULL;
 604
 605         tdata = malloc(sizeof(*tdata));
 606         if (!tdata)
 607                 return NULL;
 608
 609         tdata->temp = temp;
 610         tdata->size = 0;
 611
 612         if (temp) {
 613                 int temp_fd;
 614
 615                 snprintf(tdata->temp_file, sizeof(tdata->temp_file),
 616                          "/tmp/perf-XXXXXX");
 617                 if (!mkstemp(tdata->temp_file)) {
 618                         pr_debug("Can't make temp file");
 619                         free(tdata);
 620                         return NULL;
 621                 }
 622
 623                 temp_fd = open(tdata->temp_file, O_RDWR);
 624                 if (temp_fd < 0) {
 625                         pr_debug("Can't read '%s'", tdata->temp_file);
 626                         free(tdata);
 627                         return NULL;
 628                 }
 629
 630                 /*
 631                  * Set the temp file the default output, so all the
 632                  * tracing data are stored into it.
 633                  */
 634                 output_fd = temp_fd;
 635         }
 636
 637         err = tracing_data_header();
 638         if (err)
 639                 goto out;
 640         err = record_header_files();
 641         if (err)
 642                 goto out;
 643         err = record_ftrace_files(tps);
 644         if (err)
 645                 goto out;
 646         err = record_event_files(tps);
 647         if (err)
 648                 goto out;
 649         err = record_proc_kallsyms();
 650         if (err)
 651                 goto out;
 652         err = record_ftrace_printk();
 653         if (err)
 654                 goto out;
 655         err = record_saved_cmdline();
 656
 657 out:
 658         /*
 659          * All tracing data are stored by now, we can restore
 660          * the default output file in case we used temp file.
 661          */
 662         if (temp) {
 663                 tdata->size = lseek(output_fd, 0, SEEK_CUR);
 664                 close(output_fd);
 665                 output_fd = fd;
 666         }
 667
 668         if (err)
 669                 zfree(&tdata);
 670
 671         put_tracepoints_path(tps);
 672         return tdata;
 673 }
 674
 675 int tracing_data_put(struct tracing_data *tdata)
 676 {
 677         int err = 0;
 678
 679         if (tdata->temp) {
 680                 err = record_file(tdata->temp_file, 0);
 681                 unlink(tdata->temp_file);
 682         }
 683
 684         free(tdata);
 685         return err;
 686 }
 687
 688 int read_tracing_data(int fd, struct list_head *pattrs)
 689 {
 690         int err;
 691         struct tracing_data *tdata;
 692
 693         /*
 694          * We work over the real file, so we can write data
 695          * directly, no temp file is needed.
 696          */
 697         tdata = tracing_data_get(pattrs, fd, false);
 698         if (!tdata)
 699                 return -ENOMEM;
 700
 701         err = tracing_data_put(tdata);
 702         return err;
 703 }