Skip to contentSkip to conversation

perf tools: Allow to control synthesize during record

PATCH Superseded Namhyung Kim 2 participants 4 messages Jul 23, 2021 – Jul 24, 2021 perf events

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Namhyung Kim

author maintainer
#0 lore raw

PATCH 1/2 perf tools: Allow to control synthesize during record

Depending on the use case, it might require some kind of synthesize and some not. Make it controllable to turn off heavy operations like MMAP for all tasks.

Currently all users are converted to enable all the synthesis by default. It'll be updated in the later patch.

---
 tools/perf/bench/synthesize.c         |  4 +--
 tools/perf/builtin-kvm.c              |  2 +-
 tools/perf/builtin-record.c           |  6 ++--
 tools/perf/builtin-top.c              |  2 +-
 tools/perf/builtin-trace.c            |  4 +--
 tools/perf/tests/code-reading.c       |  3 +-
 tools/perf/tests/mmap-thread-lookup.c |  4 +--
 tools/perf/util/synthetic-events.c    | 45 ++++++++++++++++-----------
 tools/perf/util/synthetic-events.h    |  8 ++---
 9 files changed, 44 insertions(+), 34 deletions(-)
tools/perf/bench/synthesize.c +2 -2
index b2924e3181dc..9822385f9b57 100644
@@ -80,7 +80,7 @@ static int do_run_single_threaded(struct perf_session *session,
 						NULL,
 						target, threads,
 						process_synthesized_event,
-						data_mmap,
+						true, data_mmap,
 						nr_threads_synthesize);
 		if (err)
 			return err;
@@ -171,7 +171,7 @@ static int do_run_multi_threaded(struct target *target,
 						NULL,
 						target, NULL,
 						process_synthesized_event,
-						false,
+						true, false,
 						nr_threads_synthesize);
 		if (err) {
 			perf_session__delete(session);
tools/perf/builtin-kvm.c +1 -1
index 1105c9e40a80..8c7260a4cf83 100644
@@ -1456,7 +1456,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
 	perf_session__set_id_hdr_size(kvm->session);
 	ordered_events__set_copy_on_queue(&kvm->session->ordered_events, true);
 	machine__synthesize_threads(&kvm->session->machines.host, &kvm->opts.target,
-				    kvm->evlist->core.threads, false, 1);
+				    kvm->evlist->core.threads, true, false, 1);
 	err = kvm_live_open_events(kvm);
 	if (err)
 		goto out;
tools/perf/builtin-record.c +4 -2
index 671a21c9ee4d..535da4dfd8d3 100644
@@ -1265,6 +1265,7 @@ static int record__synthesize_workload(struct record *rec, bool tail)
 	err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
 						 process_synthesized_event,
 						 &rec->session->machines.host,
+						 true,
 						 rec->opts.sample_address);
 	perf_thread_map__put(thread_map);
 	return err;
@@ -1509,8 +1510,9 @@ static int record__synthesize(struct record *rec, bool tail)
 		f = process_locked_synthesized_event;
 	}
 
-	err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->core.threads,
-					    f, opts->sample_address,
+	err = __machine__synthesize_threads(machine, tool, &opts->target,
+					    rec->evlist->core.threads,
+					    f, true, opts->sample_address,
 					    rec->opts.nr_threads_synthesize);
 
 	if (rec->opts.nr_threads_synthesize > 1)
tools/perf/builtin-top.c +1 -1
index 02f8bb5dbc0f..7b057a935e67 100644
@@ -1271,7 +1271,7 @@ static int __cmd_top(struct perf_top *top)
 		pr_debug("Couldn't synthesize cgroup events.\n");
 
 	machine__synthesize_threads(&top->session->machines.host, &opts->target,
-				    top->evlist->core.threads, false,
+				    top->evlist->core.threads, true, false,
 				    top->nr_threads_synthesize);
 
 	if (top->nr_threads_synthesize > 1)
tools/perf/builtin-trace.c +2 -2
index 7ec18ff57fc4..cfd325b8c8de 100644
@@ -1620,8 +1620,8 @@ static int trace__symbols_init(struct trace *trace, struct evlist *evlist)
 		goto out;
 
 	err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
-					    evlist->core.threads, trace__tool_process, false,
-					    1);
+					    evlist->core.threads, trace__tool_process,
+					    true, false, 1);
 out:
 	if (err)
 		symbol__exit();
tools/perf/tests/code-reading.c +2 -1
index 9866cddebf23..3a4d932e7ffc 100644
@@ -606,7 +606,8 @@ static int do_test_code_reading(bool try_kcore)
 	}
 
 	ret = perf_event__synthesize_thread_map(NULL, threads,
-						perf_event__process, machine, false);
+						perf_event__process, machine,
+						true, false);
 	if (ret < 0) {
 		pr_debug("perf_event__synthesize_thread_map failed\n");
 		goto out_err;
tools/perf/tests/mmap-thread-lookup.c +2 -2
index 8d9d4cbff76d..6f2da7a72f67 100644
@@ -135,7 +135,7 @@ static int synth_all(struct machine *machine)
 {
 	return perf_event__synthesize_threads(NULL,
 					      perf_event__process,
-					      machine, 0, 1);
+					      machine, 1, 0, 1);
 }
 
 static int synth_process(struct machine *machine)
@@ -147,7 +147,7 @@ static int synth_process(struct machine *machine)
 
 	err = perf_event__synthesize_thread_map(NULL, map,
 						perf_event__process,
-						machine, 0);
+						machine, 1, 0);
 
 	perf_thread_map__put(map);
 	return err;
tools/perf/util/synthetic-events.c +26 -19

140 lines not on this page · raw message

tools/perf/util/synthetic-events.h +4 -4
index e7a3e9589738..61bbdb3b64df 100644
@@ -52,8 +52,8 @@ int perf_event__synthesize_stat_events(struct perf_stat_config *config, struct p
 int perf_event__synthesize_stat_round(struct perf_tool *tool, u64 time, u64 type, perf_event__handler_t process, struct machine *machine);
 int perf_event__synthesize_stat(struct perf_tool *tool, u32 cpu, u32 thread, u64 id, struct perf_counts_values *count, perf_event__handler_t process, struct machine *machine);
 int perf_event__synthesize_thread_map2(struct perf_tool *tool, struct perf_thread_map *threads, perf_event__handler_t process, struct machine *machine);
-int perf_event__synthesize_thread_map(struct perf_tool *tool, struct perf_thread_map *threads, perf_event__handler_t process, struct machine *machine, bool mmap_data);
-int perf_event__synthesize_threads(struct perf_tool *tool, perf_event__handler_t process, struct machine *machine, bool mmap_data, unsigned int nr_threads_synthesize);
+int perf_event__synthesize_thread_map(struct perf_tool *tool, struct perf_thread_map *threads, perf_event__handler_t process, struct machine *machine, bool needs_mmap, bool mmap_data);
+int perf_event__synthesize_threads(struct perf_tool *tool, perf_event__handler_t process, struct machine *machine, bool needs_mmap, bool mmap_data, unsigned int nr_threads_synthesize);
 int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd, struct evlist *evlist, perf_event__handler_t process);
 int perf_event__synth_time_conv(const struct perf_event_mmap_page *pc, struct perf_tool *tool, perf_event__handler_t process, struct machine *machine);
 pid_t perf_event__synthesize_comm(struct perf_tool *tool, union perf_event *event, pid_t pid, perf_event__handler_t process, struct machine *machine);
@@ -64,10 +64,10 @@ size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,
 
 int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool,
 				  struct target *target, struct perf_thread_map *threads,
-				  perf_event__handler_t process, bool data_mmap,
+				  perf_event__handler_t process, bool needs_mmap, bool data_mmap,
 				  unsigned int nr_threads_synthesize);
 int machine__synthesize_threads(struct machine *machine, struct target *target,
-				struct perf_thread_map *threads, bool data_mmap,
+				struct perf_thread_map *threads, bool needs_mmap, bool data_mmap,
 				unsigned int nr_threads_synthesize);
 
 #ifdef HAVE_AUXTRACE_SUPPORT
Signature · 1 line
2.32.0.432.gabb21c7263-goog
author maintainer
#1 lore raw

PATCH 2/2 perf record: Add --synth option

Add an option to control synthesize behavior.

--synth <no|all|task|mmap|cgroup>
Fine-tune event synthesis: default=all

This can be useful when we know it doesn't need some synthesis like in a specific usecase and/or when using pipe:

  $ perf record -a --all-cgroups --synth cgroup -o- sleep 1 | \
Quoted 1 line

perf report -i- -s cgroup

---
 tools/perf/Documentation/perf-record.txt |  4 ++
 tools/perf/builtin-record.c              | 48 +++++++++++++++++++-----
 tools/perf/util/record.h                 |  1 +
 tools/perf/util/synthetic-events.c       | 28 ++++++++++++++
 tools/perf/util/synthetic-events.h       | 12 ++++++
 5 files changed, 84 insertions(+), 9 deletions(-)
tools/perf/Documentation/perf-record.txt +4 -0
index d71bac847936..421a7b93c4b5 100644
@@ -596,6 +596,10 @@ options.
 'perf record --dry-run -e' can act as a BPF script compiler if llvm.dump-obj
 in config file is set to true.
 
+--synth=TYPE::
+Collect and synthesize given type of events.  Available types are:
+task, mmap, cgroup, all, no
+
 --tail-synthesize::
 Instead of collecting non-sample events (for example, fork, comm, mmap) at
 the beginning of record, collect them during finalizing an output file.
tools/perf/builtin-record.c +39 -9

90 lines not on this page · raw message

tools/perf/util/record.h +1 -0
index 68f471d9a88b..ef6c2715fdd9 100644
@@ -77,6 +77,7 @@ struct record_opts {
 	int	      ctl_fd;
 	int	      ctl_fd_ack;
 	bool	      ctl_fd_close;
+	int	      synth;
 };
 
 extern const char * const *record_usage;
tools/perf/util/synthetic-events.c +28 -0
index 566e0859fcfb..9485d0532b9c 100644
@@ -2186,3 +2186,31 @@ int perf_event__synthesize_features(struct perf_tool *tool, struct perf_session
 	free(ff.buf);
 	return ret;
 }
+
+int parse_synth_opt(char *synth)
+{
+	char *p, *q;
+	int ret = 0;
+
+	if (synth == NULL)
+		return -1;
+
+	for (q = synth; (p = strsep(&q, ",")); p = q) {
+		if (!strcasecmp(p, "no") || !strcasecmp(p, "none"))
+			return 0;
+
+		if (!strcasecmp(p, "all"))
+			return PERF_SYNTH_ALL;
+
+		if (!strcasecmp(p, "task"))
+			ret |= PERF_SYNTH_TASK;
+		else if (!strcasecmp(p, "mmap"))
+			ret |= PERF_SYNTH_TASK | PERF_SYNTH_MMAP;
+		else if (!strcasecmp(p, "cgroup"))
+			ret |= PERF_SYNTH_CGROUP;
+		else
+			return -1;
+	}
+
+	return ret;
+}
tools/perf/util/synthetic-events.h +12 -0
index 61bbdb3b64df..913803506345 100644
@@ -26,6 +26,18 @@ struct target;
 
 union perf_event;
 
+enum perf_record_synth {
+	PERF_SYNTH_TASK		= 1 << 0,
+	PERF_SYNTH_MMAP		= 1 << 1,
+	PERF_SYNTH_CGROUP	= 1 << 2,
+
+	/* last element */
+	PERF_SYNTH_MAX		= 1 << 3,
+};
+#define PERF_SYNTH_ALL  (PERF_SYNTH_MAX - 1)
+
+int parse_synth_opt(char *str);
+
 typedef int (*perf_event__handler_t)(struct perf_tool *tool, union perf_event *event,
 				     struct perf_sample *sample, struct machine *machine);
 
Signature · 1 line
2.32.0.432.gabb21c7263-goog
#2 lore raw

Re: [PATCH 2/2] perf record: Add --synth option

Quoted 26 lines · Namhyung Kim

Add an option to control synthesize behavior.

--synth <no|all|task|mmap|cgroup>
Fine-tune event synthesis: default=all

This can be useful when we know it doesn't need some synthesis like in a specific usecase and/or when using pipe:

  $ perf record -a --all-cgroups --synth cgroup -o- sleep 1 | \
Quoted 1 line

perf report -i- -s cgroup

---
 tools/perf/Documentation/perf-record.txt |  4 ++
 tools/perf/builtin-record.c              | 48 +++++++++++++++++++-----
 tools/perf/util/record.h                 |  1 +
 tools/perf/util/synthetic-events.c       | 28 ++++++++++++++
 tools/perf/util/synthetic-events.h       | 12 ++++++
 5 files changed, 84 insertions(+), 9 deletions(-)
tools/perf/Documentation/perf-record.txt +0 -0
index d71bac847936..421a7b93c4b5 100644

tools/perf/Documentation/perf-record.txt options. · line 602

Quoted 7 lines
tools/perf/Documentation/perf-record.txt +4 -0
@@ -596,6 +596,10 @@ options.
 'perf record --dry-run -e' can act as a BPF script compiler if llvm.dump-obj
 in config file is set to true.
 
+--synth=TYPE::
+Collect and synthesize given type of events.  Available types are:
+task, mmap, cgroup, all, no
+

I would explain what each option disables in the synthesis. It is not clear in your description
or your explain in the commit msg.

Quoted 178 lines
tools/perf/Documentation/perf-record.txt +0 -0
 --tail-synthesize::
 Instead of collecting non-sample events (for example, fork, comm, mmap) at
 the beginning of record, collect them during finalizing an output file.
tools/perf/builtin-record.c +39 -9
index 535da4dfd8d3..caaada3594ce 100644
@@ -1254,6 +1254,7 @@ static int record__synthesize_workload(struct record *rec, bool tail)
 {
        int err;
        struct perf_thread_map *thread_map;
+       bool needs_mmap = rec->opts.synth & PERF_SYNTH_MMAP;
 
        if (rec->opts.tail_synthesize != tail)
                return 0;
@@ -1265,7 +1266,7 @@ static int record__synthesize_workload(struct record *rec, bool tail)
        err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
                                                 process_synthesized_event,
                                                 &rec->session->machines.host,
-                                                true,
+                                                needs_mmap,
                                                 rec->opts.sample_address);
        perf_thread_map__put(thread_map);
        return err;
@@ -1500,20 +1501,26 @@ static int record__synthesize(struct record *rec, bool tail)
        if (err < 0)
                pr_warning("Couldn't synthesize bpf events.\n");
 
-       err = perf_event__synthesize_cgroups(tool, process_synthesized_event,
-                                            machine);
-       if (err < 0)
-               pr_warning("Couldn't synthesize cgroup events.\n");
+       if (rec->opts.synth & PERF_SYNTH_CGROUP) {
+               err = perf_event__synthesize_cgroups(tool, process_synthesized_event,
+                                                    machine);
+               if (err < 0)
+                       pr_warning("Couldn't synthesize cgroup events.\n");
+       }
 
        if (rec->opts.nr_threads_synthesize > 1) {
                perf_set_multithreaded();
                f = process_locked_synthesized_event;
        }
 
-       err = __machine__synthesize_threads(machine, tool, &opts->target,
-                                           rec->evlist->core.threads,
-                                           f, true, opts->sample_address,
-                                           rec->opts.nr_threads_synthesize);
+       if (rec->opts.synth & PERF_SYNTH_TASK) {
+               bool needs_mmap = rec->opts.synth & PERF_SYNTH_MMAP;
+
+               err = __machine__synthesize_threads(machine, tool, &opts->target,
+                                                   rec->evlist->core.threads,
+                                                   f, needs_mmap, opts->sample_address,
+                                                   rec->opts.nr_threads_synthesize);
+       }
 
        if (rec->opts.nr_threads_synthesize > 1)
                perf_set_singlethreaded();
@@ -2422,6 +2429,26 @@ static int process_timestamp_boundary(struct perf_tool *tool,
        return 0;
 }
 
+static int parse_record_synth_option(const struct option *opt,
+                                    const char *str,
+                                    int unset __maybe_unused)
+{
+       struct record_opts *opts = opt->value;
+       char *p = strdup(str);
+
+       if (p == NULL)
+               return -1;
+
+       opts->synth = parse_synth_opt(p);
+       free(p);
+
+       if (opts->synth < 0) {
+               pr_err("Invalid synth option: %s\n", str);
+               return -1;
+       }
+       return 0;
+}
+
 /*
  * XXX Ideally would be local to cmd_record() and passed to a record__new
  * because we need to have access to it in record__exit, that is called
@@ -2447,6 +2474,7 @@ static struct record record = {
                .nr_threads_synthesize = 1,
                .ctl_fd              = -1,
                .ctl_fd_ack          = -1,
+               .synth               = PERF_SYNTH_ALL,
        },
        .tool = {
                .sample         = process_sample_event,
@@ -2662,6 +2690,8 @@ static struct option __record_options[] = {
                     "\t\t\t  Optionally send control command completion ('ack\\n') to ack-fd descriptor.\n"
                     "\t\t\t  Alternatively, ctl-fifo / ack-fifo will be opened and used as ctl-fd / ack-fd.",
                      parse_control_option),
+       OPT_CALLBACK(0, "synth", &record.opts, "no|all|task|mmap|cgroup",
+                    "Fine-tune event synthesis: default=all", parse_record_synth_option),
        OPT_END()
 };
 
tools/perf/util/record.h +1 -0
index 68f471d9a88b..ef6c2715fdd9 100644
@@ -77,6 +77,7 @@ struct record_opts {
        int           ctl_fd;
        int           ctl_fd_ack;
        bool          ctl_fd_close;
+       int           synth;
 };
 
 extern const char * const *record_usage;
tools/perf/util/synthetic-events.c +28 -0
index 566e0859fcfb..9485d0532b9c 100644
@@ -2186,3 +2186,31 @@ int perf_event__synthesize_features(struct perf_tool *tool, struct perf_session
        free(ff.buf);
        return ret;
 }
+
+int parse_synth_opt(char *synth)
+{
+       char *p, *q;
+       int ret = 0;
+
+       if (synth == NULL)
+               return -1;
+
+       for (q = synth; (p = strsep(&q, ",")); p = q) {
+               if (!strcasecmp(p, "no") || !strcasecmp(p, "none"))
+                       return 0;
+
+               if (!strcasecmp(p, "all"))
+                       return PERF_SYNTH_ALL;
+
+               if (!strcasecmp(p, "task"))
+                       ret |= PERF_SYNTH_TASK;
+               else if (!strcasecmp(p, "mmap"))
+                       ret |= PERF_SYNTH_TASK | PERF_SYNTH_MMAP;
+               else if (!strcasecmp(p, "cgroup"))
+                       ret |= PERF_SYNTH_CGROUP;
+               else
+                       return -1;
+       }
+
+       return ret;
+}
tools/perf/util/synthetic-events.h +12 -1
index 61bbdb3b64df..913803506345 100644
@@ -26,6 +26,18 @@ struct target;
 
 union perf_event;
 
+enum perf_record_synth {
+       PERF_SYNTH_TASK         = 1 << 0,
+       PERF_SYNTH_MMAP         = 1 << 1,
+       PERF_SYNTH_CGROUP       = 1 << 2,
+
+       /* last element */
+       PERF_SYNTH_MAX          = 1 << 3,
+};
+#define PERF_SYNTH_ALL  (PERF_SYNTH_MAX - 1)
+
+int parse_synth_opt(char *str);
+
 typedef int (*perf_event__handler_t)(struct perf_tool *tool, union perf_event *event,
                                     struct perf_sample *sample, struct machine *machine);
 
--

2.32.0.432.gabb21c7263-goog

author maintainer
#3 lore raw

Re: [PATCH 2/2] perf record: Add --synth option

Quoted 31 lines · Stephane Eranian
Quoted 29 lines · Namhyung Kim

Add an option to control synthesize behavior.

--synth <no|all|task|mmap|cgroup>
Fine-tune event synthesis: default=all

This can be useful when we know it doesn't need some synthesis like in a specific usecase and/or when using pipe:

  $ perf record -a --all-cgroups --synth cgroup -o- sleep 1 | \
Quoted 1 line

perf report -i- -s cgroup

---
 tools/perf/Documentation/perf-record.txt |  4 ++
 tools/perf/builtin-record.c              | 48 +++++++++++++++++++-----
 tools/perf/util/record.h                 |  1 +
 tools/perf/util/synthetic-events.c       | 28 ++++++++++++++
 tools/perf/util/synthetic-events.h       | 12 ++++++
 5 files changed, 84 insertions(+), 9 deletions(-)
tools/perf/Documentation/perf-record.txt +0 -0
index d71bac847936..421a7b93c4b5 100644
@@ -596,6 +596,10 @@ options.
 'perf record --dry-run -e' can act as a BPF script compiler if llvm.dump-obj
 in config file is set to true.
 
Quoted 8 lines

tools/perf/Documentation/perf-record.txt options. · line 602

Quoted 4 lines
tools/perf/Documentation/perf-record.txt +4 -0
+--synth=TYPE::
+Collect and synthesize given type of events.  Available types are:
+task, mmap, cgroup, all, no
+

I would explain what each option disables in the synthesis. It is not clear in your description
or your explain in the commit msg.

Ok, will update.

Thanks,
Namhyung

Quoted 180 lines
Quoted 180 lines
tools/perf/Documentation/perf-record.txt +0 -0
 --tail-synthesize::
 Instead of collecting non-sample events (for example, fork, comm, mmap) at
 the beginning of record, collect them during finalizing an output file.
tools/perf/builtin-record.c +39 -9
index 535da4dfd8d3..caaada3594ce 100644
@@ -1254,6 +1254,7 @@ static int record__synthesize_workload(struct record *rec, bool tail)
 {
        int err;
        struct perf_thread_map *thread_map;
+       bool needs_mmap = rec->opts.synth & PERF_SYNTH_MMAP;
 
        if (rec->opts.tail_synthesize != tail)
                return 0;
@@ -1265,7 +1266,7 @@ static int record__synthesize_workload(struct record *rec, bool tail)
        err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
                                                 process_synthesized_event,
                                                 &rec->session->machines.host,
-                                                true,
+                                                needs_mmap,
                                                 rec->opts.sample_address);
        perf_thread_map__put(thread_map);
        return err;
@@ -1500,20 +1501,26 @@ static int record__synthesize(struct record *rec, bool tail)
        if (err < 0)
                pr_warning("Couldn't synthesize bpf events.\n");
 
-       err = perf_event__synthesize_cgroups(tool, process_synthesized_event,
-                                            machine);
-       if (err < 0)
-               pr_warning("Couldn't synthesize cgroup events.\n");
+       if (rec->opts.synth & PERF_SYNTH_CGROUP) {
+               err = perf_event__synthesize_cgroups(tool, process_synthesized_event,
+                                                    machine);
+               if (err < 0)
+                       pr_warning("Couldn't synthesize cgroup events.\n");
+       }
 
        if (rec->opts.nr_threads_synthesize > 1) {
                perf_set_multithreaded();
                f = process_locked_synthesized_event;
        }
 
-       err = __machine__synthesize_threads(machine, tool, &opts->target,
-                                           rec->evlist->core.threads,
-                                           f, true, opts->sample_address,
-                                           rec->opts.nr_threads_synthesize);
+       if (rec->opts.synth & PERF_SYNTH_TASK) {
+               bool needs_mmap = rec->opts.synth & PERF_SYNTH_MMAP;
+
+               err = __machine__synthesize_threads(machine, tool, &opts->target,
+                                                   rec->evlist->core.threads,
+                                                   f, needs_mmap, opts->sample_address,
+                                                   rec->opts.nr_threads_synthesize);
+       }
 
        if (rec->opts.nr_threads_synthesize > 1)
                perf_set_singlethreaded();
@@ -2422,6 +2429,26 @@ static int process_timestamp_boundary(struct perf_tool *tool,
        return 0;
 }
 
+static int parse_record_synth_option(const struct option *opt,
+                                    const char *str,
+                                    int unset __maybe_unused)
+{
+       struct record_opts *opts = opt->value;
+       char *p = strdup(str);
+
+       if (p == NULL)
+               return -1;
+
+       opts->synth = parse_synth_opt(p);
+       free(p);
+
+       if (opts->synth < 0) {
+               pr_err("Invalid synth option: %s\n", str);
+               return -1;
+       }
+       return 0;
+}
+
 /*
  * XXX Ideally would be local to cmd_record() and passed to a record__new
  * because we need to have access to it in record__exit, that is called
@@ -2447,6 +2474,7 @@ static struct record record = {
                .nr_threads_synthesize = 1,
                .ctl_fd              = -1,
                .ctl_fd_ack          = -1,
+               .synth               = PERF_SYNTH_ALL,
        },
        .tool = {
                .sample         = process_sample_event,
@@ -2662,6 +2690,8 @@ static struct option __record_options[] = {
                     "\t\t\t  Optionally send control command completion ('ack\\n') to ack-fd descriptor.\n"
                     "\t\t\t  Alternatively, ctl-fifo / ack-fifo will be opened and used as ctl-fd / ack-fd.",
                      parse_control_option),
+       OPT_CALLBACK(0, "synth", &record.opts, "no|all|task|mmap|cgroup",
+                    "Fine-tune event synthesis: default=all", parse_record_synth_option),
        OPT_END()
 };
 
tools/perf/util/record.h +1 -0
index 68f471d9a88b..ef6c2715fdd9 100644
@@ -77,6 +77,7 @@ struct record_opts {
        int           ctl_fd;
        int           ctl_fd_ack;
        bool          ctl_fd_close;
+       int           synth;
 };
 
 extern const char * const *record_usage;
tools/perf/util/synthetic-events.c +28 -0
index 566e0859fcfb..9485d0532b9c 100644
@@ -2186,3 +2186,31 @@ int perf_event__synthesize_features(struct perf_tool *tool, struct perf_session
        free(ff.buf);
        return ret;
 }
+
+int parse_synth_opt(char *synth)
+{
+       char *p, *q;
+       int ret = 0;
+
+       if (synth == NULL)
+               return -1;
+
+       for (q = synth; (p = strsep(&q, ",")); p = q) {
+               if (!strcasecmp(p, "no") || !strcasecmp(p, "none"))
+                       return 0;
+
+               if (!strcasecmp(p, "all"))
+                       return PERF_SYNTH_ALL;
+
+               if (!strcasecmp(p, "task"))
+                       ret |= PERF_SYNTH_TASK;
+               else if (!strcasecmp(p, "mmap"))
+                       ret |= PERF_SYNTH_TASK | PERF_SYNTH_MMAP;
+               else if (!strcasecmp(p, "cgroup"))
+                       ret |= PERF_SYNTH_CGROUP;
+               else
+                       return -1;
+       }
+
+       return ret;
+}
tools/perf/util/synthetic-events.h +12 -1
index 61bbdb3b64df..913803506345 100644
@@ -26,6 +26,18 @@ struct target;
 
 union perf_event;
 
+enum perf_record_synth {
+       PERF_SYNTH_TASK         = 1 << 0,
+       PERF_SYNTH_MMAP         = 1 << 1,
+       PERF_SYNTH_CGROUP       = 1 << 2,
+
+       /* last element */
+       PERF_SYNTH_MAX          = 1 << 3,
+};
+#define PERF_SYNTH_ALL  (PERF_SYNTH_MAX - 1)
+
+int parse_synth_opt(char *str);
+
 typedef int (*perf_event__handler_t)(struct perf_tool *tool, union perf_event *event,
                                     struct perf_sample *sample, struct machine *machine);
 
--

2.32.0.432.gabb21c7263-goog