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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2008,2009, Steven Rostedt <[email protected]>
   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         closedir(dir);
 317         put_tracing_file(path);
 318
 319         return err;
 320 }
 321
 322 static int record_proc_kallsyms(void)
 323 {
 324         unsigned long long size = 0;
 325         /*
 326          * Just to keep older perf.data file parsers happy, record a zero
 327          * sized kallsyms file, i.e. do the same thing that was done when
 328          * /proc/kallsyms (or something specified via --kallsyms, in a
 329          * different path) couldn't be read.
 330          */
 331         return write(output_fd, &size, 4) != 4 ? -EIO : 0;
 332 }
 333
 334 static int record_ftrace_printk(void)
 335 {
 336         unsigned int size;
 337         char *path;
 338         struct stat st;
 339         int ret, err = 0;
 340
 341         path = get_tracing_file("printk_formats");
 342         if (!path) {
 343                 pr_debug("can't get tracing/printk_formats");
 344                 return -ENOMEM;
 345         }
 346
 347         ret = stat(path, &st);
 348         if (ret < 0) {
 349                 /* not found */
 350                 size = 0;
 351                 if (write(output_fd, &size, 4) != 4)
 352                         err = -EIO;
 353                 goto out;
 354         }
 355         err = record_file(path, 4);
 356
 357 out:
 358         put_tracing_file(path);
 359         return err;
 360 }
 361
 362 static int record_saved_cmdline(void)
 363 {
 364         unsigned long long size;
 365         char *path;
 366         struct stat st;
 367         int ret, err = 0;
 368
 369         path = get_tracing_file("saved_cmdlines");
 370         if (!path) {
 371                 pr_debug("can't get tracing/saved_cmdline");
 372                 return -ENOMEM;
 373         }
 374
 375         ret = stat(path, &st);
 376         if (ret < 0) {
 377                 /* not found */
 378                 size = 0;
 379                 if (write(output_fd, &size, 8) != 8)
 380                         err = -EIO;
 381                 goto out;
 382         }
 383         err = record_file(path, 8);
 384
 385 out:
 386         put_tracing_file(path);
 387         return err;
 388 }
 389
 390 static void
 391 put_tracepoints_path(struct tracepoint_path *tps)
 392 {
 393         while (tps) {
 394                 struct tracepoint_path *t = tps;
 395
 396                 tps = tps->next;
 397                 zfree(&t->name);
 398                 zfree(&t->system);
 399                 free(t);
 400         }
 401 }
 402
 403 static struct tracepoint_path *tracepoint_id_to_path(u64 config)
 404 {
 405         struct tracepoint_path *path = NULL;
 406         DIR *sys_dir, *evt_dir;
 407         struct dirent *sys_dirent, *evt_dirent;
 408         char id_buf[24];
 409         int fd;
 410         u64 id;
 411         char evt_path[MAXPATHLEN];
 412         char *dir_path;
 413
 414         sys_dir = tracing_events__opendir();
 415         if (!sys_dir)
 416                 return NULL;
 417
 418         for_each_subsystem(sys_dir, sys_dirent) {
 419                 dir_path = get_events_file(sys_dirent->d_name);
 420                 if (!dir_path)
 421                         continue;
 422                 evt_dir = opendir(dir_path);
 423                 if (!evt_dir)
 424                         goto next;
 425
 426                 for_each_event(dir_path, evt_dir, evt_dirent) {
 427
 428                         scnprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
 429                                   evt_dirent->d_name);
 430                         fd = open(evt_path, O_RDONLY);
 431                         if (fd < 0)
 432                                 continue;
 433                         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
 434                                 close(fd);
 435                                 continue;
 436                         }
 437                         close(fd);
 438                         id = atoll(id_buf);
 439                         if (id == config) {
 440                                 put_events_file(dir_path);
 441                                 closedir(evt_dir);
 442                                 closedir(sys_dir);
 443                                 path = zalloc(sizeof(*path));
 444                                 if (!path)
 445                                         return NULL;
 446                                 if (asprintf(&path->system, "%.*s",
 447                                              MAX_EVENT_LENGTH, sys_dirent->d_name) < 0) {
 448                                         free(path);
 449                                         return NULL;
 450                                 }
 451                                 if (asprintf(&path->name, "%.*s",
 452                                              MAX_EVENT_LENGTH, evt_dirent->d_name) < 0) {
 453                                         zfree(&path->system);
 454                                         free(path);
 455                                         return NULL;
 456                                 }
 457                                 return path;
 458                         }
 459                 }
 460                 closedir(evt_dir);
 461 next:
 462                 put_events_file(dir_path);
 463         }
 464
 465         closedir(sys_dir);
 466         return NULL;
 467 }
 468
 469 char *tracepoint_id_to_name(u64 config)
 470 {
 471         struct tracepoint_path *path = tracepoint_id_to_path(config);
 472         char *buf = NULL;
 473
 474         if (path && asprintf(&buf, "%s:%s", path->system, path->name) < 0)
 475                 buf = NULL;
 476
 477         put_tracepoints_path(path);
 478         return buf;
 479 }
 480
 481 static struct tracepoint_path *tracepoint_name_to_path(const char *name)
 482 {
 483         struct tracepoint_path *path = zalloc(sizeof(*path));
 484         char *str = strchr(name, ':');
 485
 486         if (path == NULL || str == NULL) {
 487                 free(path);
 488                 return NULL;
 489         }
 490
 491         path->system = strndup(name, str - name);
 492         path->name = strdup(str+1);
 493
 494         if (path->system == NULL || path->name == NULL) {
 495                 zfree(&path->system);
 496                 zfree(&path->name);
 497                 zfree(&path);
 498         }
 499
 500         return path;
 501 }
 502
 503 static struct tracepoint_path *
 504 get_tracepoints_path(struct list_head *pattrs)
 505 {
 506         struct tracepoint_path path, *ppath = &path;
 507         struct evsel *pos;
 508         int nr_tracepoints = 0;
 509
 510         list_for_each_entry(pos, pattrs, core.node) {
 511                 if (pos->core.attr.type != PERF_TYPE_TRACEPOINT)
 512                         continue;
 513                 ++nr_tracepoints;
 514
 515                 if (pos->name) {
 516                         ppath->next = tracepoint_name_to_path(pos->name);
 517                         if (ppath->next)
 518                                 goto next;
 519
 520                         if (strchr(pos->name, ':') == NULL)
 521                                 goto try_id;
 522
 523                         goto error;
 524                 }
 525
 526 try_id:
 527                 ppath->next = tracepoint_id_to_path(pos->core.attr.config);
 528                 if (!ppath->next) {
 529 error:
 530                         pr_debug("No memory to alloc tracepoints list\n");
 531                         put_tracepoints_path(path.next);
 532                         return NULL;
 533                 }
 534 next:
 535                 ppath = ppath->next;
 536         }
 537
 538         return nr_tracepoints > 0 ? path.next : NULL;
 539 }
 540
 541 bool have_tracepoints(struct list_head *pattrs)
 542 {
 543         struct evsel *pos;
 544
 545         list_for_each_entry(pos, pattrs, core.node)
 546                 if (pos->core.attr.type == PERF_TYPE_TRACEPOINT)
 547                         return true;
 548
 549         return false;
 550 }
 551
 552 static int tracing_data_header(void)
 553 {
 554         char buf[20];
 555         ssize_t size;
 556
 557         /* just guessing this is someone's birthday.. ;) */
 558         buf[0] = 23;
 559         buf[1] = 8;
 560         buf[2] = 68;
 561         memcpy(buf + 3, "tracing", 7);
 562
 563         if (write(output_fd, buf, 10) != 10)
 564                 return -1;
 565
 566         size = strlen(VERSION) + 1;
 567         if (write(output_fd, VERSION, size) != size)
 568                 return -1;
 569
 570         /* save endian */
 571         if (host_is_bigendian())
 572                 buf[0] = 1;
 573         else
 574                 buf[0] = 0;
 575
 576         if (write(output_fd, buf, 1) != 1)
 577                 return -1;
 578
 579         /* save size of long */
 580         buf[0] = sizeof(long);
 581         if (write(output_fd, buf, 1) != 1)
 582                 return -1;
 583
 584         /* save page_size */
 585         if (write(output_fd, &page_size, 4) != 4)
 586                 return -1;
 587
 588         return 0;
 589 }
 590
 591 struct tracing_data *tracing_data_get(struct list_head *pattrs,
 592                                       int fd, bool temp)
 593 {
 594         struct tracepoint_path *tps;
 595         struct tracing_data *tdata;
 596         int err;
 597
 598         output_fd = fd;
 599
 600         tps = get_tracepoints_path(pattrs);
 601         if (!tps)
 602                 return NULL;
 603
 604         tdata = malloc(sizeof(*tdata));
 605         if (!tdata)
 606                 return NULL;
 607
 608         tdata->temp = temp;
 609         tdata->size = 0;
 610
 611         if (temp) {
 612                 int temp_fd;
 613
 614                 snprintf(tdata->temp_file, sizeof(tdata->temp_file),
 615                          "/tmp/perf-XXXXXX");
 616                 if (!mkstemp(tdata->temp_file)) {
 617                         pr_debug("Can't make temp file");
 618                         free(tdata);
 619                         return NULL;
 620                 }
 621
 622                 temp_fd = open(tdata->temp_file, O_RDWR);
 623                 if (temp_fd < 0) {
 624                         pr_debug("Can't read '%s'", tdata->temp_file);
 625                         free(tdata);
 626                         return NULL;
 627                 }
 628
 629                 /*
 630                  * Set the temp file the default output, so all the
 631                  * tracing data are stored into it.
 632                  */
 633                 output_fd = temp_fd;
 634         }
 635
 636         err = tracing_data_header();
 637         if (err)
 638                 goto out;
 639         err = record_header_files();
 640         if (err)
 641                 goto out;
 642         err = record_ftrace_files(tps);
 643         if (err)
 644                 goto out;
 645         err = record_event_files(tps);
 646         if (err)
 647                 goto out;
 648         err = record_proc_kallsyms();
 649         if (err)
 650                 goto out;
 651         err = record_ftrace_printk();
 652         if (err)
 653                 goto out;
 654         err = record_saved_cmdline();
 655
 656 out:
 657         /*
 658          * All tracing data are stored by now, we can restore
 659          * the default output file in case we used temp file.
 660          */
 661         if (temp) {
 662                 tdata->size = lseek(output_fd, 0, SEEK_CUR);
 663                 close(output_fd);
 664                 output_fd = fd;
 665         }
 666
 667         if (err)
 668                 zfree(&tdata);
 669
 670         put_tracepoints_path(tps);
 671         return tdata;
 672 }
 673
 674 int tracing_data_put(struct tracing_data *tdata)
 675 {
 676         int err = 0;
 677
 678         if (tdata->temp) {
 679                 err = record_file(tdata->temp_file, 0);
 680                 unlink(tdata->temp_file);
 681         }
 682
 683         free(tdata);
 684         return err;
 685 }
 686
 687 int read_tracing_data(int fd, struct list_head *pattrs)
 688 {
 689         int err;
 690         struct tracing_data *tdata;
 691
 692         /*
 693          * We work over the real file, so we can write data
 694          * directly, no temp file is needed.
 695          */
 696         tdata = tracing_data_get(pattrs, fd, false);
 697         if (!tdata)
 698                 return -ENOMEM;
 699
 700         err = tracing_data_put(tdata);
 701         return err;
 702 }