[linux-2.6-block.git] / tools / perf / builtin-inject.c

/*
 * builtin-inject.c
 *
 * Builtin inject command: Examine the live mode (stdin) event stream
 * and repipe it to stdout while optionally injecting additional
 * events into it.
 */
#include "builtin.h"

#include "perf.h"
#include "util/color.h"
#include "util/evlist.h"
#include "util/evsel.h"
#include "util/session.h"
#include "util/tool.h"
#include "util/debug.h"
#include "util/build-id.h"
#include "util/data.h"
#include "util/auxtrace.h"

#include "util/parse-options.h"

#include <linux/list.h>

struct perf_inject {
	struct perf_tool	tool;
	struct perf_session	*session;
	bool			build_ids;
	bool			sched_stat;
	bool			have_auxtrace;
	const char		*input_name;
	struct perf_data_file	output;
	u64			bytes_written;
	struct list_head	samples;
	struct itrace_synth_opts itrace_synth_opts;
};

struct event_entry {
	struct list_head node;
	u32		 tid;
	union perf_event event[0];
};

static int output_bytes(struct perf_inject *inject, void *buf, size_t sz)
{
	ssize_t size;

	size = perf_data_file__write(&inject->output, buf, sz);
	if (size < 0)
		return -errno;

	inject->bytes_written += size;
	return 0;
}

static int perf_event__repipe_synth(struct perf_tool *tool,
				    union perf_event *event)
{
	struct perf_inject *inject = container_of(tool, struct perf_inject,
						  tool);

	return output_bytes(inject, event, event->header.size);
}

static int perf_event__repipe_oe_synth(struct perf_tool *tool,
				       union perf_event *event,
				       struct ordered_events *oe __maybe_unused)
{
	return perf_event__repipe_synth(tool, event);
}

static int perf_event__repipe_op2_synth(struct perf_tool *tool,
					union perf_event *event,
					struct perf_session *session
					__maybe_unused)
{
	return perf_event__repipe_synth(tool, event);
}

static int perf_event__repipe_attr(struct perf_tool *tool,
				   union perf_event *event,
				   struct perf_evlist **pevlist)
{
	struct perf_inject *inject = container_of(tool, struct perf_inject,
						  tool);
	int ret;

	ret = perf_event__process_attr(tool, event, pevlist);
	if (ret)
		return ret;

	if (!inject->output.is_pipe)
		return 0;

	return perf_event__repipe_synth(tool, event);
}

#ifdef HAVE_AUXTRACE_SUPPORT

static int copy_bytes(struct perf_inject *inject, int fd, off_t size)
{
	char buf[4096];
	ssize_t ssz;
	int ret;

	while (size > 0) {
		ssz = read(fd, buf, min(size, (off_t)sizeof(buf)));
		if (ssz < 0)
			return -errno;
		ret = output_bytes(inject, buf, ssz);
		if (ret)
			return ret;
		size -= ssz;
	}

	return 0;
}

static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
				       union perf_event *event,
				       struct perf_session *session
				       __maybe_unused)
{
	struct perf_inject *inject = container_of(tool, struct perf_inject,
						  tool);
	int ret;

	inject->have_auxtrace = true;

	if (!inject->output.is_pipe) {
		off_t offset;

		offset = lseek(inject->output.fd, 0, SEEK_CUR);
		if (offset == -1)
			return -errno;
		ret = auxtrace_index__auxtrace_event(&session->auxtrace_index,
						     event, offset);
		if (ret < 0)
			return ret;
	}

	if (perf_data_file__is_pipe(session->file) || !session->one_mmap) {
		ret = output_bytes(inject, event, event->header.size);
		if (ret < 0)
			return ret;
		ret = copy_bytes(inject, perf_data_file__fd(session->file),
				 event->auxtrace.size);
	} else {
		ret = output_bytes(inject, event,
				   event->header.size + event->auxtrace.size);
	}
	if (ret < 0)
		return ret;

	return event->auxtrace.size;
}

#else

static s64
perf_event__repipe_auxtrace(struct perf_tool *tool __maybe_unused,
			    union perf_event *event __maybe_unused,
			    struct perf_session *session __maybe_unused)
{
	pr_err("AUX area tracing not supported\n");
	return -EINVAL;
}

#endif

static int perf_event__repipe(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample __maybe_unused,
			      struct machine *machine __maybe_unused)
{
	return perf_event__repipe_synth(tool, event);
}

typedef int (*inject_handler)(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample,
			      struct perf_evsel *evsel,
			      struct machine *machine);

static int perf_event__repipe_sample(struct perf_tool *tool,
				     union perf_event *event,
				     struct perf_sample *sample,
				     struct perf_evsel *evsel,
				     struct machine *machine)
{
	if (evsel->handler) {
		inject_handler f = evsel->handler;
		return f(tool, event, sample, evsel, machine);
	}

	build_id__mark_dso_hit(tool, event, sample, evsel, machine);

	return perf_event__repipe_synth(tool, event);
}

static int perf_event__repipe_mmap(struct perf_tool *tool,
				   union perf_event *event,
				   struct perf_sample *sample,
				   struct machine *machine)
{
	int err;

	err = perf_event__process_mmap(tool, event, sample, machine);
	perf_event__repipe(tool, event, sample, machine);

	return err;
}

static int perf_event__repipe_mmap2(struct perf_tool *tool,
				   union perf_event *event,
				   struct perf_sample *sample,
				   struct machine *machine)
{
	int err;

	err = perf_event__process_mmap2(tool, event, sample, machine);
	perf_event__repipe(tool, event, sample, machine);

	return err;
}

static int perf_event__repipe_fork(struct perf_tool *tool,
				   union perf_event *event,
				   struct perf_sample *sample,
				   struct machine *machine)
{
	int err;

	err = perf_event__process_fork(tool, event, sample, machine);
	perf_event__repipe(tool, event, sample, machine);

	return err;
}

static int perf_event__repipe_comm(struct perf_tool *tool,
				   union perf_event *event,
				   struct perf_sample *sample,
				   struct machine *machine)
{
	int err;

	err = perf_event__process_comm(tool, event, sample, machine);
	perf_event__repipe(tool, event, sample, machine);

	return err;
}

static int perf_event__repipe_exit(struct perf_tool *tool,
				   union perf_event *event,
				   struct perf_sample *sample,
				   struct machine *machine)
{
	int err;

	err = perf_event__process_exit(tool, event, sample, machine);
	perf_event__repipe(tool, event, sample, machine);

	return err;
}

static int perf_event__repipe_tracing_data(struct perf_tool *tool,
					   union perf_event *event,
					   struct perf_session *session)
{
	int err;

	perf_event__repipe_synth(tool, event);
	err = perf_event__process_tracing_data(tool, event, session);

	return err;
}

static int perf_event__repipe_id_index(struct perf_tool *tool,
				       union perf_event *event,
				       struct perf_session *session)
{
	int err;

	perf_event__repipe_synth(tool, event);
	err = perf_event__process_id_index(tool, event, session);

	return err;
}

static int dso__read_build_id(struct dso *dso)
{
	if (dso->has_build_id)
		return 0;

	if (filename__read_build_id(dso->long_name, dso->build_id,
				    sizeof(dso->build_id)) > 0) {
		dso->has_build_id = true;
		return 0;
	}

	return -1;
}

static int dso__inject_build_id(struct dso *dso, struct perf_tool *tool,
				struct machine *machine)
{
	u16 misc = PERF_RECORD_MISC_USER;
	int err;

	if (dso__read_build_id(dso) < 0) {
		pr_debug("no build_id found for %s\n", dso->long_name);
		return -1;
	}

	if (dso->kernel)
		misc = PERF_RECORD_MISC_KERNEL;

	err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe,
					      machine);
	if (err) {
		pr_err("Can't synthesize build_id event for %s\n", dso->long_name);
		return -1;
	}

	return 0;
}

static int perf_event__inject_buildid(struct perf_tool *tool,
				      union perf_event *event,
				      struct perf_sample *sample,
				      struct perf_evsel *evsel __maybe_unused,
				      struct machine *machine)
{
	struct addr_location al;
	struct thread *thread;
	u8 cpumode;

	cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;

	thread = machine__findnew_thread(machine, sample->pid, sample->tid);
	if (thread == NULL) {
		pr_err("problem processing %d event, skipping it.\n",
		       event->header.type);
		goto repipe;
	}

	thread__find_addr_map(thread, cpumode, MAP__FUNCTION, sample->ip, &al);

	if (al.map != NULL) {
		if (!al.map->dso->hit) {
			al.map->dso->hit = 1;
			if (map__load(al.map, NULL) >= 0) {
				dso__inject_build_id(al.map->dso, tool, machine);
				/*
				 * If this fails, too bad, let the other side
				 * account this as unresolved.
				 */
			} else {
#ifdef HAVE_LIBELF_SUPPORT
				pr_warning("no symbols found in %s, maybe "
					   "install a debug package?\n",
					   al.map->dso->long_name);
#endif
			}
		}
	}

	thread__put(thread);
repipe:
	perf_event__repipe(tool, event, sample, machine);
	return 0;
}

static int perf_inject__sched_process_exit(struct perf_tool *tool,
					   union perf_event *event __maybe_unused,
					   struct perf_sample *sample,
					   struct perf_evsel *evsel __maybe_unused,
					   struct machine *machine __maybe_unused)
{
	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
	struct event_entry *ent;

	list_for_each_entry(ent, &inject->samples, node) {
		if (sample->tid == ent->tid) {
			list_del_init(&ent->node);
			free(ent);
			break;
		}
	}

	return 0;
}

static int perf_inject__sched_switch(struct perf_tool *tool,
				     union perf_event *event,
				     struct perf_sample *sample,
				     struct perf_evsel *evsel,
				     struct machine *machine)
{
	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
	struct event_entry *ent;

	perf_inject__sched_process_exit(tool, event, sample, evsel, machine);

	ent = malloc(event->header.size + sizeof(struct event_entry));
	if (ent == NULL) {
		color_fprintf(stderr, PERF_COLOR_RED,
			     "Not enough memory to process sched switch event!");
		return -1;
	}

	ent->tid = sample->tid;
	memcpy(&ent->event, event, event->header.size);
	list_add(&ent->node, &inject->samples);
	return 0;
}

static int perf_inject__sched_stat(struct perf_tool *tool,
				   union perf_event *event __maybe_unused,
				   struct perf_sample *sample,
				   struct perf_evsel *evsel,
				   struct machine *machine)
{
	struct event_entry *ent;
	union perf_event *event_sw;
	struct perf_sample sample_sw;
	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
	u32 pid = perf_evsel__intval(evsel, sample, "pid");

	list_for_each_entry(ent, &inject->samples, node) {
		if (pid == ent->tid)
			goto found;
	}

	return 0;
found:
	event_sw = &ent->event[0];
	perf_evsel__parse_sample(evsel, event_sw, &sample_sw);

	sample_sw.period = sample->period;
	sample_sw.time	 = sample->time;
	perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
				      evsel->attr.read_format, &sample_sw,
				      false);
	build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
	return perf_event__repipe(tool, event_sw, &sample_sw, machine);
}

static void sig_handler(int sig __maybe_unused)
{
	session_done = 1;
}

static int perf_evsel__check_stype(struct perf_evsel *evsel,
				   u64 sample_type, const char *sample_msg)
{
	struct perf_event_attr *attr = &evsel->attr;
	const char *name = perf_evsel__name(evsel);

	if (!(attr->sample_type & sample_type)) {
		pr_err("Samples for %s event do not have %s attribute set.",
			name, sample_msg);
		return -EINVAL;
	}

	return 0;
}

static int __cmd_inject(struct perf_inject *inject)
{
	int ret = -EINVAL;
	struct perf_session *session = inject->session;
	struct perf_data_file *file_out = &inject->output;
	int fd = perf_data_file__fd(file_out);
	u64 output_data_offset;

	signal(SIGINT, sig_handler);

	if (inject->build_ids || inject->sched_stat ||
	    inject->itrace_synth_opts.set) {
		inject->tool.mmap	  = perf_event__repipe_mmap;
		inject->tool.mmap2	  = perf_event__repipe_mmap2;
		inject->tool.fork	  = perf_event__repipe_fork;
		inject->tool.tracing_data = perf_event__repipe_tracing_data;
	}

	output_data_offset = session->header.data_offset;

	if (inject->build_ids) {
		inject->tool.sample = perf_event__inject_buildid;
	} else if (inject->sched_stat) {
		struct perf_evsel *evsel;

		evlist__for_each(session->evlist, evsel) {
			const char *name = perf_evsel__name(evsel);

			if (!strcmp(name, "sched:sched_switch")) {
				if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID"))
					return -EINVAL;

				evsel->handler = perf_inject__sched_switch;
			} else if (!strcmp(name, "sched:sched_process_exit"))
				evsel->handler = perf_inject__sched_process_exit;
			else if (!strncmp(name, "sched:sched_stat_", 17))
				evsel->handler = perf_inject__sched_stat;
		}
	} else if (inject->itrace_synth_opts.set) {
		session->itrace_synth_opts = &inject->itrace_synth_opts;
		inject->itrace_synth_opts.inject = true;
		inject->tool.comm	    = perf_event__repipe_comm;
		inject->tool.exit	    = perf_event__repipe_exit;
		inject->tool.id_index	    = perf_event__repipe_id_index;
		inject->tool.auxtrace_info  = perf_event__process_auxtrace_info;
		inject->tool.auxtrace	    = perf_event__process_auxtrace;
		inject->tool.ordered_events = true;
		inject->tool.ordering_requires_timestamps = true;
		/* Allow space in the header for new attributes */
		output_data_offset = 4096;
	}

	if (!inject->itrace_synth_opts.set)
		auxtrace_index__free(&session->auxtrace_index);

	if (!file_out->is_pipe)
		lseek(fd, output_data_offset, SEEK_SET);

	ret = perf_session__process_events(session);

	if (!file_out->is_pipe) {
		if (inject->build_ids) {
			perf_header__set_feat(&session->header,
					      HEADER_BUILD_ID);
			if (inject->have_auxtrace)
				dsos__hit_all(session);
		}
		/*
		 * The AUX areas have been removed and replaced with
		 * synthesized hardware events, so clear the feature flag.
		 */
		if (inject->itrace_synth_opts.set)
			perf_header__clear_feat(&session->header,
						HEADER_AUXTRACE);
		session->header.data_offset = output_data_offset;
		session->header.data_size = inject->bytes_written;
		perf_session__write_header(session, session->evlist, fd, true);
	}

	return ret;
}

int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
{
	struct perf_inject inject = {
		.tool = {
			.sample		= perf_event__repipe_sample,
			.mmap		= perf_event__repipe,
			.mmap2		= perf_event__repipe,
			.comm		= perf_event__repipe,
			.fork		= perf_event__repipe,
			.exit		= perf_event__repipe,
			.lost		= perf_event__repipe,
			.aux		= perf_event__repipe,
			.itrace_start	= perf_event__repipe,
			.read		= perf_event__repipe_sample,
			.throttle	= perf_event__repipe,
			.unthrottle	= perf_event__repipe,
			.attr		= perf_event__repipe_attr,
			.tracing_data	= perf_event__repipe_op2_synth,
			.auxtrace_info	= perf_event__repipe_op2_synth,
			.auxtrace	= perf_event__repipe_auxtrace,
			.auxtrace_error	= perf_event__repipe_op2_synth,
			.finished_round	= perf_event__repipe_oe_synth,
			.build_id	= perf_event__repipe_op2_synth,
			.id_index	= perf_event__repipe_op2_synth,
		},
		.input_name  = "-",
		.samples = LIST_HEAD_INIT(inject.samples),
		.output = {
			.path = "-",
			.mode = PERF_DATA_MODE_WRITE,
		},
	};
	struct perf_data_file file = {
		.mode = PERF_DATA_MODE_READ,
	};
	int ret;

	const struct option options[] = {
		OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
			    "Inject build-ids into the output stream"),
		OPT_STRING('i', "input", &inject.input_name, "file",
			   "input file name"),
		OPT_STRING('o', "output", &inject.output.path, "file",
			   "output file name"),
		OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
			    "Merge sched-stat and sched-switch for getting events "
			    "where and how long tasks slept"),
		OPT_INCR('v', "verbose", &verbose,
			 "be more verbose (show build ids, etc)"),
		OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file",
			   "kallsyms pathname"),
		OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
		OPT_CALLBACK_OPTARG(0, "itrace", &inject.itrace_synth_opts,
				    NULL, "opts", "Instruction Tracing options",
				    itrace_parse_synth_opts),
		OPT_END()
	};
	const char * const inject_usage[] = {
		"perf inject [<options>]",
		NULL
	};

	argc = parse_options(argc, argv, options, inject_usage, 0);

	/*
	 * Any (unrecognized) arguments left?
	 */
	if (argc)
		usage_with_options(inject_usage, options);

	if (perf_data_file__open(&inject.output)) {
		perror("failed to create output file");
		return -1;
	}

	inject.tool.ordered_events = inject.sched_stat;

	file.path = inject.input_name;
	inject.session = perf_session__new(&file, true, &inject.tool);
	if (inject.session == NULL)
		return -1;

	ret = symbol__init(&inject.session->header.env);
	if (ret < 0)
		goto out_delete;

	ret = __cmd_inject(&inject);

out_delete:
	perf_session__delete(inject.session);
	return ret;
}
Commit	Line	Data
454c407e TZ	1	/*
	2	* builtin-inject.c
	3	*
	4	* Builtin inject command: Examine the live mode (stdin) event stream
	5	* and repipe it to stdout while optionally injecting additional
	6	* events into it.
	7	*/
	8	#include "builtin.h"
	9
	10	#include "perf.h"
26a031e1 AV	11	#include "util/color.h"
	12	#include "util/evlist.h"
	13	#include "util/evsel.h"
454c407e	14	#include "util/session.h"
45694aa7	15	#include "util/tool.h"
454c407e	16	#include "util/debug.h"
54a3cf59	17	#include "util/build-id.h"
f5fc1412	18	#include "util/data.h"
0f0aa5e0	19	#include "util/auxtrace.h"
454c407e TZ	20
	21	#include "util/parse-options.h"
	22
26a031e1 AV	23	#include <linux/list.h>
26a031e1 AV	24
5ded57ac	25	struct perf_inject {
3406912c	26	struct perf_tool tool;
1cb8bdcc	27	struct perf_session *session;
3406912c JO	28	bool build_ids;
3406912c JO	29	bool sched_stat;
cd10b289	30	bool have_auxtrace;
3406912c JO	31	const char *input_name;
	32	struct perf_data_file output;
	33	u64 bytes_written;
	34	struct list_head samples;
0f0aa5e0	35	struct itrace_synth_opts itrace_synth_opts;
26a031e1 AV	36	};
	37
	38	struct event_entry {
	39	struct list_head node;
	40	u32 tid;
	41	union perf_event event[0];
5ded57ac	42	};
454c407e	43
cd17a9b5	44	static int output_bytes(struct perf_inject inject, void buf, size_t sz)
454c407e	45	{
3406912c	46	ssize_t size;
454c407e	47
cd17a9b5	48	size = perf_data_file__write(&inject->output, buf, sz);
3406912c JO	49	if (size < 0)
3406912c JO	50	return -errno;
454c407e	51
3406912c	52	inject->bytes_written += size;
454c407e TZ	53	return 0;
	54	}
	55
cd17a9b5 AH	56	static int perf_event__repipe_synth(struct perf_tool *tool,
	57	union perf_event *event)
	58	{
	59	struct perf_inject *inject = container_of(tool, struct perf_inject,
	60	tool);
	61
	62	return output_bytes(inject, event, event->header.size);
	63	}
	64
d704ebda ACM	65	static int perf_event__repipe_oe_synth(struct perf_tool *tool,
	66	union perf_event *event,
	67	struct ordered_events *oe __maybe_unused)
	68	{
	69	return perf_event__repipe_synth(tool, event);
	70	}
	71
45694aa7	72	static int perf_event__repipe_op2_synth(struct perf_tool *tool,
743eb868	73	union perf_event *event,
1d037ca1 IT	74	struct perf_session *session
1d037ca1 IT	75	__maybe_unused)
743eb868	76	{
63c2c9f8	77	return perf_event__repipe_synth(tool, event);
743eb868 ACM	78	}
743eb868 ACM	79
47c3d109 AH	80	static int perf_event__repipe_attr(struct perf_tool *tool,
	81	union perf_event *event,
	82	struct perf_evlist **pevlist)
10d0f086	83	{
89c97d93 AH	84	struct perf_inject *inject = container_of(tool, struct perf_inject,
89c97d93 AH	85	tool);
1a1ed1ba	86	int ret;
47c3d109 AH	87
47c3d109 AH	88	ret = perf_event__process_attr(tool, event, pevlist);
1a1ed1ba SE	89	if (ret)
	90	return ret;
	91
a261e4a0	92	if (!inject->output.is_pipe)
89c97d93 AH	93	return 0;
89c97d93 AH	94
47c3d109	95	return perf_event__repipe_synth(tool, event);
10d0f086 ACM	96	}
10d0f086 ACM	97
e31f0d01 AH	98	#ifdef HAVE_AUXTRACE_SUPPORT
	99
	100	static int copy_bytes(struct perf_inject *inject, int fd, off_t size)
	101	{
	102	char buf[4096];
	103	ssize_t ssz;
	104	int ret;
	105
	106	while (size > 0) {
	107	ssz = read(fd, buf, min(size, (off_t)sizeof(buf)));
	108	if (ssz < 0)
	109	return -errno;
	110	ret = output_bytes(inject, buf, ssz);
	111	if (ret)
	112	return ret;
	113	size -= ssz;
	114	}
	115
	116	return 0;
	117	}
	118
cd17a9b5 AH	119	static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
	120	union perf_event *event,
	121	struct perf_session *session
	122	__maybe_unused)
	123	{
	124	struct perf_inject *inject = container_of(tool, struct perf_inject,
	125	tool);
	126	int ret;
	127
cd10b289 AH	128	inject->have_auxtrace = true;
cd10b289 AH	129
99fa2984 AH	130	if (!inject->output.is_pipe) {
	131	off_t offset;
	132
	133	offset = lseek(inject->output.fd, 0, SEEK_CUR);
	134	if (offset == -1)
	135	return -errno;
	136	ret = auxtrace_index__auxtrace_event(&session->auxtrace_index,
	137	event, offset);
	138	if (ret < 0)
	139	return ret;
	140	}
	141
cd17a9b5 AH	142	if (perf_data_file__is_pipe(session->file) \|\| !session->one_mmap) {
	143	ret = output_bytes(inject, event, event->header.size);
	144	if (ret < 0)
	145	return ret;
	146	ret = copy_bytes(inject, perf_data_file__fd(session->file),
	147	event->auxtrace.size);
	148	} else {
	149	ret = output_bytes(inject, event,
	150	event->header.size + event->auxtrace.size);
	151	}
	152	if (ret < 0)
	153	return ret;
	154
	155	return event->auxtrace.size;
	156	}
	157
e31f0d01 AH	158	#else
	159
	160	static s64
	161	perf_event__repipe_auxtrace(struct perf_tool *tool __maybe_unused,
	162	union perf_event *event __maybe_unused,
	163	struct perf_session *session __maybe_unused)
	164	{
	165	pr_err("AUX area tracing not supported\n");
	166	return -EINVAL;
	167	}
	168
	169	#endif
	170
45694aa7	171	static int perf_event__repipe(struct perf_tool *tool,
d20deb64	172	union perf_event *event,
1d037ca1	173	struct perf_sample *sample __maybe_unused,
63c2c9f8	174	struct machine *machine __maybe_unused)
640c03ce	175	{
63c2c9f8	176	return perf_event__repipe_synth(tool, event);
640c03ce ACM	177	}
640c03ce ACM	178
26a031e1 AV	179	typedef int (inject_handler)(struct perf_tool tool,
	180	union perf_event *event,
	181	struct perf_sample *sample,
	182	struct perf_evsel *evsel,
	183	struct machine *machine);
	184
45694aa7	185	static int perf_event__repipe_sample(struct perf_tool *tool,
d20deb64	186	union perf_event *event,
26a031e1 AV	187	struct perf_sample *sample,
	188	struct perf_evsel *evsel,
	189	struct machine *machine)
9e69c210	190	{
744a9719 ACM	191	if (evsel->handler) {
744a9719 ACM	192	inject_handler f = evsel->handler;
26a031e1 AV	193	return f(tool, event, sample, evsel, machine);
	194	}
	195
54a3cf59 AV	196	build_id__mark_dso_hit(tool, event, sample, evsel, machine);
54a3cf59 AV	197
63c2c9f8	198	return perf_event__repipe_synth(tool, event);
9e69c210 ACM	199	}
9e69c210 ACM	200
45694aa7	201	static int perf_event__repipe_mmap(struct perf_tool *tool,
d20deb64	202	union perf_event *event,
8115d60c	203	struct perf_sample *sample,
743eb868	204	struct machine *machine)
454c407e TZ	205	{
	206	int err;
	207
45694aa7 ACM	208	err = perf_event__process_mmap(tool, event, sample, machine);
45694aa7 ACM	209	perf_event__repipe(tool, event, sample, machine);
454c407e TZ	210
	211	return err;
	212	}
	213
5c5e854b SE	214	static int perf_event__repipe_mmap2(struct perf_tool *tool,
	215	union perf_event *event,
	216	struct perf_sample *sample,
	217	struct machine *machine)
	218	{
	219	int err;
	220
	221	err = perf_event__process_mmap2(tool, event, sample, machine);
	222	perf_event__repipe(tool, event, sample, machine);
	223
	224	return err;
	225	}
	226
f62d3f0f	227	static int perf_event__repipe_fork(struct perf_tool *tool,
d20deb64	228	union perf_event *event,
8115d60c	229	struct perf_sample *sample,
743eb868	230	struct machine *machine)
454c407e TZ	231	{
	232	int err;
	233
f62d3f0f	234	err = perf_event__process_fork(tool, event, sample, machine);
45694aa7	235	perf_event__repipe(tool, event, sample, machine);
454c407e TZ	236
	237	return err;
	238	}
	239
0f0aa5e0 AH	240	static int perf_event__repipe_comm(struct perf_tool *tool,
	241	union perf_event *event,
	242	struct perf_sample *sample,
	243	struct machine *machine)
	244	{
	245	int err;
	246
	247	err = perf_event__process_comm(tool, event, sample, machine);
	248	perf_event__repipe(tool, event, sample, machine);
	249
	250	return err;
	251	}
	252
	253	static int perf_event__repipe_exit(struct perf_tool *tool,
	254	union perf_event *event,
	255	struct perf_sample *sample,
	256	struct machine *machine)
	257	{
	258	int err;
	259
	260	err = perf_event__process_exit(tool, event, sample, machine);
	261	perf_event__repipe(tool, event, sample, machine);
	262
	263	return err;
	264	}
	265
47c3d109 AH	266	static int perf_event__repipe_tracing_data(struct perf_tool *tool,
47c3d109 AH	267	union perf_event *event,
8115d60c	268	struct perf_session *session)
454c407e TZ	269	{
	270	int err;
	271
47c3d109 AH	272	perf_event__repipe_synth(tool, event);
47c3d109 AH	273	err = perf_event__process_tracing_data(tool, event, session);
454c407e TZ	274
	275	return err;
	276	}
	277
0f0aa5e0 AH	278	static int perf_event__repipe_id_index(struct perf_tool *tool,
	279	union perf_event *event,
	280	struct perf_session *session)
	281	{
	282	int err;
	283
	284	perf_event__repipe_synth(tool, event);
	285	err = perf_event__process_id_index(tool, event, session);
	286
	287	return err;
	288	}
	289
c824c433	290	static int dso__read_build_id(struct dso *dso)
454c407e	291	{
c824c433	292	if (dso->has_build_id)
090f7204	293	return 0;
454c407e	294
c824c433 ACM	295	if (filename__read_build_id(dso->long_name, dso->build_id,
	296	sizeof(dso->build_id)) > 0) {
	297	dso->has_build_id = true;
090f7204 ACM	298	return 0;
090f7204 ACM	299	}
454c407e	300
090f7204 ACM	301	return -1;
090f7204 ACM	302	}
454c407e	303
c824c433	304	static int dso__inject_build_id(struct dso dso, struct perf_tool tool,
743eb868	305	struct machine *machine)
090f7204 ACM	306	{
090f7204 ACM	307	u16 misc = PERF_RECORD_MISC_USER;
090f7204	308	int err;
454c407e	309
c824c433 ACM	310	if (dso__read_build_id(dso) < 0) {
c824c433 ACM	311	pr_debug("no build_id found for %s\n", dso->long_name);
090f7204 ACM	312	return -1;
090f7204 ACM	313	}
454c407e	314
c824c433	315	if (dso->kernel)
090f7204	316	misc = PERF_RECORD_MISC_KERNEL;
454c407e	317
c824c433	318	err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe,
743eb868	319	machine);
090f7204	320	if (err) {
c824c433	321	pr_err("Can't synthesize build_id event for %s\n", dso->long_name);
454c407e TZ	322	return -1;
	323	}
	324
	325	return 0;
	326	}
	327
45694aa7	328	static int perf_event__inject_buildid(struct perf_tool *tool,
d20deb64	329	union perf_event *event,
8115d60c	330	struct perf_sample *sample,
1d037ca1	331	struct perf_evsel *evsel __maybe_unused,
743eb868	332	struct machine *machine)
454c407e TZ	333	{
	334	struct addr_location al;
	335	struct thread *thread;
	336	u8 cpumode;
454c407e TZ	337
	338	cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
	339
13ce34df	340	thread = machine__findnew_thread(machine, sample->pid, sample->tid);
454c407e TZ	341	if (thread == NULL) {
	342	pr_err("problem processing %d event, skipping it.\n",
	343	event->header.type);
454c407e TZ	344	goto repipe;
	345	}
	346
bb871a9c	347	thread__find_addr_map(thread, cpumode, MAP__FUNCTION, sample->ip, &al);
454c407e TZ	348
	349	if (al.map != NULL) {
	350	if (!al.map->dso->hit) {
	351	al.map->dso->hit = 1;
090f7204	352	if (map__load(al.map, NULL) >= 0) {
45694aa7	353	dso__inject_build_id(al.map->dso, tool, machine);
090f7204 ACM	354	/*
	355	* If this fails, too bad, let the other side
	356	* account this as unresolved.
	357	*/
393be2e3	358	} else {
89fe808a	359	#ifdef HAVE_LIBELF_SUPPORT
454c407e TZ	360	pr_warning("no symbols found in %s, maybe "
	361	"install a debug package?\n",
	362	al.map->dso->long_name);
393be2e3 NK	363	#endif
393be2e3 NK	364	}
454c407e TZ	365	}
	366	}
	367
b91fc39f	368	thread__put(thread);
454c407e	369	repipe:
45694aa7	370	perf_event__repipe(tool, event, sample, machine);
090f7204	371	return 0;
454c407e TZ	372	}
454c407e TZ	373
26a031e1 AV	374	static int perf_inject__sched_process_exit(struct perf_tool *tool,
	375	union perf_event *event __maybe_unused,
	376	struct perf_sample *sample,
	377	struct perf_evsel *evsel __maybe_unused,
	378	struct machine *machine __maybe_unused)
	379	{
	380	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
	381	struct event_entry *ent;
	382
	383	list_for_each_entry(ent, &inject->samples, node) {
	384	if (sample->tid == ent->tid) {
	385	list_del_init(&ent->node);
	386	free(ent);
	387	break;
	388	}
	389	}
	390
	391	return 0;
	392	}
	393
	394	static int perf_inject__sched_switch(struct perf_tool *tool,
	395	union perf_event *event,
	396	struct perf_sample *sample,
	397	struct perf_evsel *evsel,
	398	struct machine *machine)
	399	{
	400	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
	401	struct event_entry *ent;
	402
	403	perf_inject__sched_process_exit(tool, event, sample, evsel, machine);
	404
	405	ent = malloc(event->header.size + sizeof(struct event_entry));
	406	if (ent == NULL) {
	407	color_fprintf(stderr, PERF_COLOR_RED,
	408	"Not enough memory to process sched switch event!");
	409	return -1;
	410	}
	411
	412	ent->tid = sample->tid;
	413	memcpy(&ent->event, event, event->header.size);
	414	list_add(&ent->node, &inject->samples);
	415	return 0;
	416	}
	417
	418	static int perf_inject__sched_stat(struct perf_tool *tool,
	419	union perf_event *event __maybe_unused,
	420	struct perf_sample *sample,
	421	struct perf_evsel *evsel,
	422	struct machine *machine)
	423	{
	424	struct event_entry *ent;
	425	union perf_event *event_sw;
	426	struct perf_sample sample_sw;
	427	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
	428	u32 pid = perf_evsel__intval(evsel, sample, "pid");
	429
	430	list_for_each_entry(ent, &inject->samples, node) {
	431	if (pid == ent->tid)
	432	goto found;
	433	}
	434
	435	return 0;
	436	found:
	437	event_sw = &ent->event[0];
438	perf_evsel__parse_sample(evsel, event_sw, &sample_sw);
439
440	sample_sw.period = sample->period;
441	sample_sw.time = sample->time;
442	perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
d03f2170 AH	443	evsel->attr.read_format, &sample_sw,
d03f2170 AH	444	false);
54a3cf59	445	build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
26a031e1 AV	446	return perf_event__repipe(tool, event_sw, &sample_sw, machine);
	447	}
	448
1d037ca1	449	static void sig_handler(int sig __maybe_unused)
454c407e TZ	450	{
	451	session_done = 1;
	452	}
	453
26a031e1 AV	454	static int perf_evsel__check_stype(struct perf_evsel *evsel,
	455	u64 sample_type, const char *sample_msg)
	456	{
	457	struct perf_event_attr *attr = &evsel->attr;
	458	const char *name = perf_evsel__name(evsel);
	459
	460	if (!(attr->sample_type & sample_type)) {
	461	pr_err("Samples for %s event do not have %s attribute set.",
	462	name, sample_msg);
	463	return -EINVAL;
	464	}
	465
	466	return 0;
	467	}
	468
5ded57ac	469	static int __cmd_inject(struct perf_inject *inject)
454c407e	470	{
454c407e	471	int ret = -EINVAL;
1cb8bdcc	472	struct perf_session *session = inject->session;
3406912c	473	struct perf_data_file *file_out = &inject->output;
42aa276f	474	int fd = perf_data_file__fd(file_out);
0f0aa5e0	475	u64 output_data_offset;
454c407e TZ	476
	477	signal(SIGINT, sig_handler);
	478
0f0aa5e0 AH	479	if (inject->build_ids \|\| inject->sched_stat \|\|
0f0aa5e0 AH	480	inject->itrace_synth_opts.set) {
5ded57ac	481	inject->tool.mmap = perf_event__repipe_mmap;
5c5e854b	482	inject->tool.mmap2 = perf_event__repipe_mmap2;
f62d3f0f	483	inject->tool.fork = perf_event__repipe_fork;
5ded57ac	484	inject->tool.tracing_data = perf_event__repipe_tracing_data;
454c407e TZ	485	}
454c407e TZ	486
0f0aa5e0 AH	487	output_data_offset = session->header.data_offset;
0f0aa5e0 AH	488
54a3cf59 AV	489	if (inject->build_ids) {
	490	inject->tool.sample = perf_event__inject_buildid;
	491	} else if (inject->sched_stat) {
26a031e1 AV	492	struct perf_evsel *evsel;
26a031e1 AV	493
0050f7aa	494	evlist__for_each(session->evlist, evsel) {
26a031e1 AV	495	const char *name = perf_evsel__name(evsel);
	496
	497	if (!strcmp(name, "sched:sched_switch")) {
	498	if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID"))
	499	return -EINVAL;
	500
744a9719	501	evsel->handler = perf_inject__sched_switch;
26a031e1	502	} else if (!strcmp(name, "sched:sched_process_exit"))
744a9719	503	evsel->handler = perf_inject__sched_process_exit;
26a031e1	504	else if (!strncmp(name, "sched:sched_stat_", 17))
744a9719	505	evsel->handler = perf_inject__sched_stat;
26a031e1	506	}
0f0aa5e0 AH	507	} else if (inject->itrace_synth_opts.set) {
	508	session->itrace_synth_opts = &inject->itrace_synth_opts;
	509	inject->itrace_synth_opts.inject = true;
	510	inject->tool.comm = perf_event__repipe_comm;
	511	inject->tool.exit = perf_event__repipe_exit;
	512	inject->tool.id_index = perf_event__repipe_id_index;
	513	inject->tool.auxtrace_info = perf_event__process_auxtrace_info;
	514	inject->tool.auxtrace = perf_event__process_auxtrace;
	515	inject->tool.ordered_events = true;
	516	inject->tool.ordering_requires_timestamps = true;
	517	/* Allow space in the header for new attributes */
	518	output_data_offset = 4096;
26a031e1 AV	519	}
26a031e1 AV	520
99fa2984 AH	521	if (!inject->itrace_synth_opts.set)
	522	auxtrace_index__free(&session->auxtrace_index);
	523
3406912c	524	if (!file_out->is_pipe)
0f0aa5e0	525	lseek(fd, output_data_offset, SEEK_SET);
e558a5bd	526
b7b61cbe	527	ret = perf_session__process_events(session);
454c407e	528
3406912c	529	if (!file_out->is_pipe) {
cd10b289	530	if (inject->build_ids) {
e38b43c3 AH	531	perf_header__set_feat(&session->header,
e38b43c3 AH	532	HEADER_BUILD_ID);
cd10b289 AH	533	if (inject->have_auxtrace)
	534	dsos__hit_all(session);
	535	}
0f0aa5e0 AH	536	/*
	537	* The AUX areas have been removed and replaced with
	538	* synthesized hardware events, so clear the feature flag.
	539	*/
	540	if (inject->itrace_synth_opts.set)
	541	perf_header__clear_feat(&session->header,
	542	HEADER_AUXTRACE);
	543	session->header.data_offset = output_data_offset;
e558a5bd	544	session->header.data_size = inject->bytes_written;
42aa276f	545	perf_session__write_header(session, session->evlist, fd, true);
e558a5bd AV	546	}
e558a5bd AV	547
454c407e TZ	548	return ret;
	549	}
	550
1d037ca1	551	int cmd_inject(int argc, const char *argv, const char prefix __maybe_unused)
454c407e	552	{
5ded57ac ACM	553	struct perf_inject inject = {
	554	.tool = {
	555	.sample = perf_event__repipe_sample,
	556	.mmap = perf_event__repipe,
5c5e854b	557	.mmap2 = perf_event__repipe,
5ded57ac ACM	558	.comm = perf_event__repipe,
	559	.fork = perf_event__repipe,
	560	.exit = perf_event__repipe,
	561	.lost = perf_event__repipe,
4a96f7a0	562	.aux = perf_event__repipe,
0ad21f68	563	.itrace_start = perf_event__repipe,
5ded57ac ACM	564	.read = perf_event__repipe_sample,
	565	.throttle = perf_event__repipe,
	566	.unthrottle = perf_event__repipe,
	567	.attr = perf_event__repipe_attr,
47c3d109	568	.tracing_data = perf_event__repipe_op2_synth,
cd17a9b5 AH	569	.auxtrace_info = perf_event__repipe_op2_synth,
	570	.auxtrace = perf_event__repipe_auxtrace,
	571	.auxtrace_error = perf_event__repipe_op2_synth,
d704ebda	572	.finished_round = perf_event__repipe_oe_synth,
5ded57ac	573	.build_id = perf_event__repipe_op2_synth,
3c659eed	574	.id_index = perf_event__repipe_op2_synth,
5ded57ac	575	},
e558a5bd	576	.input_name = "-",
26a031e1	577	.samples = LIST_HEAD_INIT(inject.samples),
3406912c JO	578	.output = {
	579	.path = "-",
	580	.mode = PERF_DATA_MODE_WRITE,
	581	},
5ded57ac	582	};
1cb8bdcc NK	583	struct perf_data_file file = {
	584	.mode = PERF_DATA_MODE_READ,
	585	};
	586	int ret;
	587
5ded57ac ACM	588	const struct option options[] = {
	589	OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
	590	"Inject build-ids into the output stream"),
e558a5bd AV	591	OPT_STRING('i', "input", &inject.input_name, "file",
e558a5bd AV	592	"input file name"),
3406912c	593	OPT_STRING('o', "output", &inject.output.path, "file",
e558a5bd	594	"output file name"),
26a031e1 AV	595	OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
	596	"Merge sched-stat and sched-switch for getting events "
	597	"where and how long tasks slept"),
5ded57ac ACM	598	OPT_INCR('v', "verbose", &verbose,
5ded57ac ACM	599	"be more verbose (show build ids, etc)"),
a7a2b8b4 AH	600	OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file",
a7a2b8b4 AH	601	"kallsyms pathname"),
ccaa474c	602	OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
0f0aa5e0 AH	603	OPT_CALLBACK_OPTARG(0, "itrace", &inject.itrace_synth_opts,
	604	NULL, "opts", "Instruction Tracing options",
	605	itrace_parse_synth_opts),
5ded57ac ACM	606	OPT_END()
5ded57ac ACM	607	};
002439e8 ACM	608	const char * const inject_usage[] = {
	609	"perf inject [<options>]",
	610	NULL
	611	};
5ded57ac	612
002439e8	613	argc = parse_options(argc, argv, options, inject_usage, 0);
454c407e TZ	614
	615	/*
	616	* Any (unrecognized) arguments left?
	617	*/
	618	if (argc)
002439e8	619	usage_with_options(inject_usage, options);
454c407e	620
3406912c JO	621	if (perf_data_file__open(&inject.output)) {
	622	perror("failed to create output file");
	623	return -1;
e558a5bd AV	624	}
e558a5bd AV	625
b7b61cbe ACM	626	inject.tool.ordered_events = inject.sched_stat;
b7b61cbe ACM	627
1cb8bdcc NK	628	file.path = inject.input_name;
	629	inject.session = perf_session__new(&file, true, &inject.tool);
	630	if (inject.session == NULL)
52e02834	631	return -1;
1cb8bdcc	632
9fedfb0c TS	633	ret = symbol__init(&inject.session->header.env);
	634	if (ret < 0)
	635	goto out_delete;
454c407e	636
1cb8bdcc NK	637	ret = __cmd_inject(&inject);
1cb8bdcc NK	638
9fedfb0c	639	out_delete:
1cb8bdcc	640	perf_session__delete(inject.session);
1cb8bdcc	641	return ret;
454c407e	642	}