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