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