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#define _FILE_OFFSET_BITS 64 9 10#include "builtin.h" 11 12#include "perf.h" 13 14#include "util/build-id.h" 15#include "util/util.h" 16#include "util/parse-options.h" 17#include "util/parse-events.h" 18 19#include "util/header.h" 20#include "util/event.h" 21#include "util/debug.h" 22#include "util/session.h" 23#include "util/symbol.h" 24#include "util/cpumap.h" 25 26#include <unistd.h> 27#include <sched.h> 28#include <sys/mman.h> 29 30enum write_mode_t { 31 WRITE_FORCE, 32 WRITE_APPEND 33}; 34 35static int *fd[MAX_NR_CPUS][MAX_COUNTERS]; 36 37static u64 user_interval = ULLONG_MAX; 38static u64 default_interval = 0; 39 40static int nr_cpus = 0; 41static unsigned int page_size; 42static unsigned int mmap_pages = 128; 43static unsigned int user_freq = UINT_MAX; 44static int freq = 1000; 45static int output; 46static int pipe_output = 0; 47static const char *output_name = "perf.data"; 48static int group = 0; 49static int realtime_prio = 0; 50static bool raw_samples = false; 51static bool system_wide = false; 52static pid_t target_pid = -1; 53static pid_t target_tid = -1; 54static pid_t *all_tids = NULL; 55static int thread_num = 0; 56static pid_t child_pid = -1; 57static bool no_inherit = false; 58static enum write_mode_t write_mode = WRITE_FORCE; 59static bool call_graph = false; 60static bool inherit_stat = false; 61static bool no_samples = false; 62static bool sample_address = false; 63static bool no_buildid = false; 64 65static long samples = 0; 66static u64 bytes_written = 0; 67 68static struct pollfd *event_array; 69 70static int nr_poll = 0; 71static int nr_cpu = 0; 72 73static int file_new = 1; 74static off_t post_processing_offset; 75 76static struct perf_session *session; 77static const char *cpu_list; 78 79struct mmap_data { 80 int counter; 81 void *base; 82 unsigned int mask; 83 unsigned int prev; 84}; 85 86static struct mmap_data mmap_array[MAX_NR_CPUS]; 87 88static unsigned long mmap_read_head(struct mmap_data *md) 89{ 90 struct perf_event_mmap_page *pc = md->base; 91 long head; 92 93 head = pc->data_head; 94 rmb(); 95 96 return head; 97} 98 99static void mmap_write_tail(struct mmap_data *md, unsigned long tail) 100{ 101 struct perf_event_mmap_page *pc = md->base; 102 103 /* 104 * ensure all reads are done before we write the tail out. 105 */ 106 /* mb(); */ 107 pc->data_tail = tail; 108} 109 110static void advance_output(size_t size) 111{ 112 bytes_written += size; 113} 114 115static void write_output(void *buf, size_t size) 116{ 117 while (size) { 118 int ret = write(output, buf, size); 119 120 if (ret < 0) 121 die("failed to write"); 122 123 size -= ret; 124 buf += ret; 125 126 bytes_written += ret; 127 } 128} 129 130static int process_synthesized_event(event_t *event, 131 struct perf_session *self __used) 132{ 133 write_output(event, event->header.size); 134 return 0; 135} 136 137static void mmap_read(struct mmap_data *md) 138{ 139 unsigned int head = mmap_read_head(md); 140 unsigned int old = md->prev; 141 unsigned char *data = md->base + page_size; 142 unsigned long size; 143 void *buf; 144 int diff; 145 146 /* 147 * If we're further behind than half the buffer, there's a chance 148 * the writer will bite our tail and mess up the samples under us. 149 * 150 * If we somehow ended up ahead of the head, we got messed up. 151 * 152 * In either case, truncate and restart at head. 153 */ 154 diff = head - old; 155 if (diff < 0) { 156 fprintf(stderr, "WARNING: failed to keep up with mmap data\n"); 157 /* 158 * head points to a known good entry, start there. 159 */ 160 old = head; 161 } 162 163 if (old != head) 164 samples++; 165 166 size = head - old; 167 168 if ((old & md->mask) + size != (head & md->mask)) { 169 buf = &data[old & md->mask]; 170 size = md->mask + 1 - (old & md->mask); 171 old += size; 172 173 write_output(buf, size); 174 } 175 176 buf = &data[old & md->mask]; 177 size = head - old; 178 old += size; 179 180 write_output(buf, size); 181 182 md->prev = old; 183 mmap_write_tail(md, old); 184} 185 186static volatile int done = 0; 187static volatile int signr = -1; 188 189static void sig_handler(int sig) 190{ 191 done = 1; 192 signr = sig; 193} 194 195static void sig_atexit(void) 196{ 197 if (child_pid > 0) 198 kill(child_pid, SIGTERM); 199 200 if (signr == -1) 201 return; 202 203 signal(signr, SIG_DFL); 204 kill(getpid(), signr); 205} 206 207static int group_fd; 208 209static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int nr) 210{ 211 struct perf_header_attr *h_attr; 212 213 if (nr < session->header.attrs) { 214 h_attr = session->header.attr[nr]; 215 } else { 216 h_attr = perf_header_attr__new(a); 217 if (h_attr != NULL) 218 if (perf_header__add_attr(&session->header, h_attr) < 0) { 219 perf_header_attr__delete(h_attr); 220 h_attr = NULL; 221 } 222 } 223 224 return h_attr; 225} 226 227static void create_counter(int counter, int cpu) 228{ 229 char *filter = filters[counter]; 230 struct perf_event_attr *attr = attrs + counter; 231 struct perf_header_attr *h_attr; 232 int track = !counter; /* only the first counter needs these */ 233 int thread_index; 234 int ret; 235 struct { 236 u64 count; 237 u64 time_enabled; 238 u64 time_running; 239 u64 id; 240 } read_data; 241 242 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | 243 PERF_FORMAT_TOTAL_TIME_RUNNING | 244 PERF_FORMAT_ID; 245 246 attr->sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID; 247 248 if (nr_counters > 1) 249 attr->sample_type |= PERF_SAMPLE_ID; 250 251 /* 252 * We default some events to a 1 default interval. But keep 253 * it a weak assumption overridable by the user. 254 */ 255 if (!attr->sample_period || (user_freq != UINT_MAX && 256 user_interval != ULLONG_MAX)) { 257 if (freq) { 258 attr->sample_type |= PERF_SAMPLE_PERIOD; 259 attr->freq = 1; 260 attr->sample_freq = freq; 261 } else { 262 attr->sample_period = default_interval; 263 } 264 } 265 266 if (no_samples) 267 attr->sample_freq = 0; 268 269 if (inherit_stat) 270 attr->inherit_stat = 1; 271 272 if (sample_address) { 273 attr->sample_type |= PERF_SAMPLE_ADDR; 274 attr->mmap_data = track; 275 } 276 277 if (call_graph) 278 attr->sample_type |= PERF_SAMPLE_CALLCHAIN; 279 280 if (system_wide) 281 attr->sample_type |= PERF_SAMPLE_CPU; 282 283 if (raw_samples) { 284 attr->sample_type |= PERF_SAMPLE_TIME; 285 attr->sample_type |= PERF_SAMPLE_RAW; 286 attr->sample_type |= PERF_SAMPLE_CPU; 287 } 288 289 attr->mmap = track; 290 attr->comm = track; 291 attr->inherit = !no_inherit; 292 if (target_pid == -1 && target_tid == -1 && !system_wide) { 293 attr->disabled = 1; 294 attr->enable_on_exec = 1; 295 } 296 297 for (thread_index = 0; thread_index < thread_num; thread_index++) { 298try_again: 299 fd[nr_cpu][counter][thread_index] = sys_perf_event_open(attr, 300 all_tids[thread_index], cpu, group_fd, 0); 301 302 if (fd[nr_cpu][counter][thread_index] < 0) { 303 int err = errno; 304 305 if (err == EPERM || err == EACCES) 306 die("Permission error - are you root?\n" 307 "\t Consider tweaking" 308 " /proc/sys/kernel/perf_event_paranoid.\n"); 309 else if (err == ENODEV && cpu_list) { 310 die("No such device - did you specify" 311 " an out-of-range profile CPU?\n"); 312 } 313 314 /* 315 * If it's cycles then fall back to hrtimer 316 * based cpu-clock-tick sw counter, which 317 * is always available even if no PMU support: 318 */ 319 if (attr->type == PERF_TYPE_HARDWARE 320 && attr->config == PERF_COUNT_HW_CPU_CYCLES) { 321 322 if (verbose) 323 warning(" ... trying to fall back to cpu-clock-ticks\n"); 324 attr->type = PERF_TYPE_SOFTWARE; 325 attr->config = PERF_COUNT_SW_CPU_CLOCK; 326 goto try_again; 327 } 328 printf("\n"); 329 error("perfcounter syscall returned with %d (%s)\n", 330 fd[nr_cpu][counter][thread_index], strerror(err)); 331 332#if defined(__i386__) || defined(__x86_64__) 333 if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP) 334 die("No hardware sampling interrupt available." 335 " No APIC? If so then you can boot the kernel" 336 " with the \"lapic\" boot parameter to" 337 " force-enable it.\n"); 338#endif 339 340 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n"); 341 exit(-1); 342 } 343 344 h_attr = get_header_attr(attr, counter); 345 if (h_attr == NULL) 346 die("nomem\n"); 347 348 if (!file_new) { 349 if (memcmp(&h_attr->attr, attr, sizeof(*attr))) { 350 fprintf(stderr, "incompatible append\n"); 351 exit(-1); 352 } 353 } 354 355 if (read(fd[nr_cpu][counter][thread_index], &read_data, sizeof(read_data)) == -1) { 356 perror("Unable to read perf file descriptor\n"); 357 exit(-1); 358 } 359 360 if (perf_header_attr__add_id(h_attr, read_data.id) < 0) { 361 pr_warning("Not enough memory to add id\n"); 362 exit(-1); 363 } 364 365 assert(fd[nr_cpu][counter][thread_index] >= 0); 366 fcntl(fd[nr_cpu][counter][thread_index], F_SETFL, O_NONBLOCK); 367 368 /* 369 * First counter acts as the group leader: 370 */ 371 if (group && group_fd == -1) 372 group_fd = fd[nr_cpu][counter][thread_index]; 373 374 if (counter || thread_index) { 375 ret = ioctl(fd[nr_cpu][counter][thread_index], 376 PERF_EVENT_IOC_SET_OUTPUT, 377 fd[nr_cpu][0][0]); 378 if (ret) { 379 error("failed to set output: %d (%s)\n", errno, 380 strerror(errno)); 381 exit(-1); 382 } 383 } else { 384 mmap_array[nr_cpu].counter = counter; 385 mmap_array[nr_cpu].prev = 0; 386 mmap_array[nr_cpu].mask = mmap_pages*page_size - 1; 387 mmap_array[nr_cpu].base = mmap(NULL, (mmap_pages+1)*page_size, 388 PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter][thread_index], 0); 389 if (mmap_array[nr_cpu].base == MAP_FAILED) { 390 error("failed to mmap with %d (%s)\n", errno, strerror(errno)); 391 exit(-1); 392 } 393 394 event_array[nr_poll].fd = fd[nr_cpu][counter][thread_index]; 395 event_array[nr_poll].events = POLLIN; 396 nr_poll++; 397 } 398 399 if (filter != NULL) { 400 ret = ioctl(fd[nr_cpu][counter][thread_index], 401 PERF_EVENT_IOC_SET_FILTER, filter); 402 if (ret) { 403 error("failed to set filter with %d (%s)\n", errno, 404 strerror(errno)); 405 exit(-1); 406 } 407 } 408 } 409} 410 411static void open_counters(int cpu) 412{ 413 int counter; 414 415 group_fd = -1; 416 for (counter = 0; counter < nr_counters; counter++) 417 create_counter(counter, cpu); 418 419 nr_cpu++; 420} 421 422static int process_buildids(void) 423{ 424 u64 size = lseek(output, 0, SEEK_CUR); 425 426 if (size == 0) 427 return 0; 428 429 session->fd = output; 430 return __perf_session__process_events(session, post_processing_offset, 431 size - post_processing_offset, 432 size, &build_id__mark_dso_hit_ops); 433} 434 435static void atexit_header(void) 436{ 437 if (!pipe_output) { 438 session->header.data_size += bytes_written; 439 440 process_buildids(); 441 perf_header__write(&session->header, output, true); 442 perf_session__delete(session); 443 symbol__exit(); 444 } 445} 446 447static void event__synthesize_guest_os(struct machine *machine, void *data) 448{ 449 int err; 450 struct perf_session *psession = data; 451 452 if (machine__is_host(machine)) 453 return; 454 455 err = event__synthesize_modules(process_synthesized_event, 456 psession, machine); 457 if (err < 0) 458 pr_err("Couldn't record guest kernel [%d]'s reference" 459 " relocation symbol.\n", machine->pid); 460 461 /* 462 * We use _stext for guest kernel because guest kernel's /proc/kallsyms 463 * have no _text sometimes. 464 */ 465 err = event__synthesize_kernel_mmap(process_synthesized_event, 466 psession, machine, "_text"); 467 if (err < 0) 468 err = event__synthesize_kernel_mmap(process_synthesized_event, 469 psession, machine, "_stext"); 470 if (err < 0) 471 pr_err("Couldn't record guest kernel [%d]'s reference" 472 " relocation symbol.\n", machine->pid); 473} 474 475static struct perf_event_header finished_round_event = { 476 .size = sizeof(struct perf_event_header), 477 .type = PERF_RECORD_FINISHED_ROUND, 478}; 479 480static void mmap_read_all(void) 481{ 482 int i; 483 484 for (i = 0; i < nr_cpu; i++) { 485 if (mmap_array[i].base) 486 mmap_read(&mmap_array[i]); 487 } 488 489 if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO)) 490 write_output(&finished_round_event, sizeof(finished_round_event)); 491} 492 493static int __cmd_record(int argc, const char **argv) 494{ 495 int i, counter; 496 struct stat st; 497 int flags; 498 int err; 499 unsigned long waking = 0; 500 int child_ready_pipe[2], go_pipe[2]; 501 const bool forks = argc > 0; 502 char buf; 503 struct machine *machine; 504 505 page_size = sysconf(_SC_PAGE_SIZE); 506 507 atexit(sig_atexit); 508 signal(SIGCHLD, sig_handler); 509 signal(SIGINT, sig_handler); 510 511 if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) { 512 perror("failed to create pipes"); 513 exit(-1); 514 } 515 516 if (!strcmp(output_name, "-")) 517 pipe_output = 1; 518 else if (!stat(output_name, &st) && st.st_size) { 519 if (write_mode == WRITE_FORCE) { 520 char oldname[PATH_MAX]; 521 snprintf(oldname, sizeof(oldname), "%s.old", 522 output_name); 523 unlink(oldname); 524 rename(output_name, oldname); 525 } 526 } else if (write_mode == WRITE_APPEND) { 527 write_mode = WRITE_FORCE; 528 } 529 530 flags = O_CREAT|O_RDWR; 531 if (write_mode == WRITE_APPEND) 532 file_new = 0; 533 else 534 flags |= O_TRUNC; 535 536 if (pipe_output) 537 output = STDOUT_FILENO; 538 else 539 output = open(output_name, flags, S_IRUSR | S_IWUSR); 540 if (output < 0) { 541 perror("failed to create output file"); 542 exit(-1); 543 } 544 545 session = perf_session__new(output_name, O_WRONLY, 546 write_mode == WRITE_FORCE, false); 547 if (session == NULL) { 548 pr_err("Not enough memory for reading perf file header\n"); 549 return -1; 550 } 551 552 if (!file_new) { 553 err = perf_header__read(session, output); 554 if (err < 0) 555 goto out_delete_session; 556 } 557 558 if (have_tracepoints(attrs, nr_counters)) 559 perf_header__set_feat(&session->header, HEADER_TRACE_INFO); 560 561 /* 562 * perf_session__delete(session) will be called at atexit_header() 563 */ 564 atexit(atexit_header); 565 566 if (forks) { 567 child_pid = fork(); 568 if (child_pid < 0) { 569 perror("failed to fork"); 570 exit(-1); 571 } 572 573 if (!child_pid) { 574 if (pipe_output) 575 dup2(2, 1); 576 close(child_ready_pipe[0]); 577 close(go_pipe[1]); 578 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC); 579 580 /* 581 * Do a dummy execvp to get the PLT entry resolved, 582 * so we avoid the resolver overhead on the real 583 * execvp call. 584 */ 585 execvp("", (char **)argv); 586 587 /* 588 * Tell the parent we're ready to go 589 */ 590 close(child_ready_pipe[1]); 591 592 /* 593 * Wait until the parent tells us to go. 594 */ 595 if (read(go_pipe[0], &buf, 1) == -1) 596 perror("unable to read pipe"); 597 598 execvp(argv[0], (char **)argv); 599 600 perror(argv[0]); 601 exit(-1); 602 } 603 604 if (!system_wide && target_tid == -1 && target_pid == -1) 605 all_tids[0] = child_pid; 606 607 close(child_ready_pipe[1]); 608 close(go_pipe[0]); 609 /* 610 * wait for child to settle 611 */ 612 if (read(child_ready_pipe[0], &buf, 1) == -1) { 613 perror("unable to read pipe"); 614 exit(-1); 615 } 616 close(child_ready_pipe[0]); 617 } 618 619 nr_cpus = read_cpu_map(cpu_list); 620 if (nr_cpus < 1) { 621 perror("failed to collect number of CPUs\n"); 622 return -1; 623 } 624 625 if (!system_wide && no_inherit && !cpu_list) { 626 open_counters(-1); 627 } else { 628 for (i = 0; i < nr_cpus; i++) 629 open_counters(cpumap[i]); 630 } 631 632 if (pipe_output) { 633 err = perf_header__write_pipe(output); 634 if (err < 0) 635 return err; 636 } else if (file_new) { 637 err = perf_header__write(&session->header, output, false); 638 if (err < 0) 639 return err; 640 } 641 642 post_processing_offset = lseek(output, 0, SEEK_CUR); 643 644 if (pipe_output) { 645 err = event__synthesize_attrs(&session->header, 646 process_synthesized_event, 647 session); 648 if (err < 0) { 649 pr_err("Couldn't synthesize attrs.\n"); 650 return err; 651 } 652 653 err = event__synthesize_event_types(process_synthesized_event, 654 session); 655 if (err < 0) { 656 pr_err("Couldn't synthesize event_types.\n"); 657 return err; 658 } 659 660 if (have_tracepoints(attrs, nr_counters)) { 661 err = event__synthesize_tracing_data(output, attrs, 662 nr_counters, 663 process_synthesized_event, 664 session); 665 if (err <= 0) { 666 pr_err("Couldn't record tracing data.\n"); 667 return err; 668 } 669 advance_output(err); 670 } 671 } 672 673 machine = perf_session__find_host_machine(session); 674 if (!machine) { 675 pr_err("Couldn't find native kernel information.\n"); 676 return -1; 677 } 678 679 err = event__synthesize_kernel_mmap(process_synthesized_event, 680 session, machine, "_text"); 681 if (err < 0) 682 err = event__synthesize_kernel_mmap(process_synthesized_event, 683 session, machine, "_stext"); 684 if (err < 0) { 685 pr_err("Couldn't record kernel reference relocation symbol.\n"); 686 return err; 687 } 688 689 err = event__synthesize_modules(process_synthesized_event, 690 session, machine); 691 if (err < 0) { 692 pr_err("Couldn't record kernel reference relocation symbol.\n"); 693 return err; 694 } 695 if (perf_guest) 696 perf_session__process_machines(session, event__synthesize_guest_os); 697 698 if (!system_wide) 699 event__synthesize_thread(target_tid, process_synthesized_event, 700 session); 701 else 702 event__synthesize_threads(process_synthesized_event, session); 703 704 if (realtime_prio) { 705 struct sched_param param; 706 707 param.sched_priority = realtime_prio; 708 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 709 pr_err("Could not set realtime priority.\n"); 710 exit(-1); 711 } 712 } 713 714 /* 715 * Let the child rip 716 */ 717 if (forks) 718 close(go_pipe[1]); 719 720 for (;;) { 721 int hits = samples; 722 int thread; 723 724 mmap_read_all(); 725 726 if (hits == samples) { 727 if (done) 728 break; 729 err = poll(event_array, nr_poll, -1); 730 waking++; 731 } 732 733 if (done) { 734 for (i = 0; i < nr_cpu; i++) { 735 for (counter = 0; 736 counter < nr_counters; 737 counter++) { 738 for (thread = 0; 739 thread < thread_num; 740 thread++) 741 ioctl(fd[i][counter][thread], 742 PERF_EVENT_IOC_DISABLE); 743 } 744 } 745 } 746 } 747 748 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking); 749 750 /* 751 * Approximate RIP event size: 24 bytes. 752 */ 753 fprintf(stderr, 754 "[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n", 755 (double)bytes_written / 1024.0 / 1024.0, 756 output_name, 757 bytes_written / 24); 758 759 return 0; 760 761out_delete_session: 762 perf_session__delete(session); 763 return err; 764} 765 766static const char * const record_usage[] = { 767 "perf record [<options>] [<command>]", 768 "perf record [<options>] -- <command> [<options>]", 769 NULL 770}; 771 772static bool force, append_file; 773 774static const struct option options[] = { 775 OPT_CALLBACK('e', "event", NULL, "event", 776 "event selector. use 'perf list' to list available events", 777 parse_events), 778 OPT_CALLBACK(0, "filter", NULL, "filter", 779 "event filter", parse_filter), 780 OPT_INTEGER('p', "pid", &target_pid, 781 "record events on existing process id"), 782 OPT_INTEGER('t', "tid", &target_tid, 783 "record events on existing thread id"), 784 OPT_INTEGER('r', "realtime", &realtime_prio, 785 "collect data with this RT SCHED_FIFO priority"), 786 OPT_BOOLEAN('R', "raw-samples", &raw_samples, 787 "collect raw sample records from all opened counters"), 788 OPT_BOOLEAN('a', "all-cpus", &system_wide, 789 "system-wide collection from all CPUs"), 790 OPT_BOOLEAN('A', "append", &append_file, 791 "append to the output file to do incremental profiling"), 792 OPT_STRING('C', "cpu", &cpu_list, "cpu", 793 "list of cpus to monitor"), 794 OPT_BOOLEAN('f', "force", &force, 795 "overwrite existing data file (deprecated)"), 796 OPT_U64('c', "count", &user_interval, "event period to sample"), 797 OPT_STRING('o', "output", &output_name, "file", 798 "output file name"), 799 OPT_BOOLEAN('i', "no-inherit", &no_inherit, 800 "child tasks do not inherit counters"), 801 OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"), 802 OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"), 803 OPT_BOOLEAN('g', "call-graph", &call_graph, 804 "do call-graph (stack chain/backtrace) recording"), 805 OPT_INCR('v', "verbose", &verbose, 806 "be more verbose (show counter open errors, etc)"), 807 OPT_BOOLEAN('s', "stat", &inherit_stat, 808 "per thread counts"), 809 OPT_BOOLEAN('d', "data", &sample_address, 810 "Sample addresses"), 811 OPT_BOOLEAN('n', "no-samples", &no_samples, 812 "don't sample"), 813 OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid, 814 "do not update the buildid cache"), 815 OPT_END() 816}; 817 818int cmd_record(int argc, const char **argv, const char *prefix __used) 819{ 820 int i, j, err = -ENOMEM; 821 822 argc = parse_options(argc, argv, options, record_usage, 823 PARSE_OPT_STOP_AT_NON_OPTION); 824 if (!argc && target_pid == -1 && target_tid == -1 && 825 !system_wide && !cpu_list) 826 usage_with_options(record_usage, options); 827 828 if (force && append_file) { 829 fprintf(stderr, "Can't overwrite and append at the same time." 830 " You need to choose between -f and -A"); 831 usage_with_options(record_usage, options); 832 } else if (append_file) { 833 write_mode = WRITE_APPEND; 834 } else { 835 write_mode = WRITE_FORCE; 836 } 837 838 symbol__init(); 839 if (no_buildid) 840 disable_buildid_cache(); 841 842 if (!nr_counters) { 843 nr_counters = 1; 844 attrs[0].type = PERF_TYPE_HARDWARE; 845 attrs[0].config = PERF_COUNT_HW_CPU_CYCLES; 846 } 847 848 if (target_pid != -1) { 849 target_tid = target_pid; 850 thread_num = find_all_tid(target_pid, &all_tids); 851 if (thread_num <= 0) { 852 fprintf(stderr, "Can't find all threads of pid %d\n", 853 target_pid); 854 usage_with_options(record_usage, options); 855 } 856 } else { 857 all_tids=malloc(sizeof(pid_t)); 858 if (!all_tids) 859 goto out_symbol_exit; 860 861 all_tids[0] = target_tid; 862 thread_num = 1; 863 } 864 865 for (i = 0; i < MAX_NR_CPUS; i++) { 866 for (j = 0; j < MAX_COUNTERS; j++) { 867 fd[i][j] = malloc(sizeof(int)*thread_num); 868 if (!fd[i][j]) 869 goto out_free_fd; 870 } 871 } 872 event_array = malloc( 873 sizeof(struct pollfd)*MAX_NR_CPUS*MAX_COUNTERS*thread_num); 874 if (!event_array) 875 goto out_free_fd; 876 877 if (user_interval != ULLONG_MAX) 878 default_interval = user_interval; 879 if (user_freq != UINT_MAX) 880 freq = user_freq; 881 882 /* 883 * User specified count overrides default frequency. 884 */ 885 if (default_interval) 886 freq = 0; 887 else if (freq) { 888 default_interval = freq; 889 } else { 890 fprintf(stderr, "frequency and count are zero, aborting\n"); 891 err = -EINVAL; 892 goto out_free_event_array; 893 } 894 895 err = __cmd_record(argc, argv); 896 897out_free_event_array: 898 free(event_array); 899out_free_fd: 900 for (i = 0; i < MAX_NR_CPUS; i++) { 901 for (j = 0; j < MAX_COUNTERS; j++) 902 free(fd[i][j]); 903 } 904 free(all_tids); 905 all_tids = NULL; 906out_symbol_exit: 907 symbol__exit(); 908 return err; 909} 910