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/callchain.h"
  18 #include "util/cgroup.h"
  19 #include "util/header.h"
  20 #include "util/event.h"
  21 #include "util/evlist.h"
  22 #include "util/evsel.h"
  23 #include "util/debug.h"
  24 #include "util/session.h"
  25 #include "util/tool.h"
  26 #include "util/symbol.h"
  27 #include "util/cpumap.h"
  28 #include "util/thread_map.h"
  29 #include "util/data.h"
  30 #include "util/auxtrace.h"
  31 #include "util/parse-branch-options.h"
  32
  33 #include <unistd.h>
  34 #include <sched.h>
  35 #include <sys/mman.h>
  36
  37
  38 struct record {
  39         struct perf_tool        tool;
  40         struct record_opts      opts;
  41         u64                     bytes_written;
  42         struct perf_data_file   file;
  43         struct auxtrace_record  *itr;
  44         struct perf_evlist      *evlist;
  45         struct perf_session     *session;
  46         const char              *progname;
  47         int                     realtime_prio;
  48         bool                    no_buildid;
  49         bool                    no_buildid_cache;
  50         long                    samples;
  51 };
  52
  53 static int record__write(struct record *rec, void *bf, size_t size)
  54 {
  55         if (perf_data_file__write(rec->session->file, bf, size) < 0) {
  56                 pr_err("failed to write perf data, error: %m\n");
  57                 return -1;
  58         }
  59
  60         rec->bytes_written += size;
  61         return 0;
  62 }
  63
  64 static int process_synthesized_event(struct perf_tool *tool,
  65                                      union perf_event *event,
  66                                      struct perf_sample *sample __maybe_unused,
  67                                      struct machine *machine __maybe_unused)
  68 {
  69         struct record *rec = container_of(tool, struct record, tool);
  70         return record__write(rec, event, event->header.size);
  71 }
  72
  73 static int record__mmap_read(struct record *rec, int idx)
  74 {
  75         struct perf_mmap *md = &rec->evlist->mmap[idx];
  76         u64 head = perf_mmap__read_head(md);
  77         u64 old = md->prev;
  78         unsigned char *data = md->base + page_size;
  79         unsigned long size;
  80         void *buf;
  81         int rc = 0;
  82
  83         if (old == head)
  84                 return 0;
  85
  86         rec->samples++;
  87
  88         size = head - old;
  89
  90         if ((old & md->mask) + size != (head & md->mask)) {
  91                 buf = &data[old & md->mask];
  92                 size = md->mask + 1 - (old & md->mask);
  93                 old += size;
  94
  95                 if (record__write(rec, buf, size) < 0) {
  96                         rc = -1;
  97                         goto out;
  98                 }
  99         }
 100
 101         buf = &data[old & md->mask];
 102         size = head - old;
 103         old += size;
 104
 105         if (record__write(rec, buf, size) < 0) {
 106                 rc = -1;
 107                 goto out;
 108         }
 109
 110         md->prev = old;
 111         perf_evlist__mmap_consume(rec->evlist, idx);
 112 out:
 113         return rc;
 114 }
 115
 116 static volatile int done;
 117 static volatile int signr = -1;
 118 static volatile int child_finished;
 119 static volatile int auxtrace_snapshot_enabled;
 120 static volatile int auxtrace_snapshot_err;
 121 static volatile int auxtrace_record__snapshot_started;
 122
 123 static void sig_handler(int sig)
 124 {
 125         if (sig == SIGCHLD)
 126                 child_finished = 1;
 127         else
 128                 signr = sig;
 129
 130         done = 1;
 131 }
 132
 133 static void record__sig_exit(void)
 134 {
 135         if (signr == -1)
 136                 return;
 137
 138         signal(signr, SIG_DFL);
 139         raise(signr);
 140 }
 141
 142 #ifdef HAVE_AUXTRACE_SUPPORT
 143
 144 static int record__process_auxtrace(struct perf_tool *tool,
 145                                     union perf_event *event, void *data1,
 146                                     size_t len1, void *data2, size_t len2)
 147 {
 148         struct record *rec = container_of(tool, struct record, tool);
 149         struct perf_data_file *file = &rec->file;
 150         size_t padding;
 151         u8 pad[8] = {0};
 152
 153         if (!perf_data_file__is_pipe(file)) {
 154                 off_t file_offset;
 155                 int fd = perf_data_file__fd(file);
 156                 int err;
 157
 158                 file_offset = lseek(fd, 0, SEEK_CUR);
 159                 if (file_offset == -1)
 160                         return -1;
 161                 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
 162                                                      event, file_offset);
 163                 if (err)
 164                         return err;
 165         }
 166
 167         /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
 168         padding = (len1 + len2) & 7;
 169         if (padding)
 170                 padding = 8 - padding;
 171
 172         record__write(rec, event, event->header.size);
 173         record__write(rec, data1, len1);
 174         if (len2)
 175                 record__write(rec, data2, len2);
 176         record__write(rec, &pad, padding);
 177
 178         return 0;
 179 }
 180
 181 static int record__auxtrace_mmap_read(struct record *rec,
 182                                       struct auxtrace_mmap *mm)
 183 {
 184         int ret;
 185
 186         ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
 187                                   record__process_auxtrace);
 188         if (ret < 0)
 189                 return ret;
 190
 191         if (ret)
 192                 rec->samples++;
 193
 194         return 0;
 195 }
 196
 197 static int record__auxtrace_mmap_read_snapshot(struct record *rec,
 198                                                struct auxtrace_mmap *mm)
 199 {
 200         int ret;
 201
 202         ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
 203                                            record__process_auxtrace,
 204                                            rec->opts.auxtrace_snapshot_size);
 205         if (ret < 0)
 206                 return ret;
 207
 208         if (ret)
 209                 rec->samples++;
 210
 211         return 0;
 212 }
 213
 214 static int record__auxtrace_read_snapshot_all(struct record *rec)
 215 {
 216         int i;
 217         int rc = 0;
 218
 219         for (i = 0; i < rec->evlist->nr_mmaps; i++) {
 220                 struct auxtrace_mmap *mm =
 221                                 &rec->evlist->mmap[i].auxtrace_mmap;
 222
 223                 if (!mm->base)
 224                         continue;
 225
 226                 if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
 227                         rc = -1;
 228                         goto out;
 229                 }
 230         }
 231 out:
 232         return rc;
 233 }
 234
 235 static void record__read_auxtrace_snapshot(struct record *rec)
 236 {
 237         pr_debug("Recording AUX area tracing snapshot\n");
 238         if (record__auxtrace_read_snapshot_all(rec) < 0) {
 239                 auxtrace_snapshot_err = -1;
 240         } else {
 241                 auxtrace_snapshot_err = auxtrace_record__snapshot_finish(rec->itr);
 242                 if (!auxtrace_snapshot_err)
 243                         auxtrace_snapshot_enabled = 1;
 244         }
 245 }
 246
 247 #else
 248
 249 static inline
 250 int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
 251                                struct auxtrace_mmap *mm __maybe_unused)
 252 {
 253         return 0;
 254 }
 255
 256 static inline
 257 void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
 258 {
 259 }
 260
 261 static inline
 262 int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
 263 {
 264         return 0;
 265 }
 266
 267 #endif
 268
 269 static int record__open(struct record *rec)
 270 {
 271         char msg[512];
 272         struct perf_evsel *pos;
 273         struct perf_evlist *evlist = rec->evlist;
 274         struct perf_session *session = rec->session;
 275         struct record_opts *opts = &rec->opts;
 276         int rc = 0;
 277
 278         perf_evlist__config(evlist, opts);
 279
 280         evlist__for_each(evlist, pos) {
 281 try_again:
 282                 if (perf_evsel__open(pos, evlist->cpus, evlist->threads) < 0) {
 283                         if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
 284                                 if (verbose)
 285                                         ui__warning("%s\n", msg);
 286                                 goto try_again;
 287                         }
 288
 289                         rc = -errno;
 290                         perf_evsel__open_strerror(pos, &opts->target,
 291                                                   errno, msg, sizeof(msg));
 292                         ui__error("%s\n", msg);
 293                         goto out;
 294                 }
 295         }
 296
 297         if (perf_evlist__apply_filters(evlist, &pos)) {
 298                 error("failed to set filter \"%s\" on event %s with %d (%s)\n",
 299                         pos->filter, perf_evsel__name(pos), errno,
 300                         strerror_r(errno, msg, sizeof(msg)));
 301                 rc = -1;
 302                 goto out;
 303         }
 304
 305         if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
 306                                  opts->auxtrace_mmap_pages,
 307                                  opts->auxtrace_snapshot_mode) < 0) {
 308                 if (errno == EPERM) {
 309                         pr_err("Permission error mapping pages.\n"
 310                                "Consider increasing "
 311                                "/proc/sys/kernel/perf_event_mlock_kb,\n"
 312                                "or try again with a smaller value of -m/--mmap_pages.\n"
 313                                "(current value: %u,%u)\n",
 314                                opts->mmap_pages, opts->auxtrace_mmap_pages);
 315                         rc = -errno;
 316                 } else {
 317                         pr_err("failed to mmap with %d (%s)\n", errno,
 318                                 strerror_r(errno, msg, sizeof(msg)));
 319                         rc = -errno;
 320                 }
 321                 goto out;
 322         }
 323
 324         session->evlist = evlist;
 325         perf_session__set_id_hdr_size(session);
 326 out:
 327         return rc;
 328 }
 329
 330 static int process_sample_event(struct perf_tool *tool,
 331                                 union perf_event *event,
 332                                 struct perf_sample *sample,
 333                                 struct perf_evsel *evsel,
 334                                 struct machine *machine)
 335 {
 336         struct record *rec = container_of(tool, struct record, tool);
 337
 338         rec->samples++;
 339
 340         return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
 341 }
 342
 343 static int process_buildids(struct record *rec)
 344 {
 345         struct perf_data_file *file  = &rec->file;
 346         struct perf_session *session = rec->session;
 347
 348         u64 size = lseek(perf_data_file__fd(file), 0, SEEK_CUR);
 349         if (size == 0)
 350                 return 0;
 351
 352         file->size = size;
 353
 354         /*
 355          * During this process, it'll load kernel map and replace the
 356          * dso->long_name to a real pathname it found.  In this case
 357          * we prefer the vmlinux path like
 358          *   /lib/modules/3.16.4/build/vmlinux
 359          *
 360          * rather than build-id path (in debug directory).
 361          *   $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
 362          */
 363         symbol_conf.ignore_vmlinux_buildid = true;
 364
 365         return perf_session__process_events(session);
 366 }
 367
 368 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
 369 {
 370         int err;
 371         struct perf_tool *tool = data;
 372         /*
 373          *As for guest kernel when processing subcommand record&report,
 374          *we arrange module mmap prior to guest kernel mmap and trigger
 375          *a preload dso because default guest module symbols are loaded
 376          *from guest kallsyms instead of /lib/modules/XXX/XXX. This
 377          *method is used to avoid symbol missing when the first addr is
 378          *in module instead of in guest kernel.
 379          */
 380         err = perf_event__synthesize_modules(tool, process_synthesized_event,
 381                                              machine);
 382         if (err < 0)
 383                 pr_err("Couldn't record guest kernel [%d]'s reference"
 384                        " relocation symbol.\n", machine->pid);
 385
 386         /*
 387          * We use _stext for guest kernel because guest kernel's /proc/kallsyms
 388          * have no _text sometimes.
 389          */
 390         err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 391                                                  machine);
 392         if (err < 0)
 393                 pr_err("Couldn't record guest kernel [%d]'s reference"
 394                        " relocation symbol.\n", machine->pid);
 395 }
 396
 397 static struct perf_event_header finished_round_event = {
 398         .size = sizeof(struct perf_event_header),
 399         .type = PERF_RECORD_FINISHED_ROUND,
 400 };
 401
 402 static int record__mmap_read_all(struct record *rec)
 403 {
 404         u64 bytes_written = rec->bytes_written;
 405         int i;
 406         int rc = 0;
 407
 408         for (i = 0; i < rec->evlist->nr_mmaps; i++) {
 409                 struct auxtrace_mmap *mm = &rec->evlist->mmap[i].auxtrace_mmap;
 410
 411                 if (rec->evlist->mmap[i].base) {
 412                         if (record__mmap_read(rec, i) != 0) {
 413                                 rc = -1;
 414                                 goto out;
 415                         }
 416                 }
 417
 418                 if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
 419                     record__auxtrace_mmap_read(rec, mm) != 0) {
 420                         rc = -1;
 421                         goto out;
 422                 }
 423         }
 424
 425         /*
 426          * Mark the round finished in case we wrote
 427          * at least one event.
 428          */
 429         if (bytes_written != rec->bytes_written)
 430                 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
 431
 432 out:
 433         return rc;
 434 }
 435
 436 static void record__init_features(struct record *rec)
 437 {
 438         struct perf_session *session = rec->session;
 439         int feat;
 440
 441         for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
 442                 perf_header__set_feat(&session->header, feat);
 443
 444         if (rec->no_buildid)
 445                 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
 446
 447         if (!have_tracepoints(&rec->evlist->entries))
 448                 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
 449
 450         if (!rec->opts.branch_stack)
 451                 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
 452
 453         if (!rec->opts.full_auxtrace)
 454                 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
 455 }
 456
 457 static volatile int workload_exec_errno;
 458
 459 /*
 460  * perf_evlist__prepare_workload will send a SIGUSR1
 461  * if the fork fails, since we asked by setting its
 462  * want_signal to true.
 463  */
 464 static void workload_exec_failed_signal(int signo __maybe_unused,
 465                                         siginfo_t *info,
 466                                         void *ucontext __maybe_unused)
 467 {
 468         workload_exec_errno = info->si_value.sival_int;
 469         done = 1;
 470         child_finished = 1;
 471 }
 472
 473 static void snapshot_sig_handler(int sig);
 474
 475 static int __cmd_record(struct record *rec, int argc, const char **argv)
 476 {
 477         int err;
 478         int status = 0;
 479         unsigned long waking = 0;
 480         const bool forks = argc > 0;
 481         struct machine *machine;
 482         struct perf_tool *tool = &rec->tool;
 483         struct record_opts *opts = &rec->opts;
 484         struct perf_data_file *file = &rec->file;
 485         struct perf_session *session;
 486         bool disabled = false, draining = false;
 487         int fd;
 488
 489         rec->progname = argv[0];
 490
 491         atexit(record__sig_exit);
 492         signal(SIGCHLD, sig_handler);
 493         signal(SIGINT, sig_handler);
 494         signal(SIGTERM, sig_handler);
 495         if (rec->opts.auxtrace_snapshot_mode)
 496                 signal(SIGUSR2, snapshot_sig_handler);
 497         else
 498                 signal(SIGUSR2, SIG_IGN);
 499
 500         session = perf_session__new(file, false, tool);
 501         if (session == NULL) {
 502                 pr_err("Perf session creation failed.\n");
 503                 return -1;
 504         }
 505
 506         fd = perf_data_file__fd(file);
 507         rec->session = session;
 508
 509         record__init_features(rec);
 510
 511         if (forks) {
 512                 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
 513                                                     argv, file->is_pipe,
 514                                                     workload_exec_failed_signal);
 515                 if (err < 0) {
 516                         pr_err("Couldn't run the workload!\n");
 517                         status = err;
 518                         goto out_delete_session;
 519                 }
 520         }
 521
 522         if (record__open(rec) != 0) {
 523                 err = -1;
 524                 goto out_child;
 525         }
 526
 527         if (!rec->evlist->nr_groups)
 528                 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
 529
 530         if (file->is_pipe) {
 531                 err = perf_header__write_pipe(fd);
 532                 if (err < 0)
 533                         goto out_child;
 534         } else {
 535                 err = perf_session__write_header(session, rec->evlist, fd, false);
 536                 if (err < 0)
 537                         goto out_child;
 538         }
 539
 540         if (!rec->no_buildid
 541             && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
 542                 pr_err("Couldn't generate buildids. "
 543                        "Use --no-buildid to profile anyway.\n");
 544                 err = -1;
 545                 goto out_child;
 546         }
 547
 548         machine = &session->machines.host;
 549
 550         if (file->is_pipe) {
 551                 err = perf_event__synthesize_attrs(tool, session,
 552                                                    process_synthesized_event);
 553                 if (err < 0) {
 554                         pr_err("Couldn't synthesize attrs.\n");
 555                         goto out_child;
 556                 }
 557
 558                 if (have_tracepoints(&rec->evlist->entries)) {
 559                         /*
 560                          * FIXME err <= 0 here actually means that
 561                          * there were no tracepoints so its not really
 562                          * an error, just that we don't need to
 563                          * synthesize anything.  We really have to
 564                          * return this more properly and also
 565                          * propagate errors that now are calling die()
 566                          */
 567                         err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
 568                                                                   process_synthesized_event);
 569                         if (err <= 0) {
 570                                 pr_err("Couldn't record tracing data.\n");
 571                                 goto out_child;
 572                         }
 573                         rec->bytes_written += err;
 574                 }
 575         }
 576
 577         if (rec->opts.full_auxtrace) {
 578                 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
 579                                         session, process_synthesized_event);
 580                 if (err)
 581                         goto out_delete_session;
 582         }
 583
 584         err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 585                                                  machine);
 586         if (err < 0)
 587                 pr_err("Couldn't record kernel reference relocation symbol\n"
 588                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 589                        "Check /proc/kallsyms permission or run as root.\n");
 590
 591         err = perf_event__synthesize_modules(tool, process_synthesized_event,
 592                                              machine);
 593         if (err < 0)
 594                 pr_err("Couldn't record kernel module information.\n"
 595                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 596                        "Check /proc/modules permission or run as root.\n");
 597
 598         if (perf_guest) {
 599                 machines__process_guests(&session->machines,
 600                                          perf_event__synthesize_guest_os, tool);
 601         }
 602
 603         err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
 604                                             process_synthesized_event, opts->sample_address);
 605         if (err != 0)
 606                 goto out_child;
 607
 608         if (rec->realtime_prio) {
 609                 struct sched_param param;
 610
 611                 param.sched_priority = rec->realtime_prio;
 612                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
 613                         pr_err("Could not set realtime priority.\n");
 614                         err = -1;
 615                         goto out_child;
 616                 }
 617         }
 618
 619         /*
 620          * When perf is starting the traced process, all the events
 621          * (apart from group members) have enable_on_exec=1 set,
 622          * so don't spoil it by prematurely enabling them.
 623          */
 624         if (!target__none(&opts->target) && !opts->initial_delay)
 625                 perf_evlist__enable(rec->evlist);
 626
 627         /*
 628          * Let the child rip
 629          */
 630         if (forks)
 631                 perf_evlist__start_workload(rec->evlist);
 632
 633         if (opts->initial_delay) {
 634                 usleep(opts->initial_delay * 1000);
 635                 perf_evlist__enable(rec->evlist);
 636         }
 637
 638         auxtrace_snapshot_enabled = 1;
 639         for (;;) {
 640                 int hits = rec->samples;
 641
 642                 if (record__mmap_read_all(rec) < 0) {
 643                         auxtrace_snapshot_enabled = 0;
 644                         err = -1;
 645                         goto out_child;
 646                 }
 647
 648                 if (auxtrace_record__snapshot_started) {
 649                         auxtrace_record__snapshot_started = 0;
 650                         if (!auxtrace_snapshot_err)
 651                                 record__read_auxtrace_snapshot(rec);
 652                         if (auxtrace_snapshot_err) {
 653                                 pr_err("AUX area tracing snapshot failed\n");
 654                                 err = -1;
 655                                 goto out_child;
 656                         }
 657                 }
 658
 659                 if (hits == rec->samples) {
 660                         if (done || draining)
 661                                 break;
 662                         err = perf_evlist__poll(rec->evlist, -1);
 663                         /*
 664                          * Propagate error, only if there's any. Ignore positive
 665                          * number of returned events and interrupt error.
 666                          */
 667                         if (err > 0 || (err < 0 && errno == EINTR))
 668                                 err = 0;
 669                         waking++;
 670
 671                         if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
 672                                 draining = true;
 673                 }
 674
 675                 /*
 676                  * When perf is starting the traced process, at the end events
 677                  * die with the process and we wait for that. Thus no need to
 678                  * disable events in this case.
 679                  */
 680                 if (done && !disabled && !target__none(&opts->target)) {
 681                         auxtrace_snapshot_enabled = 0;
 682                         perf_evlist__disable(rec->evlist);
 683                         disabled = true;
 684                 }
 685         }
 686         auxtrace_snapshot_enabled = 0;
 687
 688         if (forks && workload_exec_errno) {
 689                 char msg[STRERR_BUFSIZE];
 690                 const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
 691                 pr_err("Workload failed: %s\n", emsg);
 692                 err = -1;
 693                 goto out_child;
 694         }
 695
 696         if (!quiet)
 697                 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
 698
 699 out_child:
 700         if (forks) {
 701                 int exit_status;
 702
 703                 if (!child_finished)
 704                         kill(rec->evlist->workload.pid, SIGTERM);
 705
 706                 wait(&exit_status);
 707
 708                 if (err < 0)
 709                         status = err;
 710                 else if (WIFEXITED(exit_status))
 711                         status = WEXITSTATUS(exit_status);
 712                 else if (WIFSIGNALED(exit_status))
 713                         signr = WTERMSIG(exit_status);
 714         } else
 715                 status = err;
 716
 717         /* this will be recalculated during process_buildids() */
 718         rec->samples = 0;
 719
 720         if (!err && !file->is_pipe) {
 721                 rec->session->header.data_size += rec->bytes_written;
 722
 723                 if (!rec->no_buildid) {
 724                         process_buildids(rec);
 725                         /*
 726                          * We take all buildids when the file contains
 727                          * AUX area tracing data because we do not decode the
 728                          * trace because it would take too long.
 729                          */
 730                         if (rec->opts.full_auxtrace)
 731                                 dsos__hit_all(rec->session);
 732                 }
 733                 perf_session__write_header(rec->session, rec->evlist, fd, true);
 734         }
 735
 736         if (!err && !quiet) {
 737                 char samples[128];
 738
 739                 if (rec->samples && !rec->opts.full_auxtrace)
 740                         scnprintf(samples, sizeof(samples),
 741                                   " (%" PRIu64 " samples)", rec->samples);
 742                 else
 743                         samples[0] = '\0';
 744
 745                 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s ]\n",
 746                         perf_data_file__size(file) / 1024.0 / 1024.0,
 747                         file->path, samples);
 748         }
 749
 750 out_delete_session:
 751         perf_session__delete(session);
 752         return status;
 753 }
 754
 755 static void callchain_debug(void)
 756 {
 757         static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
 758
 759         pr_debug("callchain: type %s\n", str[callchain_param.record_mode]);
 760
 761         if (callchain_param.record_mode == CALLCHAIN_DWARF)
 762                 pr_debug("callchain: stack dump size %d\n",
 763                          callchain_param.dump_size);
 764 }
 765
 766 int record_parse_callchain_opt(const struct option *opt __maybe_unused,
 767                                const char *arg,
 768                                int unset)
 769 {
 770         int ret;
 771
 772         callchain_param.enabled = !unset;
 773
 774         /* --no-call-graph */
 775         if (unset) {
 776                 callchain_param.record_mode = CALLCHAIN_NONE;
 777                 pr_debug("callchain: disabled\n");
 778                 return 0;
 779         }
 780
 781         ret = parse_callchain_record_opt(arg);
 782         if (!ret)
 783                 callchain_debug();
 784
 785         return ret;
 786 }
 787
 788 int record_callchain_opt(const struct option *opt __maybe_unused,
 789                          const char *arg __maybe_unused,
 790                          int unset __maybe_unused)
 791 {
 792         callchain_param.enabled = true;
 793
 794         if (callchain_param.record_mode == CALLCHAIN_NONE)
 795                 callchain_param.record_mode = CALLCHAIN_FP;
 796
 797         callchain_debug();
 798         return 0;
 799 }
 800
 801 static int perf_record_config(const char *var, const char *value, void *cb)
 802 {
 803         if (!strcmp(var, "record.call-graph"))
 804                 var = "call-graph.record-mode"; /* fall-through */
 805
 806         return perf_default_config(var, value, cb);
 807 }
 808
 809 struct clockid_map {
 810         const char *name;
 811         int clockid;
 812 };
 813
 814 #define CLOCKID_MAP(n, c)       \
 815         { .name = n, .clockid = (c), }
 816
 817 #define CLOCKID_END     { .name = NULL, }
 818
 819
 820 /*
 821  * Add the missing ones, we need to build on many distros...
 822  */
 823 #ifndef CLOCK_MONOTONIC_RAW
 824 #define CLOCK_MONOTONIC_RAW 4
 825 #endif
 826 #ifndef CLOCK_BOOTTIME
 827 #define CLOCK_BOOTTIME 7
 828 #endif
 829 #ifndef CLOCK_TAI
 830 #define CLOCK_TAI 11
 831 #endif
 832
 833 static const struct clockid_map clockids[] = {
 834         /* available for all events, NMI safe */
 835         CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
 836         CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
 837
 838         /* available for some events */
 839         CLOCKID_MAP("realtime", CLOCK_REALTIME),
 840         CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
 841         CLOCKID_MAP("tai", CLOCK_TAI),
 842
 843         /* available for the lazy */
 844         CLOCKID_MAP("mono", CLOCK_MONOTONIC),
 845         CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
 846         CLOCKID_MAP("real", CLOCK_REALTIME),
 847         CLOCKID_MAP("boot", CLOCK_BOOTTIME),
 848
 849         CLOCKID_END,
 850 };
 851
 852 static int parse_clockid(const struct option *opt, const char *str, int unset)
 853 {
 854         struct record_opts *opts = (struct record_opts *)opt->value;
 855         const struct clockid_map *cm;
 856         const char *ostr = str;
 857
 858         if (unset) {
 859                 opts->use_clockid = 0;
 860                 return 0;
 861         }
 862
 863         /* no arg passed */
 864         if (!str)
 865                 return 0;
 866
 867         /* no setting it twice */
 868         if (opts->use_clockid)
 869                 return -1;
 870
 871         opts->use_clockid = true;
 872
 873         /* if its a number, we're done */
 874         if (sscanf(str, "%d", &opts->clockid) == 1)
 875                 return 0;
 876
 877         /* allow a "CLOCK_" prefix to the name */
 878         if (!strncasecmp(str, "CLOCK_", 6))
 879                 str += 6;
 880
 881         for (cm = clockids; cm->name; cm++) {
 882                 if (!strcasecmp(str, cm->name)) {
 883                         opts->clockid = cm->clockid;
 884                         return 0;
 885                 }
 886         }
 887
 888         opts->use_clockid = false;
 889         ui__warning("unknown clockid %s, check man page\n", ostr);
 890         return -1;
 891 }
 892
 893 static int record__parse_mmap_pages(const struct option *opt,
 894                                     const char *str,
 895                                     int unset __maybe_unused)
 896 {
 897         struct record_opts *opts = opt->value;
 898         char *s, *p;
 899         unsigned int mmap_pages;
 900         int ret;
 901
 902         if (!str)
 903                 return -EINVAL;
 904
 905         s = strdup(str);
 906         if (!s)
 907                 return -ENOMEM;
 908
 909         p = strchr(s, ',');
 910         if (p)
 911                 *p = '\0';
 912
 913         if (*s) {
 914                 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
 915                 if (ret)
 916                         goto out_free;
 917                 opts->mmap_pages = mmap_pages;
 918         }
 919
 920         if (!p) {
 921                 ret = 0;
 922                 goto out_free;
 923         }
 924
 925         ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
 926         if (ret)
 927                 goto out_free;
 928
 929         opts->auxtrace_mmap_pages = mmap_pages;
 930
 931 out_free:
 932         free(s);
 933         return ret;
 934 }
 935
 936 static const char * const __record_usage[] = {
 937         "perf record [<options>] [<command>]",
 938         "perf record [<options>] -- <command> [<options>]",
 939         NULL
 940 };
 941 const char * const *record_usage = __record_usage;
 942
 943 /*
 944  * XXX Ideally would be local to cmd_record() and passed to a record__new
 945  * because we need to have access to it in record__exit, that is called
 946  * after cmd_record() exits, but since record_options need to be accessible to
 947  * builtin-script, leave it here.
 948  *
 949  * At least we don't ouch it in all the other functions here directly.
 950  *
 951  * Just say no to tons of global variables, sigh.
 952  */
 953 static struct record record = {
 954         .opts = {
 955                 .sample_time         = true,
 956                 .mmap_pages          = UINT_MAX,
 957                 .user_freq           = UINT_MAX,
 958                 .user_interval       = ULLONG_MAX,
 959                 .freq                = 4000,
 960                 .target              = {
 961                         .uses_mmap   = true,
 962                         .default_per_cpu = true,
 963                 },
 964         },
 965         .tool = {
 966                 .sample         = process_sample_event,
 967                 .fork           = perf_event__process_fork,
 968                 .comm           = perf_event__process_comm,
 969                 .mmap           = perf_event__process_mmap,
 970                 .mmap2          = perf_event__process_mmap2,
 971         },
 972 };
 973
 974 #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
 975
 976 #ifdef HAVE_DWARF_UNWIND_SUPPORT
 977 const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf lbr";
 978 #else
 979 const char record_callchain_help[] = CALLCHAIN_HELP "fp lbr";
 980 #endif
 981
 982 /*
 983  * XXX Will stay a global variable till we fix builtin-script.c to stop messing
 984  * with it and switch to use the library functions in perf_evlist that came
 985  * from builtin-record.c, i.e. use record_opts,
 986  * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
 987  * using pipes, etc.
 988  */
 989 struct option __record_options[] = {
 990         OPT_CALLBACK('e', "event", &record.evlist, "event",
 991                      "event selector. use 'perf list' to list available events",
 992                      parse_events_option),
 993         OPT_CALLBACK(0, "filter", &record.evlist, "filter",
 994                      "event filter", parse_filter),
 995         OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
 996                     "record events on existing process id"),
 997         OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
 998                     "record events on existing thread id"),
 999         OPT_INTEGER('r', "realtime", &record.realtime_prio,
1000                     "collect data with this RT SCHED_FIFO priority"),
1001         OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
1002                     "collect data without buffering"),
1003         OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
1004                     "collect raw sample records from all opened counters"),
1005         OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
1006                             "system-wide collection from all CPUs"),
1007         OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
1008                     "list of cpus to monitor"),
1009         OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
1010         OPT_STRING('o', "output", &record.file.path, "file",
1011                     "output file name"),
1012         OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
1013                         &record.opts.no_inherit_set,
1014                         "child tasks do not inherit counters"),
1015         OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
1016         OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
1017                      "number of mmap data pages and AUX area tracing mmap pages",
1018                      record__parse_mmap_pages),
1019         OPT_BOOLEAN(0, "group", &record.opts.group,
1020                     "put the counters into a counter group"),
1021         OPT_CALLBACK_NOOPT('g', NULL, &record.opts,
1022                            NULL, "enables call-graph recording" ,
1023                            &record_callchain_opt),
1024         OPT_CALLBACK(0, "call-graph", &record.opts,
1025                      "mode[,dump_size]", record_callchain_help,
1026                      &record_parse_callchain_opt),
1027         OPT_INCR('v', "verbose", &verbose,
1028                     "be more verbose (show counter open errors, etc)"),
1029         OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
1030         OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
1031                     "per thread counts"),
1032         OPT_BOOLEAN('d', "data", &record.opts.sample_address,
1033                     "Sample addresses"),
1034         OPT_BOOLEAN('T', "timestamp", &record.opts.sample_time, "Sample timestamps"),
1035         OPT_BOOLEAN('P', "period", &record.opts.period, "Sample period"),
1036         OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
1037                     "don't sample"),
1038         OPT_BOOLEAN('N', "no-buildid-cache", &record.no_buildid_cache,
1039                     "do not update the buildid cache"),
1040         OPT_BOOLEAN('B', "no-buildid", &record.no_buildid,
1041                     "do not collect buildids in perf.data"),
1042         OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
1043                      "monitor event in cgroup name only",
1044                      parse_cgroups),
1045         OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
1046                   "ms to wait before starting measurement after program start"),
1047         OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
1048                    "user to profile"),
1049
1050         OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
1051                      "branch any", "sample any taken branches",
1052                      parse_branch_stack),
1053
1054         OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
1055                      "branch filter mask", "branch stack filter modes",
1056                      parse_branch_stack),
1057         OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
1058                     "sample by weight (on special events only)"),
1059         OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
1060                     "sample transaction flags (special events only)"),
1061         OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
1062                     "use per-thread mmaps"),
1063         OPT_BOOLEAN('I', "intr-regs", &record.opts.sample_intr_regs,
1064                     "Sample machine registers on interrupt"),
1065         OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
1066                     "Record running/enabled time of read (:S) events"),
1067         OPT_CALLBACK('k', "clockid", &record.opts,
1068         "clockid", "clockid to use for events, see clock_gettime()",
1069         parse_clockid),
1070         OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
1071                           "opts", "AUX area tracing Snapshot Mode", ""),
1072         OPT_END()
1073 };
1074
1075 struct option *record_options = __record_options;
1076
1077 int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
1078 {
1079         int err;
1080         struct record *rec = &record;
1081         char errbuf[BUFSIZ];
1082
1083         rec->evlist = perf_evlist__new();
1084         if (rec->evlist == NULL)
1085                 return -ENOMEM;
1086
1087         perf_config(perf_record_config, rec);
1088
1089         argc = parse_options(argc, argv, record_options, record_usage,
1090                             PARSE_OPT_STOP_AT_NON_OPTION);
1091         if (!argc && target__none(&rec->opts.target))
1092                 usage_with_options(record_usage, record_options);
1093
1094         if (nr_cgroups && !rec->opts.target.system_wide) {
1095                 ui__error("cgroup monitoring only available in"
1096                           " system-wide mode\n");
1097                 usage_with_options(record_usage, record_options);
1098         }
1099
1100         if (!rec->itr) {
1101                 rec->itr = auxtrace_record__init(rec->evlist, &err);
1102                 if (err)
1103                         return err;
1104         }
1105
1106         err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
1107                                               rec->opts.auxtrace_snapshot_opts);
1108         if (err)
1109                 return err;
1110
1111         err = -ENOMEM;
1112
1113         symbol__init(NULL);
1114
1115         if (symbol_conf.kptr_restrict)
1116                 pr_warning(
1117 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
1118 "check /proc/sys/kernel/kptr_restrict.\n\n"
1119 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
1120 "file is not found in the buildid cache or in the vmlinux path.\n\n"
1121 "Samples in kernel modules won't be resolved at all.\n\n"
1122 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
1123 "even with a suitable vmlinux or kallsyms file.\n\n");
1124
1125         if (rec->no_buildid_cache || rec->no_buildid)
1126                 disable_buildid_cache();
1127
1128         if (rec->evlist->nr_entries == 0 &&
1129             perf_evlist__add_default(rec->evlist) < 0) {
1130                 pr_err("Not enough memory for event selector list\n");
1131                 goto out_symbol_exit;
1132         }
1133
1134         if (rec->opts.target.tid && !rec->opts.no_inherit_set)
1135                 rec->opts.no_inherit = true;
1136
1137         err = target__validate(&rec->opts.target);
1138         if (err) {
1139                 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1140                 ui__warning("%s", errbuf);
1141         }
1142
1143         err = target__parse_uid(&rec->opts.target);
1144         if (err) {
1145                 int saved_errno = errno;
1146
1147                 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1148                 ui__error("%s", errbuf);
1149
1150                 err = -saved_errno;
1151                 goto out_symbol_exit;
1152         }
1153
1154         err = -ENOMEM;
1155         if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
1156                 usage_with_options(record_usage, record_options);
1157
1158         err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
1159         if (err)
1160                 goto out_symbol_exit;
1161
1162         if (record_opts__config(&rec->opts)) {
1163                 err = -EINVAL;
1164                 goto out_symbol_exit;
1165         }
1166
1167         err = __cmd_record(&record, argc, argv);
1168 out_symbol_exit:
1169         perf_evlist__delete(rec->evlist);
1170         symbol__exit();
1171         auxtrace_record__free(rec->itr);
1172         return err;
1173 }
1174
1175 static void snapshot_sig_handler(int sig __maybe_unused)
1176 {
1177         if (!auxtrace_snapshot_enabled)
1178                 return;
1179         auxtrace_snapshot_enabled = 0;
1180         auxtrace_snapshot_err = auxtrace_record__snapshot_start(record.itr);
1181         auxtrace_record__snapshot_started = 1;
1182 }