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         if (file->size == 0)
 349                 return 0;
 350
 351         /*
 352          * During this process, it'll load kernel map and replace the
 353          * dso->long_name to a real pathname it found.  In this case
 354          * we prefer the vmlinux path like
 355          *   /lib/modules/3.16.4/build/vmlinux
 356          *
 357          * rather than build-id path (in debug directory).
 358          *   $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
 359          */
 360         symbol_conf.ignore_vmlinux_buildid = true;
 361
 362         return perf_session__process_events(session);
 363 }
 364
 365 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
 366 {
 367         int err;
 368         struct perf_tool *tool = data;
 369         /*
 370          *As for guest kernel when processing subcommand record&report,
 371          *we arrange module mmap prior to guest kernel mmap and trigger
 372          *a preload dso because default guest module symbols are loaded
 373          *from guest kallsyms instead of /lib/modules/XXX/XXX. This
 374          *method is used to avoid symbol missing when the first addr is
 375          *in module instead of in guest kernel.
 376          */
 377         err = perf_event__synthesize_modules(tool, process_synthesized_event,
 378                                              machine);
 379         if (err < 0)
 380                 pr_err("Couldn't record guest kernel [%d]'s reference"
 381                        " relocation symbol.\n", machine->pid);
 382
 383         /*
 384          * We use _stext for guest kernel because guest kernel's /proc/kallsyms
 385          * have no _text sometimes.
 386          */
 387         err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 388                                                  machine);
 389         if (err < 0)
 390                 pr_err("Couldn't record guest kernel [%d]'s reference"
 391                        " relocation symbol.\n", machine->pid);
 392 }
 393
 394 static struct perf_event_header finished_round_event = {
 395         .size = sizeof(struct perf_event_header),
 396         .type = PERF_RECORD_FINISHED_ROUND,
 397 };
 398
 399 static int record__mmap_read_all(struct record *rec)
 400 {
 401         u64 bytes_written = rec->bytes_written;
 402         int i;
 403         int rc = 0;
 404
 405         for (i = 0; i < rec->evlist->nr_mmaps; i++) {
 406                 struct auxtrace_mmap *mm = &rec->evlist->mmap[i].auxtrace_mmap;
 407
 408                 if (rec->evlist->mmap[i].base) {
 409                         if (record__mmap_read(rec, i) != 0) {
 410                                 rc = -1;
 411                                 goto out;
 412                         }
 413                 }
 414
 415                 if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
 416                     record__auxtrace_mmap_read(rec, mm) != 0) {
 417                         rc = -1;
 418                         goto out;
 419                 }
 420         }
 421
 422         /*
 423          * Mark the round finished in case we wrote
 424          * at least one event.
 425          */
 426         if (bytes_written != rec->bytes_written)
 427                 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
 428
 429 out:
 430         return rc;
 431 }
 432
 433 static void record__init_features(struct record *rec)
 434 {
 435         struct perf_session *session = rec->session;
 436         int feat;
 437
 438         for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
 439                 perf_header__set_feat(&session->header, feat);
 440
 441         if (rec->no_buildid)
 442                 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
 443
 444         if (!have_tracepoints(&rec->evlist->entries))
 445                 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
 446
 447         if (!rec->opts.branch_stack)
 448                 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
 449
 450         if (!rec->opts.full_auxtrace)
 451                 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
 452 }
 453
 454 static volatile int workload_exec_errno;
 455
 456 /*
 457  * perf_evlist__prepare_workload will send a SIGUSR1
 458  * if the fork fails, since we asked by setting its
 459  * want_signal to true.
 460  */
 461 static void workload_exec_failed_signal(int signo __maybe_unused,
 462                                         siginfo_t *info,
 463                                         void *ucontext __maybe_unused)
 464 {
 465         workload_exec_errno = info->si_value.sival_int;
 466         done = 1;
 467         child_finished = 1;
 468 }
 469
 470 static void snapshot_sig_handler(int sig);
 471
 472 static int __cmd_record(struct record *rec, int argc, const char **argv)
 473 {
 474         int err;
 475         int status = 0;
 476         unsigned long waking = 0;
 477         const bool forks = argc > 0;
 478         struct machine *machine;
 479         struct perf_tool *tool = &rec->tool;
 480         struct record_opts *opts = &rec->opts;
 481         struct perf_data_file *file = &rec->file;
 482         struct perf_session *session;
 483         bool disabled = false, draining = false;
 484         int fd;
 485
 486         rec->progname = argv[0];
 487
 488         atexit(record__sig_exit);
 489         signal(SIGCHLD, sig_handler);
 490         signal(SIGINT, sig_handler);
 491         signal(SIGTERM, sig_handler);
 492         if (rec->opts.auxtrace_snapshot_mode)
 493                 signal(SIGUSR2, snapshot_sig_handler);
 494         else
 495                 signal(SIGUSR2, SIG_IGN);
 496
 497         session = perf_session__new(file, false, tool);
 498         if (session == NULL) {
 499                 pr_err("Perf session creation failed.\n");
 500                 return -1;
 501         }
 502
 503         fd = perf_data_file__fd(file);
 504         rec->session = session;
 505
 506         record__init_features(rec);
 507
 508         if (forks) {
 509                 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
 510                                                     argv, file->is_pipe,
 511                                                     workload_exec_failed_signal);
 512                 if (err < 0) {
 513                         pr_err("Couldn't run the workload!\n");
 514                         status = err;
 515                         goto out_delete_session;
 516                 }
 517         }
 518
 519         if (record__open(rec) != 0) {
 520                 err = -1;
 521                 goto out_child;
 522         }
 523
 524         /*
 525          * Normally perf_session__new would do this, but it doesn't have the
 526          * evlist.
 527          */
 528         if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) {
 529                 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
 530                 rec->tool.ordered_events = false;
 531         }
 532
 533         if (!rec->evlist->nr_groups)
 534                 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
 535
 536         if (file->is_pipe) {
 537                 err = perf_header__write_pipe(fd);
 538                 if (err < 0)
 539                         goto out_child;
 540         } else {
 541                 err = perf_session__write_header(session, rec->evlist, fd, false);
 542                 if (err < 0)
 543                         goto out_child;
 544         }
 545
 546         if (!rec->no_buildid
 547             && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
 548                 pr_err("Couldn't generate buildids. "
 549                        "Use --no-buildid to profile anyway.\n");
 550                 err = -1;
 551                 goto out_child;
 552         }
 553
 554         machine = &session->machines.host;
 555
 556         if (file->is_pipe) {
 557                 err = perf_event__synthesize_attrs(tool, session,
 558                                                    process_synthesized_event);
 559                 if (err < 0) {
 560                         pr_err("Couldn't synthesize attrs.\n");
 561                         goto out_child;
 562                 }
 563
 564                 if (have_tracepoints(&rec->evlist->entries)) {
 565                         /*
 566                          * FIXME err <= 0 here actually means that
 567                          * there were no tracepoints so its not really
 568                          * an error, just that we don't need to
 569                          * synthesize anything.  We really have to
 570                          * return this more properly and also
 571                          * propagate errors that now are calling die()
 572                          */
 573                         err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
 574                                                                   process_synthesized_event);
 575                         if (err <= 0) {
 576                                 pr_err("Couldn't record tracing data.\n");
 577                                 goto out_child;
 578                         }
 579                         rec->bytes_written += err;
 580                 }
 581         }
 582
 583         if (rec->opts.full_auxtrace) {
 584                 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
 585                                         session, process_synthesized_event);
 586                 if (err)
 587                         goto out_delete_session;
 588         }
 589
 590         err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 591                                                  machine);
 592         if (err < 0)
 593                 pr_err("Couldn't record kernel reference relocation symbol\n"
 594                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 595                        "Check /proc/kallsyms permission or run as root.\n");
 596
 597         err = perf_event__synthesize_modules(tool, process_synthesized_event,
 598                                              machine);
 599         if (err < 0)
 600                 pr_err("Couldn't record kernel module information.\n"
 601                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 602                        "Check /proc/modules permission or run as root.\n");
 603
 604         if (perf_guest) {
 605                 machines__process_guests(&session->machines,
 606                                          perf_event__synthesize_guest_os, tool);
 607         }
 608
 609         err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
 610                                             process_synthesized_event, opts->sample_address,
 611                                             opts->proc_map_timeout);
 612         if (err != 0)
 613                 goto out_child;
 614
 615         if (rec->realtime_prio) {
 616                 struct sched_param param;
 617
 618                 param.sched_priority = rec->realtime_prio;
 619                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
 620                         pr_err("Could not set realtime priority.\n");
 621                         err = -1;
 622                         goto out_child;
 623                 }
 624         }
 625
 626         /*
 627          * When perf is starting the traced process, all the events
 628          * (apart from group members) have enable_on_exec=1 set,
 629          * so don't spoil it by prematurely enabling them.
 630          */
 631         if (!target__none(&opts->target) && !opts->initial_delay)
 632                 perf_evlist__enable(rec->evlist);
 633
 634         /*
 635          * Let the child rip
 636          */
 637         if (forks)
 638                 perf_evlist__start_workload(rec->evlist);
 639
 640         if (opts->initial_delay) {
 641                 usleep(opts->initial_delay * 1000);
 642                 perf_evlist__enable(rec->evlist);
 643         }
 644
 645         auxtrace_snapshot_enabled = 1;
 646         for (;;) {
 647                 int hits = rec->samples;
 648
 649                 if (record__mmap_read_all(rec) < 0) {
 650                         auxtrace_snapshot_enabled = 0;
 651                         err = -1;
 652                         goto out_child;
 653                 }
 654
 655                 if (auxtrace_record__snapshot_started) {
 656                         auxtrace_record__snapshot_started = 0;
 657                         if (!auxtrace_snapshot_err)
 658                                 record__read_auxtrace_snapshot(rec);
 659                         if (auxtrace_snapshot_err) {
 660                                 pr_err("AUX area tracing snapshot failed\n");
 661                                 err = -1;
 662                                 goto out_child;
 663                         }
 664                 }
 665
 666                 if (hits == rec->samples) {
 667                         if (done || draining)
 668                                 break;
 669                         err = perf_evlist__poll(rec->evlist, -1);
 670                         /*
 671                          * Propagate error, only if there's any. Ignore positive
 672                          * number of returned events and interrupt error.
 673                          */
 674                         if (err > 0 || (err < 0 && errno == EINTR))
 675                                 err = 0;
 676                         waking++;
 677
 678                         if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
 679                                 draining = true;
 680                 }
 681
 682                 /*
 683                  * When perf is starting the traced process, at the end events
 684                  * die with the process and we wait for that. Thus no need to
 685                  * disable events in this case.
 686                  */
 687                 if (done && !disabled && !target__none(&opts->target)) {
 688                         auxtrace_snapshot_enabled = 0;
 689                         perf_evlist__disable(rec->evlist);
 690                         disabled = true;
 691                 }
 692         }
 693         auxtrace_snapshot_enabled = 0;
 694
 695         if (forks && workload_exec_errno) {
 696                 char msg[STRERR_BUFSIZE];
 697                 const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
 698                 pr_err("Workload failed: %s\n", emsg);
 699                 err = -1;
 700                 goto out_child;
 701         }
 702
 703         if (!quiet)
 704                 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
 705
 706 out_child:
 707         if (forks) {
 708                 int exit_status;
 709
 710                 if (!child_finished)
 711                         kill(rec->evlist->workload.pid, SIGTERM);
 712
 713                 wait(&exit_status);
 714
 715                 if (err < 0)
 716                         status = err;
 717                 else if (WIFEXITED(exit_status))
 718                         status = WEXITSTATUS(exit_status);
 719                 else if (WIFSIGNALED(exit_status))
 720                         signr = WTERMSIG(exit_status);
 721         } else
 722                 status = err;
 723
 724         /* this will be recalculated during process_buildids() */
 725         rec->samples = 0;
 726
 727         if (!err && !file->is_pipe) {
 728                 rec->session->header.data_size += rec->bytes_written;
 729                 file->size = lseek(perf_data_file__fd(file), 0, SEEK_CUR);
 730
 731                 if (!rec->no_buildid) {
 732                         process_buildids(rec);
 733                         /*
 734                          * We take all buildids when the file contains
 735                          * AUX area tracing data because we do not decode the
 736                          * trace because it would take too long.
 737                          */
 738                         if (rec->opts.full_auxtrace)
 739                                 dsos__hit_all(rec->session);
 740                 }
 741                 perf_session__write_header(rec->session, rec->evlist, fd, true);
 742         }
 743
 744         if (!err && !quiet) {
 745                 char samples[128];
 746
 747                 if (rec->samples && !rec->opts.full_auxtrace)
 748                         scnprintf(samples, sizeof(samples),
 749                                   " (%" PRIu64 " samples)", rec->samples);
 750                 else
 751                         samples[0] = '\0';
 752
 753                 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s ]\n",
 754                         perf_data_file__size(file) / 1024.0 / 1024.0,
 755                         file->path, samples);
 756         }
 757
 758 out_delete_session:
 759         perf_session__delete(session);
 760         return status;
 761 }
 762
 763 static void callchain_debug(void)
 764 {
 765         static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
 766
 767         pr_debug("callchain: type %s\n", str[callchain_param.record_mode]);
 768
 769         if (callchain_param.record_mode == CALLCHAIN_DWARF)
 770                 pr_debug("callchain: stack dump size %d\n",
 771                          callchain_param.dump_size);
 772 }
 773
 774 int record_parse_callchain_opt(const struct option *opt,
 775                                const char *arg,
 776                                int unset)
 777 {
 778         int ret;
 779         struct record_opts *record = (struct record_opts *)opt->value;
 780
 781         record->callgraph_set = true;
 782         callchain_param.enabled = !unset;
 783
 784         /* --no-call-graph */
 785         if (unset) {
 786                 callchain_param.record_mode = CALLCHAIN_NONE;
 787                 pr_debug("callchain: disabled\n");
 788                 return 0;
 789         }
 790
 791         ret = parse_callchain_record_opt(arg, &callchain_param);
 792         if (!ret)
 793                 callchain_debug();
 794
 795         return ret;
 796 }
 797
 798 int record_callchain_opt(const struct option *opt,
 799                          const char *arg __maybe_unused,
 800                          int unset __maybe_unused)
 801 {
 802         struct record_opts *record = (struct record_opts *)opt->value;
 803
 804         record->callgraph_set = true;
 805         callchain_param.enabled = true;
 806
 807         if (callchain_param.record_mode == CALLCHAIN_NONE)
 808                 callchain_param.record_mode = CALLCHAIN_FP;
 809
 810         callchain_debug();
 811         return 0;
 812 }
 813
 814 static int perf_record_config(const char *var, const char *value, void *cb)
 815 {
 816         if (!strcmp(var, "record.call-graph"))
 817                 var = "call-graph.record-mode"; /* fall-through */
 818
 819         return perf_default_config(var, value, cb);
 820 }
 821
 822 struct clockid_map {
 823         const char *name;
 824         int clockid;
 825 };
 826
 827 #define CLOCKID_MAP(n, c)       \
 828         { .name = n, .clockid = (c), }
 829
 830 #define CLOCKID_END     { .name = NULL, }
 831
 832
 833 /*
 834  * Add the missing ones, we need to build on many distros...
 835  */
 836 #ifndef CLOCK_MONOTONIC_RAW
 837 #define CLOCK_MONOTONIC_RAW 4
 838 #endif
 839 #ifndef CLOCK_BOOTTIME
 840 #define CLOCK_BOOTTIME 7
 841 #endif
 842 #ifndef CLOCK_TAI
 843 #define CLOCK_TAI 11
 844 #endif
 845
 846 static const struct clockid_map clockids[] = {
 847         /* available for all events, NMI safe */
 848         CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
 849         CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
 850
 851         /* available for some events */
 852         CLOCKID_MAP("realtime", CLOCK_REALTIME),
 853         CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
 854         CLOCKID_MAP("tai", CLOCK_TAI),
 855
 856         /* available for the lazy */
 857         CLOCKID_MAP("mono", CLOCK_MONOTONIC),
 858         CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
 859         CLOCKID_MAP("real", CLOCK_REALTIME),
 860         CLOCKID_MAP("boot", CLOCK_BOOTTIME),
 861
 862         CLOCKID_END,
 863 };
 864
 865 static int parse_clockid(const struct option *opt, const char *str, int unset)
 866 {
 867         struct record_opts *opts = (struct record_opts *)opt->value;
 868         const struct clockid_map *cm;
 869         const char *ostr = str;
 870
 871         if (unset) {
 872                 opts->use_clockid = 0;
 873                 return 0;
 874         }
 875
 876         /* no arg passed */
 877         if (!str)
 878                 return 0;
 879
 880         /* no setting it twice */
 881         if (opts->use_clockid)
 882                 return -1;
 883
 884         opts->use_clockid = true;
 885
 886         /* if its a number, we're done */
 887         if (sscanf(str, "%d", &opts->clockid) == 1)
 888                 return 0;
 889
 890         /* allow a "CLOCK_" prefix to the name */
 891         if (!strncasecmp(str, "CLOCK_", 6))
 892                 str += 6;
 893
 894         for (cm = clockids; cm->name; cm++) {
 895                 if (!strcasecmp(str, cm->name)) {
 896                         opts->clockid = cm->clockid;
 897                         return 0;
 898                 }
 899         }
 900
 901         opts->use_clockid = false;
 902         ui__warning("unknown clockid %s, check man page\n", ostr);
 903         return -1;
 904 }
 905
 906 static int record__parse_mmap_pages(const struct option *opt,
 907                                     const char *str,
 908                                     int unset __maybe_unused)
 909 {
 910         struct record_opts *opts = opt->value;
 911         char *s, *p;
 912         unsigned int mmap_pages;
 913         int ret;
 914
 915         if (!str)
 916                 return -EINVAL;
 917
 918         s = strdup(str);
 919         if (!s)
 920                 return -ENOMEM;
 921
 922         p = strchr(s, ',');
 923         if (p)
 924                 *p = '\0';
 925
 926         if (*s) {
 927                 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
 928                 if (ret)
 929                         goto out_free;
 930                 opts->mmap_pages = mmap_pages;
 931         }
 932
 933         if (!p) {
 934                 ret = 0;
 935                 goto out_free;
 936         }
 937
 938         ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
 939         if (ret)
 940                 goto out_free;
 941
 942         opts->auxtrace_mmap_pages = mmap_pages;
 943
 944 out_free:
 945         free(s);
 946         return ret;
 947 }
 948
 949 static const char * const __record_usage[] = {
 950         "perf record [<options>] [<command>]",
 951         "perf record [<options>] -- <command> [<options>]",
 952         NULL
 953 };
 954 const char * const *record_usage = __record_usage;
 955
 956 /*
 957  * XXX Ideally would be local to cmd_record() and passed to a record__new
 958  * because we need to have access to it in record__exit, that is called
 959  * after cmd_record() exits, but since record_options need to be accessible to
 960  * builtin-script, leave it here.
 961  *
 962  * At least we don't ouch it in all the other functions here directly.
 963  *
 964  * Just say no to tons of global variables, sigh.
 965  */
 966 static struct record record = {
 967         .opts = {
 968                 .sample_time         = true,
 969                 .mmap_pages          = UINT_MAX,
 970                 .user_freq           = UINT_MAX,
 971                 .user_interval       = ULLONG_MAX,
 972                 .freq                = 4000,
 973                 .target              = {
 974                         .uses_mmap   = true,
 975                         .default_per_cpu = true,
 976                 },
 977                 .proc_map_timeout     = 500,
 978         },
 979         .tool = {
 980                 .sample         = process_sample_event,
 981                 .fork           = perf_event__process_fork,
 982                 .exit           = perf_event__process_exit,
 983                 .comm           = perf_event__process_comm,
 984                 .mmap           = perf_event__process_mmap,
 985                 .mmap2          = perf_event__process_mmap2,
 986                 .ordered_events = true,
 987         },
 988 };
 989
 990 #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
 991
 992 #ifdef HAVE_DWARF_UNWIND_SUPPORT
 993 const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf lbr";
 994 #else
 995 const char record_callchain_help[] = CALLCHAIN_HELP "fp lbr";
 996 #endif
 997
 998 /*
 999  * XXX Will stay a global variable till we fix builtin-script.c to stop messing
1000  * with it and switch to use the library functions in perf_evlist that came
1001  * from builtin-record.c, i.e. use record_opts,
1002  * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
1003  * using pipes, etc.
1004  */
1005 struct option __record_options[] = {
1006         OPT_CALLBACK('e', "event", &record.evlist, "event",
1007                      "event selector. use 'perf list' to list available events",
1008                      parse_events_option),
1009         OPT_CALLBACK(0, "filter", &record.evlist, "filter",
1010                      "event filter", parse_filter),
1011         OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
1012                            NULL, "don't record events from perf itself",
1013                            exclude_perf),
1014         OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
1015                     "record events on existing process id"),
1016         OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
1017                     "record events on existing thread id"),
1018         OPT_INTEGER('r', "realtime", &record.realtime_prio,
1019                     "collect data with this RT SCHED_FIFO priority"),
1020         OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
1021                     "collect data without buffering"),
1022         OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
1023                     "collect raw sample records from all opened counters"),
1024         OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
1025                             "system-wide collection from all CPUs"),
1026         OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
1027                     "list of cpus to monitor"),
1028         OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
1029         OPT_STRING('o', "output", &record.file.path, "file",
1030                     "output file name"),
1031         OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
1032                         &record.opts.no_inherit_set,
1033                         "child tasks do not inherit counters"),
1034         OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
1035         OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
1036                      "number of mmap data pages and AUX area tracing mmap pages",
1037                      record__parse_mmap_pages),
1038         OPT_BOOLEAN(0, "group", &record.opts.group,
1039                     "put the counters into a counter group"),
1040         OPT_CALLBACK_NOOPT('g', NULL, &record.opts,
1041                            NULL, "enables call-graph recording" ,
1042                            &record_callchain_opt),
1043         OPT_CALLBACK(0, "call-graph", &record.opts,
1044                      "mode[,dump_size]", record_callchain_help,
1045                      &record_parse_callchain_opt),
1046         OPT_INCR('v', "verbose", &verbose,
1047                     "be more verbose (show counter open errors, etc)"),
1048         OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
1049         OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
1050                     "per thread counts"),
1051         OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
1052         OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
1053                         &record.opts.sample_time_set,
1054                         "Record the sample timestamps"),
1055         OPT_BOOLEAN('P', "period", &record.opts.period, "Record the sample period"),
1056         OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
1057                     "don't sample"),
1058         OPT_BOOLEAN('N', "no-buildid-cache", &record.no_buildid_cache,
1059                     "do not update the buildid cache"),
1060         OPT_BOOLEAN('B', "no-buildid", &record.no_buildid,
1061                     "do not collect buildids in perf.data"),
1062         OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
1063                      "monitor event in cgroup name only",
1064                      parse_cgroups),
1065         OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
1066                   "ms to wait before starting measurement after program start"),
1067         OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
1068                    "user to profile"),
1069
1070         OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
1071                      "branch any", "sample any taken branches",
1072                      parse_branch_stack),
1073
1074         OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
1075                      "branch filter mask", "branch stack filter modes",
1076                      parse_branch_stack),
1077         OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
1078                     "sample by weight (on special events only)"),
1079         OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
1080                     "sample transaction flags (special events only)"),
1081         OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
1082                     "use per-thread mmaps"),
1083         OPT_BOOLEAN('I', "intr-regs", &record.opts.sample_intr_regs,
1084                     "Sample machine registers on interrupt"),
1085         OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
1086                     "Record running/enabled time of read (:S) events"),
1087         OPT_CALLBACK('k', "clockid", &record.opts,
1088         "clockid", "clockid to use for events, see clock_gettime()",
1089         parse_clockid),
1090         OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
1091                           "opts", "AUX area tracing Snapshot Mode", ""),
1092         OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout,
1093                         "per thread proc mmap processing timeout in ms"),
1094         OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
1095                     "Record context switch events"),
1096         OPT_END()
1097 };
1098
1099 struct option *record_options = __record_options;
1100
1101 int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
1102 {
1103         int err;
1104         struct record *rec = &record;
1105         char errbuf[BUFSIZ];
1106
1107         rec->evlist = perf_evlist__new();
1108         if (rec->evlist == NULL)
1109                 return -ENOMEM;
1110
1111         perf_config(perf_record_config, rec);
1112
1113         argc = parse_options(argc, argv, record_options, record_usage,
1114                             PARSE_OPT_STOP_AT_NON_OPTION);
1115         if (!argc && target__none(&rec->opts.target))
1116                 usage_with_options(record_usage, record_options);
1117
1118         if (nr_cgroups && !rec->opts.target.system_wide) {
1119                 ui__error("cgroup monitoring only available in"
1120                           " system-wide mode\n");
1121                 usage_with_options(record_usage, record_options);
1122         }
1123         if (rec->opts.record_switch_events &&
1124             !perf_can_record_switch_events()) {
1125                 ui__error("kernel does not support recording context switch events (--switch-events option)\n");
1126                 usage_with_options(record_usage, record_options);
1127         }
1128
1129         if (!rec->itr) {
1130                 rec->itr = auxtrace_record__init(rec->evlist, &err);
1131                 if (err)
1132                         return err;
1133         }
1134
1135         err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
1136                                               rec->opts.auxtrace_snapshot_opts);
1137         if (err)
1138                 return err;
1139
1140         err = -ENOMEM;
1141
1142         symbol__init(NULL);
1143
1144         if (symbol_conf.kptr_restrict)
1145                 pr_warning(
1146 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
1147 "check /proc/sys/kernel/kptr_restrict.\n\n"
1148 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
1149 "file is not found in the buildid cache or in the vmlinux path.\n\n"
1150 "Samples in kernel modules won't be resolved at all.\n\n"
1151 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
1152 "even with a suitable vmlinux or kallsyms file.\n\n");
1153
1154         if (rec->no_buildid_cache || rec->no_buildid)
1155                 disable_buildid_cache();
1156
1157         if (rec->evlist->nr_entries == 0 &&
1158             perf_evlist__add_default(rec->evlist) < 0) {
1159                 pr_err("Not enough memory for event selector list\n");
1160                 goto out_symbol_exit;
1161         }
1162
1163         if (rec->opts.target.tid && !rec->opts.no_inherit_set)
1164                 rec->opts.no_inherit = true;
1165
1166         err = target__validate(&rec->opts.target);
1167         if (err) {
1168                 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1169                 ui__warning("%s", errbuf);
1170         }
1171
1172         err = target__parse_uid(&rec->opts.target);
1173         if (err) {
1174                 int saved_errno = errno;
1175
1176                 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1177                 ui__error("%s", errbuf);
1178
1179                 err = -saved_errno;
1180                 goto out_symbol_exit;
1181         }
1182
1183         err = -ENOMEM;
1184         if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
1185                 usage_with_options(record_usage, record_options);
1186
1187         err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
1188         if (err)
1189                 goto out_symbol_exit;
1190
1191         if (record_opts__config(&rec->opts)) {
1192                 err = -EINVAL;
1193                 goto out_symbol_exit;
1194         }
1195
1196         err = __cmd_record(&record, argc, argv);
1197 out_symbol_exit:
1198         perf_evlist__delete(rec->evlist);
1199         symbol__exit();
1200         auxtrace_record__free(rec->itr);
1201         return err;
1202 }
1203
1204 static void snapshot_sig_handler(int sig __maybe_unused)
1205 {
1206         if (!auxtrace_snapshot_enabled)
1207                 return;
1208         auxtrace_snapshot_enabled = 0;
1209         auxtrace_snapshot_err = auxtrace_record__snapshot_start(record.itr);
1210         auxtrace_record__snapshot_started = 1;
1211 }