tools/perf/builtin-record.c

   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/build-id.h"
  13 #include "util/util.h"
  14 #include "util/parse-options.h"
  15 #include "util/parse-events.h"
  16
  17 #include "util/header.h"
  18 #include "util/event.h"
  19 #include "util/evlist.h"
  20 #include "util/evsel.h"
  21 #include "util/debug.h"
  22 #include "util/session.h"
  23 #include "util/tool.h"
  24 #include "util/symbol.h"
  25 #include "util/cpumap.h"
  26 #include "util/thread_map.h"
  27 #include "util/data.h"
  28
  29 #include <unistd.h>
  30 #include <sched.h>
  31 #include <sys/mman.h>
  32
  33 #ifndef HAVE_ON_EXIT_SUPPORT
  34 #ifndef ATEXIT_MAX
  35 #define ATEXIT_MAX 32
  36 #endif
  37 static int __on_exit_count = 0;
  38 typedef void (*on_exit_func_t) (int, void *);
  39 static on_exit_func_t __on_exit_funcs[ATEXIT_MAX];
  40 static void *__on_exit_args[ATEXIT_MAX];
  41 static int __exitcode = 0;
  42 static void __handle_on_exit_funcs(void);
  43 static int on_exit(on_exit_func_t function, void *arg);
  44 #define exit(x) (exit)(__exitcode = (x))
  45
  46 static int on_exit(on_exit_func_t function, void *arg)
  47 {
  48         if (__on_exit_count == ATEXIT_MAX)
  49                 return -ENOMEM;
  50         else if (__on_exit_count == 0)
  51                 atexit(__handle_on_exit_funcs);
  52         __on_exit_funcs[__on_exit_count] = function;
  53         __on_exit_args[__on_exit_count++] = arg;
  54         return 0;
  55 }
  56
  57 static void __handle_on_exit_funcs(void)
  58 {
  59         int i;
  60         for (i = 0; i < __on_exit_count; i++)
  61                 __on_exit_funcs[i] (__exitcode, __on_exit_args[i]);
  62 }
  63 #endif
  64
  65 struct record {
  66         struct perf_tool        tool;
  67         struct record_opts      opts;
  68         u64                     bytes_written;
  69         struct perf_data_file   file;
  70         struct perf_evlist      *evlist;
  71         struct perf_session     *session;
  72         const char              *progname;
  73         int                     realtime_prio;
  74         bool                    no_buildid;
  75         bool                    no_buildid_cache;
  76         long                    samples;
  77 };
  78
  79 static int record__write(struct record *rec, void *bf, size_t size)
  80 {
  81         if (perf_data_file__write(rec->session->file, bf, size) < 0) {
  82                 pr_err("failed to write perf data, error: %m\n");
  83                 return -1;
  84         }
  85
  86         rec->bytes_written += size;
  87         return 0;
  88 }
  89
  90 static int process_synthesized_event(struct perf_tool *tool,
  91                                      union perf_event *event,
  92                                      struct perf_sample *sample __maybe_unused,
  93                                      struct machine *machine __maybe_unused)
  94 {
  95         struct record *rec = container_of(tool, struct record, tool);
  96         return record__write(rec, event, event->header.size);
  97 }
  98
  99 static int record__mmap_read(struct record *rec, struct perf_mmap *md)
 100 {
 101         unsigned int head = perf_mmap__read_head(md);
 102         unsigned int old = md->prev;
 103         unsigned char *data = md->base + page_size;
 104         unsigned long size;
 105         void *buf;
 106         int rc = 0;
 107
 108         if (old == head)
 109                 return 0;
 110
 111         rec->samples++;
 112
 113         size = head - old;
 114
 115         if ((old & md->mask) + size != (head & md->mask)) {
 116                 buf = &data[old & md->mask];
 117                 size = md->mask + 1 - (old & md->mask);
 118                 old += size;
 119
 120                 if (record__write(rec, buf, size) < 0) {
 121                         rc = -1;
 122                         goto out;
 123                 }
 124         }
 125
 126         buf = &data[old & md->mask];
 127         size = head - old;
 128         old += size;
 129
 130         if (record__write(rec, buf, size) < 0) {
 131                 rc = -1;
 132                 goto out;
 133         }
 134
 135         md->prev = old;
 136         perf_mmap__write_tail(md, old);
 137
 138 out:
 139         return rc;
 140 }
 141
 142 static volatile int done = 0;
 143 static volatile int signr = -1;
 144 static volatile int child_finished = 0;
 145
 146 static void sig_handler(int sig)
 147 {
 148         if (sig == SIGCHLD)
 149                 child_finished = 1;
 150
 151         done = 1;
 152         signr = sig;
 153 }
 154
 155 static void record__sig_exit(int exit_status __maybe_unused, void *arg)
 156 {
 157         struct record *rec = arg;
 158         int status;
 159
 160         if (rec->evlist->workload.pid > 0) {
 161                 if (!child_finished)
 162                         kill(rec->evlist->workload.pid, SIGTERM);
 163
 164                 wait(&status);
 165                 if (WIFSIGNALED(status))
 166                         psignal(WTERMSIG(status), rec->progname);
 167         }
 168
 169         if (signr == -1 || signr == SIGUSR1)
 170                 return;
 171
 172         signal(signr, SIG_DFL);
 173 }
 174
 175 static int record__open(struct record *rec)
 176 {
 177         char msg[512];
 178         struct perf_evsel *pos;
 179         struct perf_evlist *evlist = rec->evlist;
 180         struct perf_session *session = rec->session;
 181         struct record_opts *opts = &rec->opts;
 182         int rc = 0;
 183
 184         perf_evlist__config(evlist, opts);
 185
 186         evlist__for_each(evlist, pos) {
 187 try_again:
 188                 if (perf_evsel__open(pos, evlist->cpus, evlist->threads) < 0) {
 189                         if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
 190                                 if (verbose)
 191                                         ui__warning("%s\n", msg);
 192                                 goto try_again;
 193                         }
 194
 195                         rc = -errno;
 196                         perf_evsel__open_strerror(pos, &opts->target,
 197                                                   errno, msg, sizeof(msg));
 198                         ui__error("%s\n", msg);
 199                         goto out;
 200                 }
 201         }
 202
 203         if (perf_evlist__apply_filters(evlist)) {
 204                 error("failed to set filter with %d (%s)\n", errno,
 205                         strerror(errno));
 206                 rc = -1;
 207                 goto out;
 208         }
 209
 210         if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) {
 211                 if (errno == EPERM) {
 212                         pr_err("Permission error mapping pages.\n"
 213                                "Consider increasing "
 214                                "/proc/sys/kernel/perf_event_mlock_kb,\n"
 215                                "or try again with a smaller value of -m/--mmap_pages.\n"
 216                                "(current value: %u)\n", opts->mmap_pages);
 217                         rc = -errno;
 218                 } else {
 219                         pr_err("failed to mmap with %d (%s)\n", errno, strerror(errno));
 220                         rc = -errno;
 221                 }
 222                 goto out;
 223         }
 224
 225         session->evlist = evlist;
 226         perf_session__set_id_hdr_size(session);
 227 out:
 228         return rc;
 229 }
 230
 231 static int process_buildids(struct record *rec)
 232 {
 233         struct perf_data_file *file  = &rec->file;
 234         struct perf_session *session = rec->session;
 235         u64 start = session->header.data_offset;
 236
 237         u64 size = lseek(file->fd, 0, SEEK_CUR);
 238         if (size == 0)
 239                 return 0;
 240
 241         return __perf_session__process_events(session, start,
 242                                               size - start,
 243                                               size, &build_id__mark_dso_hit_ops);
 244 }
 245
 246 static void record__exit(int status, void *arg)
 247 {
 248         struct record *rec = arg;
 249         struct perf_data_file *file = &rec->file;
 250
 251         if (status != 0)
 252                 return;
 253
 254         if (!file->is_pipe) {
 255                 rec->session->header.data_size += rec->bytes_written;
 256
 257                 if (!rec->no_buildid)
 258                         process_buildids(rec);
 259                 perf_session__write_header(rec->session, rec->evlist,
 260                                            file->fd, true);
 261                 perf_session__delete(rec->session);
 262                 perf_evlist__delete(rec->evlist);
 263                 symbol__exit();
 264         }
 265 }
 266
 267 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
 268 {
 269         int err;
 270         struct perf_tool *tool = data;
 271         /*
 272          *As for guest kernel when processing subcommand record&report,
 273          *we arrange module mmap prior to guest kernel mmap and trigger
 274          *a preload dso because default guest module symbols are loaded
 275          *from guest kallsyms instead of /lib/modules/XXX/XXX. This
 276          *method is used to avoid symbol missing when the first addr is
 277          *in module instead of in guest kernel.
 278          */
 279         err = perf_event__synthesize_modules(tool, process_synthesized_event,
 280                                              machine);
 281         if (err < 0)
 282                 pr_err("Couldn't record guest kernel [%d]'s reference"
 283                        " relocation symbol.\n", machine->pid);
 284
 285         /*
 286          * We use _stext for guest kernel because guest kernel's /proc/kallsyms
 287          * have no _text sometimes.
 288          */
 289         err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 290                                                  machine, "_text");
 291         if (err < 0)
 292                 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 293                                                          machine, "_stext");
 294         if (err < 0)
 295                 pr_err("Couldn't record guest kernel [%d]'s reference"
 296                        " relocation symbol.\n", machine->pid);
 297 }
 298
 299 static struct perf_event_header finished_round_event = {
 300         .size = sizeof(struct perf_event_header),
 301         .type = PERF_RECORD_FINISHED_ROUND,
 302 };
 303
 304 static int record__mmap_read_all(struct record *rec)
 305 {
 306         int i;
 307         int rc = 0;
 308
 309         for (i = 0; i < rec->evlist->nr_mmaps; i++) {
 310                 if (rec->evlist->mmap[i].base) {
 311                         if (record__mmap_read(rec, &rec->evlist->mmap[i]) != 0) {
 312                                 rc = -1;
 313                                 goto out;
 314                         }
 315                 }
 316         }
 317
 318         if (perf_header__has_feat(&rec->session->header, HEADER_TRACING_DATA))
 319                 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
 320
 321 out:
 322         return rc;
 323 }
 324
 325 static void record__init_features(struct record *rec)
 326 {
 327         struct perf_session *session = rec->session;
 328         int feat;
 329
 330         for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
 331                 perf_header__set_feat(&session->header, feat);
 332
 333         if (rec->no_buildid)
 334                 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
 335
 336         if (!have_tracepoints(&rec->evlist->entries))
 337                 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
 338
 339         if (!rec->opts.branch_stack)
 340                 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
 341 }
 342
 343 static volatile int workload_exec_errno;
 344
 345 /*
 346  * perf_evlist__prepare_workload will send a SIGUSR1
 347  * if the fork fails, since we asked by setting its
 348  * want_signal to true.
 349  */
 350 static void workload_exec_failed_signal(int signo, siginfo_t *info,
 351                                         void *ucontext __maybe_unused)
 352 {
 353         workload_exec_errno = info->si_value.sival_int;
 354         done = 1;
 355         signr = signo;
 356         child_finished = 1;
 357 }
 358
 359 static int __cmd_record(struct record *rec, int argc, const char **argv)
 360 {
 361         int err;
 362         unsigned long waking = 0;
 363         const bool forks = argc > 0;
 364         struct machine *machine;
 365         struct perf_tool *tool = &rec->tool;
 366         struct record_opts *opts = &rec->opts;
 367         struct perf_data_file *file = &rec->file;
 368         struct perf_session *session;
 369         bool disabled = false;
 370
 371         rec->progname = argv[0];
 372
 373         on_exit(record__sig_exit, rec);
 374         signal(SIGCHLD, sig_handler);
 375         signal(SIGINT, sig_handler);
 376         signal(SIGTERM, sig_handler);
 377
 378         session = perf_session__new(file, false, NULL);
 379         if (session == NULL) {
 380                 pr_err("Not enough memory for reading perf file header\n");
 381                 return -1;
 382         }
 383
 384         rec->session = session;
 385
 386         record__init_features(rec);
 387
 388         if (forks) {
 389                 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
 390                                                     argv, file->is_pipe,
 391                                                     workload_exec_failed_signal);
 392                 if (err < 0) {
 393                         pr_err("Couldn't run the workload!\n");
 394                         goto out_delete_session;
 395                 }
 396         }
 397
 398         if (record__open(rec) != 0) {
 399                 err = -1;
 400                 goto out_delete_session;
 401         }
 402
 403         if (!rec->evlist->nr_groups)
 404                 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
 405
 406         /*
 407          * perf_session__delete(session) will be called at record__exit()
 408          */
 409         on_exit(record__exit, rec);
 410
 411         if (file->is_pipe) {
 412                 err = perf_header__write_pipe(file->fd);
 413                 if (err < 0)
 414                         goto out_delete_session;
 415         } else {
 416                 err = perf_session__write_header(session, rec->evlist,
 417                                                  file->fd, false);
 418                 if (err < 0)
 419                         goto out_delete_session;
 420         }
 421
 422         if (!rec->no_buildid
 423             && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
 424                 pr_err("Couldn't generate buildids. "
 425                        "Use --no-buildid to profile anyway.\n");
 426                 err = -1;
 427                 goto out_delete_session;
 428         }
 429
 430         machine = &session->machines.host;
 431
 432         if (file->is_pipe) {
 433                 err = perf_event__synthesize_attrs(tool, session,
 434                                                    process_synthesized_event);
 435                 if (err < 0) {
 436                         pr_err("Couldn't synthesize attrs.\n");
 437                         goto out_delete_session;
 438                 }
 439
 440                 if (have_tracepoints(&rec->evlist->entries)) {
 441                         /*
 442                          * FIXME err <= 0 here actually means that
 443                          * there were no tracepoints so its not really
 444                          * an error, just that we don't need to
 445                          * synthesize anything.  We really have to
 446                          * return this more properly and also
 447                          * propagate errors that now are calling die()
 448                          */
 449                         err = perf_event__synthesize_tracing_data(tool, file->fd, rec->evlist,
 450                                                                   process_synthesized_event);
 451                         if (err <= 0) {
 452                                 pr_err("Couldn't record tracing data.\n");
 453                                 goto out_delete_session;
 454                         }
 455                         rec->bytes_written += err;
 456                 }
 457         }
 458
 459         err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 460                                                  machine, "_text");
 461         if (err < 0)
 462                 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 463                                                          machine, "_stext");
 464         if (err < 0)
 465                 pr_err("Couldn't record kernel reference relocation symbol\n"
 466                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 467                        "Check /proc/kallsyms permission or run as root.\n");
 468
 469         err = perf_event__synthesize_modules(tool, process_synthesized_event,
 470                                              machine);
 471         if (err < 0)
 472                 pr_err("Couldn't record kernel module information.\n"
 473                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 474                        "Check /proc/modules permission or run as root.\n");
 475
 476         if (perf_guest) {
 477                 machines__process_guests(&session->machines,
 478                                          perf_event__synthesize_guest_os, tool);
 479         }
 480
 481         err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
 482                                             process_synthesized_event, opts->sample_address);
 483         if (err != 0)
 484                 goto out_delete_session;
 485
 486         if (rec->realtime_prio) {
 487                 struct sched_param param;
 488
 489                 param.sched_priority = rec->realtime_prio;
 490                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
 491                         pr_err("Could not set realtime priority.\n");
 492                         err = -1;
 493                         goto out_delete_session;
 494                 }
 495         }
 496
 497         /*
 498          * When perf is starting the traced process, all the events
 499          * (apart from group members) have enable_on_exec=1 set,
 500          * so don't spoil it by prematurely enabling them.
 501          */
 502         if (!target__none(&opts->target))
 503                 perf_evlist__enable(rec->evlist);
 504
 505         /*
 506          * Let the child rip
 507          */
 508         if (forks)
 509                 perf_evlist__start_workload(rec->evlist);
 510
 511         for (;;) {
 512                 int hits = rec->samples;
 513
 514                 if (record__mmap_read_all(rec) < 0) {
 515                         err = -1;
 516                         goto out_delete_session;
 517                 }
 518
 519                 if (hits == rec->samples) {
 520                         if (done)
 521                                 break;
 522                         err = poll(rec->evlist->pollfd, rec->evlist->nr_fds, -1);
 523                         waking++;
 524                 }
 525
 526                 /*
 527                  * When perf is starting the traced process, at the end events
 528                  * die with the process and we wait for that. Thus no need to
 529                  * disable events in this case.
 530                  */
 531                 if (done && !disabled && !target__none(&opts->target)) {
 532                         perf_evlist__disable(rec->evlist);
 533                         disabled = true;
 534                 }
 535         }
 536
 537         if (forks && workload_exec_errno) {
 538                 char msg[512];
 539                 const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
 540                 pr_err("Workload failed: %s\n", emsg);
 541                 err = -1;
 542                 goto out_delete_session;
 543         }
 544
 545         if (quiet || signr == SIGUSR1)
 546                 return 0;
 547
 548         fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
 549
 550         /*
 551          * Approximate RIP event size: 24 bytes.
 552          */
 553         fprintf(stderr,
 554                 "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
 555                 (double)rec->bytes_written / 1024.0 / 1024.0,
 556                 file->path,
 557                 rec->bytes_written / 24);
 558
 559         return 0;
 560
 561 out_delete_session:
 562         perf_session__delete(session);
 563         return err;
 564 }
 565
 566 #define BRANCH_OPT(n, m) \
 567         { .name = n, .mode = (m) }
 568
 569 #define BRANCH_END { .name = NULL }
 570
 571 struct branch_mode {
 572         const char *name;
 573         int mode;
 574 };
 575
 576 static const struct branch_mode branch_modes[] = {
 577         BRANCH_OPT("u", PERF_SAMPLE_BRANCH_USER),
 578         BRANCH_OPT("k", PERF_SAMPLE_BRANCH_KERNEL),
 579         BRANCH_OPT("hv", PERF_SAMPLE_BRANCH_HV),
 580         BRANCH_OPT("any", PERF_SAMPLE_BRANCH_ANY),
 581         BRANCH_OPT("any_call", PERF_SAMPLE_BRANCH_ANY_CALL),
 582         BRANCH_OPT("any_ret", PERF_SAMPLE_BRANCH_ANY_RETURN),
 583         BRANCH_OPT("ind_call", PERF_SAMPLE_BRANCH_IND_CALL),
 584         BRANCH_OPT("abort_tx", PERF_SAMPLE_BRANCH_ABORT_TX),
 585         BRANCH_OPT("in_tx", PERF_SAMPLE_BRANCH_IN_TX),
 586         BRANCH_OPT("no_tx", PERF_SAMPLE_BRANCH_NO_TX),
 587         BRANCH_END
 588 };
 589
 590 static int
 591 parse_branch_stack(const struct option *opt, const char *str, int unset)
 592 {
 593 #define ONLY_PLM \
 594         (PERF_SAMPLE_BRANCH_USER        |\
 595          PERF_SAMPLE_BRANCH_KERNEL      |\
 596          PERF_SAMPLE_BRANCH_HV)
 597
 598         uint64_t *mode = (uint64_t *)opt->value;
 599         const struct branch_mode *br;
 600         char *s, *os = NULL, *p;
 601         int ret = -1;
 602
 603         if (unset)
 604                 return 0;
 605
 606         /*
 607          * cannot set it twice, -b + --branch-filter for instance
 608          */
 609         if (*mode)
 610                 return -1;
 611
 612         /* str may be NULL in case no arg is passed to -b */
 613         if (str) {
 614                 /* because str is read-only */
 615                 s = os = strdup(str);
 616                 if (!s)
 617                         return -1;
 618
 619                 for (;;) {
 620                         p = strchr(s, ',');
 621                         if (p)
 622                                 *p = '\0';
 623
 624                         for (br = branch_modes; br->name; br++) {
 625                                 if (!strcasecmp(s, br->name))
 626                                         break;
 627                         }
 628                         if (!br->name) {
 629                                 ui__warning("unknown branch filter %s,"
 630                                             " check man page\n", s);
 631                                 goto error;
 632                         }
 633
 634                         *mode |= br->mode;
 635
 636                         if (!p)
 637                                 break;
 638
 639                         s = p + 1;
 640                 }
 641         }
 642         ret = 0;
 643
 644         /* default to any branch */
 645         if ((*mode & ~ONLY_PLM) == 0) {
 646                 *mode = PERF_SAMPLE_BRANCH_ANY;
 647         }
 648 error:
 649         free(os);
 650         return ret;
 651 }
 652
 653 #ifdef HAVE_LIBUNWIND_SUPPORT
 654 static int get_stack_size(char *str, unsigned long *_size)
 655 {
 656         char *endptr;
 657         unsigned long size;
 658         unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
 659
 660         size = strtoul(str, &endptr, 0);
 661
 662         do {
 663                 if (*endptr)
 664                         break;
 665
 666                 size = round_up(size, sizeof(u64));
 667                 if (!size || size > max_size)
 668                         break;
 669
 670                 *_size = size;
 671                 return 0;
 672
 673         } while (0);
 674
 675         pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
 676                max_size, str);
 677         return -1;
 678 }
 679 #endif /* HAVE_LIBUNWIND_SUPPORT */
 680
 681 int record_parse_callchain(const char *arg, struct record_opts *opts)
 682 {
 683         char *tok, *name, *saveptr = NULL;
 684         char *buf;
 685         int ret = -1;
 686
 687         /* We need buffer that we know we can write to. */
 688         buf = malloc(strlen(arg) + 1);
 689         if (!buf)
 690                 return -ENOMEM;
 691
 692         strcpy(buf, arg);
 693
 694         tok = strtok_r((char *)buf, ",", &saveptr);
 695         name = tok ? : (char *)buf;
 696
 697         do {
 698                 /* Framepointer style */
 699                 if (!strncmp(name, "fp", sizeof("fp"))) {
 700                         if (!strtok_r(NULL, ",", &saveptr)) {
 701                                 opts->call_graph = CALLCHAIN_FP;
 702                                 ret = 0;
 703                         } else
 704                                 pr_err("callchain: No more arguments "
 705                                        "needed for -g fp\n");
 706                         break;
 707
 708 #ifdef HAVE_LIBUNWIND_SUPPORT
 709                 /* Dwarf style */
 710                 } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
 711                         const unsigned long default_stack_dump_size = 8192;
 712
 713                         ret = 0;
 714                         opts->call_graph = CALLCHAIN_DWARF;
 715                         opts->stack_dump_size = default_stack_dump_size;
 716
 717                         tok = strtok_r(NULL, ",", &saveptr);
 718                         if (tok) {
 719                                 unsigned long size = 0;
 720
 721                                 ret = get_stack_size(tok, &size);
 722                                 opts->stack_dump_size = size;
 723                         }
 724 #endif /* HAVE_LIBUNWIND_SUPPORT */
 725                 } else {
 726                         pr_err("callchain: Unknown --call-graph option "
 727                                "value: %s\n", arg);
 728                         break;
 729                 }
 730
 731         } while (0);
 732
 733         free(buf);
 734         return ret;
 735 }
 736
 737 static void callchain_debug(struct record_opts *opts)
 738 {
 739         pr_debug("callchain: type %d\n", opts->call_graph);
 740
 741         if (opts->call_graph == CALLCHAIN_DWARF)
 742                 pr_debug("callchain: stack dump size %d\n",
 743                          opts->stack_dump_size);
 744 }
 745
 746 int record_parse_callchain_opt(const struct option *opt,
 747                                const char *arg,
 748                                int unset)
 749 {
 750         struct record_opts *opts = opt->value;
 751         int ret;
 752
 753         /* --no-call-graph */
 754         if (unset) {
 755                 opts->call_graph = CALLCHAIN_NONE;
 756                 pr_debug("callchain: disabled\n");
 757                 return 0;
 758         }
 759
 760         ret = record_parse_callchain(arg, opts);
 761         if (!ret)
 762                 callchain_debug(opts);
 763
 764         return ret;
 765 }
 766
 767 int record_callchain_opt(const struct option *opt,
 768                          const char *arg __maybe_unused,
 769                          int unset __maybe_unused)
 770 {
 771         struct record_opts *opts = opt->value;
 772
 773         if (opts->call_graph == CALLCHAIN_NONE)
 774                 opts->call_graph = CALLCHAIN_FP;
 775
 776         callchain_debug(opts);
 777         return 0;
 778 }
 779
 780 static const char * const record_usage[] = {
 781         "perf record [<options>] [<command>]",
 782         "perf record [<options>] -- <command> [<options>]",
 783         NULL
 784 };
 785
 786 /*
 787  * XXX Ideally would be local to cmd_record() and passed to a record__new
 788  * because we need to have access to it in record__exit, that is called
 789  * after cmd_record() exits, but since record_options need to be accessible to
 790  * builtin-script, leave it here.
 791  *
 792  * At least we don't ouch it in all the other functions here directly.
 793  *
 794  * Just say no to tons of global variables, sigh.
 795  */
 796 static struct record record = {
 797         .opts = {
 798                 .mmap_pages          = UINT_MAX,
 799                 .user_freq           = UINT_MAX,
 800                 .user_interval       = ULLONG_MAX,
 801                 .freq                = 4000,
 802                 .target              = {
 803                         .uses_mmap   = true,
 804                         .default_per_cpu = true,
 805                 },
 806         },
 807 };
 808
 809 #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
 810
 811 #ifdef HAVE_LIBUNWIND_SUPPORT
 812 const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf";
 813 #else
 814 const char record_callchain_help[] = CALLCHAIN_HELP "fp";
 815 #endif
 816
 817 /*
 818  * XXX Will stay a global variable till we fix builtin-script.c to stop messing
 819  * with it and switch to use the library functions in perf_evlist that came
 820  * from builtin-record.c, i.e. use record_opts,
 821  * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
 822  * using pipes, etc.
 823  */
 824 const struct option record_options[] = {
 825         OPT_CALLBACK('e', "event", &record.evlist, "event",
 826                      "event selector. use 'perf list' to list available events",
 827                      parse_events_option),
 828         OPT_CALLBACK(0, "filter", &record.evlist, "filter",
 829                      "event filter", parse_filter),
 830         OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
 831                     "record events on existing process id"),
 832         OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
 833                     "record events on existing thread id"),
 834         OPT_INTEGER('r', "realtime", &record.realtime_prio,
 835                     "collect data with this RT SCHED_FIFO priority"),
 836         OPT_BOOLEAN('D', "no-delay", &record.opts.no_delay,
 837                     "collect data without buffering"),
 838         OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
 839                     "collect raw sample records from all opened counters"),
 840         OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
 841                             "system-wide collection from all CPUs"),
 842         OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
 843                     "list of cpus to monitor"),
 844         OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
 845         OPT_STRING('o', "output", &record.file.path, "file",
 846                     "output file name"),
 847         OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
 848                         &record.opts.no_inherit_set,
 849                         "child tasks do not inherit counters"),
 850         OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
 851         OPT_CALLBACK('m', "mmap-pages", &record.opts.mmap_pages, "pages",
 852                      "number of mmap data pages",
 853                      perf_evlist__parse_mmap_pages),
 854         OPT_BOOLEAN(0, "group", &record.opts.group,
 855                     "put the counters into a counter group"),
 856         OPT_CALLBACK_NOOPT('g', NULL, &record.opts,
 857                            NULL, "enables call-graph recording" ,
 858                            &record_callchain_opt),
 859         OPT_CALLBACK(0, "call-graph", &record.opts,
 860                      "mode[,dump_size]", record_callchain_help,
 861                      &record_parse_callchain_opt),
 862         OPT_INCR('v', "verbose", &verbose,
 863                     "be more verbose (show counter open errors, etc)"),
 864         OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
 865         OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
 866                     "per thread counts"),
 867         OPT_BOOLEAN('d', "data", &record.opts.sample_address,
 868                     "Sample addresses"),
 869         OPT_BOOLEAN('T', "timestamp", &record.opts.sample_time, "Sample timestamps"),
 870         OPT_BOOLEAN('P', "period", &record.opts.period, "Sample period"),
 871         OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
 872                     "don't sample"),
 873         OPT_BOOLEAN('N', "no-buildid-cache", &record.no_buildid_cache,
 874                     "do not update the buildid cache"),
 875         OPT_BOOLEAN('B', "no-buildid", &record.no_buildid,
 876                     "do not collect buildids in perf.data"),
 877         OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
 878                      "monitor event in cgroup name only",
 879                      parse_cgroups),
 880         OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
 881                    "user to profile"),
 882
 883         OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
 884                      "branch any", "sample any taken branches",
 885                      parse_branch_stack),
 886
 887         OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
 888                      "branch filter mask", "branch stack filter modes",
 889                      parse_branch_stack),
 890         OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
 891                     "sample by weight (on special events only)"),
 892         OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
 893                     "sample transaction flags (special events only)"),
 894         OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
 895                     "use per-thread mmaps"),
 896         OPT_END()
 897 };
 898
 899 int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
 900 {
 901         int err = -ENOMEM;
 902         struct record *rec = &record;
 903         char errbuf[BUFSIZ];
 904
 905         rec->evlist = perf_evlist__new();
 906         if (rec->evlist == NULL)
 907                 return -ENOMEM;
 908
 909         argc = parse_options(argc, argv, record_options, record_usage,
 910                             PARSE_OPT_STOP_AT_NON_OPTION);
 911         if (!argc && target__none(&rec->opts.target))
 912                 usage_with_options(record_usage, record_options);
 913
 914         if (nr_cgroups && !rec->opts.target.system_wide) {
 915                 ui__error("cgroup monitoring only available in"
 916                           " system-wide mode\n");
 917                 usage_with_options(record_usage, record_options);
 918         }
 919
 920         symbol__init();
 921
 922         if (symbol_conf.kptr_restrict)
 923                 pr_warning(
 924 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
 925 "check /proc/sys/kernel/kptr_restrict.\n\n"
 926 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
 927 "file is not found in the buildid cache or in the vmlinux path.\n\n"
 928 "Samples in kernel modules won't be resolved at all.\n\n"
 929 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
 930 "even with a suitable vmlinux or kallsyms file.\n\n");
 931
 932         if (rec->no_buildid_cache || rec->no_buildid)
 933                 disable_buildid_cache();
 934
 935         if (rec->evlist->nr_entries == 0 &&
 936             perf_evlist__add_default(rec->evlist) < 0) {
 937                 pr_err("Not enough memory for event selector list\n");
 938                 goto out_symbol_exit;
 939         }
 940
 941         if (rec->opts.target.tid && !rec->opts.no_inherit_set)
 942                 rec->opts.no_inherit = true;
 943
 944         err = target__validate(&rec->opts.target);
 945         if (err) {
 946                 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
 947                 ui__warning("%s", errbuf);
 948         }
 949
 950         err = target__parse_uid(&rec->opts.target);
 951         if (err) {
 952                 int saved_errno = errno;
 953
 954                 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
 955                 ui__error("%s", errbuf);
 956
 957                 err = -saved_errno;
 958                 goto out_symbol_exit;
 959         }
 960
 961         err = -ENOMEM;
 962         if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
 963                 usage_with_options(record_usage, record_options);
 964
 965         if (record_opts__config(&rec->opts)) {
 966                 err = -EINVAL;
 967                 goto out_symbol_exit;
 968         }
 969
 970         err = __cmd_record(&record, argc, argv);
 971 out_symbol_exit:
 972         symbol__exit();
 973         return err;
 974 }