1 files changed, 215 insertions, 168 deletions

diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index ba6777a147c..4642d38b8d1 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -35,43 +35,36 @@ enum write_mode_t {
         WRITE_APPEND
 };
 
-struct perf_record_opts record_opts = {
-        .target_pid          = -1,
-        .target_tid          = -1,
-        .mmap_pages          = UINT_MAX,
-        .user_freq           = UINT_MAX,
-        .user_interval       = ULLONG_MAX,
-        .freq                = 1000,
-        .sample_id_all_avail = true,
+struct perf_record {
+        struct perf_event_ops   ops;
+        struct perf_record_opts opts;
+        u64                     bytes_written;
+        const char              *output_name;
+        struct perf_evlist      *evlist;
+        struct perf_session     *session;
+        const char              *progname;
+        int                     output;
+        unsigned int            page_size;
+        int                     realtime_prio;
+        enum write_mode_t       write_mode;
+        bool                    no_buildid;
+        bool                    no_buildid_cache;
+        bool                    force;
+        bool                    file_new;
+        bool                    append_file;
+        long                    samples;
+        off_t                   post_processing_offset;
 };
 
-static unsigned int             page_size;
-static int                      output;
-static const char               *output_name                    = NULL;
-static int                      realtime_prio                   =      0;
-static enum write_mode_t        write_mode                      = WRITE_FORCE;
-static bool                     no_buildid                      =  false;
-static bool                     no_buildid_cache                =  false;
-static struct perf_evlist       *evsel_list;
-
-static long                     samples                         =      0;
-static u64                      bytes_written                   =      0;
-
-static int                      file_new                        =      1;
-static off_t                    post_processing_offset;
-
-static struct perf_session      *session;
-static const char               *progname;
-
-static void advance_output(size_t size)
+static void advance_output(struct perf_record *rec, size_t size)
 {
-        bytes_written += size;
+        rec->bytes_written += size;
 }
 
-static void write_output(void *buf, size_t size)
+static void write_output(struct perf_record *rec, void *buf, size_t size)
 {
         while (size) {
-                int ret = write(output, buf, size);
+                int ret = write(rec->output, buf, size);
 
                 if (ret < 0)
                         die("failed to write");
@@ -79,30 +72,33 @@ static void write_output(void *buf, size_t size)
                 size -= ret;
                 buf += ret;
 
-                bytes_written += ret;
+                rec->bytes_written += ret;
         }
 }
 
-static int process_synthesized_event(union perf_event *event,
+static int process_synthesized_event(struct perf_event_ops *ops,
+                                     union perf_event *event,
                                      struct perf_sample *sample __used,
                                      struct perf_session *self __used)
 {
-        write_output(event, event->header.size);
+        struct perf_record *rec = container_of(ops, struct perf_record, ops);
+        write_output(rec, event, event->header.size);
         return 0;
 }
 
-static void mmap_read(struct perf_mmap *md)
+static void perf_record__mmap_read(struct perf_record *rec,
+                                   struct perf_mmap *md)
 {
         unsigned int head = perf_mmap__read_head(md);
         unsigned int old = md->prev;
-        unsigned char *data = md->base + page_size;
+        unsigned char *data = md->base + rec->page_size;
         unsigned long size;
         void *buf;
 
         if (old == head)
                 return;
 
-        samples++;
+        rec->samples++;
 
         size = head - old;
 
@@ -111,14 +107,14 @@ static void mmap_read(struct perf_mmap *md)
                 size = md->mask + 1 - (old & md->mask);
                 old += size;
 
-                write_output(buf, size);
+                write_output(rec, buf, size);
         }
 
         buf = &data[old & md->mask];
         size = head - old;
         old += size;
 
-        write_output(buf, size);
+        write_output(rec, buf, size);
 
         md->prev = old;
         perf_mmap__write_tail(md, old);
@@ -137,17 +133,18 @@ static void sig_handler(int sig)
         signr = sig;
 }
 
-static void sig_atexit(void)
+static void perf_record__sig_exit(int exit_status __used, void *arg)
 {
+        struct perf_record *rec = arg;
         int status;
 
-        if (evsel_list->workload.pid > 0) {
+        if (rec->evlist->workload.pid > 0) {
                 if (!child_finished)
-                        kill(evsel_list->workload.pid, SIGTERM);
+                        kill(rec->evlist->workload.pid, SIGTERM);
 
                 wait(&status);
                 if (WIFSIGNALED(status))
-                        psignal(WTERMSIG(status), progname);
+                        psignal(WTERMSIG(status), rec->progname);
         }
 
         if (signr == -1 || signr == SIGUSR1)
@@ -176,13 +173,16 @@ static bool perf_evlist__equal(struct perf_evlist *evlist,
         return true;
 }
 
-static void open_counters(struct perf_evlist *evlist)
+static void perf_record__open(struct perf_record *rec)
 {
         struct perf_evsel *pos, *first;
+        struct perf_evlist *evlist = rec->evlist;
+        struct perf_session *session = rec->session;
+        struct perf_record_opts *opts = &rec->opts;
 
         first = list_entry(evlist->entries.next, struct perf_evsel, node);
 
-        perf_evlist__config_attrs(evlist, &record_opts);
+        perf_evlist__config_attrs(evlist, opts);
 
         list_for_each_entry(pos, &evlist->entries, node) {
                 struct perf_event_attr *attr = &pos->attr;
@@ -201,27 +201,27 @@ static void open_counters(struct perf_evlist *evlist)
                  */
                 bool time_needed = attr->sample_type & PERF_SAMPLE_TIME;
 
-                if (record_opts.group && pos != first)
+                if (opts->group && pos != first)
                         group_fd = first->fd;
 retry_sample_id:
-                attr->sample_id_all = record_opts.sample_id_all_avail ? 1 : 0;
+                attr->sample_id_all = opts->sample_id_all_avail ? 1 : 0;
 try_again:
                 if (perf_evsel__open(pos, evlist->cpus, evlist->threads,
-                                     record_opts.group, group_fd) < 0) {
+                                     opts->group, group_fd) < 0) {
                         int err = errno;
 
                         if (err == EPERM || err == EACCES) {
                                 ui__error_paranoid();
                                 exit(EXIT_FAILURE);
-                        } else if (err ==  ENODEV && record_opts.cpu_list) {
+                        } else if (err ==  ENODEV && opts->cpu_list) {
                                 die("No such device - did you specify"
                                         " an out-of-range profile CPU?\n");
-                        } else if (err == EINVAL && record_opts.sample_id_all_avail) {
+                        } else if (err == EINVAL && opts->sample_id_all_avail) {
                                 /*
                                  * Old kernel, no attr->sample_id_type_all field
                                  */
-                                record_opts.sample_id_all_avail = false;
-                                if (!record_opts.sample_time && !record_opts.raw_samples && !time_needed)
+                                opts->sample_id_all_avail = false;
+                                if (!opts->sample_time && !opts->raw_samples && !time_needed)
                                         attr->sample_type &= ~PERF_SAMPLE_TIME;
 
                                 goto retry_sample_id;
@@ -271,10 +271,10 @@ try_again:
                 exit(-1);
         }
 
-        if (perf_evlist__mmap(evlist, record_opts.mmap_pages, false) < 0)
+        if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0)
                 die("failed to mmap with %d (%s)\n", errno, strerror(errno));
 
-        if (file_new)
+        if (rec->file_new)
                 session->evlist = evlist;
         else {
                 if (!perf_evlist__equal(session->evlist, evlist)) {
@@ -286,29 +286,32 @@ try_again:
         perf_session__update_sample_type(session);
 }
 
-static int process_buildids(void)
+static int process_buildids(struct perf_record *rec)
 {
-        u64 size = lseek(output, 0, SEEK_CUR);
+        u64 size = lseek(rec->output, 0, SEEK_CUR);
 
         if (size == 0)
                 return 0;
 
-        session->fd = output;
-        return __perf_session__process_events(session, post_processing_offset,
-                                              size - post_processing_offset,
+        rec->session->fd = rec->output;
+        return __perf_session__process_events(rec->session, rec->post_processing_offset,
+                                              size - rec->post_processing_offset,
                                               size, &build_id__mark_dso_hit_ops);
 }
 
-static void atexit_header(void)
+static void perf_record__exit(int status __used, void *arg)
 {
-        if (!record_opts.pipe_output) {
-                session->header.data_size += bytes_written;
-
-                if (!no_buildid)
-                        process_buildids();
-                perf_session__write_header(session, evsel_list, output, true);
-                perf_session__delete(session);
-                perf_evlist__delete(evsel_list);
+        struct perf_record *rec = arg;
+
+        if (!rec->opts.pipe_output) {
+                rec->session->header.data_size += rec->bytes_written;
+
+                if (!rec->no_buildid)
+                        process_buildids(rec);
+                perf_session__write_header(rec->session, rec->evlist,
+                                           rec->output, true);
+                perf_session__delete(rec->session);
+                perf_evlist__delete(rec->evlist);
                 symbol__exit();
         }
 }
@@ -316,7 +319,9 @@ static void atexit_header(void)
 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
 {
         int err;
-        struct perf_session *psession = data;
+        struct perf_event_ops *ops = data;
+        struct perf_record *rec = container_of(ops, struct perf_record, ops);
+        struct perf_session *psession = rec->session;
 
         if (machine__is_host(machine))
                 return;
@@ -329,7 +334,7 @@ static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
          *method is used to avoid symbol missing when the first addr is
          *in module instead of in guest kernel.
          */
-        err = perf_event__synthesize_modules(process_synthesized_event,
+        err = perf_event__synthesize_modules(ops, process_synthesized_event,
                                              psession, machine);
         if (err < 0)
                 pr_err("Couldn't record guest kernel [%d]'s reference"
@@ -339,10 +344,10 @@ static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
          * We use _stext for guest kernel because guest kernel's /proc/kallsyms
          * have no _text sometimes.
          */
-        err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
+        err = perf_event__synthesize_kernel_mmap(ops, process_synthesized_event,
                                                  psession, machine, "_text");
         if (err < 0)
-                err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
+                err = perf_event__synthesize_kernel_mmap(ops, process_synthesized_event,
                                                          psession, machine,
                                                          "_stext");
         if (err < 0)
@@ -355,66 +360,71 @@ static struct perf_event_header finished_round_event = {
         .type = PERF_RECORD_FINISHED_ROUND,
 };
 
-static void mmap_read_all(void)
+static void perf_record__mmap_read_all(struct perf_record *rec)
 {
         int i;
 
-        for (i = 0; i < evsel_list->nr_mmaps; i++) {
-                if (evsel_list->mmap[i].base)
-                        mmap_read(&evsel_list->mmap[i]);
+        for (i = 0; i < rec->evlist->nr_mmaps; i++) {
+                if (rec->evlist->mmap[i].base)
+                        perf_record__mmap_read(rec, &rec->evlist->mmap[i]);
         }
 
-        if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO))
-                write_output(&finished_round_event, sizeof(finished_round_event));
+        if (perf_header__has_feat(&rec->session->header, HEADER_TRACE_INFO))
+                write_output(rec, &finished_round_event, sizeof(finished_round_event));
 }
 
-static int __cmd_record(int argc, const char **argv)
+static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
 {
         struct stat st;
         int flags;
-        int err;
+        int err, output;
         unsigned long waking = 0;
         const bool forks = argc > 0;
         struct machine *machine;
+        struct perf_event_ops *ops = &rec->ops;
+        struct perf_record_opts *opts = &rec->opts;
+        struct perf_evlist *evsel_list = rec->evlist;
+        const char *output_name = rec->output_name;
+        struct perf_session *session;
 
-        progname = argv[0];
+        rec->progname = argv[0];
 
-        page_size = sysconf(_SC_PAGE_SIZE);
+        rec->page_size = sysconf(_SC_PAGE_SIZE);
 
-        atexit(sig_atexit);
+        on_exit(perf_record__sig_exit, rec);
         signal(SIGCHLD, sig_handler);
         signal(SIGINT, sig_handler);
         signal(SIGUSR1, sig_handler);
 
         if (!output_name) {
                 if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
-                        record_opts.pipe_output = true;
+                        opts->pipe_output = true;
                 else
-                        output_name = "perf.data";
+                        rec->output_name = output_name = "perf.data";
         }
         if (output_name) {
                 if (!strcmp(output_name, "-"))
-                        record_opts.pipe_output = true;
+                        opts->pipe_output = true;
                 else if (!stat(output_name, &st) && st.st_size) {
-                        if (write_mode == WRITE_FORCE) {
+                        if (rec->write_mode == WRITE_FORCE) {
                                 char oldname[PATH_MAX];
                                 snprintf(oldname, sizeof(oldname), "%s.old",
                                          output_name);
                                 unlink(oldname);
                                 rename(output_name, oldname);
                         }
-                } else if (write_mode == WRITE_APPEND) {
-                        write_mode = WRITE_FORCE;
+                } else if (rec->write_mode == WRITE_APPEND) {
+                        rec->write_mode = WRITE_FORCE;
                 }
         }
 
         flags = O_CREAT|O_RDWR;
-        if (write_mode == WRITE_APPEND)
-                file_new = 0;
+        if (rec->write_mode == WRITE_APPEND)
+                rec->file_new = 0;
         else
                 flags |= O_TRUNC;
 
-        if (record_opts.pipe_output)
+        if (opts->pipe_output)
                 output = STDOUT_FILENO;
         else
                 output = open(output_name, flags, S_IRUSR | S_IWUSR);
@@ -423,17 +433,21 @@ static int __cmd_record(int argc, const char **argv)
                 exit(-1);
         }
 
+        rec->output = output;
+
         session = perf_session__new(output_name, O_WRONLY,
-                                    write_mode == WRITE_FORCE, false, NULL);
+                                    rec->write_mode == WRITE_FORCE, false, NULL);
         if (session == NULL) {
                 pr_err("Not enough memory for reading perf file header\n");
                 return -1;
         }
 
-        if (!no_buildid)
+        rec->session = session;
+
+        if (!rec->no_buildid)
                 perf_header__set_feat(&session->header, HEADER_BUILD_ID);
 
-        if (!file_new) {
+        if (!rec->file_new) {
                 err = perf_session__read_header(session, output);
                 if (err < 0)
                         goto out_delete_session;
@@ -456,42 +470,42 @@ static int __cmd_record(int argc, const char **argv)
         perf_header__set_feat(&session->header, HEADER_CPUID);
 
         if (forks) {
-                err = perf_evlist__prepare_workload(evsel_list, &record_opts, argv);
+                err = perf_evlist__prepare_workload(evsel_list, opts, argv);
                 if (err < 0) {
                         pr_err("Couldn't run the workload!\n");
                         goto out_delete_session;
                 }
         }
 
-        open_counters(evsel_list);
+        perf_record__open(rec);
 
         /*
-         * perf_session__delete(session) will be called at atexit_header()
+         * perf_session__delete(session) will be called at perf_record__exit()
          */
-        atexit(atexit_header);
+        on_exit(perf_record__exit, rec);
 
-        if (record_opts.pipe_output) {
+        if (opts->pipe_output) {
                 err = perf_header__write_pipe(output);
                 if (err < 0)
                         return err;
-        } else if (file_new) {
+        } else if (rec->file_new) {
                 err = perf_session__write_header(session, evsel_list,
                                                  output, false);
                 if (err < 0)
                         return err;
         }
 
-        post_processing_offset = lseek(output, 0, SEEK_CUR);
+        rec->post_processing_offset = lseek(output, 0, SEEK_CUR);
 
-        if (record_opts.pipe_output) {
-                err = perf_session__synthesize_attrs(session,
-                                                     process_synthesized_event);
+        if (opts->pipe_output) {
+                err = perf_event__synthesize_attrs(ops, session,
+                                                   process_synthesized_event);
                 if (err < 0) {
                         pr_err("Couldn't synthesize attrs.\n");
                         return err;
                 }
 
-                err = perf_event__synthesize_event_types(process_synthesized_event,
+                err = perf_event__synthesize_event_types(ops, process_synthesized_event,
                                                          session);
                 if (err < 0) {
                         pr_err("Couldn't synthesize event_types.\n");
@@ -507,14 +521,14 @@ static int __cmd_record(int argc, const char **argv)
                          * return this more properly and also
                          * propagate errors that now are calling die()
                          */
-                        err = perf_event__synthesize_tracing_data(output, evsel_list,
+                        err = perf_event__synthesize_tracing_data(ops, output, evsel_list,
                                                                   process_synthesized_event,
                                                                   session);
                         if (err <= 0) {
                                 pr_err("Couldn't record tracing data.\n");
                                 return err;
                         }
-                        advance_output(err);
+                        advance_output(rec, err);
                 }
         }
 
@@ -524,17 +538,17 @@ static int __cmd_record(int argc, const char **argv)
                 return -1;
         }
 
-        err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
+        err = perf_event__synthesize_kernel_mmap(ops, process_synthesized_event,
                                                  session, machine, "_text");
         if (err < 0)
-                err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
+                err = perf_event__synthesize_kernel_mmap(ops, process_synthesized_event,
                                                          session, machine, "_stext");
         if (err < 0)
                 pr_err("Couldn't record kernel reference relocation symbol\n"
                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
                        "Check /proc/kallsyms permission or run as root.\n");
 
-        err = perf_event__synthesize_modules(process_synthesized_event,
+        err = perf_event__synthesize_modules(ops, process_synthesized_event,
                                              session, machine);
         if (err < 0)
                 pr_err("Couldn't record kernel module information.\n"
@@ -542,21 +556,21 @@ static int __cmd_record(int argc, const char **argv)
                        "Check /proc/modules permission or run as root.\n");
 
         if (perf_guest)
-                perf_session__process_machines(session,
+                perf_session__process_machines(session, ops,
                                                perf_event__synthesize_guest_os);
 
-        if (!record_opts.system_wide)
-                perf_event__synthesize_thread_map(evsel_list->threads,
+        if (!opts->system_wide)
+                perf_event__synthesize_thread_map(ops, evsel_list->threads,
                                                   process_synthesized_event,
                                                   session);
         else
-                perf_event__synthesize_threads(process_synthesized_event,
+                perf_event__synthesize_threads(ops, process_synthesized_event,
                                                session);
 
-        if (realtime_prio) {
+        if (rec->realtime_prio) {
                 struct sched_param param;
 
-                param.sched_priority = realtime_prio;
+                param.sched_priority = rec->realtime_prio;
                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
                         pr_err("Could not set realtime priority.\n");
                         exit(-1);
@@ -572,11 +586,11 @@ static int __cmd_record(int argc, const char **argv)
                 perf_evlist__start_workload(evsel_list);
 
         for (;;) {
-                int hits = samples;
+                int hits = rec->samples;
 
-                mmap_read_all();
+                perf_record__mmap_read_all(rec);
 
-                if (hits == samples) {
+                if (hits == rec->samples) {
                         if (done)
                                 break;
                         err = poll(evsel_list->pollfd, evsel_list->nr_fds, -1);
@@ -597,9 +611,9 @@ static int __cmd_record(int argc, const char **argv)
          */
         fprintf(stderr,
                 "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
-                (double)bytes_written / 1024.0 / 1024.0,
+                (double)rec->bytes_written / 1024.0 / 1024.0,
                 output_name,
-                bytes_written / 24);
+                rec->bytes_written / 24);
 
         return 0;
 
@@ -614,59 +628,88 @@ static const char * const record_usage[] = {
         NULL
 };
 
-static bool force, append_file;
+/*
+ * XXX Ideally would be local to cmd_record() and passed to a perf_record__new
+ * because we need to have access to it in perf_record__exit, that is called
+ * after cmd_record() exits, but since record_options need to be accessible to
+ * builtin-script, leave it here.
+ *
+ * At least we don't ouch it in all the other functions here directly.
+ *
+ * Just say no to tons of global variables, sigh.
+ */
+static struct perf_record record = {
+        .opts = {
+                .target_pid          = -1,
+                .target_tid          = -1,
+                .mmap_pages          = UINT_MAX,
+                .user_freq           = UINT_MAX,
+                .user_interval       = ULLONG_MAX,
+                .freq                = 1000,
+                .sample_id_all_avail = true,
+        },
+        .write_mode = WRITE_FORCE,
+        .file_new   = true,
+};
 
+/*
+ * XXX Will stay a global variable till we fix builtin-script.c to stop messing
+ * with it and switch to use the library functions in perf_evlist that came
+ * from builtin-record.c, i.e. use perf_record_opts,
+ * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
+ * using pipes, etc.
+ */
 const struct option record_options[] = {
-        OPT_CALLBACK('e', "event", &evsel_list, "event",
+        OPT_CALLBACK('e', "event", &record.evlist, "event",
                      "event selector. use 'perf list' to list available events",
                      parse_events_option),
-        OPT_CALLBACK(0, "filter", &evsel_list, "filter",
+        OPT_CALLBACK(0, "filter", &record.evlist, "filter",
                      "event filter", parse_filter),
-        OPT_INTEGER('p', "pid", &record_opts.target_pid,
+        OPT_INTEGER('p', "pid", &record.opts.target_pid,
                     "record events on existing process id"),
-        OPT_INTEGER('t', "tid", &record_opts.target_tid,
+        OPT_INTEGER('t', "tid", &record.opts.target_tid,
                     "record events on existing thread id"),
-        OPT_INTEGER('r', "realtime", &realtime_prio,
+        OPT_INTEGER('r', "realtime", &record.realtime_prio,
                     "collect data with this RT SCHED_FIFO priority"),
-        OPT_BOOLEAN('D', "no-delay", &record_opts.no_delay,
+        OPT_BOOLEAN('D', "no-delay", &record.opts.no_delay,
                     "collect data without buffering"),
-        OPT_BOOLEAN('R', "raw-samples", &record_opts.raw_samples,
+        OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
                     "collect raw sample records from all opened counters"),
-        OPT_BOOLEAN('a', "all-cpus", &record_opts.system_wide,
+        OPT_BOOLEAN('a', "all-cpus", &record.opts.system_wide,
                             "system-wide collection from all CPUs"),
-        OPT_BOOLEAN('A', "append", &append_file,
+        OPT_BOOLEAN('A', "append", &record.append_file,
                             "append to the output file to do incremental profiling"),
-        OPT_STRING('C', "cpu", &record_opts.cpu_list, "cpu",
+        OPT_STRING('C', "cpu", &record.opts.cpu_list, "cpu",
                     "list of cpus to monitor"),
-        OPT_BOOLEAN('f', "force", &force,
+        OPT_BOOLEAN('f', "force", &record.force,
                         "overwrite existing data file (deprecated)"),
-        OPT_U64('c', "count", &record_opts.user_interval, "event period to sample"),
-        OPT_STRING('o', "output", &output_name, "file",
+        OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
+        OPT_STRING('o', "output", &record.output_name, "file",
                     "output file name"),
-        OPT_BOOLEAN('i', "no-inherit", &record_opts.no_inherit,
+        OPT_BOOLEAN('i', "no-inherit", &record.opts.no_inherit,
                     "child tasks do not inherit counters"),
-        OPT_UINTEGER('F', "freq", &record_opts.user_freq, "profile at this frequency"),
-        OPT_UINTEGER('m', "mmap-pages", &record_opts.mmap_pages,
+        OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
+        OPT_UINTEGER('m', "mmap-pages", &record.opts.mmap_pages,
                      "number of mmap data pages"),
-        OPT_BOOLEAN(0, "group", &record_opts.group,
+        OPT_BOOLEAN(0, "group", &record.opts.group,
                     "put the counters into a counter group"),
-        OPT_BOOLEAN('g', "call-graph", &record_opts.call_graph,
+        OPT_BOOLEAN('g', "call-graph", &record.opts.call_graph,
                     "do call-graph (stack chain/backtrace) recording"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
-        OPT_BOOLEAN('s', "stat", &record_opts.inherit_stat,
+        OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
                     "per thread counts"),
-        OPT_BOOLEAN('d', "data", &record_opts.sample_address,
+        OPT_BOOLEAN('d', "data", &record.opts.sample_address,
                     "Sample addresses"),
-        OPT_BOOLEAN('T', "timestamp", &record_opts.sample_time, "Sample timestamps"),
-        OPT_BOOLEAN('n', "no-samples", &record_opts.no_samples,
+        OPT_BOOLEAN('T', "timestamp", &record.opts.sample_time, "Sample timestamps"),
+        OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
                     "don't sample"),
-        OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid_cache,
+        OPT_BOOLEAN('N', "no-buildid-cache", &record.no_buildid_cache,
                     "do not update the buildid cache"),
-        OPT_BOOLEAN('B', "no-buildid", &no_buildid,
+        OPT_BOOLEAN('B', "no-buildid", &record.no_buildid,
                     "do not collect buildids in perf.data"),
-        OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
+        OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
                      "monitor event in cgroup name only",
                      parse_cgroups),
         OPT_END()
@@ -676,6 +719,8 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
 {
         int err = -ENOMEM;
         struct perf_evsel *pos;
+        struct perf_evlist *evsel_list;
+        struct perf_record *rec = &record;
 
         perf_header__set_cmdline(argc, argv);
 
@@ -683,23 +728,25 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
         if (evsel_list == NULL)
                 return -ENOMEM;
 
+        rec->evlist = evsel_list;
+
         argc = parse_options(argc, argv, record_options, record_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc && record_opts.target_pid == -1 && record_opts.target_tid == -1 &&
-                !record_opts.system_wide && !record_opts.cpu_list)
+        if (!argc && rec->opts.target_pid == -1 && rec->opts.target_tid == -1 &&
+                !rec->opts.system_wide && !rec->opts.cpu_list)
                 usage_with_options(record_usage, record_options);
 
-        if (force && append_file) {
+        if (rec->force && rec->append_file) {
                 fprintf(stderr, "Can't overwrite and append at the same time."
                                 " You need to choose between -f and -A");
                 usage_with_options(record_usage, record_options);
-        } else if (append_file) {
-                write_mode = WRITE_APPEND;
+        } else if (rec->append_file) {
+                rec->write_mode = WRITE_APPEND;
         } else {
-                write_mode = WRITE_FORCE;
+                rec->write_mode = WRITE_FORCE;
         }
 
-        if (nr_cgroups && !record_opts.system_wide) {
+        if (nr_cgroups && !rec->opts.system_wide) {
                 fprintf(stderr, "cgroup monitoring only available in"
                         " system-wide mode\n");
                 usage_with_options(record_usage, record_options);
@@ -717,7 +764,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
 "even with a suitable vmlinux or kallsyms file.\n\n");
 
-        if (no_buildid_cache || no_buildid)
+        if (rec->no_buildid_cache || rec->no_buildid)
                 disable_buildid_cache();
 
         if (evsel_list->nr_entries == 0 &&
@@ -726,11 +773,11 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
                 goto out_symbol_exit;
         }
 
-        if (record_opts.target_pid != -1)
-                record_opts.target_tid = record_opts.target_pid;
+        if (rec->opts.target_pid != -1)
+                rec->opts.target_tid = rec->opts.target_pid;
 
-        if (perf_evlist__create_maps(evsel_list, record_opts.target_pid,
-                                     record_opts.target_tid, record_opts.cpu_list) < 0)
+        if (perf_evlist__create_maps(evsel_list, rec->opts.target_pid,
+                                     rec->opts.target_tid, rec->opts.cpu_list) < 0)
                 usage_with_options(record_usage, record_options);
 
         list_for_each_entry(pos, &evsel_list->entries, node) {
@@ -744,25 +791,25 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
         if (perf_evlist__alloc_pollfd(evsel_list) < 0)
                 goto out_free_fd;
 
-        if (record_opts.user_interval != ULLONG_MAX)
-                record_opts.default_interval = record_opts.user_interval;
-        if (record_opts.user_freq != UINT_MAX)
-                record_opts.freq = record_opts.user_freq;
+        if (rec->opts.user_interval != ULLONG_MAX)
+                rec->opts.default_interval = rec->opts.user_interval;
+        if (rec->opts.user_freq != UINT_MAX)
+                rec->opts.freq = rec->opts.user_freq;
 
         /*
          * User specified count overrides default frequency.
          */
-        if (record_opts.default_interval)
-                record_opts.freq = 0;
-        else if (record_opts.freq) {
-                record_opts.default_interval = record_opts.freq;
+        if (rec->opts.default_interval)
+                rec->opts.freq = 0;
+        else if (rec->opts.freq) {
+                rec->opts.default_interval = rec->opts.freq;
         } else {
                 fprintf(stderr, "frequency and count are zero, aborting\n");
                 err = -EINVAL;
                 goto out_free_fd;
         }
 
-        err = __cmd_record(argc, argv);
+        err = __cmd_record(&record, argc, argv);
 out_free_fd:
         perf_evlist__delete_maps(evsel_list);
 out_symbol_exit: