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 23 #include "trace-event.h" 24 #include <api/fs/tracing_path.h> 25 #include "evsel.h" 26 #include "debug.h" 27 28 #define VERSION "0.6" 29 30 static int output_fd; 31 32 33 int bigendian(void) 34 { 35 unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0}; 36 unsigned int *ptr; 37 38 ptr = (unsigned int *)(void *)str; 39 return *ptr == 0x01020304; 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 (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 * 404 get_tracepoints_path(struct list_head *pattrs) 405 { 406 struct tracepoint_path path, *ppath = &path; 407 struct evsel *pos; 408 int nr_tracepoints = 0; 409 410 list_for_each_entry(pos, pattrs, core.node) { 411 if (pos->core.attr.type != PERF_TYPE_TRACEPOINT) 412 continue; 413 ++nr_tracepoints; 414 415 if (pos->name) { 416 ppath->next = tracepoint_name_to_path(pos->name); 417 if (ppath->next) 418 goto next; 419 420 if (strchr(pos->name, ':') == NULL) 421 goto try_id; 422 423 goto error; 424 } 425 426 try_id: 427 ppath->next = tracepoint_id_to_path(pos->core.attr.config); 428 if (!ppath->next) { 429 error: 430 pr_debug("No memory to alloc tracepoints list\n"); 431 put_tracepoints_path(path.next); 432 return NULL; 433 } 434 next: 435 ppath = ppath->next; 436 } 437 438 return nr_tracepoints > 0 ? path.next : NULL; 439 } 440 441 bool have_tracepoints(struct list_head *pattrs) 442 { 443 struct evsel *pos; 444 445 list_for_each_entry(pos, pattrs, core.node) 446 if (pos->core.attr.type == PERF_TYPE_TRACEPOINT) 447 return true; 448 449 return false; 450 } 451 452 static int tracing_data_header(void) 453 { 454 char buf[20]; 455 ssize_t size; 456 457 /* just guessing this is someone's birthday.. ;) */ 458 buf[0] = 23; 459 buf[1] = 8; 460 buf[2] = 68; 461 memcpy(buf + 3, "tracing", 7); 462 463 if (write(output_fd, buf, 10) != 10) 464 return -1; 465 466 size = strlen(VERSION) + 1; 467 if (write(output_fd, VERSION, size) != size) 468 return -1; 469 470 /* save endian */ 471 if (bigendian()) 472 buf[0] = 1; 473 else 474 buf[0] = 0; 475 476 if (write(output_fd, buf, 1) != 1) 477 return -1; 478 479 /* save size of long */ 480 buf[0] = sizeof(long); 481 if (write(output_fd, buf, 1) != 1) 482 return -1; 483 484 /* save page_size */ 485 if (write(output_fd, &page_size, 4) != 4) 486 return -1; 487 488 return 0; 489 } 490 491 struct tracing_data *tracing_data_get(struct list_head *pattrs, 492 int fd, bool temp) 493 { 494 struct tracepoint_path *tps; 495 struct tracing_data *tdata; 496 int err; 497 498 output_fd = fd; 499 500 tps = get_tracepoints_path(pattrs); 501 if (!tps) 502 return NULL; 503 504 tdata = malloc(sizeof(*tdata)); 505 if (!tdata) 506 return NULL; 507 508 tdata->temp = temp; 509 tdata->size = 0; 510 511 if (temp) { 512 int temp_fd; 513 514 snprintf(tdata->temp_file, sizeof(tdata->temp_file), 515 "/tmp/perf-XXXXXX"); 516 if (!mkstemp(tdata->temp_file)) { 517 pr_debug("Can't make temp file"); 518 free(tdata); 519 return NULL; 520 } 521 522 temp_fd = open(tdata->temp_file, O_RDWR); 523 if (temp_fd < 0) { 524 pr_debug("Can't read '%s'", tdata->temp_file); 525 free(tdata); 526 return NULL; 527 } 528 529 /* 530 * Set the temp file the default output, so all the 531 * tracing data are stored into it. 532 */ 533 output_fd = temp_fd; 534 } 535 536 err = tracing_data_header(); 537 if (err) 538 goto out; 539 err = record_header_files(); 540 if (err) 541 goto out; 542 err = record_ftrace_files(tps); 543 if (err) 544 goto out; 545 err = record_event_files(tps); 546 if (err) 547 goto out; 548 err = record_proc_kallsyms(); 549 if (err) 550 goto out; 551 err = record_ftrace_printk(); 552 if (err) 553 goto out; 554 err = record_saved_cmdline(); 555 556 out: 557 /* 558 * All tracing data are stored by now, we can restore 559 * the default output file in case we used temp file. 560 */ 561 if (temp) { 562 tdata->size = lseek(output_fd, 0, SEEK_CUR); 563 close(output_fd); 564 output_fd = fd; 565 } 566 567 if (err) 568 zfree(&tdata); 569 570 put_tracepoints_path(tps); 571 return tdata; 572 } 573 574 int tracing_data_put(struct tracing_data *tdata) 575 { 576 int err = 0; 577 578 if (tdata->temp) { 579 err = record_file(tdata->temp_file, 0); 580 unlink(tdata->temp_file); 581 } 582 583 free(tdata); 584 return err; 585 } 586 587 int read_tracing_data(int fd, struct list_head *pattrs) 588 { 589 int err; 590 struct tracing_data *tdata; 591 592 /* 593 * We work over the real file, so we can write data 594 * directly, no temp file is needed. 595 */ 596 tdata = tracing_data_get(pattrs, fd, false); 597 if (!tdata) 598 return -ENOMEM; 599 600 err = tracing_data_put(tdata); 601 return err; 602 } 603