Commit 6331b266 authored by Ian Rogers's avatar Ian Rogers Committed by Namhyung Kim
Browse files

perf tool: Add a delegate_tool that just delegates actions to another tool 



Add an ability to be able to compose perf_tools, by having one perform
an action and then calling a delegate. Currently the perf_tools have
if-then-elses setting the callback and then if-then-elses within the
callback. Understanding the behavior is complex as it is in two places
and logic for numerous operations, within things like perf inject, is
interwoven. By chaining perf_tools together based on command line
options this kind of code can be avoided.

Signed-off-by: default avatarIan Rogers <irogers@google.com>
Signed-off-by: default avatarNamhyung Kim <namhyung@kernel.org>
parent 71062e28

tools/perf/util/tool.c

+171 −0
Original line number Diff line number Diff line
@@ -321,3 +321,174 @@ bool perf_tool__compressed_is_stub(const struct perf_tool *tool) 
{

	return tool->compressed == perf_session__process_compressed_event_stub;

}



#define CREATE_DELEGATE_SAMPLE(name) \

	static int delegate_ ## name(const struct perf_tool *tool, \

				     union perf_event *event, \

				     struct perf_sample *sample, \

				     struct evsel *evsel, \

				     struct machine *machine) \

	{								\

		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \

		struct perf_tool *delegate = del_tool->delegate;		\

		return delegate->name(delegate, event, sample, evsel, machine);	\

	}

CREATE_DELEGATE_SAMPLE(read);

CREATE_DELEGATE_SAMPLE(sample);



#define CREATE_DELEGATE_ATTR(name)					\

	static int delegate_ ## name(const struct perf_tool *tool,	\

				union perf_event *event,		\

				struct evlist **pevlist)		\

	{								\

		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \

		struct perf_tool *delegate = del_tool->delegate;		\

		return delegate->name(delegate, event, pevlist);	\

	}

CREATE_DELEGATE_ATTR(attr);

CREATE_DELEGATE_ATTR(event_update);



#define CREATE_DELEGATE_OE(name)				   \

	static int delegate_ ## name(const struct perf_tool *tool, \

				     union perf_event *event,	   \

				     struct ordered_events *oe)	   \

	{								\

		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \

		struct perf_tool *delegate = del_tool->delegate;		\

		return delegate->name(delegate, event, oe);	\

	}

CREATE_DELEGATE_OE(finished_round);



#define CREATE_DELEGATE_OP(name)				   \

	static int delegate_ ## name(const struct perf_tool *tool, \

				     union perf_event *event, \

				     struct perf_sample *sample, \

				     struct machine *machine) \

	{								\

		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \

		struct perf_tool *delegate = del_tool->delegate;		\

		return delegate->name(delegate, event, sample, machine); \

	}

CREATE_DELEGATE_OP(aux);

CREATE_DELEGATE_OP(aux_output_hw_id);

CREATE_DELEGATE_OP(bpf);

CREATE_DELEGATE_OP(cgroup);

CREATE_DELEGATE_OP(comm);

CREATE_DELEGATE_OP(context_switch);

CREATE_DELEGATE_OP(exit);

CREATE_DELEGATE_OP(fork);

CREATE_DELEGATE_OP(itrace_start);

CREATE_DELEGATE_OP(ksymbol);

CREATE_DELEGATE_OP(lost);

CREATE_DELEGATE_OP(lost_samples);

CREATE_DELEGATE_OP(mmap);

CREATE_DELEGATE_OP(mmap2);

CREATE_DELEGATE_OP(namespaces);

CREATE_DELEGATE_OP(text_poke);

CREATE_DELEGATE_OP(throttle);

CREATE_DELEGATE_OP(unthrottle);



#define CREATE_DELEGATE_OP2(name)					\

	static int delegate_ ## name(const struct perf_tool *tool,	\

				     struct perf_session *session,	\

				     union perf_event *event)		\

	{								\

		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \

		struct perf_tool *delegate = del_tool->delegate;		\

		return delegate->name(delegate, session, event);	\

	}

CREATE_DELEGATE_OP2(auxtrace_error);

CREATE_DELEGATE_OP2(auxtrace_info);

CREATE_DELEGATE_OP2(bpf_metadata);

CREATE_DELEGATE_OP2(build_id);

CREATE_DELEGATE_OP2(cpu_map);

CREATE_DELEGATE_OP2(feature);

CREATE_DELEGATE_OP2(finished_init);

CREATE_DELEGATE_OP2(id_index);

CREATE_DELEGATE_OP2(stat);

CREATE_DELEGATE_OP2(stat_config);

CREATE_DELEGATE_OP2(stat_round);

CREATE_DELEGATE_OP2(thread_map);

CREATE_DELEGATE_OP2(time_conv);

CREATE_DELEGATE_OP2(tracing_data);



#define CREATE_DELEGATE_OP3(name)					\

	static s64 delegate_ ## name(const struct perf_tool *tool,	\

				     struct perf_session *session,      \

				     union perf_event *event)           \

	{								\

		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \

		struct perf_tool *delegate = del_tool->delegate;	\

		return delegate->name(delegate, session, event);	\

	}

CREATE_DELEGATE_OP3(auxtrace);



#define CREATE_DELEGATE_OP4(name)					\

	static int delegate_ ## name(const struct perf_tool *tool, \

			struct perf_session *session, \

			union perf_event *event, \

			u64 data, \

			const char *str) \

	{								\

		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \

		struct perf_tool *delegate = del_tool->delegate;		\

		return delegate->name(delegate, session, event, data, str);	\

	}

CREATE_DELEGATE_OP4(compressed);



void delegate_tool__init(struct delegate_tool *tool, struct perf_tool *delegate)

{

	tool->delegate = delegate;



	tool->tool.ordered_events = delegate->ordered_events;

	tool->tool.ordering_requires_timestamps = delegate->ordering_requires_timestamps;

	tool->tool.namespace_events = delegate->namespace_events;

	tool->tool.cgroup_events = delegate->cgroup_events;

	tool->tool.no_warn = delegate->no_warn;

	tool->tool.show_feat_hdr = delegate->show_feat_hdr;



	tool->tool.sample = delegate_sample;

	tool->tool.read = delegate_read;



	tool->tool.mmap = delegate_mmap;

	tool->tool.mmap2 = delegate_mmap2;

	tool->tool.comm = delegate_comm;

	tool->tool.namespaces = delegate_namespaces;

	tool->tool.cgroup = delegate_cgroup;

	tool->tool.fork = delegate_fork;

	tool->tool.exit = delegate_exit;

	tool->tool.lost = delegate_lost;

	tool->tool.lost_samples = delegate_lost_samples;

	tool->tool.aux = delegate_aux;

	tool->tool.itrace_start = delegate_itrace_start;

	tool->tool.aux_output_hw_id = delegate_aux_output_hw_id;

	tool->tool.context_switch = delegate_context_switch;

	tool->tool.throttle = delegate_throttle;

	tool->tool.unthrottle = delegate_unthrottle;

	tool->tool.ksymbol = delegate_ksymbol;

	tool->tool.bpf = delegate_bpf;

	tool->tool.text_poke = delegate_text_poke;



	tool->tool.attr = delegate_attr;

	tool->tool.event_update = delegate_event_update;



	tool->tool.tracing_data = delegate_tracing_data;



	tool->tool.finished_round = delegate_finished_round;



	tool->tool.build_id = delegate_build_id;

	tool->tool.id_index = delegate_id_index;

	tool->tool.auxtrace_info = delegate_auxtrace_info;

	tool->tool.auxtrace_error = delegate_auxtrace_error;

	tool->tool.time_conv = delegate_time_conv;

	tool->tool.thread_map = delegate_thread_map;

	tool->tool.cpu_map = delegate_cpu_map;

	tool->tool.stat_config = delegate_stat_config;

	tool->tool.stat = delegate_stat;

	tool->tool.stat_round = delegate_stat_round;

	tool->tool.feature = delegate_feature;

	tool->tool.finished_init = delegate_finished_init;

	tool->tool.bpf_metadata = delegate_bpf_metadata;

	tool->tool.compressed = delegate_compressed;

	tool->tool.auxtrace = delegate_auxtrace;

}

tools/perf/util/tool.h

+9 −0
Original line number Diff line number Diff line
@@ -102,4 +102,13 @@ int process_event_sample_stub(const struct perf_tool *tool, 
			      struct evsel *evsel,

			      struct machine *machine);



struct delegate_tool {

	/** @tool: The actual tool that calls the delegate. */

	struct perf_tool tool;

	/** @delegate: The tool that is delegated to. */

	struct perf_tool *delegate;

};



void delegate_tool__init(struct delegate_tool *tool, struct perf_tool *delegate);



#endif /* __PERF_TOOL_H */