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 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 } 703