1 /* 2 * builtin-record.c 3 * 4 * Builtin record command: Record the profile of a workload 5 * (or a CPU, or a PID) into the perf.data output file - for 6 * later analysis via perf report. 7 */ 8 #include "builtin.h" 9 10 #include "perf.h" 11 12 #include "util/util.h" 13 #include "util/parse-options.h" 14 #include "util/parse-events.h" 15 #include "util/string.h" 16 17 #include "util/header.h" 18 #include "util/event.h" 19 #include "util/debug.h" 20 #include "util/trace-event.h" 21 22 #include <unistd.h> 23 #include <sched.h> 24 25 #define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a)-1) 26 #define __ALIGN_MASK(x, mask) (((x)+(mask))&~(mask)) 27 28 static int fd[MAX_NR_CPUS][MAX_COUNTERS]; 29 30 static long default_interval = 100000; 31 32 static int nr_cpus = 0; 33 static unsigned int page_size; 34 static unsigned int mmap_pages = 128; 35 static int freq = 0; 36 static int output; 37 static const char *output_name = "perf.data"; 38 static int group = 0; 39 static unsigned int realtime_prio = 0; 40 static int raw_samples = 0; 41 static int system_wide = 0; 42 static int profile_cpu = -1; 43 static pid_t target_pid = -1; 44 static int inherit = 1; 45 static int force = 0; 46 static int append_file = 0; 47 static int call_graph = 0; 48 static int inherit_stat = 0; 49 static int no_samples = 0; 50 static int sample_address = 0; 51 static int multiplex = 0; 52 static int multiplex_fd = -1; 53 54 static long samples; 55 static struct timeval last_read; 56 static struct timeval this_read; 57 58 static u64 bytes_written; 59 60 static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS]; 61 62 static int nr_poll; 63 static int nr_cpu; 64 65 static int file_new = 1; 66 67 struct perf_header *header; 68 69 struct mmap_data { 70 int counter; 71 void *base; 72 unsigned int mask; 73 unsigned int prev; 74 }; 75 76 static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS]; 77 78 static unsigned long mmap_read_head(struct mmap_data *md) 79 { 80 struct perf_event_mmap_page *pc = md->base; 81 long head; 82 83 head = pc->data_head; 84 rmb(); 85 86 return head; 87 } 88 89 static void mmap_write_tail(struct mmap_data *md, unsigned long tail) 90 { 91 struct perf_event_mmap_page *pc = md->base; 92 93 /* 94 * ensure all reads are done before we write the tail out. 95 */ 96 /* mb(); */ 97 pc->data_tail = tail; 98 } 99 100 static void write_output(void *buf, size_t size) 101 { 102 while (size) { 103 int ret = write(output, buf, size); 104 105 if (ret < 0) 106 die("failed to write"); 107 108 size -= ret; 109 buf += ret; 110 111 bytes_written += ret; 112 } 113 } 114 115 static void mmap_read(struct mmap_data *md) 116 { 117 unsigned int head = mmap_read_head(md); 118 unsigned int old = md->prev; 119 unsigned char *data = md->base + page_size; 120 unsigned long size; 121 void *buf; 122 int diff; 123 124 gettimeofday(&this_read, NULL); 125 126 /* 127 * If we're further behind than half the buffer, there's a chance 128 * the writer will bite our tail and mess up the samples under us. 129 * 130 * If we somehow ended up ahead of the head, we got messed up. 131 * 132 * In either case, truncate and restart at head. 133 */ 134 diff = head - old; 135 if (diff < 0) { 136 struct timeval iv; 137 unsigned long msecs; 138 139 timersub(&this_read, &last_read, &iv); 140 msecs = iv.tv_sec*1000 + iv.tv_usec/1000; 141 142 fprintf(stderr, "WARNING: failed to keep up with mmap data." 143 " Last read %lu msecs ago.\n", msecs); 144 145 /* 146 * head points to a known good entry, start there. 147 */ 148 old = head; 149 } 150 151 last_read = this_read; 152 153 if (old != head) 154 samples++; 155 156 size = head - old; 157 158 if ((old & md->mask) + size != (head & md->mask)) { 159 buf = &data[old & md->mask]; 160 size = md->mask + 1 - (old & md->mask); 161 old += size; 162 163 write_output(buf, size); 164 } 165 166 buf = &data[old & md->mask]; 167 size = head - old; 168 old += size; 169 170 write_output(buf, size); 171 172 md->prev = old; 173 mmap_write_tail(md, old); 174 } 175 176 static volatile int done = 0; 177 static volatile int signr = -1; 178 179 static void sig_handler(int sig) 180 { 181 done = 1; 182 signr = sig; 183 } 184 185 static void sig_atexit(void) 186 { 187 if (signr == -1) 188 return; 189 190 signal(signr, SIG_DFL); 191 kill(getpid(), signr); 192 } 193 194 static pid_t pid_synthesize_comm_event(pid_t pid, int full) 195 { 196 struct comm_event comm_ev; 197 char filename[PATH_MAX]; 198 char bf[BUFSIZ]; 199 FILE *fp; 200 size_t size = 0; 201 DIR *tasks; 202 struct dirent dirent, *next; 203 pid_t tgid = 0; 204 205 snprintf(filename, sizeof(filename), "/proc/%d/status", pid); 206 207 fp = fopen(filename, "r"); 208 if (fp == NULL) { 209 /* 210 * We raced with a task exiting - just return: 211 */ 212 if (verbose) 213 fprintf(stderr, "couldn't open %s\n", filename); 214 return 0; 215 } 216 217 memset(&comm_ev, 0, sizeof(comm_ev)); 218 while (!comm_ev.comm[0] || !comm_ev.pid) { 219 if (fgets(bf, sizeof(bf), fp) == NULL) 220 goto out_failure; 221 222 if (memcmp(bf, "Name:", 5) == 0) { 223 char *name = bf + 5; 224 while (*name && isspace(*name)) 225 ++name; 226 size = strlen(name) - 1; 227 memcpy(comm_ev.comm, name, size++); 228 } else if (memcmp(bf, "Tgid:", 5) == 0) { 229 char *tgids = bf + 5; 230 while (*tgids && isspace(*tgids)) 231 ++tgids; 232 tgid = comm_ev.pid = atoi(tgids); 233 } 234 } 235 236 comm_ev.header.type = PERF_RECORD_COMM; 237 size = ALIGN(size, sizeof(u64)); 238 comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size); 239 240 if (!full) { 241 comm_ev.tid = pid; 242 243 write_output(&comm_ev, comm_ev.header.size); 244 goto out_fclose; 245 } 246 247 snprintf(filename, sizeof(filename), "/proc/%d/task", pid); 248 249 tasks = opendir(filename); 250 while (!readdir_r(tasks, &dirent, &next) && next) { 251 char *end; 252 pid = strtol(dirent.d_name, &end, 10); 253 if (*end) 254 continue; 255 256 comm_ev.tid = pid; 257 258 write_output(&comm_ev, comm_ev.header.size); 259 } 260 closedir(tasks); 261 262 out_fclose: 263 fclose(fp); 264 return tgid; 265 266 out_failure: 267 fprintf(stderr, "couldn't get COMM and pgid, malformed %s\n", 268 filename); 269 exit(EXIT_FAILURE); 270 } 271 272 static void pid_synthesize_mmap_samples(pid_t pid, pid_t tgid) 273 { 274 char filename[PATH_MAX]; 275 FILE *fp; 276 277 snprintf(filename, sizeof(filename), "/proc/%d/maps", pid); 278 279 fp = fopen(filename, "r"); 280 if (fp == NULL) { 281 /* 282 * We raced with a task exiting - just return: 283 */ 284 if (verbose) 285 fprintf(stderr, "couldn't open %s\n", filename); 286 return; 287 } 288 while (1) { 289 char bf[BUFSIZ], *pbf = bf; 290 struct mmap_event mmap_ev = { 291 .header = { .type = PERF_RECORD_MMAP }, 292 }; 293 int n; 294 size_t size; 295 if (fgets(bf, sizeof(bf), fp) == NULL) 296 break; 297 298 /* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */ 299 n = hex2u64(pbf, &mmap_ev.start); 300 if (n < 0) 301 continue; 302 pbf += n + 1; 303 n = hex2u64(pbf, &mmap_ev.len); 304 if (n < 0) 305 continue; 306 pbf += n + 3; 307 if (*pbf == 'x') { /* vm_exec */ 308 char *execname = strchr(bf, '/'); 309 310 /* Catch VDSO */ 311 if (execname == NULL) 312 execname = strstr(bf, "[vdso]"); 313 314 if (execname == NULL) 315 continue; 316 317 size = strlen(execname); 318 execname[size - 1] = '\0'; /* Remove \n */ 319 memcpy(mmap_ev.filename, execname, size); 320 size = ALIGN(size, sizeof(u64)); 321 mmap_ev.len -= mmap_ev.start; 322 mmap_ev.header.size = (sizeof(mmap_ev) - 323 (sizeof(mmap_ev.filename) - size)); 324 mmap_ev.pid = tgid; 325 mmap_ev.tid = pid; 326 327 write_output(&mmap_ev, mmap_ev.header.size); 328 } 329 } 330 331 fclose(fp); 332 } 333 334 static void synthesize_all(void) 335 { 336 DIR *proc; 337 struct dirent dirent, *next; 338 339 proc = opendir("/proc"); 340 341 while (!readdir_r(proc, &dirent, &next) && next) { 342 char *end; 343 pid_t pid, tgid; 344 345 pid = strtol(dirent.d_name, &end, 10); 346 if (*end) /* only interested in proper numerical dirents */ 347 continue; 348 349 tgid = pid_synthesize_comm_event(pid, 1); 350 pid_synthesize_mmap_samples(pid, tgid); 351 } 352 353 closedir(proc); 354 } 355 356 static int group_fd; 357 358 static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int nr) 359 { 360 struct perf_header_attr *h_attr; 361 362 if (nr < header->attrs) { 363 h_attr = header->attr[nr]; 364 } else { 365 h_attr = perf_header_attr__new(a); 366 perf_header__add_attr(header, h_attr); 367 } 368 369 return h_attr; 370 } 371 372 static void create_counter(int counter, int cpu, pid_t pid) 373 { 374 struct perf_event_attr *attr = attrs + counter; 375 struct perf_header_attr *h_attr; 376 int track = !counter; /* only the first counter needs these */ 377 struct { 378 u64 count; 379 u64 time_enabled; 380 u64 time_running; 381 u64 id; 382 } read_data; 383 384 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | 385 PERF_FORMAT_TOTAL_TIME_RUNNING | 386 PERF_FORMAT_ID; 387 388 attr->sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID; 389 390 if (freq) { 391 attr->sample_type |= PERF_SAMPLE_PERIOD; 392 attr->freq = 1; 393 attr->sample_freq = freq; 394 } 395 396 if (no_samples) 397 attr->sample_freq = 0; 398 399 if (inherit_stat) 400 attr->inherit_stat = 1; 401 402 if (sample_address) 403 attr->sample_type |= PERF_SAMPLE_ADDR; 404 405 if (call_graph) 406 attr->sample_type |= PERF_SAMPLE_CALLCHAIN; 407 408 if (raw_samples) { 409 attr->sample_type |= PERF_SAMPLE_TIME; 410 attr->sample_type |= PERF_SAMPLE_RAW; 411 attr->sample_type |= PERF_SAMPLE_CPU; 412 } 413 414 attr->mmap = track; 415 attr->comm = track; 416 attr->inherit = (cpu < 0) && inherit; 417 attr->disabled = 1; 418 419 try_again: 420 fd[nr_cpu][counter] = sys_perf_event_open(attr, pid, cpu, group_fd, 0); 421 422 if (fd[nr_cpu][counter] < 0) { 423 int err = errno; 424 425 if (err == EPERM) 426 die("Permission error - are you root?\n"); 427 else if (err == ENODEV && profile_cpu != -1) 428 die("No such device - did you specify an out-of-range profile CPU?\n"); 429 430 /* 431 * If it's cycles then fall back to hrtimer 432 * based cpu-clock-tick sw counter, which 433 * is always available even if no PMU support: 434 */ 435 if (attr->type == PERF_TYPE_HARDWARE 436 && attr->config == PERF_COUNT_HW_CPU_CYCLES) { 437 438 if (verbose) 439 warning(" ... trying to fall back to cpu-clock-ticks\n"); 440 attr->type = PERF_TYPE_SOFTWARE; 441 attr->config = PERF_COUNT_SW_CPU_CLOCK; 442 goto try_again; 443 } 444 printf("\n"); 445 error("perfcounter syscall returned with %d (%s)\n", 446 fd[nr_cpu][counter], strerror(err)); 447 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n"); 448 exit(-1); 449 } 450 451 h_attr = get_header_attr(attr, counter); 452 453 if (!file_new) { 454 if (memcmp(&h_attr->attr, attr, sizeof(*attr))) { 455 fprintf(stderr, "incompatible append\n"); 456 exit(-1); 457 } 458 } 459 460 if (read(fd[nr_cpu][counter], &read_data, sizeof(read_data)) == -1) { 461 perror("Unable to read perf file descriptor\n"); 462 exit(-1); 463 } 464 465 perf_header_attr__add_id(h_attr, read_data.id); 466 467 assert(fd[nr_cpu][counter] >= 0); 468 fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK); 469 470 /* 471 * First counter acts as the group leader: 472 */ 473 if (group && group_fd == -1) 474 group_fd = fd[nr_cpu][counter]; 475 if (multiplex && multiplex_fd == -1) 476 multiplex_fd = fd[nr_cpu][counter]; 477 478 if (multiplex && fd[nr_cpu][counter] != multiplex_fd) { 479 int ret; 480 481 ret = ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_SET_OUTPUT, multiplex_fd); 482 assert(ret != -1); 483 } else { 484 event_array[nr_poll].fd = fd[nr_cpu][counter]; 485 event_array[nr_poll].events = POLLIN; 486 nr_poll++; 487 488 mmap_array[nr_cpu][counter].counter = counter; 489 mmap_array[nr_cpu][counter].prev = 0; 490 mmap_array[nr_cpu][counter].mask = mmap_pages*page_size - 1; 491 mmap_array[nr_cpu][counter].base = mmap(NULL, (mmap_pages+1)*page_size, 492 PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter], 0); 493 if (mmap_array[nr_cpu][counter].base == MAP_FAILED) { 494 error("failed to mmap with %d (%s)\n", errno, strerror(errno)); 495 exit(-1); 496 } 497 } 498 499 ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_ENABLE); 500 } 501 502 static void open_counters(int cpu, pid_t pid) 503 { 504 int counter; 505 506 group_fd = -1; 507 for (counter = 0; counter < nr_counters; counter++) 508 create_counter(counter, cpu, pid); 509 510 nr_cpu++; 511 } 512 513 static void atexit_header(void) 514 { 515 header->data_size += bytes_written; 516 517 perf_header__write(header, output); 518 } 519 520 static int __cmd_record(int argc, const char **argv) 521 { 522 int i, counter; 523 struct stat st; 524 pid_t pid = 0; 525 int flags; 526 int ret; 527 unsigned long waking = 0; 528 529 page_size = sysconf(_SC_PAGE_SIZE); 530 nr_cpus = sysconf(_SC_NPROCESSORS_ONLN); 531 assert(nr_cpus <= MAX_NR_CPUS); 532 assert(nr_cpus >= 0); 533 534 atexit(sig_atexit); 535 signal(SIGCHLD, sig_handler); 536 signal(SIGINT, sig_handler); 537 538 if (!stat(output_name, &st) && st.st_size) { 539 if (!force && !append_file) { 540 fprintf(stderr, "Error, output file %s exists, use -A to append or -f to overwrite.\n", 541 output_name); 542 exit(-1); 543 } 544 } else { 545 append_file = 0; 546 } 547 548 flags = O_CREAT|O_RDWR; 549 if (append_file) 550 file_new = 0; 551 else 552 flags |= O_TRUNC; 553 554 output = open(output_name, flags, S_IRUSR|S_IWUSR); 555 if (output < 0) { 556 perror("failed to create output file"); 557 exit(-1); 558 } 559 560 if (!file_new) 561 header = perf_header__read(output); 562 else 563 header = perf_header__new(); 564 565 566 if (raw_samples) { 567 read_tracing_data(attrs, nr_counters); 568 } else { 569 for (i = 0; i < nr_counters; i++) { 570 if (attrs[i].sample_type & PERF_SAMPLE_RAW) { 571 read_tracing_data(attrs, nr_counters); 572 break; 573 } 574 } 575 } 576 atexit(atexit_header); 577 578 if (!system_wide) { 579 pid = target_pid; 580 if (pid == -1) 581 pid = getpid(); 582 583 open_counters(profile_cpu, pid); 584 } else { 585 if (profile_cpu != -1) { 586 open_counters(profile_cpu, target_pid); 587 } else { 588 for (i = 0; i < nr_cpus; i++) 589 open_counters(i, target_pid); 590 } 591 } 592 593 if (file_new) 594 perf_header__write(header, output); 595 596 if (!system_wide) { 597 pid_t tgid = pid_synthesize_comm_event(pid, 0); 598 pid_synthesize_mmap_samples(pid, tgid); 599 } else 600 synthesize_all(); 601 602 if (target_pid == -1 && argc) { 603 pid = fork(); 604 if (pid < 0) 605 perror("failed to fork"); 606 607 if (!pid) { 608 if (execvp(argv[0], (char **)argv)) { 609 perror(argv[0]); 610 exit(-1); 611 } 612 } 613 } 614 615 if (realtime_prio) { 616 struct sched_param param; 617 618 param.sched_priority = realtime_prio; 619 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 620 printf("Could not set realtime priority.\n"); 621 exit(-1); 622 } 623 } 624 625 for (;;) { 626 int hits = samples; 627 628 for (i = 0; i < nr_cpu; i++) { 629 for (counter = 0; counter < nr_counters; counter++) { 630 if (mmap_array[i][counter].base) 631 mmap_read(&mmap_array[i][counter]); 632 } 633 } 634 635 if (hits == samples) { 636 if (done) 637 break; 638 ret = poll(event_array, nr_poll, -1); 639 waking++; 640 } 641 642 if (done) { 643 for (i = 0; i < nr_cpu; i++) { 644 for (counter = 0; counter < nr_counters; counter++) 645 ioctl(fd[i][counter], PERF_EVENT_IOC_DISABLE); 646 } 647 } 648 } 649 650 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking); 651 652 /* 653 * Approximate RIP event size: 24 bytes. 654 */ 655 fprintf(stderr, 656 "[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n", 657 (double)bytes_written / 1024.0 / 1024.0, 658 output_name, 659 bytes_written / 24); 660 661 return 0; 662 } 663 664 static const char * const record_usage[] = { 665 "perf record [<options>] [<command>]", 666 "perf record [<options>] -- <command> [<options>]", 667 NULL 668 }; 669 670 static const struct option options[] = { 671 OPT_CALLBACK('e', "event", NULL, "event", 672 "event selector. use 'perf list' to list available events", 673 parse_events), 674 OPT_INTEGER('p', "pid", &target_pid, 675 "record events on existing pid"), 676 OPT_INTEGER('r', "realtime", &realtime_prio, 677 "collect data with this RT SCHED_FIFO priority"), 678 OPT_BOOLEAN('R', "raw-samples", &raw_samples, 679 "collect raw sample records from all opened counters"), 680 OPT_BOOLEAN('a', "all-cpus", &system_wide, 681 "system-wide collection from all CPUs"), 682 OPT_BOOLEAN('A', "append", &append_file, 683 "append to the output file to do incremental profiling"), 684 OPT_INTEGER('C', "profile_cpu", &profile_cpu, 685 "CPU to profile on"), 686 OPT_BOOLEAN('f', "force", &force, 687 "overwrite existing data file"), 688 OPT_LONG('c', "count", &default_interval, 689 "event period to sample"), 690 OPT_STRING('o', "output", &output_name, "file", 691 "output file name"), 692 OPT_BOOLEAN('i', "inherit", &inherit, 693 "child tasks inherit counters"), 694 OPT_INTEGER('F', "freq", &freq, 695 "profile at this frequency"), 696 OPT_INTEGER('m', "mmap-pages", &mmap_pages, 697 "number of mmap data pages"), 698 OPT_BOOLEAN('g', "call-graph", &call_graph, 699 "do call-graph (stack chain/backtrace) recording"), 700 OPT_BOOLEAN('v', "verbose", &verbose, 701 "be more verbose (show counter open errors, etc)"), 702 OPT_BOOLEAN('s', "stat", &inherit_stat, 703 "per thread counts"), 704 OPT_BOOLEAN('d', "data", &sample_address, 705 "Sample addresses"), 706 OPT_BOOLEAN('n', "no-samples", &no_samples, 707 "don't sample"), 708 OPT_BOOLEAN('M', "multiplex", &multiplex, 709 "multiplex counter output in a single channel"), 710 OPT_END() 711 }; 712 713 int cmd_record(int argc, const char **argv, const char *prefix __used) 714 { 715 int counter; 716 717 argc = parse_options(argc, argv, options, record_usage, 718 PARSE_OPT_STOP_AT_NON_OPTION); 719 if (!argc && target_pid == -1 && !system_wide) 720 usage_with_options(record_usage, options); 721 722 if (!nr_counters) { 723 nr_counters = 1; 724 attrs[0].type = PERF_TYPE_HARDWARE; 725 attrs[0].config = PERF_COUNT_HW_CPU_CYCLES; 726 } 727 728 for (counter = 0; counter < nr_counters; counter++) { 729 if (attrs[counter].sample_period) 730 continue; 731 732 attrs[counter].sample_period = default_interval; 733 } 734 735 return __cmd_record(argc, argv); 736 } 737