Linux Audio

Check our new training course

Loading...
v3.15
  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"
 11#include "util/color.h"
 12#include "util/evlist.h"
 13#include "util/evsel.h"
 14#include "util/session.h"
 15#include "util/tool.h"
 16#include "util/debug.h"
 17#include "util/build-id.h"
 18#include "util/data.h"
 
 
 19
 20#include "util/parse-options.h"
 21
 22#include <linux/list.h>
 23
 24struct perf_inject {
 25	struct perf_tool	tool;
 
 26	bool			build_ids;
 27	bool			sched_stat;
 
 
 
 28	const char		*input_name;
 29	struct perf_data_file	output;
 30	u64			bytes_written;
 
 31	struct list_head	samples;
 
 32};
 33
 34struct event_entry {
 35	struct list_head node;
 36	u32		 tid;
 37	union perf_event event[0];
 38};
 39
 40static int perf_event__repipe_synth(struct perf_tool *tool,
 41				    union perf_event *event)
 42{
 43	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
 44	ssize_t size;
 45
 46	size = perf_data_file__write(&inject->output, event,
 47				     event->header.size);
 48	if (size < 0)
 49		return -errno;
 50
 51	inject->bytes_written += size;
 52	return 0;
 53}
 54
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 55static int perf_event__repipe_op2_synth(struct perf_tool *tool,
 56					union perf_event *event,
 57					struct perf_session *session
 58					__maybe_unused)
 59{
 60	return perf_event__repipe_synth(tool, event);
 61}
 62
 63static int perf_event__repipe_attr(struct perf_tool *tool,
 64				   union perf_event *event,
 65				   struct perf_evlist **pevlist)
 66{
 67	struct perf_inject *inject = container_of(tool, struct perf_inject,
 68						  tool);
 69	int ret;
 70
 71	ret = perf_event__process_attr(tool, event, pevlist);
 72	if (ret)
 73		return ret;
 74
 75	if (&inject->output.is_pipe)
 76		return 0;
 77
 78	return perf_event__repipe_synth(tool, event);
 79}
 80
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 81static int perf_event__repipe(struct perf_tool *tool,
 82			      union perf_event *event,
 83			      struct perf_sample *sample __maybe_unused,
 84			      struct machine *machine __maybe_unused)
 85{
 86	return perf_event__repipe_synth(tool, event);
 87}
 88
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 89typedef int (*inject_handler)(struct perf_tool *tool,
 90			      union perf_event *event,
 91			      struct perf_sample *sample,
 92			      struct perf_evsel *evsel,
 93			      struct machine *machine);
 94
 95static int perf_event__repipe_sample(struct perf_tool *tool,
 96				     union perf_event *event,
 97				     struct perf_sample *sample,
 98				     struct perf_evsel *evsel,
 99				     struct machine *machine)
100{
101	if (evsel->handler) {
102		inject_handler f = evsel->handler;
103		return f(tool, event, sample, evsel, machine);
104	}
105
106	build_id__mark_dso_hit(tool, event, sample, evsel, machine);
107
108	return perf_event__repipe_synth(tool, event);
109}
110
111static int perf_event__repipe_mmap(struct perf_tool *tool,
112				   union perf_event *event,
113				   struct perf_sample *sample,
114				   struct machine *machine)
115{
116	int err;
117
118	err = perf_event__process_mmap(tool, event, sample, machine);
119	perf_event__repipe(tool, event, sample, machine);
120
121	return err;
122}
123
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
124static int perf_event__repipe_mmap2(struct perf_tool *tool,
125				   union perf_event *event,
126				   struct perf_sample *sample,
127				   struct machine *machine)
128{
129	int err;
130
131	err = perf_event__process_mmap2(tool, event, sample, machine);
132	perf_event__repipe(tool, event, sample, machine);
133
134	return err;
135}
136
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
137static int perf_event__repipe_fork(struct perf_tool *tool,
138				   union perf_event *event,
139				   struct perf_sample *sample,
140				   struct machine *machine)
141{
142	int err;
143
144	err = perf_event__process_fork(tool, event, sample, machine);
145	perf_event__repipe(tool, event, sample, machine);
146
147	return err;
148}
149
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
150static int perf_event__repipe_tracing_data(struct perf_tool *tool,
151					   union perf_event *event,
152					   struct perf_session *session)
153{
154	int err;
155
156	perf_event__repipe_synth(tool, event);
157	err = perf_event__process_tracing_data(tool, event, session);
158
159	return err;
160}
161
 
 
 
 
 
 
 
 
 
 
 
 
162static int dso__read_build_id(struct dso *dso)
163{
164	if (dso->has_build_id)
165		return 0;
166
167	if (filename__read_build_id(dso->long_name, dso->build_id,
168				    sizeof(dso->build_id)) > 0) {
169		dso->has_build_id = true;
170		return 0;
171	}
172
173	return -1;
174}
175
176static int dso__inject_build_id(struct dso *dso, struct perf_tool *tool,
177				struct machine *machine)
178{
179	u16 misc = PERF_RECORD_MISC_USER;
180	int err;
181
182	if (dso__read_build_id(dso) < 0) {
183		pr_debug("no build_id found for %s\n", dso->long_name);
184		return -1;
185	}
186
187	if (dso->kernel)
188		misc = PERF_RECORD_MISC_KERNEL;
189
190	err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe,
191					      machine);
192	if (err) {
193		pr_err("Can't synthesize build_id event for %s\n", dso->long_name);
194		return -1;
195	}
196
197	return 0;
198}
199
200static int perf_event__inject_buildid(struct perf_tool *tool,
201				      union perf_event *event,
202				      struct perf_sample *sample,
203				      struct perf_evsel *evsel __maybe_unused,
204				      struct machine *machine)
205{
206	struct addr_location al;
207	struct thread *thread;
208	u8 cpumode;
209
210	cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
211
212	thread = machine__findnew_thread(machine, sample->pid, sample->pid);
213	if (thread == NULL) {
214		pr_err("problem processing %d event, skipping it.\n",
215		       event->header.type);
216		goto repipe;
217	}
218
219	thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
220			      sample->ip, &al);
221
222	if (al.map != NULL) {
223		if (!al.map->dso->hit) {
224			al.map->dso->hit = 1;
225			if (map__load(al.map, NULL) >= 0) {
226				dso__inject_build_id(al.map->dso, tool, machine);
227				/*
228				 * If this fails, too bad, let the other side
229				 * account this as unresolved.
230				 */
231			} else {
232#ifdef HAVE_LIBELF_SUPPORT
233				pr_warning("no symbols found in %s, maybe "
234					   "install a debug package?\n",
235					   al.map->dso->long_name);
236#endif
237			}
238		}
239	}
240
 
241repipe:
242	perf_event__repipe(tool, event, sample, machine);
243	return 0;
244}
245
246static int perf_inject__sched_process_exit(struct perf_tool *tool,
247					   union perf_event *event __maybe_unused,
248					   struct perf_sample *sample,
249					   struct perf_evsel *evsel __maybe_unused,
250					   struct machine *machine __maybe_unused)
251{
252	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
253	struct event_entry *ent;
254
255	list_for_each_entry(ent, &inject->samples, node) {
256		if (sample->tid == ent->tid) {
257			list_del_init(&ent->node);
258			free(ent);
259			break;
260		}
261	}
262
263	return 0;
264}
265
266static int perf_inject__sched_switch(struct perf_tool *tool,
267				     union perf_event *event,
268				     struct perf_sample *sample,
269				     struct perf_evsel *evsel,
270				     struct machine *machine)
271{
272	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
273	struct event_entry *ent;
274
275	perf_inject__sched_process_exit(tool, event, sample, evsel, machine);
276
277	ent = malloc(event->header.size + sizeof(struct event_entry));
278	if (ent == NULL) {
279		color_fprintf(stderr, PERF_COLOR_RED,
280			     "Not enough memory to process sched switch event!");
281		return -1;
282	}
283
284	ent->tid = sample->tid;
285	memcpy(&ent->event, event, event->header.size);
286	list_add(&ent->node, &inject->samples);
287	return 0;
288}
289
290static int perf_inject__sched_stat(struct perf_tool *tool,
291				   union perf_event *event __maybe_unused,
292				   struct perf_sample *sample,
293				   struct perf_evsel *evsel,
294				   struct machine *machine)
295{
296	struct event_entry *ent;
297	union perf_event *event_sw;
298	struct perf_sample sample_sw;
299	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
300	u32 pid = perf_evsel__intval(evsel, sample, "pid");
301
302	list_for_each_entry(ent, &inject->samples, node) {
303		if (pid == ent->tid)
304			goto found;
305	}
306
307	return 0;
308found:
309	event_sw = &ent->event[0];
310	perf_evsel__parse_sample(evsel, event_sw, &sample_sw);
311
312	sample_sw.period = sample->period;
313	sample_sw.time	 = sample->time;
314	perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
315				      evsel->attr.read_format, &sample_sw,
316				      false);
317	build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
318	return perf_event__repipe(tool, event_sw, &sample_sw, machine);
319}
320
321static void sig_handler(int sig __maybe_unused)
322{
323	session_done = 1;
324}
325
326static int perf_evsel__check_stype(struct perf_evsel *evsel,
327				   u64 sample_type, const char *sample_msg)
328{
329	struct perf_event_attr *attr = &evsel->attr;
330	const char *name = perf_evsel__name(evsel);
331
332	if (!(attr->sample_type & sample_type)) {
333		pr_err("Samples for %s event do not have %s attribute set.",
334			name, sample_msg);
335		return -EINVAL;
336	}
337
338	return 0;
339}
340
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
341static int __cmd_inject(struct perf_inject *inject)
342{
343	struct perf_session *session;
344	int ret = -EINVAL;
345	struct perf_data_file file = {
346		.path = inject->input_name,
347		.mode = PERF_DATA_MODE_READ,
348	};
349	struct perf_data_file *file_out = &inject->output;
 
 
350
351	signal(SIGINT, sig_handler);
352
353	if (inject->build_ids || inject->sched_stat) {
 
354		inject->tool.mmap	  = perf_event__repipe_mmap;
355		inject->tool.mmap2	  = perf_event__repipe_mmap2;
356		inject->tool.fork	  = perf_event__repipe_fork;
357		inject->tool.tracing_data = perf_event__repipe_tracing_data;
358	}
359
360	session = perf_session__new(&file, true, &inject->tool);
361	if (session == NULL)
362		return -ENOMEM;
363
364	if (inject->build_ids) {
365		inject->tool.sample = perf_event__inject_buildid;
366	} else if (inject->sched_stat) {
367		struct perf_evsel *evsel;
368
369		inject->tool.ordered_samples = true;
370
371		evlist__for_each(session->evlist, evsel) {
372			const char *name = perf_evsel__name(evsel);
373
374			if (!strcmp(name, "sched:sched_switch")) {
375				if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID"))
376					return -EINVAL;
377
378				evsel->handler = perf_inject__sched_switch;
379			} else if (!strcmp(name, "sched:sched_process_exit"))
380				evsel->handler = perf_inject__sched_process_exit;
381			else if (!strncmp(name, "sched:sched_stat_", 17))
382				evsel->handler = perf_inject__sched_stat;
383		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
384	}
385
 
 
 
386	if (!file_out->is_pipe)
387		lseek(file_out->fd, session->header.data_offset, SEEK_SET);
388
389	ret = perf_session__process_events(session, &inject->tool);
390
391	if (!file_out->is_pipe) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
392		session->header.data_size = inject->bytes_written;
393		perf_session__write_header(session, session->evlist, file_out->fd, true);
394	}
395
396	perf_session__delete(session);
397
398	return ret;
399}
400
401int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
402{
403	struct perf_inject inject = {
404		.tool = {
405			.sample		= perf_event__repipe_sample,
406			.mmap		= perf_event__repipe,
407			.mmap2		= perf_event__repipe,
408			.comm		= perf_event__repipe,
409			.fork		= perf_event__repipe,
410			.exit		= perf_event__repipe,
411			.lost		= perf_event__repipe,
 
 
 
 
412			.read		= perf_event__repipe_sample,
413			.throttle	= perf_event__repipe,
414			.unthrottle	= perf_event__repipe,
415			.attr		= perf_event__repipe_attr,
416			.tracing_data	= perf_event__repipe_op2_synth,
417			.finished_round	= perf_event__repipe_op2_synth,
 
 
 
418			.build_id	= perf_event__repipe_op2_synth,
 
419		},
420		.input_name  = "-",
421		.samples = LIST_HEAD_INIT(inject.samples),
422		.output = {
423			.path = "-",
424			.mode = PERF_DATA_MODE_WRITE,
425		},
426	};
427	const struct option options[] = {
 
 
 
 
 
428		OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
429			    "Inject build-ids into the output stream"),
430		OPT_STRING('i', "input", &inject.input_name, "file",
431			   "input file name"),
432		OPT_STRING('o', "output", &inject.output.path, "file",
433			   "output file name"),
434		OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
435			    "Merge sched-stat and sched-switch for getting events "
436			    "where and how long tasks slept"),
 
 
 
437		OPT_INCR('v', "verbose", &verbose,
438			 "be more verbose (show build ids, etc)"),
 
 
 
 
 
 
 
 
439		OPT_END()
440	};
441	const char * const inject_usage[] = {
442		"perf inject [<options>]",
443		NULL
444	};
445
 
 
446	argc = parse_options(argc, argv, options, inject_usage, 0);
447
448	/*
449	 * Any (unrecognized) arguments left?
450	 */
451	if (argc)
452		usage_with_options(inject_usage, options);
453
 
 
 
 
 
454	if (perf_data_file__open(&inject.output)) {
455		perror("failed to create output file");
456		return -1;
457	}
458
459	if (symbol__init() < 0)
 
 
 
 
460		return -1;
461
462	return __cmd_inject(&inject);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
463}
v4.6
  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"
 11#include "util/color.h"
 12#include "util/evlist.h"
 13#include "util/evsel.h"
 14#include "util/session.h"
 15#include "util/tool.h"
 16#include "util/debug.h"
 17#include "util/build-id.h"
 18#include "util/data.h"
 19#include "util/auxtrace.h"
 20#include "util/jit.h"
 21
 22#include <subcmd/parse-options.h>
 23
 24#include <linux/list.h>
 25
 26struct perf_inject {
 27	struct perf_tool	tool;
 28	struct perf_session	*session;
 29	bool			build_ids;
 30	bool			sched_stat;
 31	bool			have_auxtrace;
 32	bool			strip;
 33	bool			jit_mode;
 34	const char		*input_name;
 35	struct perf_data_file	output;
 36	u64			bytes_written;
 37	u64			aux_id;
 38	struct list_head	samples;
 39	struct itrace_synth_opts itrace_synth_opts;
 40};
 41
 42struct event_entry {
 43	struct list_head node;
 44	u32		 tid;
 45	union perf_event event[0];
 46};
 47
 48static int output_bytes(struct perf_inject *inject, void *buf, size_t sz)
 
 49{
 
 50	ssize_t size;
 51
 52	size = perf_data_file__write(&inject->output, buf, sz);
 
 53	if (size < 0)
 54		return -errno;
 55
 56	inject->bytes_written += size;
 57	return 0;
 58}
 59
 60static int perf_event__repipe_synth(struct perf_tool *tool,
 61				    union perf_event *event)
 62{
 63	struct perf_inject *inject = container_of(tool, struct perf_inject,
 64						  tool);
 65
 66	return output_bytes(inject, event, event->header.size);
 67}
 68
 69static int perf_event__repipe_oe_synth(struct perf_tool *tool,
 70				       union perf_event *event,
 71				       struct ordered_events *oe __maybe_unused)
 72{
 73	return perf_event__repipe_synth(tool, event);
 74}
 75
 76#ifdef HAVE_JITDUMP
 77static int perf_event__drop_oe(struct perf_tool *tool __maybe_unused,
 78			       union perf_event *event __maybe_unused,
 79			       struct ordered_events *oe __maybe_unused)
 80{
 81	return 0;
 82}
 83#endif
 84
 85static int perf_event__repipe_op2_synth(struct perf_tool *tool,
 86					union perf_event *event,
 87					struct perf_session *session
 88					__maybe_unused)
 89{
 90	return perf_event__repipe_synth(tool, event);
 91}
 92
 93static int perf_event__repipe_attr(struct perf_tool *tool,
 94				   union perf_event *event,
 95				   struct perf_evlist **pevlist)
 96{
 97	struct perf_inject *inject = container_of(tool, struct perf_inject,
 98						  tool);
 99	int ret;
100
101	ret = perf_event__process_attr(tool, event, pevlist);
102	if (ret)
103		return ret;
104
105	if (!inject->output.is_pipe)
106		return 0;
107
108	return perf_event__repipe_synth(tool, event);
109}
110
111#ifdef HAVE_AUXTRACE_SUPPORT
112
113static int copy_bytes(struct perf_inject *inject, int fd, off_t size)
114{
115	char buf[4096];
116	ssize_t ssz;
117	int ret;
118
119	while (size > 0) {
120		ssz = read(fd, buf, min(size, (off_t)sizeof(buf)));
121		if (ssz < 0)
122			return -errno;
123		ret = output_bytes(inject, buf, ssz);
124		if (ret)
125			return ret;
126		size -= ssz;
127	}
128
129	return 0;
130}
131
132static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
133				       union perf_event *event,
134				       struct perf_session *session)
135{
136	struct perf_inject *inject = container_of(tool, struct perf_inject,
137						  tool);
138	int ret;
139
140	inject->have_auxtrace = true;
141
142	if (!inject->output.is_pipe) {
143		off_t offset;
144
145		offset = lseek(inject->output.fd, 0, SEEK_CUR);
146		if (offset == -1)
147			return -errno;
148		ret = auxtrace_index__auxtrace_event(&session->auxtrace_index,
149						     event, offset);
150		if (ret < 0)
151			return ret;
152	}
153
154	if (perf_data_file__is_pipe(session->file) || !session->one_mmap) {
155		ret = output_bytes(inject, event, event->header.size);
156		if (ret < 0)
157			return ret;
158		ret = copy_bytes(inject, perf_data_file__fd(session->file),
159				 event->auxtrace.size);
160	} else {
161		ret = output_bytes(inject, event,
162				   event->header.size + event->auxtrace.size);
163	}
164	if (ret < 0)
165		return ret;
166
167	return event->auxtrace.size;
168}
169
170#else
171
172static s64
173perf_event__repipe_auxtrace(struct perf_tool *tool __maybe_unused,
174			    union perf_event *event __maybe_unused,
175			    struct perf_session *session __maybe_unused)
176{
177	pr_err("AUX area tracing not supported\n");
178	return -EINVAL;
179}
180
181#endif
182
183static int perf_event__repipe(struct perf_tool *tool,
184			      union perf_event *event,
185			      struct perf_sample *sample __maybe_unused,
186			      struct machine *machine __maybe_unused)
187{
188	return perf_event__repipe_synth(tool, event);
189}
190
191static int perf_event__drop(struct perf_tool *tool __maybe_unused,
192			    union perf_event *event __maybe_unused,
193			    struct perf_sample *sample __maybe_unused,
194			    struct machine *machine __maybe_unused)
195{
196	return 0;
197}
198
199static int perf_event__drop_aux(struct perf_tool *tool,
200				union perf_event *event __maybe_unused,
201				struct perf_sample *sample,
202				struct machine *machine __maybe_unused)
203{
204	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
205
206	if (!inject->aux_id)
207		inject->aux_id = sample->id;
208
209	return 0;
210}
211
212typedef int (*inject_handler)(struct perf_tool *tool,
213			      union perf_event *event,
214			      struct perf_sample *sample,
215			      struct perf_evsel *evsel,
216			      struct machine *machine);
217
218static int perf_event__repipe_sample(struct perf_tool *tool,
219				     union perf_event *event,
220				     struct perf_sample *sample,
221				     struct perf_evsel *evsel,
222				     struct machine *machine)
223{
224	if (evsel->handler) {
225		inject_handler f = evsel->handler;
226		return f(tool, event, sample, evsel, machine);
227	}
228
229	build_id__mark_dso_hit(tool, event, sample, evsel, machine);
230
231	return perf_event__repipe_synth(tool, event);
232}
233
234static int perf_event__repipe_mmap(struct perf_tool *tool,
235				   union perf_event *event,
236				   struct perf_sample *sample,
237				   struct machine *machine)
238{
239	int err;
240
241	err = perf_event__process_mmap(tool, event, sample, machine);
242	perf_event__repipe(tool, event, sample, machine);
243
244	return err;
245}
246
247#ifdef HAVE_JITDUMP
248static int perf_event__jit_repipe_mmap(struct perf_tool *tool,
249				       union perf_event *event,
250				       struct perf_sample *sample,
251				       struct machine *machine)
252{
253	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
254	u64 n = 0;
255	int ret;
256
257	/*
258	 * if jit marker, then inject jit mmaps and generate ELF images
259	 */
260	ret = jit_process(inject->session, &inject->output, machine,
261			  event->mmap.filename, sample->pid, &n);
262	if (ret < 0)
263		return ret;
264	if (ret) {
265		inject->bytes_written += n;
266		return 0;
267	}
268	return perf_event__repipe_mmap(tool, event, sample, machine);
269}
270#endif
271
272static int perf_event__repipe_mmap2(struct perf_tool *tool,
273				   union perf_event *event,
274				   struct perf_sample *sample,
275				   struct machine *machine)
276{
277	int err;
278
279	err = perf_event__process_mmap2(tool, event, sample, machine);
280	perf_event__repipe(tool, event, sample, machine);
281
282	return err;
283}
284
285#ifdef HAVE_JITDUMP
286static int perf_event__jit_repipe_mmap2(struct perf_tool *tool,
287					union perf_event *event,
288					struct perf_sample *sample,
289					struct machine *machine)
290{
291	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
292	u64 n = 0;
293	int ret;
294
295	/*
296	 * if jit marker, then inject jit mmaps and generate ELF images
297	 */
298	ret = jit_process(inject->session, &inject->output, machine,
299			  event->mmap2.filename, sample->pid, &n);
300	if (ret < 0)
301		return ret;
302	if (ret) {
303		inject->bytes_written += n;
304		return 0;
305	}
306	return perf_event__repipe_mmap2(tool, event, sample, machine);
307}
308#endif
309
310static int perf_event__repipe_fork(struct perf_tool *tool,
311				   union perf_event *event,
312				   struct perf_sample *sample,
313				   struct machine *machine)
314{
315	int err;
316
317	err = perf_event__process_fork(tool, event, sample, machine);
318	perf_event__repipe(tool, event, sample, machine);
319
320	return err;
321}
322
323static int perf_event__repipe_comm(struct perf_tool *tool,
324				   union perf_event *event,
325				   struct perf_sample *sample,
326				   struct machine *machine)
327{
328	int err;
329
330	err = perf_event__process_comm(tool, event, sample, machine);
331	perf_event__repipe(tool, event, sample, machine);
332
333	return err;
334}
335
336static int perf_event__repipe_exit(struct perf_tool *tool,
337				   union perf_event *event,
338				   struct perf_sample *sample,
339				   struct machine *machine)
340{
341	int err;
342
343	err = perf_event__process_exit(tool, event, sample, machine);
344	perf_event__repipe(tool, event, sample, machine);
345
346	return err;
347}
348
349static int perf_event__repipe_tracing_data(struct perf_tool *tool,
350					   union perf_event *event,
351					   struct perf_session *session)
352{
353	int err;
354
355	perf_event__repipe_synth(tool, event);
356	err = perf_event__process_tracing_data(tool, event, session);
357
358	return err;
359}
360
361static int perf_event__repipe_id_index(struct perf_tool *tool,
362				       union perf_event *event,
363				       struct perf_session *session)
364{
365	int err;
366
367	perf_event__repipe_synth(tool, event);
368	err = perf_event__process_id_index(tool, event, session);
369
370	return err;
371}
372
373static int dso__read_build_id(struct dso *dso)
374{
375	if (dso->has_build_id)
376		return 0;
377
378	if (filename__read_build_id(dso->long_name, dso->build_id,
379				    sizeof(dso->build_id)) > 0) {
380		dso->has_build_id = true;
381		return 0;
382	}
383
384	return -1;
385}
386
387static int dso__inject_build_id(struct dso *dso, struct perf_tool *tool,
388				struct machine *machine)
389{
390	u16 misc = PERF_RECORD_MISC_USER;
391	int err;
392
393	if (dso__read_build_id(dso) < 0) {
394		pr_debug("no build_id found for %s\n", dso->long_name);
395		return -1;
396	}
397
398	if (dso->kernel)
399		misc = PERF_RECORD_MISC_KERNEL;
400
401	err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe,
402					      machine);
403	if (err) {
404		pr_err("Can't synthesize build_id event for %s\n", dso->long_name);
405		return -1;
406	}
407
408	return 0;
409}
410
411static int perf_event__inject_buildid(struct perf_tool *tool,
412				      union perf_event *event,
413				      struct perf_sample *sample,
414				      struct perf_evsel *evsel __maybe_unused,
415				      struct machine *machine)
416{
417	struct addr_location al;
418	struct thread *thread;
 
419
420	thread = machine__findnew_thread(machine, sample->pid, sample->tid);
 
 
421	if (thread == NULL) {
422		pr_err("problem processing %d event, skipping it.\n",
423		       event->header.type);
424		goto repipe;
425	}
426
427	thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, sample->ip, &al);
 
428
429	if (al.map != NULL) {
430		if (!al.map->dso->hit) {
431			al.map->dso->hit = 1;
432			if (map__load(al.map, NULL) >= 0) {
433				dso__inject_build_id(al.map->dso, tool, machine);
434				/*
435				 * If this fails, too bad, let the other side
436				 * account this as unresolved.
437				 */
438			} else {
439#ifdef HAVE_LIBELF_SUPPORT
440				pr_warning("no symbols found in %s, maybe "
441					   "install a debug package?\n",
442					   al.map->dso->long_name);
443#endif
444			}
445		}
446	}
447
448	thread__put(thread);
449repipe:
450	perf_event__repipe(tool, event, sample, machine);
451	return 0;
452}
453
454static int perf_inject__sched_process_exit(struct perf_tool *tool,
455					   union perf_event *event __maybe_unused,
456					   struct perf_sample *sample,
457					   struct perf_evsel *evsel __maybe_unused,
458					   struct machine *machine __maybe_unused)
459{
460	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
461	struct event_entry *ent;
462
463	list_for_each_entry(ent, &inject->samples, node) {
464		if (sample->tid == ent->tid) {
465			list_del_init(&ent->node);
466			free(ent);
467			break;
468		}
469	}
470
471	return 0;
472}
473
474static int perf_inject__sched_switch(struct perf_tool *tool,
475				     union perf_event *event,
476				     struct perf_sample *sample,
477				     struct perf_evsel *evsel,
478				     struct machine *machine)
479{
480	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
481	struct event_entry *ent;
482
483	perf_inject__sched_process_exit(tool, event, sample, evsel, machine);
484
485	ent = malloc(event->header.size + sizeof(struct event_entry));
486	if (ent == NULL) {
487		color_fprintf(stderr, PERF_COLOR_RED,
488			     "Not enough memory to process sched switch event!");
489		return -1;
490	}
491
492	ent->tid = sample->tid;
493	memcpy(&ent->event, event, event->header.size);
494	list_add(&ent->node, &inject->samples);
495	return 0;
496}
497
498static int perf_inject__sched_stat(struct perf_tool *tool,
499				   union perf_event *event __maybe_unused,
500				   struct perf_sample *sample,
501				   struct perf_evsel *evsel,
502				   struct machine *machine)
503{
504	struct event_entry *ent;
505	union perf_event *event_sw;
506	struct perf_sample sample_sw;
507	struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
508	u32 pid = perf_evsel__intval(evsel, sample, "pid");
509
510	list_for_each_entry(ent, &inject->samples, node) {
511		if (pid == ent->tid)
512			goto found;
513	}
514
515	return 0;
516found:
517	event_sw = &ent->event[0];
518	perf_evsel__parse_sample(evsel, event_sw, &sample_sw);
519
520	sample_sw.period = sample->period;
521	sample_sw.time	 = sample->time;
522	perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
523				      evsel->attr.read_format, &sample_sw,
524				      false);
525	build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
526	return perf_event__repipe(tool, event_sw, &sample_sw, machine);
527}
528
529static void sig_handler(int sig __maybe_unused)
530{
531	session_done = 1;
532}
533
534static int perf_evsel__check_stype(struct perf_evsel *evsel,
535				   u64 sample_type, const char *sample_msg)
536{
537	struct perf_event_attr *attr = &evsel->attr;
538	const char *name = perf_evsel__name(evsel);
539
540	if (!(attr->sample_type & sample_type)) {
541		pr_err("Samples for %s event do not have %s attribute set.",
542			name, sample_msg);
543		return -EINVAL;
544	}
545
546	return 0;
547}
548
549static int drop_sample(struct perf_tool *tool __maybe_unused,
550		       union perf_event *event __maybe_unused,
551		       struct perf_sample *sample __maybe_unused,
552		       struct perf_evsel *evsel __maybe_unused,
553		       struct machine *machine __maybe_unused)
554{
555	return 0;
556}
557
558static void strip_init(struct perf_inject *inject)
559{
560	struct perf_evlist *evlist = inject->session->evlist;
561	struct perf_evsel *evsel;
562
563	inject->tool.context_switch = perf_event__drop;
564
565	evlist__for_each(evlist, evsel)
566		evsel->handler = drop_sample;
567}
568
569static bool has_tracking(struct perf_evsel *evsel)
570{
571	return evsel->attr.mmap || evsel->attr.mmap2 || evsel->attr.comm ||
572	       evsel->attr.task;
573}
574
575#define COMPAT_MASK (PERF_SAMPLE_ID | PERF_SAMPLE_TID | PERF_SAMPLE_TIME | \
576		     PERF_SAMPLE_ID | PERF_SAMPLE_CPU | PERF_SAMPLE_IDENTIFIER)
577
578/*
579 * In order that the perf.data file is parsable, tracking events like MMAP need
580 * their selected event to exist, except if there is only 1 selected event left
581 * and it has a compatible sample type.
582 */
583static bool ok_to_remove(struct perf_evlist *evlist,
584			 struct perf_evsel *evsel_to_remove)
585{
586	struct perf_evsel *evsel;
587	int cnt = 0;
588	bool ok = false;
589
590	if (!has_tracking(evsel_to_remove))
591		return true;
592
593	evlist__for_each(evlist, evsel) {
594		if (evsel->handler != drop_sample) {
595			cnt += 1;
596			if ((evsel->attr.sample_type & COMPAT_MASK) ==
597			    (evsel_to_remove->attr.sample_type & COMPAT_MASK))
598				ok = true;
599		}
600	}
601
602	return ok && cnt == 1;
603}
604
605static void strip_fini(struct perf_inject *inject)
606{
607	struct perf_evlist *evlist = inject->session->evlist;
608	struct perf_evsel *evsel, *tmp;
609
610	/* Remove non-synthesized evsels if possible */
611	evlist__for_each_safe(evlist, tmp, evsel) {
612		if (evsel->handler == drop_sample &&
613		    ok_to_remove(evlist, evsel)) {
614			pr_debug("Deleting %s\n", perf_evsel__name(evsel));
615			perf_evlist__remove(evlist, evsel);
616			perf_evsel__delete(evsel);
617		}
618	}
619}
620
621static int __cmd_inject(struct perf_inject *inject)
622{
 
623	int ret = -EINVAL;
624	struct perf_session *session = inject->session;
 
 
 
625	struct perf_data_file *file_out = &inject->output;
626	int fd = perf_data_file__fd(file_out);
627	u64 output_data_offset;
628
629	signal(SIGINT, sig_handler);
630
631	if (inject->build_ids || inject->sched_stat ||
632	    inject->itrace_synth_opts.set) {
633		inject->tool.mmap	  = perf_event__repipe_mmap;
634		inject->tool.mmap2	  = perf_event__repipe_mmap2;
635		inject->tool.fork	  = perf_event__repipe_fork;
636		inject->tool.tracing_data = perf_event__repipe_tracing_data;
637	}
638
639	output_data_offset = session->header.data_offset;
 
 
640
641	if (inject->build_ids) {
642		inject->tool.sample = perf_event__inject_buildid;
643	} else if (inject->sched_stat) {
644		struct perf_evsel *evsel;
645
 
 
646		evlist__for_each(session->evlist, evsel) {
647			const char *name = perf_evsel__name(evsel);
648
649			if (!strcmp(name, "sched:sched_switch")) {
650				if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID"))
651					return -EINVAL;
652
653				evsel->handler = perf_inject__sched_switch;
654			} else if (!strcmp(name, "sched:sched_process_exit"))
655				evsel->handler = perf_inject__sched_process_exit;
656			else if (!strncmp(name, "sched:sched_stat_", 17))
657				evsel->handler = perf_inject__sched_stat;
658		}
659	} else if (inject->itrace_synth_opts.set) {
660		session->itrace_synth_opts = &inject->itrace_synth_opts;
661		inject->itrace_synth_opts.inject = true;
662		inject->tool.comm	    = perf_event__repipe_comm;
663		inject->tool.exit	    = perf_event__repipe_exit;
664		inject->tool.id_index	    = perf_event__repipe_id_index;
665		inject->tool.auxtrace_info  = perf_event__process_auxtrace_info;
666		inject->tool.auxtrace	    = perf_event__process_auxtrace;
667		inject->tool.aux	    = perf_event__drop_aux;
668		inject->tool.itrace_start   = perf_event__drop_aux,
669		inject->tool.ordered_events = true;
670		inject->tool.ordering_requires_timestamps = true;
671		/* Allow space in the header for new attributes */
672		output_data_offset = 4096;
673		if (inject->strip)
674			strip_init(inject);
675	}
676
677	if (!inject->itrace_synth_opts.set)
678		auxtrace_index__free(&session->auxtrace_index);
679
680	if (!file_out->is_pipe)
681		lseek(fd, output_data_offset, SEEK_SET);
682
683	ret = perf_session__process_events(session);
684
685	if (!file_out->is_pipe) {
686		if (inject->build_ids)
687			perf_header__set_feat(&session->header,
688					      HEADER_BUILD_ID);
689		/*
690		 * Keep all buildids when there is unprocessed AUX data because
691		 * it is not known which ones the AUX trace hits.
692		 */
693		if (perf_header__has_feat(&session->header, HEADER_BUILD_ID) &&
694		    inject->have_auxtrace && !inject->itrace_synth_opts.set)
695			dsos__hit_all(session);
696		/*
697		 * The AUX areas have been removed and replaced with
698		 * synthesized hardware events, so clear the feature flag and
699		 * remove the evsel.
700		 */
701		if (inject->itrace_synth_opts.set) {
702			struct perf_evsel *evsel;
703
704			perf_header__clear_feat(&session->header,
705						HEADER_AUXTRACE);
706			if (inject->itrace_synth_opts.last_branch)
707				perf_header__set_feat(&session->header,
708						      HEADER_BRANCH_STACK);
709			evsel = perf_evlist__id2evsel_strict(session->evlist,
710							     inject->aux_id);
711			if (evsel) {
712				pr_debug("Deleting %s\n",
713					 perf_evsel__name(evsel));
714				perf_evlist__remove(session->evlist, evsel);
715				perf_evsel__delete(evsel);
716			}
717			if (inject->strip)
718				strip_fini(inject);
719		}
720		session->header.data_offset = output_data_offset;
721		session->header.data_size = inject->bytes_written;
722		perf_session__write_header(session, session->evlist, fd, true);
723	}
724
 
 
725	return ret;
726}
727
728int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
729{
730	struct perf_inject inject = {
731		.tool = {
732			.sample		= perf_event__repipe_sample,
733			.mmap		= perf_event__repipe,
734			.mmap2		= perf_event__repipe,
735			.comm		= perf_event__repipe,
736			.fork		= perf_event__repipe,
737			.exit		= perf_event__repipe,
738			.lost		= perf_event__repipe,
739			.lost_samples	= perf_event__repipe,
740			.aux		= perf_event__repipe,
741			.itrace_start	= perf_event__repipe,
742			.context_switch	= perf_event__repipe,
743			.read		= perf_event__repipe_sample,
744			.throttle	= perf_event__repipe,
745			.unthrottle	= perf_event__repipe,
746			.attr		= perf_event__repipe_attr,
747			.tracing_data	= perf_event__repipe_op2_synth,
748			.auxtrace_info	= perf_event__repipe_op2_synth,
749			.auxtrace	= perf_event__repipe_auxtrace,
750			.auxtrace_error	= perf_event__repipe_op2_synth,
751			.finished_round	= perf_event__repipe_oe_synth,
752			.build_id	= perf_event__repipe_op2_synth,
753			.id_index	= perf_event__repipe_op2_synth,
754		},
755		.input_name  = "-",
756		.samples = LIST_HEAD_INIT(inject.samples),
757		.output = {
758			.path = "-",
759			.mode = PERF_DATA_MODE_WRITE,
760		},
761	};
762	struct perf_data_file file = {
763		.mode = PERF_DATA_MODE_READ,
764	};
765	int ret;
766
767	struct option options[] = {
768		OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
769			    "Inject build-ids into the output stream"),
770		OPT_STRING('i', "input", &inject.input_name, "file",
771			   "input file name"),
772		OPT_STRING('o', "output", &inject.output.path, "file",
773			   "output file name"),
774		OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
775			    "Merge sched-stat and sched-switch for getting events "
776			    "where and how long tasks slept"),
777#ifdef HAVE_JITDUMP
778		OPT_BOOLEAN('j', "jit", &inject.jit_mode, "merge jitdump files into perf.data file"),
779#endif
780		OPT_INCR('v', "verbose", &verbose,
781			 "be more verbose (show build ids, etc)"),
782		OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file",
783			   "kallsyms pathname"),
784		OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
785		OPT_CALLBACK_OPTARG(0, "itrace", &inject.itrace_synth_opts,
786				    NULL, "opts", "Instruction Tracing options",
787				    itrace_parse_synth_opts),
788		OPT_BOOLEAN(0, "strip", &inject.strip,
789			    "strip non-synthesized events (use with --itrace)"),
790		OPT_END()
791	};
792	const char * const inject_usage[] = {
793		"perf inject [<options>]",
794		NULL
795	};
796#ifndef HAVE_JITDUMP
797	set_option_nobuild(options, 'j', "jit", "NO_LIBELF=1", true);
798#endif
799	argc = parse_options(argc, argv, options, inject_usage, 0);
800
801	/*
802	 * Any (unrecognized) arguments left?
803	 */
804	if (argc)
805		usage_with_options(inject_usage, options);
806
807	if (inject.strip && !inject.itrace_synth_opts.set) {
808		pr_err("--strip option requires --itrace option\n");
809		return -1;
810	}
811
812	if (perf_data_file__open(&inject.output)) {
813		perror("failed to create output file");
814		return -1;
815	}
816
817	inject.tool.ordered_events = inject.sched_stat;
818
819	file.path = inject.input_name;
820	inject.session = perf_session__new(&file, true, &inject.tool);
821	if (inject.session == NULL)
822		return -1;
823
824	if (inject.build_ids) {
825		/*
826		 * to make sure the mmap records are ordered correctly
827		 * and so that the correct especially due to jitted code
828		 * mmaps. We cannot generate the buildid hit list and
829		 * inject the jit mmaps at the same time for now.
830		 */
831		inject.tool.ordered_events = true;
832		inject.tool.ordering_requires_timestamps = true;
833	}
834#ifdef HAVE_JITDUMP
835	if (inject.jit_mode) {
836		inject.tool.mmap2	   = perf_event__jit_repipe_mmap2;
837		inject.tool.mmap	   = perf_event__jit_repipe_mmap;
838		inject.tool.ordered_events = true;
839		inject.tool.ordering_requires_timestamps = true;
840		/*
841		 * JIT MMAP injection injects all MMAP events in one go, so it
842		 * does not obey finished_round semantics.
843		 */
844		inject.tool.finished_round = perf_event__drop_oe;
845	}
846#endif
847	ret = symbol__init(&inject.session->header.env);
848	if (ret < 0)
849		goto out_delete;
850
851	ret = __cmd_inject(&inject);
852
853out_delete:
854	perf_session__delete(inject.session);
855	return ret;
856}