1 #include "../perf.h" 2 #include "util.h" 3 #include "debug.h" 4 #include <api/fs/fs.h> 5 #include <sys/mman.h> 6 #include <sys/utsname.h> 7 #ifdef HAVE_BACKTRACE_SUPPORT 8 #include <execinfo.h> 9 #endif 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <string.h> 13 #include <errno.h> 14 #include <limits.h> 15 #include <byteswap.h> 16 #include <linux/kernel.h> 17 #include <linux/log2.h> 18 #include <linux/time64.h> 19 #include <unistd.h> 20 #include "callchain.h" 21 #include "strlist.h" 22 23 #define CALLCHAIN_PARAM_DEFAULT \ 24 .mode = CHAIN_GRAPH_ABS, \ 25 .min_percent = 0.5, \ 26 .order = ORDER_CALLEE, \ 27 .key = CCKEY_FUNCTION, \ 28 .value = CCVAL_PERCENT, \ 29 30 struct callchain_param callchain_param = { 31 CALLCHAIN_PARAM_DEFAULT 32 }; 33 34 struct callchain_param callchain_param_default = { 35 CALLCHAIN_PARAM_DEFAULT 36 }; 37 38 /* 39 * XXX We need to find a better place for these things... 40 */ 41 unsigned int page_size; 42 int cacheline_size; 43 44 int sysctl_perf_event_max_stack = PERF_MAX_STACK_DEPTH; 45 int sysctl_perf_event_max_contexts_per_stack = PERF_MAX_CONTEXTS_PER_STACK; 46 47 bool test_attr__enabled; 48 49 bool perf_host = true; 50 bool perf_guest = false; 51 52 void event_attr_init(struct perf_event_attr *attr) 53 { 54 if (!perf_host) 55 attr->exclude_host = 1; 56 if (!perf_guest) 57 attr->exclude_guest = 1; 58 /* to capture ABI version */ 59 attr->size = sizeof(*attr); 60 } 61 62 int mkdir_p(char *path, mode_t mode) 63 { 64 struct stat st; 65 int err; 66 char *d = path; 67 68 if (*d != '/') 69 return -1; 70 71 if (stat(path, &st) == 0) 72 return 0; 73 74 while (*++d == '/'); 75 76 while ((d = strchr(d, '/'))) { 77 *d = '\0'; 78 err = stat(path, &st) && mkdir(path, mode); 79 *d++ = '/'; 80 if (err) 81 return -1; 82 while (*d == '/') 83 ++d; 84 } 85 return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0; 86 } 87 88 int rm_rf(char *path) 89 { 90 DIR *dir; 91 int ret = 0; 92 struct dirent *d; 93 char namebuf[PATH_MAX]; 94 95 dir = opendir(path); 96 if (dir == NULL) 97 return 0; 98 99 while ((d = readdir(dir)) != NULL && !ret) { 100 struct stat statbuf; 101 102 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) 103 continue; 104 105 scnprintf(namebuf, sizeof(namebuf), "%s/%s", 106 path, d->d_name); 107 108 /* We have to check symbolic link itself */ 109 ret = lstat(namebuf, &statbuf); 110 if (ret < 0) { 111 pr_debug("stat failed: %s\n", namebuf); 112 break; 113 } 114 115 if (S_ISDIR(statbuf.st_mode)) 116 ret = rm_rf(namebuf); 117 else 118 ret = unlink(namebuf); 119 } 120 closedir(dir); 121 122 if (ret < 0) 123 return ret; 124 125 return rmdir(path); 126 } 127 128 /* A filter which removes dot files */ 129 bool lsdir_no_dot_filter(const char *name __maybe_unused, struct dirent *d) 130 { 131 return d->d_name[0] != '.'; 132 } 133 134 /* lsdir reads a directory and store it in strlist */ 135 struct strlist *lsdir(const char *name, 136 bool (*filter)(const char *, struct dirent *)) 137 { 138 struct strlist *list = NULL; 139 DIR *dir; 140 struct dirent *d; 141 142 dir = opendir(name); 143 if (!dir) 144 return NULL; 145 146 list = strlist__new(NULL, NULL); 147 if (!list) { 148 errno = ENOMEM; 149 goto out; 150 } 151 152 while ((d = readdir(dir)) != NULL) { 153 if (!filter || filter(name, d)) 154 strlist__add(list, d->d_name); 155 } 156 157 out: 158 closedir(dir); 159 return list; 160 } 161 162 static int slow_copyfile(const char *from, const char *to) 163 { 164 int err = -1; 165 char *line = NULL; 166 size_t n; 167 FILE *from_fp = fopen(from, "r"), *to_fp; 168 169 if (from_fp == NULL) 170 goto out; 171 172 to_fp = fopen(to, "w"); 173 if (to_fp == NULL) 174 goto out_fclose_from; 175 176 while (getline(&line, &n, from_fp) > 0) 177 if (fputs(line, to_fp) == EOF) 178 goto out_fclose_to; 179 err = 0; 180 out_fclose_to: 181 fclose(to_fp); 182 free(line); 183 out_fclose_from: 184 fclose(from_fp); 185 out: 186 return err; 187 } 188 189 int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size) 190 { 191 void *ptr; 192 loff_t pgoff; 193 194 pgoff = off_in & ~(page_size - 1); 195 off_in -= pgoff; 196 197 ptr = mmap(NULL, off_in + size, PROT_READ, MAP_PRIVATE, ifd, pgoff); 198 if (ptr == MAP_FAILED) 199 return -1; 200 201 while (size) { 202 ssize_t ret = pwrite(ofd, ptr + off_in, size, off_out); 203 if (ret < 0 && errno == EINTR) 204 continue; 205 if (ret <= 0) 206 break; 207 208 size -= ret; 209 off_in += ret; 210 off_out -= ret; 211 } 212 munmap(ptr, off_in + size); 213 214 return size ? -1 : 0; 215 } 216 217 int copyfile_mode(const char *from, const char *to, mode_t mode) 218 { 219 int fromfd, tofd; 220 struct stat st; 221 int err = -1; 222 char *tmp = NULL, *ptr = NULL; 223 224 if (stat(from, &st)) 225 goto out; 226 227 /* extra 'x' at the end is to reserve space for '.' */ 228 if (asprintf(&tmp, "%s.XXXXXXx", to) < 0) { 229 tmp = NULL; 230 goto out; 231 } 232 ptr = strrchr(tmp, '/'); 233 if (!ptr) 234 goto out; 235 ptr = memmove(ptr + 1, ptr, strlen(ptr) - 1); 236 *ptr = '.'; 237 238 tofd = mkstemp(tmp); 239 if (tofd < 0) 240 goto out; 241 242 if (fchmod(tofd, mode)) 243 goto out_close_to; 244 245 if (st.st_size == 0) { /* /proc? do it slowly... */ 246 err = slow_copyfile(from, tmp); 247 goto out_close_to; 248 } 249 250 fromfd = open(from, O_RDONLY); 251 if (fromfd < 0) 252 goto out_close_to; 253 254 err = copyfile_offset(fromfd, 0, tofd, 0, st.st_size); 255 256 close(fromfd); 257 out_close_to: 258 close(tofd); 259 if (!err) 260 err = link(tmp, to); 261 unlink(tmp); 262 out: 263 free(tmp); 264 return err; 265 } 266 267 int copyfile(const char *from, const char *to) 268 { 269 return copyfile_mode(from, to, 0755); 270 } 271 272 unsigned long convert_unit(unsigned long value, char *unit) 273 { 274 *unit = ' '; 275 276 if (value > 1000) { 277 value /= 1000; 278 *unit = 'K'; 279 } 280 281 if (value > 1000) { 282 value /= 1000; 283 *unit = 'M'; 284 } 285 286 if (value > 1000) { 287 value /= 1000; 288 *unit = 'G'; 289 } 290 291 return value; 292 } 293 294 static ssize_t ion(bool is_read, int fd, void *buf, size_t n) 295 { 296 void *buf_start = buf; 297 size_t left = n; 298 299 while (left) { 300 ssize_t ret = is_read ? read(fd, buf, left) : 301 write(fd, buf, left); 302 303 if (ret < 0 && errno == EINTR) 304 continue; 305 if (ret <= 0) 306 return ret; 307 308 left -= ret; 309 buf += ret; 310 } 311 312 BUG_ON((size_t)(buf - buf_start) != n); 313 return n; 314 } 315 316 /* 317 * Read exactly 'n' bytes or return an error. 318 */ 319 ssize_t readn(int fd, void *buf, size_t n) 320 { 321 return ion(true, fd, buf, n); 322 } 323 324 /* 325 * Write exactly 'n' bytes or return an error. 326 */ 327 ssize_t writen(int fd, void *buf, size_t n) 328 { 329 return ion(false, fd, buf, n); 330 } 331 332 size_t hex_width(u64 v) 333 { 334 size_t n = 1; 335 336 while ((v >>= 4)) 337 ++n; 338 339 return n; 340 } 341 342 static int hex(char ch) 343 { 344 if ((ch >= '0') && (ch <= '9')) 345 return ch - '0'; 346 if ((ch >= 'a') && (ch <= 'f')) 347 return ch - 'a' + 10; 348 if ((ch >= 'A') && (ch <= 'F')) 349 return ch - 'A' + 10; 350 return -1; 351 } 352 353 /* 354 * While we find nice hex chars, build a long_val. 355 * Return number of chars processed. 356 */ 357 int hex2u64(const char *ptr, u64 *long_val) 358 { 359 const char *p = ptr; 360 *long_val = 0; 361 362 while (*p) { 363 const int hex_val = hex(*p); 364 365 if (hex_val < 0) 366 break; 367 368 *long_val = (*long_val << 4) | hex_val; 369 p++; 370 } 371 372 return p - ptr; 373 } 374 375 /* Obtain a backtrace and print it to stdout. */ 376 #ifdef HAVE_BACKTRACE_SUPPORT 377 void dump_stack(void) 378 { 379 void *array[16]; 380 size_t size = backtrace(array, ARRAY_SIZE(array)); 381 char **strings = backtrace_symbols(array, size); 382 size_t i; 383 384 printf("Obtained %zd stack frames.\n", size); 385 386 for (i = 0; i < size; i++) 387 printf("%s\n", strings[i]); 388 389 free(strings); 390 } 391 #else 392 void dump_stack(void) {} 393 #endif 394 395 void sighandler_dump_stack(int sig) 396 { 397 psignal(sig, "perf"); 398 dump_stack(); 399 signal(sig, SIG_DFL); 400 raise(sig); 401 } 402 403 int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz) 404 { 405 u64 sec = timestamp / NSEC_PER_SEC; 406 u64 usec = (timestamp % NSEC_PER_SEC) / NSEC_PER_USEC; 407 408 return scnprintf(buf, sz, "%"PRIu64".%06"PRIu64, sec, usec); 409 } 410 411 unsigned long parse_tag_value(const char *str, struct parse_tag *tags) 412 { 413 struct parse_tag *i = tags; 414 415 while (i->tag) { 416 char *s; 417 418 s = strchr(str, i->tag); 419 if (s) { 420 unsigned long int value; 421 char *endptr; 422 423 value = strtoul(str, &endptr, 10); 424 if (s != endptr) 425 break; 426 427 if (value > ULONG_MAX / i->mult) 428 break; 429 value *= i->mult; 430 return value; 431 } 432 i++; 433 } 434 435 return (unsigned long) -1; 436 } 437 438 int get_stack_size(const char *str, unsigned long *_size) 439 { 440 char *endptr; 441 unsigned long size; 442 unsigned long max_size = round_down(USHRT_MAX, sizeof(u64)); 443 444 size = strtoul(str, &endptr, 0); 445 446 do { 447 if (*endptr) 448 break; 449 450 size = round_up(size, sizeof(u64)); 451 if (!size || size > max_size) 452 break; 453 454 *_size = size; 455 return 0; 456 457 } while (0); 458 459 pr_err("callchain: Incorrect stack dump size (max %ld): %s\n", 460 max_size, str); 461 return -1; 462 } 463 464 int parse_callchain_record(const char *arg, struct callchain_param *param) 465 { 466 char *tok, *name, *saveptr = NULL; 467 char *buf; 468 int ret = -1; 469 470 /* We need buffer that we know we can write to. */ 471 buf = malloc(strlen(arg) + 1); 472 if (!buf) 473 return -ENOMEM; 474 475 strcpy(buf, arg); 476 477 tok = strtok_r((char *)buf, ",", &saveptr); 478 name = tok ? : (char *)buf; 479 480 do { 481 /* Framepointer style */ 482 if (!strncmp(name, "fp", sizeof("fp"))) { 483 if (!strtok_r(NULL, ",", &saveptr)) { 484 param->record_mode = CALLCHAIN_FP; 485 ret = 0; 486 } else 487 pr_err("callchain: No more arguments " 488 "needed for --call-graph fp\n"); 489 break; 490 491 /* Dwarf style */ 492 } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) { 493 const unsigned long default_stack_dump_size = 8192; 494 495 ret = 0; 496 param->record_mode = CALLCHAIN_DWARF; 497 param->dump_size = default_stack_dump_size; 498 499 tok = strtok_r(NULL, ",", &saveptr); 500 if (tok) { 501 unsigned long size = 0; 502 503 ret = get_stack_size(tok, &size); 504 param->dump_size = size; 505 } 506 } else if (!strncmp(name, "lbr", sizeof("lbr"))) { 507 if (!strtok_r(NULL, ",", &saveptr)) { 508 param->record_mode = CALLCHAIN_LBR; 509 ret = 0; 510 } else 511 pr_err("callchain: No more arguments " 512 "needed for --call-graph lbr\n"); 513 break; 514 } else { 515 pr_err("callchain: Unknown --call-graph option " 516 "value: %s\n", arg); 517 break; 518 } 519 520 } while (0); 521 522 free(buf); 523 return ret; 524 } 525 526 const char *get_filename_for_perf_kvm(void) 527 { 528 const char *filename; 529 530 if (perf_host && !perf_guest) 531 filename = strdup("perf.data.host"); 532 else if (!perf_host && perf_guest) 533 filename = strdup("perf.data.guest"); 534 else 535 filename = strdup("perf.data.kvm"); 536 537 return filename; 538 } 539 540 int perf_event_paranoid(void) 541 { 542 int value; 543 544 if (sysctl__read_int("kernel/perf_event_paranoid", &value)) 545 return INT_MAX; 546 547 return value; 548 } 549 550 void mem_bswap_32(void *src, int byte_size) 551 { 552 u32 *m = src; 553 while (byte_size > 0) { 554 *m = bswap_32(*m); 555 byte_size -= sizeof(u32); 556 ++m; 557 } 558 } 559 560 void mem_bswap_64(void *src, int byte_size) 561 { 562 u64 *m = src; 563 564 while (byte_size > 0) { 565 *m = bswap_64(*m); 566 byte_size -= sizeof(u64); 567 ++m; 568 } 569 } 570 571 bool find_process(const char *name) 572 { 573 size_t len = strlen(name); 574 DIR *dir; 575 struct dirent *d; 576 int ret = -1; 577 578 dir = opendir(procfs__mountpoint()); 579 if (!dir) 580 return false; 581 582 /* Walk through the directory. */ 583 while (ret && (d = readdir(dir)) != NULL) { 584 char path[PATH_MAX]; 585 char *data; 586 size_t size; 587 588 if ((d->d_type != DT_DIR) || 589 !strcmp(".", d->d_name) || 590 !strcmp("..", d->d_name)) 591 continue; 592 593 scnprintf(path, sizeof(path), "%s/%s/comm", 594 procfs__mountpoint(), d->d_name); 595 596 if (filename__read_str(path, &data, &size)) 597 continue; 598 599 ret = strncmp(name, data, len); 600 free(data); 601 } 602 603 closedir(dir); 604 return ret ? false : true; 605 } 606 607 static int 608 fetch_ubuntu_kernel_version(unsigned int *puint) 609 { 610 ssize_t len; 611 size_t line_len = 0; 612 char *ptr, *line = NULL; 613 int version, patchlevel, sublevel, err; 614 FILE *vsig = fopen("/proc/version_signature", "r"); 615 616 if (!vsig) { 617 pr_debug("Open /proc/version_signature failed: %s\n", 618 strerror(errno)); 619 return -1; 620 } 621 622 len = getline(&line, &line_len, vsig); 623 fclose(vsig); 624 err = -1; 625 if (len <= 0) { 626 pr_debug("Reading from /proc/version_signature failed: %s\n", 627 strerror(errno)); 628 goto errout; 629 } 630 631 ptr = strrchr(line, ' '); 632 if (!ptr) { 633 pr_debug("Parsing /proc/version_signature failed: %s\n", line); 634 goto errout; 635 } 636 637 err = sscanf(ptr + 1, "%d.%d.%d", 638 &version, &patchlevel, &sublevel); 639 if (err != 3) { 640 pr_debug("Unable to get kernel version from /proc/version_signature '%s'\n", 641 line); 642 goto errout; 643 } 644 645 if (puint) 646 *puint = (version << 16) + (patchlevel << 8) + sublevel; 647 err = 0; 648 errout: 649 free(line); 650 return err; 651 } 652 653 int 654 fetch_kernel_version(unsigned int *puint, char *str, 655 size_t str_size) 656 { 657 struct utsname utsname; 658 int version, patchlevel, sublevel, err; 659 bool int_ver_ready = false; 660 661 if (access("/proc/version_signature", R_OK) == 0) 662 if (!fetch_ubuntu_kernel_version(puint)) 663 int_ver_ready = true; 664 665 if (uname(&utsname)) 666 return -1; 667 668 if (str && str_size) { 669 strncpy(str, utsname.release, str_size); 670 str[str_size - 1] = '\0'; 671 } 672 673 err = sscanf(utsname.release, "%d.%d.%d", 674 &version, &patchlevel, &sublevel); 675 676 if (err != 3) { 677 pr_debug("Unable to get kernel version from uname '%s'\n", 678 utsname.release); 679 return -1; 680 } 681 682 if (puint && !int_ver_ready) 683 *puint = (version << 16) + (patchlevel << 8) + sublevel; 684 return 0; 685 } 686 687 const char *perf_tip(const char *dirpath) 688 { 689 struct strlist *tips; 690 struct str_node *node; 691 char *tip = NULL; 692 struct strlist_config conf = { 693 .dirname = dirpath, 694 .file_only = true, 695 }; 696 697 tips = strlist__new("tips.txt", &conf); 698 if (tips == NULL) 699 return errno == ENOENT ? NULL : "Tip: get more memory! ;-p"; 700 701 if (strlist__nr_entries(tips) == 0) 702 goto out; 703 704 node = strlist__entry(tips, random() % strlist__nr_entries(tips)); 705 if (asprintf(&tip, "Tip: %s", node->s) < 0) 706 tip = (char *)"Tip: get more memory! ;-)"; 707 708 out: 709 strlist__delete(tips); 710 711 return tip; 712 } 713 714 bool is_regular_file(const char *file) 715 { 716 struct stat st; 717 718 if (stat(file, &st)) 719 return false; 720 721 return S_ISREG(st.st_mode); 722 } 723 724 int fetch_current_timestamp(char *buf, size_t sz) 725 { 726 struct timeval tv; 727 struct tm tm; 728 char dt[32]; 729 730 if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm)) 731 return -1; 732 733 if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm)) 734 return -1; 735 736 scnprintf(buf, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000); 737 738 return 0; 739 } 740 741 void print_binary(unsigned char *data, size_t len, 742 size_t bytes_per_line, print_binary_t printer, 743 void *extra) 744 { 745 size_t i, j, mask; 746 747 if (!printer) 748 return; 749 750 bytes_per_line = roundup_pow_of_two(bytes_per_line); 751 mask = bytes_per_line - 1; 752 753 printer(BINARY_PRINT_DATA_BEGIN, 0, extra); 754 for (i = 0; i < len; i++) { 755 if ((i & mask) == 0) { 756 printer(BINARY_PRINT_LINE_BEGIN, -1, extra); 757 printer(BINARY_PRINT_ADDR, i, extra); 758 } 759 760 printer(BINARY_PRINT_NUM_DATA, data[i], extra); 761 762 if (((i & mask) == mask) || i == len - 1) { 763 for (j = 0; j < mask-(i & mask); j++) 764 printer(BINARY_PRINT_NUM_PAD, -1, extra); 765 766 printer(BINARY_PRINT_SEP, i, extra); 767 for (j = i & ~mask; j <= i; j++) 768 printer(BINARY_PRINT_CHAR_DATA, data[j], extra); 769 for (j = 0; j < mask-(i & mask); j++) 770 printer(BINARY_PRINT_CHAR_PAD, i, extra); 771 printer(BINARY_PRINT_LINE_END, -1, extra); 772 } 773 } 774 printer(BINARY_PRINT_DATA_END, -1, extra); 775 } 776 777 int is_printable_array(char *p, unsigned int len) 778 { 779 unsigned int i; 780 781 if (!p || !len || p[len - 1] != 0) 782 return 0; 783 784 len--; 785 786 for (i = 0; i < len; i++) { 787 if (!isprint(p[i]) && !isspace(p[i])) 788 return 0; 789 } 790 return 1; 791 } 792