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 <subcmd/parse-options.h>
  15 #include "util/parse-events.h"
  16 #include "util/config.h"
  17
  18 #include "util/callchain.h"
  19 #include "util/cgroup.h"
  20 #include "util/header.h"
  21 #include "util/event.h"
  22 #include "util/evlist.h"
  23 #include "util/evsel.h"
  24 #include "util/debug.h"
  25 #include "util/drv_configs.h"
  26 #include "util/session.h"
  27 #include "util/tool.h"
  28 #include "util/symbol.h"
  29 #include "util/cpumap.h"
  30 #include "util/thread_map.h"
  31 #include "util/data.h"
  32 #include "util/perf_regs.h"
  33 #include "util/auxtrace.h"
  34 #include "util/tsc.h"
  35 #include "util/parse-branch-options.h"
  36 #include "util/parse-regs-options.h"
  37 #include "util/llvm-utils.h"
  38 #include "util/bpf-loader.h"
  39 #include "util/trigger.h"
  40 #include "util/perf-hooks.h"
  41 #include "util/time-utils.h"
  42 #include "util/units.h"
  43 #include "asm/bug.h"
  44
  45 #include <errno.h>
  46 #include <inttypes.h>
  47 #include <poll.h>
  48 #include <unistd.h>
  49 #include <sched.h>
  50 #include <signal.h>
  51 #include <sys/mman.h>
  52 #include <sys/wait.h>
  53 #include <asm/bug.h>
  54 #include <linux/time64.h>
  55
  56 struct switch_output {
  57         bool             enabled;
  58         bool             signal;
  59         unsigned long    size;
  60         unsigned long    time;
  61         const char      *str;
  62         bool             set;
  63 };
  64
  65 struct record {
  66         struct perf_tool        tool;
  67         struct record_opts      opts;
  68         u64                     bytes_written;
  69         struct perf_data_file   file;
  70         struct auxtrace_record  *itr;
  71         struct perf_evlist      *evlist;
  72         struct perf_session     *session;
  73         const char              *progname;
  74         int                     realtime_prio;
  75         bool                    no_buildid;
  76         bool                    no_buildid_set;
  77         bool                    no_buildid_cache;
  78         bool                    no_buildid_cache_set;
  79         bool                    buildid_all;
  80         bool                    timestamp_filename;
  81         struct switch_output    switch_output;
  82         unsigned long long      samples;
  83 };
  84
  85 static volatile int auxtrace_record__snapshot_started;
  86 static DEFINE_TRIGGER(auxtrace_snapshot_trigger);
  87 static DEFINE_TRIGGER(switch_output_trigger);
  88
  89 static bool switch_output_signal(struct record *rec)
  90 {
  91         return rec->switch_output.signal &&
  92                trigger_is_ready(&switch_output_trigger);
  93 }
  94
  95 static bool switch_output_size(struct record *rec)
  96 {
  97         return rec->switch_output.size &&
  98                trigger_is_ready(&switch_output_trigger) &&
  99                (rec->bytes_written >= rec->switch_output.size);
 100 }
 101
 102 static bool switch_output_time(struct record *rec)
 103 {
 104         return rec->switch_output.time &&
 105                trigger_is_ready(&switch_output_trigger);
 106 }
 107
 108 static int record__write(struct record *rec, void *bf, size_t size)
 109 {
 110         if (perf_data_file__write(rec->session->file, bf, size) < 0) {
 111                 pr_err("failed to write perf data, error: %m\n");
 112                 return -1;
 113         }
 114
 115         rec->bytes_written += size;
 116
 117         if (switch_output_size(rec))
 118                 trigger_hit(&switch_output_trigger);
 119
 120         return 0;
 121 }
 122
 123 static int process_synthesized_event(struct perf_tool *tool,
 124                                      union perf_event *event,
 125                                      struct perf_sample *sample __maybe_unused,
 126                                      struct machine *machine __maybe_unused)
 127 {
 128         struct record *rec = container_of(tool, struct record, tool);
 129         return record__write(rec, event, event->header.size);
 130 }
 131
 132 static int
 133 backward_rb_find_range(void *buf, int mask, u64 head, u64 *start, u64 *end)
 134 {
 135         struct perf_event_header *pheader;
 136         u64 evt_head = head;
 137         int size = mask + 1;
 138
 139         pr_debug2("backward_rb_find_range: buf=%p, head=%"PRIx64"\n", buf, head);
 140         pheader = (struct perf_event_header *)(buf + (head & mask));
 141         *start = head;
 142         while (true) {
 143                 if (evt_head - head >= (unsigned int)size) {
 144                         pr_debug("Finished reading backward ring buffer: rewind\n");
 145                         if (evt_head - head > (unsigned int)size)
 146                                 evt_head -= pheader->size;
 147                         *end = evt_head;
 148                         return 0;
 149                 }
 150
 151                 pheader = (struct perf_event_header *)(buf + (evt_head & mask));
 152
 153                 if (pheader->size == 0) {
 154                         pr_debug("Finished reading backward ring buffer: get start\n");
 155                         *end = evt_head;
 156                         return 0;
 157                 }
 158
 159                 evt_head += pheader->size;
 160                 pr_debug3("move evt_head: %"PRIx64"\n", evt_head);
 161         }
 162         WARN_ONCE(1, "Shouldn't get here\n");
 163         return -1;
 164 }
 165
 166 static int
 167 rb_find_range(void *data, int mask, u64 head, u64 old,
 168               u64 *start, u64 *end, bool backward)
 169 {
 170         if (!backward) {
 171                 *start = old;
 172                 *end = head;
 173                 return 0;
 174         }
 175
 176         return backward_rb_find_range(data, mask, head, start, end);
 177 }
 178
 179 static int
 180 record__mmap_read(struct record *rec, struct perf_mmap *md,
 181                   bool overwrite, bool backward)
 182 {
 183         u64 head = perf_mmap__read_head(md);
 184         u64 old = md->prev;
 185         u64 end = head, start = old;
 186         unsigned char *data = md->base + page_size;
 187         unsigned long size;
 188         void *buf;
 189         int rc = 0;
 190
 191         if (rb_find_range(data, md->mask, head,
 192                           old, &start, &end, backward))
 193                 return -1;
 194
 195         if (start == end)
 196                 return 0;
 197
 198         rec->samples++;
 199
 200         size = end - start;
 201         if (size > (unsigned long)(md->mask) + 1) {
 202                 WARN_ONCE(1, "failed to keep up with mmap data. (warn only once)\n");
 203
 204                 md->prev = head;
 205                 perf_mmap__consume(md, overwrite || backward);
 206                 return 0;
 207         }
 208
 209         if ((start & md->mask) + size != (end & md->mask)) {
 210                 buf = &data[start & md->mask];
 211                 size = md->mask + 1 - (start & md->mask);
 212                 start += size;
 213
 214                 if (record__write(rec, buf, size) < 0) {
 215                         rc = -1;
 216                         goto out;
 217                 }
 218         }
 219
 220         buf = &data[start & md->mask];
 221         size = end - start;
 222         start += size;
 223
 224         if (record__write(rec, buf, size) < 0) {
 225                 rc = -1;
 226                 goto out;
 227         }
 228
 229         md->prev = head;
 230         perf_mmap__consume(md, overwrite || backward);
 231 out:
 232         return rc;
 233 }
 234
 235 static volatile int done;
 236 static volatile int signr = -1;
 237 static volatile int child_finished;
 238
 239 static void sig_handler(int sig)
 240 {
 241         if (sig == SIGCHLD)
 242                 child_finished = 1;
 243         else
 244                 signr = sig;
 245
 246         done = 1;
 247 }
 248
 249 static void sigsegv_handler(int sig)
 250 {
 251         perf_hooks__recover();
 252         sighandler_dump_stack(sig);
 253 }
 254
 255 static void record__sig_exit(void)
 256 {
 257         if (signr == -1)
 258                 return;
 259
 260         signal(signr, SIG_DFL);
 261         raise(signr);
 262 }
 263
 264 #ifdef HAVE_AUXTRACE_SUPPORT
 265
 266 static int record__process_auxtrace(struct perf_tool *tool,
 267                                     union perf_event *event, void *data1,
 268                                     size_t len1, void *data2, size_t len2)
 269 {
 270         struct record *rec = container_of(tool, struct record, tool);
 271         struct perf_data_file *file = &rec->file;
 272         size_t padding;
 273         u8 pad[8] = {0};
 274
 275         if (!perf_data_file__is_pipe(file)) {
 276                 off_t file_offset;
 277                 int fd = perf_data_file__fd(file);
 278                 int err;
 279
 280                 file_offset = lseek(fd, 0, SEEK_CUR);
 281                 if (file_offset == -1)
 282                         return -1;
 283                 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
 284                                                      event, file_offset);
 285                 if (err)
 286                         return err;
 287         }
 288
 289         /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
 290         padding = (len1 + len2) & 7;
 291         if (padding)
 292                 padding = 8 - padding;
 293
 294         record__write(rec, event, event->header.size);
 295         record__write(rec, data1, len1);
 296         if (len2)
 297                 record__write(rec, data2, len2);
 298         record__write(rec, &pad, padding);
 299
 300         return 0;
 301 }
 302
 303 static int record__auxtrace_mmap_read(struct record *rec,
 304                                       struct auxtrace_mmap *mm)
 305 {
 306         int ret;
 307
 308         ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
 309                                   record__process_auxtrace);
 310         if (ret < 0)
 311                 return ret;
 312
 313         if (ret)
 314                 rec->samples++;
 315
 316         return 0;
 317 }
 318
 319 static int record__auxtrace_mmap_read_snapshot(struct record *rec,
 320                                                struct auxtrace_mmap *mm)
 321 {
 322         int ret;
 323
 324         ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
 325                                            record__process_auxtrace,
 326                                            rec->opts.auxtrace_snapshot_size);
 327         if (ret < 0)
 328                 return ret;
 329
 330         if (ret)
 331                 rec->samples++;
 332
 333         return 0;
 334 }
 335
 336 static int record__auxtrace_read_snapshot_all(struct record *rec)
 337 {
 338         int i;
 339         int rc = 0;
 340
 341         for (i = 0; i < rec->evlist->nr_mmaps; i++) {
 342                 struct auxtrace_mmap *mm =
 343                                 &rec->evlist->mmap[i].auxtrace_mmap;
 344
 345                 if (!mm->base)
 346                         continue;
 347
 348                 if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
 349                         rc = -1;
 350                         goto out;
 351                 }
 352         }
 353 out:
 354         return rc;
 355 }
 356
 357 static void record__read_auxtrace_snapshot(struct record *rec)
 358 {
 359         pr_debug("Recording AUX area tracing snapshot\n");
 360         if (record__auxtrace_read_snapshot_all(rec) < 0) {
 361                 trigger_error(&auxtrace_snapshot_trigger);
 362         } else {
 363                 if (auxtrace_record__snapshot_finish(rec->itr))
 364                         trigger_error(&auxtrace_snapshot_trigger);
 365                 else
 366                         trigger_ready(&auxtrace_snapshot_trigger);
 367         }
 368 }
 369
 370 #else
 371
 372 static inline
 373 int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
 374                                struct auxtrace_mmap *mm __maybe_unused)
 375 {
 376         return 0;
 377 }
 378
 379 static inline
 380 void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
 381 {
 382 }
 383
 384 static inline
 385 int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
 386 {
 387         return 0;
 388 }
 389
 390 #endif
 391
 392 static int record__mmap_evlist(struct record *rec,
 393                                struct perf_evlist *evlist)
 394 {
 395         struct record_opts *opts = &rec->opts;
 396         char msg[512];
 397
 398         if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
 399                                  opts->auxtrace_mmap_pages,
 400                                  opts->auxtrace_snapshot_mode) < 0) {
 401                 if (errno == EPERM) {
 402                         pr_err("Permission error mapping pages.\n"
 403                                "Consider increasing "
 404                                "/proc/sys/kernel/perf_event_mlock_kb,\n"
 405                                "or try again with a smaller value of -m/--mmap_pages.\n"
 406                                "(current value: %u,%u)\n",
 407                                opts->mmap_pages, opts->auxtrace_mmap_pages);
 408                         return -errno;
 409                 } else {
 410                         pr_err("failed to mmap with %d (%s)\n", errno,
 411                                 str_error_r(errno, msg, sizeof(msg)));
 412                         if (errno)
 413                                 return -errno;
 414                         else
 415                                 return -EINVAL;
 416                 }
 417         }
 418         return 0;
 419 }
 420
 421 static int record__mmap(struct record *rec)
 422 {
 423         return record__mmap_evlist(rec, rec->evlist);
 424 }
 425
 426 static int record__open(struct record *rec)
 427 {
 428         char msg[BUFSIZ];
 429         struct perf_evsel *pos;
 430         struct perf_evlist *evlist = rec->evlist;
 431         struct perf_session *session = rec->session;
 432         struct record_opts *opts = &rec->opts;
 433         struct perf_evsel_config_term *err_term;
 434         int rc = 0;
 435
 436         perf_evlist__config(evlist, opts, &callchain_param);
 437
 438         evlist__for_each_entry(evlist, pos) {
 439 try_again:
 440                 if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
 441                         if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
 442                                 if (verbose > 0)
 443                                         ui__warning("%s\n", msg);
 444                                 goto try_again;
 445                         }
 446
 447                         rc = -errno;
 448                         perf_evsel__open_strerror(pos, &opts->target,
 449                                                   errno, msg, sizeof(msg));
 450                         ui__error("%s\n", msg);
 451                         goto out;
 452                 }
 453         }
 454
 455         if (perf_evlist__apply_filters(evlist, &pos)) {
 456                 pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
 457                         pos->filter, perf_evsel__name(pos), errno,
 458                         str_error_r(errno, msg, sizeof(msg)));
 459                 rc = -1;
 460                 goto out;
 461         }
 462
 463         if (perf_evlist__apply_drv_configs(evlist, &pos, &err_term)) {
 464                 pr_err("failed to set config \"%s\" on event %s with %d (%s)\n",
 465                       err_term->val.drv_cfg, perf_evsel__name(pos), errno,
 466                       str_error_r(errno, msg, sizeof(msg)));
 467                 rc = -1;
 468                 goto out;
 469         }
 470
 471         rc = record__mmap(rec);
 472         if (rc)
 473                 goto out;
 474
 475         session->evlist = evlist;
 476         perf_session__set_id_hdr_size(session);
 477 out:
 478         return rc;
 479 }
 480
 481 static int process_sample_event(struct perf_tool *tool,
 482                                 union perf_event *event,
 483                                 struct perf_sample *sample,
 484                                 struct perf_evsel *evsel,
 485                                 struct machine *machine)
 486 {
 487         struct record *rec = container_of(tool, struct record, tool);
 488
 489         rec->samples++;
 490
 491         return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
 492 }
 493
 494 static int process_buildids(struct record *rec)
 495 {
 496         struct perf_data_file *file  = &rec->file;
 497         struct perf_session *session = rec->session;
 498
 499         if (file->size == 0)
 500                 return 0;
 501
 502         /*
 503          * During this process, it'll load kernel map and replace the
 504          * dso->long_name to a real pathname it found.  In this case
 505          * we prefer the vmlinux path like
 506          *   /lib/modules/3.16.4/build/vmlinux
 507          *
 508          * rather than build-id path (in debug directory).
 509          *   $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
 510          */
 511         symbol_conf.ignore_vmlinux_buildid = true;
 512
 513         /*
 514          * If --buildid-all is given, it marks all DSO regardless of hits,
 515          * so no need to process samples.
 516          */
 517         if (rec->buildid_all)
 518                 rec->tool.sample = NULL;
 519
 520         return perf_session__process_events(session);
 521 }
 522
 523 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
 524 {
 525         int err;
 526         struct perf_tool *tool = data;
 527         /*
 528          *As for guest kernel when processing subcommand record&report,
 529          *we arrange module mmap prior to guest kernel mmap and trigger
 530          *a preload dso because default guest module symbols are loaded
 531          *from guest kallsyms instead of /lib/modules/XXX/XXX. This
 532          *method is used to avoid symbol missing when the first addr is
 533          *in module instead of in guest kernel.
 534          */
 535         err = perf_event__synthesize_modules(tool, process_synthesized_event,
 536                                              machine);
 537         if (err < 0)
 538                 pr_err("Couldn't record guest kernel [%d]'s reference"
 539                        " relocation symbol.\n", machine->pid);
 540
 541         /*
 542          * We use _stext for guest kernel because guest kernel's /proc/kallsyms
 543          * have no _text sometimes.
 544          */
 545         err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 546                                                  machine);
 547         if (err < 0)
 548                 pr_err("Couldn't record guest kernel [%d]'s reference"
 549                        " relocation symbol.\n", machine->pid);
 550 }
 551
 552 static struct perf_event_header finished_round_event = {
 553         .size = sizeof(struct perf_event_header),
 554         .type = PERF_RECORD_FINISHED_ROUND,
 555 };
 556
 557 static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist,
 558                                     bool backward)
 559 {
 560         u64 bytes_written = rec->bytes_written;
 561         int i;
 562         int rc = 0;
 563         struct perf_mmap *maps;
 564
 565         if (!evlist)
 566                 return 0;
 567
 568         maps = backward ? evlist->backward_mmap : evlist->mmap;
 569         if (!maps)
 570                 return 0;
 571
 572         if (backward && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING)
 573                 return 0;
 574
 575         for (i = 0; i < evlist->nr_mmaps; i++) {
 576                 struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap;
 577
 578                 if (maps[i].base) {
 579                         if (record__mmap_read(rec, &maps[i],
 580                                               evlist->overwrite, backward) != 0) {
 581                                 rc = -1;
 582                                 goto out;
 583                         }
 584                 }
 585
 586                 if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
 587                     record__auxtrace_mmap_read(rec, mm) != 0) {
 588                         rc = -1;
 589                         goto out;
 590                 }
 591         }
 592
 593         /*
 594          * Mark the round finished in case we wrote
 595          * at least one event.
 596          */
 597         if (bytes_written != rec->bytes_written)
 598                 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
 599
 600         if (backward)
 601                 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
 602 out:
 603         return rc;
 604 }
 605
 606 static int record__mmap_read_all(struct record *rec)
 607 {
 608         int err;
 609
 610         err = record__mmap_read_evlist(rec, rec->evlist, false);
 611         if (err)
 612                 return err;
 613
 614         return record__mmap_read_evlist(rec, rec->evlist, true);
 615 }
 616
 617 static void record__init_features(struct record *rec)
 618 {
 619         struct perf_session *session = rec->session;
 620         int feat;
 621
 622         for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
 623                 perf_header__set_feat(&session->header, feat);
 624
 625         if (rec->no_buildid)
 626                 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
 627
 628         if (!have_tracepoints(&rec->evlist->entries))
 629                 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
 630
 631         if (!rec->opts.branch_stack)
 632                 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
 633
 634         if (!rec->opts.full_auxtrace)
 635                 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
 636
 637         perf_header__clear_feat(&session->header, HEADER_STAT);
 638 }
 639
 640 static void
 641 record__finish_output(struct record *rec)
 642 {
 643         struct perf_data_file *file = &rec->file;
 644         int fd = perf_data_file__fd(file);
 645
 646         if (file->is_pipe)
 647                 return;
 648
 649         rec->session->header.data_size += rec->bytes_written;
 650         file->size = lseek(perf_data_file__fd(file), 0, SEEK_CUR);
 651
 652         if (!rec->no_buildid) {
 653                 process_buildids(rec);
 654
 655                 if (rec->buildid_all)
 656                         dsos__hit_all(rec->session);
 657         }
 658         perf_session__write_header(rec->session, rec->evlist, fd, true);
 659
 660         return;
 661 }
 662
 663 static int record__synthesize_workload(struct record *rec, bool tail)
 664 {
 665         int err;
 666         struct thread_map *thread_map;
 667
 668         if (rec->opts.tail_synthesize != tail)
 669                 return 0;
 670
 671         thread_map = thread_map__new_by_tid(rec->evlist->workload.pid);
 672         if (thread_map == NULL)
 673                 return -1;
 674
 675         err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
 676                                                  process_synthesized_event,
 677                                                  &rec->session->machines.host,
 678                                                  rec->opts.sample_address,
 679                                                  rec->opts.proc_map_timeout);
 680         thread_map__put(thread_map);
 681         return err;
 682 }
 683
 684 static int record__synthesize(struct record *rec, bool tail);
 685
 686 static int
 687 record__switch_output(struct record *rec, bool at_exit)
 688 {
 689         struct perf_data_file *file = &rec->file;
 690         int fd, err;
 691
 692         /* Same Size:      "2015122520103046"*/
 693         char timestamp[] = "InvalidTimestamp";
 694
 695         record__synthesize(rec, true);
 696         if (target__none(&rec->opts.target))
 697                 record__synthesize_workload(rec, true);
 698
 699         rec->samples = 0;
 700         record__finish_output(rec);
 701         err = fetch_current_timestamp(timestamp, sizeof(timestamp));
 702         if (err) {
 703                 pr_err("Failed to get current timestamp\n");
 704                 return -EINVAL;
 705         }
 706
 707         fd = perf_data_file__switch(file, timestamp,
 708                                     rec->session->header.data_offset,
 709                                     at_exit);
 710         if (fd >= 0 && !at_exit) {
 711                 rec->bytes_written = 0;
 712                 rec->session->header.data_size = 0;
 713         }
 714
 715         if (!quiet)
 716                 fprintf(stderr, "[ perf record: Dump %s.%s ]\n",
 717                         file->path, timestamp);
 718
 719         /* Output tracking events */
 720         if (!at_exit) {
 721                 record__synthesize(rec, false);
 722
 723                 /*
 724                  * In 'perf record --switch-output' without -a,
 725                  * record__synthesize() in record__switch_output() won't
 726                  * generate tracking events because there's no thread_map
 727                  * in evlist. Which causes newly created perf.data doesn't
 728                  * contain map and comm information.
 729                  * Create a fake thread_map and directly call
 730                  * perf_event__synthesize_thread_map() for those events.
 731                  */
 732                 if (target__none(&rec->opts.target))
 733                         record__synthesize_workload(rec, false);
 734         }
 735         return fd;
 736 }
 737
 738 static volatile int workload_exec_errno;
 739
 740 /*
 741  * perf_evlist__prepare_workload will send a SIGUSR1
 742  * if the fork fails, since we asked by setting its
 743  * want_signal to true.
 744  */
 745 static void workload_exec_failed_signal(int signo __maybe_unused,
 746                                         siginfo_t *info,
 747                                         void *ucontext __maybe_unused)
 748 {
 749         workload_exec_errno = info->si_value.sival_int;
 750         done = 1;
 751         child_finished = 1;
 752 }
 753
 754 static void snapshot_sig_handler(int sig);
 755 static void alarm_sig_handler(int sig);
 756
 757 int __weak
 758 perf_event__synth_time_conv(const struct perf_event_mmap_page *pc __maybe_unused,
 759                             struct perf_tool *tool __maybe_unused,
 760                             perf_event__handler_t process __maybe_unused,
 761                             struct machine *machine __maybe_unused)
 762 {
 763         return 0;
 764 }
 765
 766 static const struct perf_event_mmap_page *
 767 perf_evlist__pick_pc(struct perf_evlist *evlist)
 768 {
 769         if (evlist) {
 770                 if (evlist->mmap && evlist->mmap[0].base)
 771                         return evlist->mmap[0].base;
 772                 if (evlist->backward_mmap && evlist->backward_mmap[0].base)
 773                         return evlist->backward_mmap[0].base;
 774         }
 775         return NULL;
 776 }
 777
 778 static const struct perf_event_mmap_page *record__pick_pc(struct record *rec)
 779 {
 780         const struct perf_event_mmap_page *pc;
 781
 782         pc = perf_evlist__pick_pc(rec->evlist);
 783         if (pc)
 784                 return pc;
 785         return NULL;
 786 }
 787
 788 static int record__synthesize(struct record *rec, bool tail)
 789 {
 790         struct perf_session *session = rec->session;
 791         struct machine *machine = &session->machines.host;
 792         struct perf_data_file *file = &rec->file;
 793         struct record_opts *opts = &rec->opts;
 794         struct perf_tool *tool = &rec->tool;
 795         int fd = perf_data_file__fd(file);
 796         int err = 0;
 797
 798         if (rec->opts.tail_synthesize != tail)
 799                 return 0;
 800
 801         if (file->is_pipe) {
 802                 err = perf_event__synthesize_features(
 803                         tool, session, rec->evlist, process_synthesized_event);
 804                 if (err < 0) {
 805                         pr_err("Couldn't synthesize features.\n");
 806                         return err;
 807                 }
 808
 809                 err = perf_event__synthesize_attrs(tool, session,
 810                                                    process_synthesized_event);
 811                 if (err < 0) {
 812                         pr_err("Couldn't synthesize attrs.\n");
 813                         goto out;
 814                 }
 815
 816                 if (have_tracepoints(&rec->evlist->entries)) {
 817                         /*
 818                          * FIXME err <= 0 here actually means that
 819                          * there were no tracepoints so its not really
 820                          * an error, just that we don't need to
 821                          * synthesize anything.  We really have to
 822                          * return this more properly and also
 823                          * propagate errors that now are calling die()
 824                          */
 825                         err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
 826                                                                   process_synthesized_event);
 827                         if (err <= 0) {
 828                                 pr_err("Couldn't record tracing data.\n");
 829                                 goto out;
 830                         }
 831                         rec->bytes_written += err;
 832                 }
 833         }
 834
 835         err = perf_event__synth_time_conv(record__pick_pc(rec), tool,
 836                                           process_synthesized_event, machine);
 837         if (err)
 838                 goto out;
 839
 840         if (rec->opts.full_auxtrace) {
 841                 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
 842                                         session, process_synthesized_event);
 843                 if (err)
 844                         goto out;
 845         }
 846
 847         err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
 848                                                  machine);
 849         WARN_ONCE(err < 0, "Couldn't record kernel reference relocation symbol\n"
 850                            "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 851                            "Check /proc/kallsyms permission or run as root.\n");
 852
 853         err = perf_event__synthesize_modules(tool, process_synthesized_event,
 854                                              machine);
 855         WARN_ONCE(err < 0, "Couldn't record kernel module information.\n"
 856                            "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 857                            "Check /proc/modules permission or run as root.\n");
 858
 859         if (perf_guest) {
 860                 machines__process_guests(&session->machines,
 861                                          perf_event__synthesize_guest_os, tool);
 862         }
 863
 864         err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
 865                                             process_synthesized_event, opts->sample_address,
 866                                             opts->proc_map_timeout);
 867 out:
 868         return err;
 869 }
 870
 871 static int __cmd_record(struct record *rec, int argc, const char **argv)
 872 {
 873         int err;
 874         int status = 0;
 875         unsigned long waking = 0;
 876         const bool forks = argc > 0;
 877         struct machine *machine;
 878         struct perf_tool *tool = &rec->tool;
 879         struct record_opts *opts = &rec->opts;
 880         struct perf_data_file *file = &rec->file;
 881         struct perf_session *session;
 882         bool disabled = false, draining = false;
 883         int fd;
 884
 885         rec->progname = argv[0];
 886
 887         atexit(record__sig_exit);
 888         signal(SIGCHLD, sig_handler);
 889         signal(SIGINT, sig_handler);
 890         signal(SIGTERM, sig_handler);
 891         signal(SIGSEGV, sigsegv_handler);
 892
 893         if (rec->opts.record_namespaces)
 894                 tool->namespace_events = true;
 895
 896         if (rec->opts.auxtrace_snapshot_mode || rec->switch_output.enabled) {
 897                 signal(SIGUSR2, snapshot_sig_handler);
 898                 if (rec->opts.auxtrace_snapshot_mode)
 899                         trigger_on(&auxtrace_snapshot_trigger);
 900                 if (rec->switch_output.enabled)
 901                         trigger_on(&switch_output_trigger);
 902         } else {
 903                 signal(SIGUSR2, SIG_IGN);
 904         }
 905
 906         session = perf_session__new(file, false, tool);
 907         if (session == NULL) {
 908                 pr_err("Perf session creation failed.\n");
 909                 return -1;
 910         }
 911
 912         fd = perf_data_file__fd(file);
 913         rec->session = session;
 914
 915         record__init_features(rec);
 916
 917         if (forks) {
 918                 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
 919                                                     argv, file->is_pipe,
 920                                                     workload_exec_failed_signal);
 921                 if (err < 0) {
 922                         pr_err("Couldn't run the workload!\n");
 923                         status = err;
 924                         goto out_delete_session;
 925                 }
 926         }
 927
 928         if (record__open(rec) != 0) {
 929                 err = -1;
 930                 goto out_child;
 931         }
 932
 933         err = bpf__apply_obj_config();
 934         if (err) {
 935                 char errbuf[BUFSIZ];
 936
 937                 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
 938                 pr_err("ERROR: Apply config to BPF failed: %s\n",
 939                          errbuf);
 940                 goto out_child;
 941         }
 942
 943         /*
 944          * Normally perf_session__new would do this, but it doesn't have the
 945          * evlist.
 946          */
 947         if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) {
 948                 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
 949                 rec->tool.ordered_events = false;
 950         }
 951
 952         if (!rec->evlist->nr_groups)
 953                 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
 954
 955         if (file->is_pipe) {
 956                 err = perf_header__write_pipe(fd);
 957                 if (err < 0)
 958                         goto out_child;
 959         } else {
 960                 err = perf_session__write_header(session, rec->evlist, fd, false);
 961                 if (err < 0)
 962                         goto out_child;
 963         }
 964
 965         if (!rec->no_buildid
 966             && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
 967                 pr_err("Couldn't generate buildids. "
 968                        "Use --no-buildid to profile anyway.\n");
 969                 err = -1;
 970                 goto out_child;
 971         }
 972
 973         machine = &session->machines.host;
 974
 975         err = record__synthesize(rec, false);
 976         if (err < 0)
 977                 goto out_child;
 978
 979         if (rec->realtime_prio) {
 980                 struct sched_param param;
 981
 982                 param.sched_priority = rec->realtime_prio;
 983                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
 984                         pr_err("Could not set realtime priority.\n");
 985                         err = -1;
 986                         goto out_child;
 987                 }
 988         }
 989
 990         /*
 991          * When perf is starting the traced process, all the events
 992          * (apart from group members) have enable_on_exec=1 set,
 993          * so don't spoil it by prematurely enabling them.
 994          */
 995         if (!target__none(&opts->target) && !opts->initial_delay)
 996                 perf_evlist__enable(rec->evlist);
 997
 998         /*
 999          * Let the child rip
1000          */
1001         if (forks) {
1002                 union perf_event *event;
1003                 pid_t tgid;
1004
1005                 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
1006                 if (event == NULL) {
1007                         err = -ENOMEM;
1008                         goto out_child;
1009                 }
1010
1011                 /*
1012                  * Some H/W events are generated before COMM event
1013                  * which is emitted during exec(), so perf script
1014                  * cannot see a correct process name for those events.
1015                  * Synthesize COMM event to prevent it.
1016                  */
1017                 tgid = perf_event__synthesize_comm(tool, event,
1018                                                    rec->evlist->workload.pid,
1019                                                    process_synthesized_event,
1020                                                    machine);
1021                 free(event);
1022
1023                 if (tgid == -1)
1024                         goto out_child;
1025
1026                 event = malloc(sizeof(event->namespaces) +
1027                                (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
1028                                machine->id_hdr_size);
1029                 if (event == NULL) {
1030                         err = -ENOMEM;
1031                         goto out_child;
1032                 }
1033
1034                 /*
1035                  * Synthesize NAMESPACES event for the command specified.
1036                  */
1037                 perf_event__synthesize_namespaces(tool, event,
1038                                                   rec->evlist->workload.pid,
1039                                                   tgid, process_synthesized_event,
1040                                                   machine);
1041                 free(event);
1042
1043                 perf_evlist__start_workload(rec->evlist);
1044         }
1045
1046         if (opts->initial_delay) {
1047                 usleep(opts->initial_delay * USEC_PER_MSEC);
1048                 perf_evlist__enable(rec->evlist);
1049         }
1050
1051         trigger_ready(&auxtrace_snapshot_trigger);
1052         trigger_ready(&switch_output_trigger);
1053         perf_hooks__invoke_record_start();
1054         for (;;) {
1055                 unsigned long long hits = rec->samples;
1056
1057                 /*
1058                  * rec->evlist->bkw_mmap_state is possible to be
1059                  * BKW_MMAP_EMPTY here: when done == true and
1060                  * hits != rec->samples in previous round.
1061                  *
1062                  * perf_evlist__toggle_bkw_mmap ensure we never
1063                  * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING.
1064                  */
1065                 if (trigger_is_hit(&switch_output_trigger) || done || draining)
1066                         perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING);
1067
1068                 if (record__mmap_read_all(rec) < 0) {
1069                         trigger_error(&auxtrace_snapshot_trigger);
1070                         trigger_error(&switch_output_trigger);
1071                         err = -1;
1072                         goto out_child;
1073                 }
1074
1075                 if (auxtrace_record__snapshot_started) {
1076                         auxtrace_record__snapshot_started = 0;
1077                         if (!trigger_is_error(&auxtrace_snapshot_trigger))
1078                                 record__read_auxtrace_snapshot(rec);
1079                         if (trigger_is_error(&auxtrace_snapshot_trigger)) {
1080                                 pr_err("AUX area tracing snapshot failed\n");
1081                                 err = -1;
1082                                 goto out_child;
1083                         }
1084                 }
1085
1086                 if (trigger_is_hit(&switch_output_trigger)) {
1087                         /*
1088                          * If switch_output_trigger is hit, the data in
1089                          * overwritable ring buffer should have been collected,
1090                          * so bkw_mmap_state should be set to BKW_MMAP_EMPTY.
1091                          *
1092                          * If SIGUSR2 raise after or during record__mmap_read_all(),
1093                          * record__mmap_read_all() didn't collect data from
1094                          * overwritable ring buffer. Read again.
1095                          */
1096                         if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING)
1097                                 continue;
1098                         trigger_ready(&switch_output_trigger);
1099
1100                         /*
1101                          * Reenable events in overwrite ring buffer after
1102                          * record__mmap_read_all(): we should have collected
1103                          * data from it.
1104                          */
1105                         perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING);
1106
1107                         if (!quiet)
1108                                 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n",
1109                                         waking);
1110                         waking = 0;
1111                         fd = record__switch_output(rec, false);
1112                         if (fd < 0) {
1113                                 pr_err("Failed to switch to new file\n");
1114                                 trigger_error(&switch_output_trigger);
1115                                 err = fd;
1116                                 goto out_child;
1117                         }
1118
1119                         /* re-arm the alarm */
1120                         if (rec->switch_output.time)
1121                                 alarm(rec->switch_output.time);
1122                 }
1123
1124                 if (hits == rec->samples) {
1125                         if (done || draining)
1126                                 break;
1127                         err = perf_evlist__poll(rec->evlist, -1);
1128                         /*
1129                          * Propagate error, only if there's any. Ignore positive
1130                          * number of returned events and interrupt error.
1131                          */
1132                         if (err > 0 || (err < 0 && errno == EINTR))
1133                                 err = 0;
1134                         waking++;
1135
1136                         if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
1137                                 draining = true;
1138                 }
1139
1140                 /*
1141                  * When perf is starting the traced process, at the end events
1142                  * die with the process and we wait for that. Thus no need to
1143                  * disable events in this case.
1144                  */
1145                 if (done && !disabled && !target__none(&opts->target)) {
1146                         trigger_off(&auxtrace_snapshot_trigger);
1147                         perf_evlist__disable(rec->evlist);
1148                         disabled = true;
1149                 }
1150         }
1151         trigger_off(&auxtrace_snapshot_trigger);
1152         trigger_off(&switch_output_trigger);
1153
1154         if (forks && workload_exec_errno) {
1155                 char msg[STRERR_BUFSIZE];
1156                 const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
1157                 pr_err("Workload failed: %s\n", emsg);
1158                 err = -1;
1159                 goto out_child;
1160         }
1161
1162         if (!quiet)
1163                 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
1164
1165         if (target__none(&rec->opts.target))
1166                 record__synthesize_workload(rec, true);
1167
1168 out_child:
1169         if (forks) {
1170                 int exit_status;
1171
1172                 if (!child_finished)
1173                         kill(rec->evlist->workload.pid, SIGTERM);
1174
1175                 wait(&exit_status);
1176
1177                 if (err < 0)
1178                         status = err;
1179                 else if (WIFEXITED(exit_status))
1180                         status = WEXITSTATUS(exit_status);
1181                 else if (WIFSIGNALED(exit_status))
1182                         signr = WTERMSIG(exit_status);
1183         } else
1184                 status = err;
1185
1186         record__synthesize(rec, true);
1187         /* this will be recalculated during process_buildids() */
1188         rec->samples = 0;
1189
1190         if (!err) {
1191                 if (!rec->timestamp_filename) {
1192                         record__finish_output(rec);
1193                 } else {
1194                         fd = record__switch_output(rec, true);
1195                         if (fd < 0) {
1196                                 status = fd;
1197                                 goto out_delete_session;
1198                         }
1199                 }
1200         }
1201
1202         perf_hooks__invoke_record_end();
1203
1204         if (!err && !quiet) {
1205                 char samples[128];
1206                 const char *postfix = rec->timestamp_filename ?
1207                                         ".<timestamp>" : "";
1208
1209                 if (rec->samples && !rec->opts.full_auxtrace)
1210                         scnprintf(samples, sizeof(samples),
1211                                   " (%" PRIu64 " samples)", rec->samples);
1212                 else
1213                         samples[0] = '\0';
1214
1215                 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s%s ]\n",
1216                         perf_data_file__size(file) / 1024.0 / 1024.0,
1217                         file->path, postfix, samples);
1218         }
1219
1220 out_delete_session:
1221         perf_session__delete(session);
1222         return status;
1223 }
1224
1225 static void callchain_debug(struct callchain_param *callchain)
1226 {
1227         static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
1228
1229         pr_debug("callchain: type %s\n", str[callchain->record_mode]);
1230
1231         if (callchain->record_mode == CALLCHAIN_DWARF)
1232                 pr_debug("callchain: stack dump size %d\n",
1233                          callchain->dump_size);
1234 }
1235
1236 int record_opts__parse_callchain(struct record_opts *record,
1237                                  struct callchain_param *callchain,
1238                                  const char *arg, bool unset)
1239 {
1240         int ret;
1241         callchain->enabled = !unset;
1242
1243         /* --no-call-graph */
1244         if (unset) {
1245                 callchain->record_mode = CALLCHAIN_NONE;
1246                 pr_debug("callchain: disabled\n");
1247                 return 0;
1248         }
1249
1250         ret = parse_callchain_record_opt(arg, callchain);
1251         if (!ret) {
1252                 /* Enable data address sampling for DWARF unwind. */
1253                 if (callchain->record_mode == CALLCHAIN_DWARF)
1254                         record->sample_address = true;
1255                 callchain_debug(callchain);
1256         }
1257
1258         return ret;
1259 }
1260
1261 int record_parse_callchain_opt(const struct option *opt,
1262                                const char *arg,
1263                                int unset)
1264 {
1265         return record_opts__parse_callchain(opt->value, &callchain_param, arg, unset);
1266 }
1267
1268 int record_callchain_opt(const struct option *opt,
1269                          const char *arg __maybe_unused,
1270                          int unset __maybe_unused)
1271 {
1272         struct callchain_param *callchain = opt->value;
1273
1274         callchain->enabled = true;
1275
1276         if (callchain->record_mode == CALLCHAIN_NONE)
1277                 callchain->record_mode = CALLCHAIN_FP;
1278
1279         callchain_debug(callchain);
1280         return 0;
1281 }
1282
1283 static int perf_record_config(const char *var, const char *value, void *cb)
1284 {
1285         struct record *rec = cb;
1286
1287         if (!strcmp(var, "record.build-id")) {
1288                 if (!strcmp(value, "cache"))
1289                         rec->no_buildid_cache = false;
1290                 else if (!strcmp(value, "no-cache"))
1291                         rec->no_buildid_cache = true;
1292                 else if (!strcmp(value, "skip"))
1293                         rec->no_buildid = true;
1294                 else
1295                         return -1;
1296                 return 0;
1297         }
1298         if (!strcmp(var, "record.call-graph"))
1299                 var = "call-graph.record-mode"; /* fall-through */
1300
1301         return perf_default_config(var, value, cb);
1302 }
1303
1304 struct clockid_map {
1305         const char *name;
1306         int clockid;
1307 };
1308
1309 #define CLOCKID_MAP(n, c)       \
1310         { .name = n, .clockid = (c), }
1311
1312 #define CLOCKID_END     { .name = NULL, }
1313
1314
1315 /*
1316  * Add the missing ones, we need to build on many distros...
1317  */
1318 #ifndef CLOCK_MONOTONIC_RAW
1319 #define CLOCK_MONOTONIC_RAW 4
1320 #endif
1321 #ifndef CLOCK_BOOTTIME
1322 #define CLOCK_BOOTTIME 7
1323 #endif
1324 #ifndef CLOCK_TAI
1325 #define CLOCK_TAI 11
1326 #endif
1327
1328 static const struct clockid_map clockids[] = {
1329         /* available for all events, NMI safe */
1330         CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
1331         CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
1332
1333         /* available for some events */
1334         CLOCKID_MAP("realtime", CLOCK_REALTIME),
1335         CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
1336         CLOCKID_MAP("tai", CLOCK_TAI),
1337
1338         /* available for the lazy */
1339         CLOCKID_MAP("mono", CLOCK_MONOTONIC),
1340         CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
1341         CLOCKID_MAP("real", CLOCK_REALTIME),
1342         CLOCKID_MAP("boot", CLOCK_BOOTTIME),
1343
1344         CLOCKID_END,
1345 };
1346
1347 static int parse_clockid(const struct option *opt, const char *str, int unset)
1348 {
1349         struct record_opts *opts = (struct record_opts *)opt->value;
1350         const struct clockid_map *cm;
1351         const char *ostr = str;
1352
1353         if (unset) {
1354                 opts->use_clockid = 0;
1355                 return 0;
1356         }
1357
1358         /* no arg passed */
1359         if (!str)
1360                 return 0;
1361
1362         /* no setting it twice */
1363         if (opts->use_clockid)
1364                 return -1;
1365
1366         opts->use_clockid = true;
1367
1368         /* if its a number, we're done */
1369         if (sscanf(str, "%d", &opts->clockid) == 1)
1370                 return 0;
1371
1372         /* allow a "CLOCK_" prefix to the name */
1373         if (!strncasecmp(str, "CLOCK_", 6))
1374                 str += 6;
1375
1376         for (cm = clockids; cm->name; cm++) {
1377                 if (!strcasecmp(str, cm->name)) {
1378                         opts->clockid = cm->clockid;
1379                         return 0;
1380                 }
1381         }
1382
1383         opts->use_clockid = false;
1384         ui__warning("unknown clockid %s, check man page\n", ostr);
1385         return -1;
1386 }
1387
1388 static int record__parse_mmap_pages(const struct option *opt,
1389                                     const char *str,
1390                                     int unset __maybe_unused)
1391 {
1392         struct record_opts *opts = opt->value;
1393         char *s, *p;
1394         unsigned int mmap_pages;
1395         int ret;
1396
1397         if (!str)
1398                 return -EINVAL;
1399
1400         s = strdup(str);
1401         if (!s)
1402                 return -ENOMEM;
1403
1404         p = strchr(s, ',');
1405         if (p)
1406                 *p = '\0';
1407
1408         if (*s) {
1409                 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
1410                 if (ret)
1411                         goto out_free;
1412                 opts->mmap_pages = mmap_pages;
1413         }
1414
1415         if (!p) {
1416                 ret = 0;
1417                 goto out_free;
1418         }
1419
1420         ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
1421         if (ret)
1422                 goto out_free;
1423
1424         opts->auxtrace_mmap_pages = mmap_pages;
1425
1426 out_free:
1427         free(s);
1428         return ret;
1429 }
1430
1431 static void switch_output_size_warn(struct record *rec)
1432 {
1433         u64 wakeup_size = perf_evlist__mmap_size(rec->opts.mmap_pages);
1434         struct switch_output *s = &rec->switch_output;
1435
1436         wakeup_size /= 2;
1437
1438         if (s->size < wakeup_size) {
1439                 char buf[100];
1440
1441                 unit_number__scnprintf(buf, sizeof(buf), wakeup_size);
1442                 pr_warning("WARNING: switch-output data size lower than "
1443                            "wakeup kernel buffer size (%s) "
1444                            "expect bigger perf.data sizes\n", buf);
1445         }
1446 }
1447
1448 static int switch_output_setup(struct record *rec)
1449 {
1450         struct switch_output *s = &rec->switch_output;
1451         static struct parse_tag tags_size[] = {
1452                 { .tag  = 'B', .mult = 1       },
1453                 { .tag  = 'K', .mult = 1 << 10 },
1454                 { .tag  = 'M', .mult = 1 << 20 },
1455                 { .tag  = 'G', .mult = 1 << 30 },
1456                 { .tag  = 0 },
1457         };
1458         static struct parse_tag tags_time[] = {
1459                 { .tag  = 's', .mult = 1        },
1460                 { .tag  = 'm', .mult = 60       },
1461                 { .tag  = 'h', .mult = 60*60    },
1462                 { .tag  = 'd', .mult = 60*60*24 },
1463                 { .tag  = 0 },
1464         };
1465         unsigned long val;
1466
1467         if (!s->set)
1468                 return 0;
1469
1470         if (!strcmp(s->str, "signal")) {
1471                 s->signal = true;
1472                 pr_debug("switch-output with SIGUSR2 signal\n");
1473                 goto enabled;
1474         }
1475
1476         val = parse_tag_value(s->str, tags_size);
1477         if (val != (unsigned long) -1) {
1478                 s->size = val;
1479                 pr_debug("switch-output with %s size threshold\n", s->str);
1480                 goto enabled;
1481         }
1482
1483         val = parse_tag_value(s->str, tags_time);
1484         if (val != (unsigned long) -1) {
1485                 s->time = val;
1486                 pr_debug("switch-output with %s time threshold (%lu seconds)\n",
1487                          s->str, s->time);
1488                 goto enabled;
1489         }
1490
1491         return -1;
1492
1493 enabled:
1494         rec->timestamp_filename = true;
1495         s->enabled              = true;
1496
1497         if (s->size && !rec->opts.no_buffering)
1498                 switch_output_size_warn(rec);
1499
1500         return 0;
1501 }
1502
1503 static const char * const __record_usage[] = {
1504         "perf record [<options>] [<command>]",
1505         "perf record [<options>] -- <command> [<options>]",
1506         NULL
1507 };
1508 const char * const *record_usage = __record_usage;
1509
1510 /*
1511  * XXX Ideally would be local to cmd_record() and passed to a record__new
1512  * because we need to have access to it in record__exit, that is called
1513  * after cmd_record() exits, but since record_options need to be accessible to
1514  * builtin-script, leave it here.
1515  *
1516  * At least we don't ouch it in all the other functions here directly.
1517  *
1518  * Just say no to tons of global variables, sigh.
1519  */
1520 static struct record record = {
1521         .opts = {
1522                 .sample_time         = true,
1523                 .mmap_pages          = UINT_MAX,
1524                 .user_freq           = UINT_MAX,
1525                 .user_interval       = ULLONG_MAX,
1526                 .freq                = 4000,
1527                 .target              = {
1528                         .uses_mmap   = true,
1529                         .default_per_cpu = true,
1530                 },
1531                 .proc_map_timeout     = 500,
1532         },
1533         .tool = {
1534                 .sample         = process_sample_event,
1535                 .fork           = perf_event__process_fork,
1536                 .exit           = perf_event__process_exit,
1537                 .comm           = perf_event__process_comm,
1538                 .namespaces     = perf_event__process_namespaces,
1539                 .mmap           = perf_event__process_mmap,
1540                 .mmap2          = perf_event__process_mmap2,
1541                 .ordered_events = true,
1542         },
1543 };
1544
1545 const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
1546         "\n\t\t\t\tDefault: fp";
1547
1548 static bool dry_run;
1549
1550 /*
1551  * XXX Will stay a global variable till we fix builtin-script.c to stop messing
1552  * with it and switch to use the library functions in perf_evlist that came
1553  * from builtin-record.c, i.e. use record_opts,
1554  * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
1555  * using pipes, etc.
1556  */
1557 static struct option __record_options[] = {
1558         OPT_CALLBACK('e', "event", &record.evlist, "event",
1559                      "event selector. use 'perf list' to list available events",
1560                      parse_events_option),
1561         OPT_CALLBACK(0, "filter", &record.evlist, "filter",
1562                      "event filter", parse_filter),
1563         OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
1564                            NULL, "don't record events from perf itself",
1565                            exclude_perf),
1566         OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
1567                     "record events on existing process id"),
1568         OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
1569                     "record events on existing thread id"),
1570         OPT_INTEGER('r', "realtime", &record.realtime_prio,
1571                     "collect data with this RT SCHED_FIFO priority"),
1572         OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
1573                     "collect data without buffering"),
1574         OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
1575                     "collect raw sample records from all opened counters"),
1576         OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
1577                             "system-wide collection from all CPUs"),
1578         OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
1579                     "list of cpus to monitor"),
1580         OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
1581         OPT_STRING('o', "output", &record.file.path, "file",
1582                     "output file name"),
1583         OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
1584                         &record.opts.no_inherit_set,
1585                         "child tasks do not inherit counters"),
1586         OPT_BOOLEAN(0, "tail-synthesize", &record.opts.tail_synthesize,
1587                     "synthesize non-sample events at the end of output"),
1588         OPT_BOOLEAN(0, "overwrite", &record.opts.overwrite, "use overwrite mode"),
1589         OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
1590         OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
1591                      "number of mmap data pages and AUX area tracing mmap pages",
1592                      record__parse_mmap_pages),
1593         OPT_BOOLEAN(0, "group", &record.opts.group,
1594                     "put the counters into a counter group"),
1595         OPT_CALLBACK_NOOPT('g', NULL, &callchain_param,
1596                            NULL, "enables call-graph recording" ,
1597                            &record_callchain_opt),
1598         OPT_CALLBACK(0, "call-graph", &record.opts,
1599                      "record_mode[,record_size]", record_callchain_help,
1600                      &record_parse_callchain_opt),
1601         OPT_INCR('v', "verbose", &verbose,
1602                     "be more verbose (show counter open errors, etc)"),
1603         OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
1604         OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
1605                     "per thread counts"),
1606         OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
1607         OPT_BOOLEAN(0, "sample-cpu", &record.opts.sample_cpu, "Record the sample cpu"),
1608         OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
1609                         &record.opts.sample_time_set,
1610                         "Record the sample timestamps"),
1611         OPT_BOOLEAN('P', "period", &record.opts.period, "Record the sample period"),
1612         OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
1613                     "don't sample"),
1614         OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache,
1615                         &record.no_buildid_cache_set,
1616                         "do not update the buildid cache"),
1617         OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid,
1618                         &record.no_buildid_set,
1619                         "do not collect buildids in perf.data"),
1620         OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
1621                      "monitor event in cgroup name only",
1622                      parse_cgroups),
1623         OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
1624                   "ms to wait before starting measurement after program start"),
1625         OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
1626                    "user to profile"),
1627
1628         OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
1629                      "branch any", "sample any taken branches",
1630                      parse_branch_stack),
1631
1632         OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
1633                      "branch filter mask", "branch stack filter modes",
1634                      parse_branch_stack),
1635         OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
1636                     "sample by weight (on special events only)"),
1637         OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
1638                     "sample transaction flags (special events only)"),
1639         OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
1640                     "use per-thread mmaps"),
1641         OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register",
1642                     "sample selected machine registers on interrupt,"
1643                     " use -I ? to list register names", parse_regs),
1644         OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
1645                     "Record running/enabled time of read (:S) events"),
1646         OPT_CALLBACK('k', "clockid", &record.opts,
1647         "clockid", "clockid to use for events, see clock_gettime()",
1648         parse_clockid),
1649         OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
1650                           "opts", "AUX area tracing Snapshot Mode", ""),
1651         OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout,
1652                         "per thread proc mmap processing timeout in ms"),
1653         OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces,
1654                     "Record namespaces events"),
1655         OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
1656                     "Record context switch events"),
1657         OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
1658                          "Configure all used events to run in kernel space.",
1659                          PARSE_OPT_EXCLUSIVE),
1660         OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user,
1661                          "Configure all used events to run in user space.",
1662                          PARSE_OPT_EXCLUSIVE),
1663         OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path",
1664                    "clang binary to use for compiling BPF scriptlets"),
1665         OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options",
1666                    "options passed to clang when compiling BPF scriptlets"),
1667         OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
1668                    "file", "vmlinux pathname"),
1669         OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
1670                     "Record build-id of all DSOs regardless of hits"),
1671         OPT_BOOLEAN(0, "timestamp-filename", &record.timestamp_filename,
1672                     "append timestamp to output filename"),
1673         OPT_STRING_OPTARG_SET(0, "switch-output", &record.switch_output.str,
1674                           &record.switch_output.set, "signal,size,time",
1675                           "Switch output when receive SIGUSR2 or cross size,time threshold",
1676                           "signal"),
1677         OPT_BOOLEAN(0, "dry-run", &dry_run,
1678                     "Parse options then exit"),
1679         OPT_END()
1680 };
1681
1682 struct option *record_options = __record_options;
1683
1684 int cmd_record(int argc, const char **argv)
1685 {
1686         int err;
1687         struct record *rec = &record;
1688         char errbuf[BUFSIZ];
1689
1690 #ifndef HAVE_LIBBPF_SUPPORT
1691 # define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c)
1692         set_nobuild('\0', "clang-path", true);
1693         set_nobuild('\0', "clang-opt", true);
1694 # undef set_nobuild
1695 #endif
1696
1697 #ifndef HAVE_BPF_PROLOGUE
1698 # if !defined (HAVE_DWARF_SUPPORT)
1699 #  define REASON  "NO_DWARF=1"
1700 # elif !defined (HAVE_LIBBPF_SUPPORT)
1701 #  define REASON  "NO_LIBBPF=1"
1702 # else
1703 #  define REASON  "this architecture doesn't support BPF prologue"
1704 # endif
1705 # define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
1706         set_nobuild('\0', "vmlinux", true);
1707 # undef set_nobuild
1708 # undef REASON
1709 #endif
1710
1711         rec->evlist = perf_evlist__new();
1712         if (rec->evlist == NULL)
1713                 return -ENOMEM;
1714
1715         err = perf_config(perf_record_config, rec);
1716         if (err)
1717                 return err;
1718
1719         argc = parse_options(argc, argv, record_options, record_usage,
1720                             PARSE_OPT_STOP_AT_NON_OPTION);
1721         if (quiet)
1722                 perf_quiet_option();
1723
1724         /* Make system wide (-a) the default target. */
1725         if (!argc && target__none(&rec->opts.target))
1726                 rec->opts.target.system_wide = true;
1727
1728         if (nr_cgroups && !rec->opts.target.system_wide) {
1729                 usage_with_options_msg(record_usage, record_options,
1730                         "cgroup monitoring only available in system-wide mode");
1731
1732         }
1733         if (rec->opts.record_switch_events &&
1734             !perf_can_record_switch_events()) {
1735                 ui__error("kernel does not support recording context switch events\n");
1736                 parse_options_usage(record_usage, record_options, "switch-events", 0);
1737                 return -EINVAL;
1738         }
1739
1740         if (switch_output_setup(rec)) {
1741                 parse_options_usage(record_usage, record_options, "switch-output", 0);
1742                 return -EINVAL;
1743         }
1744
1745         if (rec->switch_output.time) {
1746                 signal(SIGALRM, alarm_sig_handler);
1747                 alarm(rec->switch_output.time);
1748         }
1749
1750         if (!rec->itr) {
1751                 rec->itr = auxtrace_record__init(rec->evlist, &err);
1752                 if (err)
1753                         goto out;
1754         }
1755
1756         err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
1757                                               rec->opts.auxtrace_snapshot_opts);
1758         if (err)
1759                 goto out;
1760
1761         /*
1762          * Allow aliases to facilitate the lookup of symbols for address
1763          * filters. Refer to auxtrace_parse_filters().
1764          */
1765         symbol_conf.allow_aliases = true;
1766
1767         symbol__init(NULL);
1768
1769         err = auxtrace_parse_filters(rec->evlist);
1770         if (err)
1771                 goto out;
1772
1773         if (dry_run)
1774                 goto out;
1775
1776         err = bpf__setup_stdout(rec->evlist);
1777         if (err) {
1778                 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
1779                 pr_err("ERROR: Setup BPF stdout failed: %s\n",
1780                          errbuf);
1781                 goto out;
1782         }
1783
1784         err = -ENOMEM;
1785
1786         if (symbol_conf.kptr_restrict)
1787                 pr_warning(
1788 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
1789 "check /proc/sys/kernel/kptr_restrict.\n\n"
1790 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
1791 "file is not found in the buildid cache or in the vmlinux path.\n\n"
1792 "Samples in kernel modules won't be resolved at all.\n\n"
1793 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
1794 "even with a suitable vmlinux or kallsyms file.\n\n");
1795
1796         if (rec->no_buildid_cache || rec->no_buildid) {
1797                 disable_buildid_cache();
1798         } else if (rec->switch_output.enabled) {
1799                 /*
1800                  * In 'perf record --switch-output', disable buildid
1801                  * generation by default to reduce data file switching
1802                  * overhead. Still generate buildid if they are required
1803                  * explicitly using
1804                  *
1805                  *  perf record --switch-output --no-no-buildid \
1806                  *              --no-no-buildid-cache
1807                  *
1808                  * Following code equals to:
1809                  *
1810                  * if ((rec->no_buildid || !rec->no_buildid_set) &&
1811                  *     (rec->no_buildid_cache || !rec->no_buildid_cache_set))
1812                  *         disable_buildid_cache();
1813                  */
1814                 bool disable = true;
1815
1816                 if (rec->no_buildid_set && !rec->no_buildid)
1817                         disable = false;
1818                 if (rec->no_buildid_cache_set && !rec->no_buildid_cache)
1819                         disable = false;
1820                 if (disable) {
1821                         rec->no_buildid = true;
1822                         rec->no_buildid_cache = true;
1823                         disable_buildid_cache();
1824                 }
1825         }
1826
1827         if (record.opts.overwrite)
1828                 record.opts.tail_synthesize = true;
1829
1830         if (rec->evlist->nr_entries == 0 &&
1831             __perf_evlist__add_default(rec->evlist, !record.opts.no_samples) < 0) {
1832                 pr_err("Not enough memory for event selector list\n");
1833                 goto out;
1834         }
1835
1836         if (rec->opts.target.tid && !rec->opts.no_inherit_set)
1837                 rec->opts.no_inherit = true;
1838
1839         err = target__validate(&rec->opts.target);
1840         if (err) {
1841                 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1842                 ui__warning("%s", errbuf);
1843         }
1844
1845         err = target__parse_uid(&rec->opts.target);
1846         if (err) {
1847                 int saved_errno = errno;
1848
1849                 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1850                 ui__error("%s", errbuf);
1851
1852                 err = -saved_errno;
1853                 goto out;
1854         }
1855
1856         /* Enable ignoring missing threads when -u option is defined. */
1857         rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX;
1858
1859         err = -ENOMEM;
1860         if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
1861                 usage_with_options(record_usage, record_options);
1862
1863         err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
1864         if (err)
1865                 goto out;
1866
1867         /*
1868          * We take all buildids when the file contains
1869          * AUX area tracing data because we do not decode the
1870          * trace because it would take too long.
1871          */
1872         if (rec->opts.full_auxtrace)
1873                 rec->buildid_all = true;
1874
1875         if (record_opts__config(&rec->opts)) {
1876                 err = -EINVAL;
1877                 goto out;
1878         }
1879
1880         err = __cmd_record(&record, argc, argv);
1881 out:
1882         perf_evlist__delete(rec->evlist);
1883         symbol__exit();
1884         auxtrace_record__free(rec->itr);
1885         return err;
1886 }
1887
1888 static void snapshot_sig_handler(int sig __maybe_unused)
1889 {
1890         struct record *rec = &record;
1891
1892         if (trigger_is_ready(&auxtrace_snapshot_trigger)) {
1893                 trigger_hit(&auxtrace_snapshot_trigger);
1894                 auxtrace_record__snapshot_started = 1;
1895                 if (auxtrace_record__snapshot_start(record.itr))
1896                         trigger_error(&auxtrace_snapshot_trigger);
1897         }
1898
1899         if (switch_output_signal(rec))
1900                 trigger_hit(&switch_output_trigger);
1901 }
1902
1903 static void alarm_sig_handler(int sig __maybe_unused)
1904 {
1905         struct record *rec = &record;
1906
1907         if (switch_output_time(rec))
1908                 trigger_hit(&switch_output_trigger);
1909 }