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