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 static struct tracepoint_path *tracepoint_name_to_path(const char *name)
 470 {
 471         struct tracepoint_path *path = zalloc(sizeof(*path));
 472         char *str = strchr(name, ':');
 473
 474         if (path == NULL || str == NULL) {
 475                 free(path);
 476                 return NULL;
 477         }
 478
 479         path->system = strndup(name, str - name);
 480         path->name = strdup(str+1);
 481
 482         if (path->system == NULL || path->name == NULL) {
 483                 zfree(&path->system);
 484                 zfree(&path->name);
 485                 zfree(&path);
 486         }
 487
 488         return path;
 489 }
 490
 491 static struct tracepoint_path *
 492 get_tracepoints_path(struct list_head *pattrs)
 493 {
 494         struct tracepoint_path path, *ppath = &path;
 495         struct evsel *pos;
 496         int nr_tracepoints = 0;
 497
 498         list_for_each_entry(pos, pattrs, core.node) {
 499                 if (pos->core.attr.type != PERF_TYPE_TRACEPOINT)
 500                         continue;
 501                 ++nr_tracepoints;
 502
 503                 if (pos->name) {
 504                         ppath->next = tracepoint_name_to_path(pos->name);
 505                         if (ppath->next)
 506                                 goto next;
 507
 508                         if (strchr(pos->name, ':') == NULL)
 509                                 goto try_id;
 510
 511                         goto error;
 512                 }
 513
 514 try_id:
 515                 ppath->next = tracepoint_id_to_path(pos->core.attr.config);
 516                 if (!ppath->next) {
 517 error:
 518                         pr_debug("No memory to alloc tracepoints list\n");
 519                         put_tracepoints_path(path.next);
 520                         return NULL;
 521                 }
 522 next:
 523                 ppath = ppath->next;
 524         }
 525
 526         return nr_tracepoints > 0 ? path.next : NULL;
 527 }
 528
 529 bool have_tracepoints(struct list_head *pattrs)
 530 {
 531         struct evsel *pos;
 532
 533         list_for_each_entry(pos, pattrs, core.node)
 534                 if (pos->core.attr.type == PERF_TYPE_TRACEPOINT)
 535                         return true;
 536
 537         return false;
 538 }
 539
 540 static int tracing_data_header(void)
 541 {
 542         char buf[20];
 543         ssize_t size;
 544
 545         /* just guessing this is someone's birthday.. ;) */
 546         buf[0] = 23;
 547         buf[1] = 8;
 548         buf[2] = 68;
 549         memcpy(buf + 3, "tracing", 7);
 550
 551         if (write(output_fd, buf, 10) != 10)
 552                 return -1;
 553
 554         size = strlen(VERSION) + 1;
 555         if (write(output_fd, VERSION, size) != size)
 556                 return -1;
 557
 558         /* save endian */
 559         if (host_is_bigendian())
 560                 buf[0] = 1;
 561         else
 562                 buf[0] = 0;
 563
 564         if (write(output_fd, buf, 1) != 1)
 565                 return -1;
 566
 567         /* save size of long */
 568         buf[0] = sizeof(long);
 569         if (write(output_fd, buf, 1) != 1)
 570                 return -1;
 571
 572         /* save page_size */
 573         if (write(output_fd, &page_size, 4) != 4)
 574                 return -1;
 575
 576         return 0;
 577 }
 578
 579 struct tracing_data *tracing_data_get(struct list_head *pattrs,
 580                                       int fd, bool temp)
 581 {
 582         struct tracepoint_path *tps;
 583         struct tracing_data *tdata;
 584         int err;
 585
 586         output_fd = fd;
 587
 588         tps = get_tracepoints_path(pattrs);
 589         if (!tps)
 590                 return NULL;
 591
 592         tdata = malloc(sizeof(*tdata));
 593         if (!tdata)
 594                 return NULL;
 595
 596         tdata->temp = temp;
 597         tdata->size = 0;
 598
 599         if (temp) {
 600                 int temp_fd;
 601
 602                 snprintf(tdata->temp_file, sizeof(tdata->temp_file),
 603                          "/tmp/perf-XXXXXX");
 604                 if (!mkstemp(tdata->temp_file)) {
 605                         pr_debug("Can't make temp file");
 606                         free(tdata);
 607                         return NULL;
 608                 }
 609
 610                 temp_fd = open(tdata->temp_file, O_RDWR);
 611                 if (temp_fd < 0) {
 612                         pr_debug("Can't read '%s'", tdata->temp_file);
 613                         free(tdata);
 614                         return NULL;
 615                 }
 616
 617                 /*
 618                  * Set the temp file the default output, so all the
 619                  * tracing data are stored into it.
 620                  */
 621                 output_fd = temp_fd;
 622         }
 623
 624         err = tracing_data_header();
 625         if (err)
 626                 goto out;
 627         err = record_header_files();
 628         if (err)
 629                 goto out;
 630         err = record_ftrace_files(tps);
 631         if (err)
 632                 goto out;
 633         err = record_event_files(tps);
 634         if (err)
 635                 goto out;
 636         err = record_proc_kallsyms();
 637         if (err)
 638                 goto out;
 639         err = record_ftrace_printk();
 640         if (err)
 641                 goto out;
 642         err = record_saved_cmdline();
 643
 644 out:
 645         /*
 646          * All tracing data are stored by now, we can restore
 647          * the default output file in case we used temp file.
 648          */
 649         if (temp) {
 650                 tdata->size = lseek(output_fd, 0, SEEK_CUR);
 651                 close(output_fd);
 652                 output_fd = fd;
 653         }
 654
 655         if (err)
 656                 zfree(&tdata);
 657
 658         put_tracepoints_path(tps);
 659         return tdata;
 660 }
 661
 662 int tracing_data_put(struct tracing_data *tdata)
 663 {
 664         int err = 0;
 665
 666         if (tdata->temp) {
 667                 err = record_file(tdata->temp_file, 0);
 668                 unlink(tdata->temp_file);
 669         }
 670
 671         free(tdata);
 672         return err;
 673 }
 674
 675 int read_tracing_data(int fd, struct list_head *pattrs)
 676 {
 677         int err;
 678         struct tracing_data *tdata;
 679
 680         /*
 681          * We work over the real file, so we can write data
 682          * directly, no temp file is needed.
 683          */
 684         tdata = tracing_data_get(pattrs, fd, false);
 685         if (!tdata)
 686                 return -ENOMEM;
 687
 688         err = tracing_data_put(tdata);
 689         return err;
 690 }