tool.c

  1// SPDX-License-Identifier: GPL-2.0
  2#include "data.h"
  3#include "debug.h"
  4#include "event.h"
  5#include "header.h"
  6#include "session.h"
  7#include "stat.h"
  8#include "tool.h"
  9#include "tsc.h"
 10#include <linux/compiler.h>
 11#include <sys/mman.h>
 12#include <stddef.h>
 13#include <unistd.h>
 14
 15#ifdef HAVE_ZSTD_SUPPORT
 16static int perf_session__process_compressed_event(const struct perf_tool *tool __maybe_unused,
 17						  struct perf_session *session,
 18						  union perf_event *event, u64 file_offset,
 19						  const char *file_path)
 20{
 21	void *src;
 22	size_t decomp_size, src_size;
 23	u64 decomp_last_rem = 0;
 24	size_t mmap_len, decomp_len = perf_session__env(session)->comp_mmap_len;
 25	struct decomp *decomp, *decomp_last = session->active_decomp->decomp_last;
 26
 27	if (decomp_last) {
 28		decomp_last_rem = decomp_last->size - decomp_last->head;
 29		decomp_len += decomp_last_rem;
 30	}
 31
 32	mmap_len = sizeof(struct decomp) + decomp_len;
 33	decomp = mmap(NULL, mmap_len, PROT_READ|PROT_WRITE,
 34		      MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
 35	if (decomp == MAP_FAILED) {
 36		pr_err("Couldn't allocate memory for decompression\n");
 37		return -1;
 38	}
 39
 40	decomp->file_pos = file_offset;
 41	decomp->file_path = file_path;
 42	decomp->mmap_len = mmap_len;
 43	decomp->head = 0;
 44
 45	if (decomp_last_rem) {
 46		memcpy(decomp->data, &(decomp_last->data[decomp_last->head]), decomp_last_rem);
 47		decomp->size = decomp_last_rem;
 48	}
 49
 50	if (event->header.type == PERF_RECORD_COMPRESSED) {
 51		src = (void *)event + sizeof(struct perf_record_compressed);
 52		src_size = event->pack.header.size - sizeof(struct perf_record_compressed);
 53	} else if (event->header.type == PERF_RECORD_COMPRESSED2) {
 54		src = (void *)event + sizeof(struct perf_record_compressed2);
 55		src_size = event->pack2.data_size;
 56	} else {
 57		return -1;
 58	}
 59
 60	decomp_size = zstd_decompress_stream(session->active_decomp->zstd_decomp, src, src_size,
 61				&(decomp->data[decomp_last_rem]), decomp_len - decomp_last_rem);
 62	if (!decomp_size) {
 63		munmap(decomp, mmap_len);
 64		pr_err("Couldn't decompress data\n");
 65		return -1;
 66	}
 67
 68	decomp->size += decomp_size;
 69
 70	if (session->active_decomp->decomp == NULL)
 71		session->active_decomp->decomp = decomp;
 72	else
 73		session->active_decomp->decomp_last->next = decomp;
 74
 75	session->active_decomp->decomp_last = decomp;
 76
 77	pr_debug("decomp (B): %zd to %zd\n", src_size, decomp_size);
 78
 79	return 0;
 80}
 81#endif
 82
 83static int process_event_synth_tracing_data_stub(const struct perf_tool *tool __maybe_unused,
 84						 struct perf_session *session __maybe_unused,
 85						 union perf_event *event __maybe_unused)
 86{
 87	dump_printf(": unhandled!\n");
 88	return 0;
 89}
 90
 91static int process_event_synth_attr_stub(const struct perf_tool *tool __maybe_unused,
 92					 union perf_event *event __maybe_unused,
 93					 struct evlist **pevlist __maybe_unused)
 94{
 95	dump_printf(": unhandled!\n");
 96	return 0;
 97}
 98
 99static int process_event_synth_event_update_stub(const struct perf_tool *tool __maybe_unused,
100						 union perf_event *event __maybe_unused,
101						 struct evlist **pevlist __maybe_unused)
102{
103	if (dump_trace)
104		perf_event__fprintf_event_update(event, stdout);
105
106	dump_printf(": unhandled!\n");
107	return 0;
108}
109
110int process_event_sample_stub(const struct perf_tool *tool __maybe_unused,
111			      union perf_event *event __maybe_unused,
112			      struct perf_sample *sample __maybe_unused,
113			      struct evsel *evsel __maybe_unused,
114			      struct machine *machine __maybe_unused)
115{
116	dump_printf(": unhandled!\n");
117	return 0;
118}
119
120static int process_event_stub(const struct perf_tool *tool __maybe_unused,
121			      union perf_event *event __maybe_unused,
122			      struct perf_sample *sample __maybe_unused,
123			      struct machine *machine __maybe_unused)
124{
125	dump_printf(": unhandled!\n");
126	return 0;
127}
128
129static int process_finished_round_stub(const struct perf_tool *tool __maybe_unused,
130				       union perf_event *event __maybe_unused,
131				       struct ordered_events *oe __maybe_unused)
132{
133	dump_printf(": unhandled!\n");
134	return 0;
135}
136
137static int skipn(int fd, off_t n)
138{
139	char buf[4096];
140	ssize_t ret;
141
142	while (n > 0) {
143		ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
144		if (ret <= 0)
145			return ret;
146		n -= ret;
147	}
148
149	return 0;
150}
151
152static s64 process_event_auxtrace_stub(const struct perf_tool *tool __maybe_unused,
153				       struct perf_session *session __maybe_unused,
154				       union perf_event *event)
155{
156	dump_printf(": unhandled!\n");
157	if (perf_data__is_pipe(session->data))
158		skipn(perf_data__fd(session->data), event->auxtrace.size);
159	return event->auxtrace.size;
160}
161
162static int process_event_op2_stub(const struct perf_tool *tool __maybe_unused,
163				  struct perf_session *session __maybe_unused,
164				  union perf_event *event __maybe_unused)
165{
166	dump_printf(": unhandled!\n");
167	return 0;
168}
169
170
171static
172int process_event_thread_map_stub(const struct perf_tool *tool __maybe_unused,
173				  struct perf_session *session __maybe_unused,
174				  union perf_event *event __maybe_unused)
175{
176	if (dump_trace)
177		perf_event__fprintf_thread_map(event, stdout);
178
179	dump_printf(": unhandled!\n");
180	return 0;
181}
182
183static
184int process_event_cpu_map_stub(const struct perf_tool *tool __maybe_unused,
185			       struct perf_session *session __maybe_unused,
186			       union perf_event *event __maybe_unused)
187{
188	if (dump_trace)
189		perf_event__fprintf_cpu_map(event, stdout);
190
191	dump_printf(": unhandled!\n");
192	return 0;
193}
194
195static
196int process_event_stat_config_stub(const struct perf_tool *tool __maybe_unused,
197				   struct perf_session *session __maybe_unused,
198				   union perf_event *event __maybe_unused)
199{
200	if (dump_trace)
201		perf_event__fprintf_stat_config(event, stdout);
202
203	dump_printf(": unhandled!\n");
204	return 0;
205}
206
207static int process_stat_stub(const struct perf_tool *tool __maybe_unused,
208			     struct perf_session *perf_session __maybe_unused,
209			     union perf_event *event)
210{
211	if (dump_trace)
212		perf_event__fprintf_stat(event, stdout);
213
214	dump_printf(": unhandled!\n");
215	return 0;
216}
217
218static int process_stat_round_stub(const struct perf_tool *tool __maybe_unused,
219				   struct perf_session *perf_session __maybe_unused,
220				   union perf_event *event)
221{
222	if (dump_trace)
223		perf_event__fprintf_stat_round(event, stdout);
224
225	dump_printf(": unhandled!\n");
226	return 0;
227}
228
229static int process_event_time_conv_stub(const struct perf_tool *tool __maybe_unused,
230					struct perf_session *perf_session __maybe_unused,
231					union perf_event *event)
232{
233	if (dump_trace)
234		perf_event__fprintf_time_conv(event, stdout);
235
236	dump_printf(": unhandled!\n");
237	return 0;
238}
239
240static int perf_session__process_compressed_event_stub(const struct perf_tool *tool __maybe_unused,
241						       struct perf_session *session __maybe_unused,
242						       union perf_event *event __maybe_unused,
243						       u64 file_offset __maybe_unused,
244						       const char *file_path __maybe_unused)
245{
246	dump_printf(": unhandled!\n");
247	return 0;
248}
249
250static int perf_event__process_bpf_metadata_stub(const struct perf_tool *tool __maybe_unused,
251						 struct perf_session *perf_session __maybe_unused,
252						 union perf_event *event)
253{
254	if (dump_trace)
255		perf_event__fprintf_bpf_metadata(event, stdout);
256
257	dump_printf(": unhandled!\n");
258	return 0;
259}
260
261void perf_tool__init(struct perf_tool *tool, bool ordered_events)
262{
263	tool->ordered_events = ordered_events;
264	tool->ordering_requires_timestamps = false;
265	tool->namespace_events = false;
266	tool->cgroup_events = false;
267	tool->no_warn = false;
268	tool->show_feat_hdr = SHOW_FEAT_NO_HEADER;
269	tool->merge_deferred_callchains = true;
270
271	tool->sample = process_event_sample_stub;
272	tool->mmap = process_event_stub;
273	tool->mmap2 = process_event_stub;
274	tool->comm = process_event_stub;
275	tool->namespaces = process_event_stub;
276	tool->cgroup = process_event_stub;
277	tool->fork = process_event_stub;
278	tool->exit = process_event_stub;
279	tool->lost = perf_event__process_lost;
280	tool->lost_samples = perf_event__process_lost_samples;
281	tool->aux = perf_event__process_aux;
282	tool->itrace_start = perf_event__process_itrace_start;
283	tool->context_switch = perf_event__process_switch;
284	tool->ksymbol = perf_event__process_ksymbol;
285	tool->bpf = perf_event__process_bpf;
286	tool->text_poke = perf_event__process_text_poke;
287	tool->aux_output_hw_id = perf_event__process_aux_output_hw_id;
288	tool->read = process_event_sample_stub;
289	tool->throttle = process_event_stub;
290	tool->unthrottle = process_event_stub;
291	tool->callchain_deferred = process_event_sample_stub;
292	tool->attr = process_event_synth_attr_stub;
293	tool->event_update = process_event_synth_event_update_stub;
294	tool->tracing_data = process_event_synth_tracing_data_stub;
295	tool->build_id = process_event_op2_stub;
296
297	if (ordered_events)
298		tool->finished_round = perf_event__process_finished_round;
299	else
300		tool->finished_round = process_finished_round_stub;
301
302	tool->id_index = process_event_op2_stub;
303	tool->auxtrace_info = process_event_op2_stub;
304	tool->auxtrace = process_event_auxtrace_stub;
305	tool->auxtrace_error = process_event_op2_stub;
306	tool->thread_map = process_event_thread_map_stub;
307	tool->cpu_map = process_event_cpu_map_stub;
308	tool->stat_config = process_event_stat_config_stub;
309	tool->stat = process_stat_stub;
310	tool->stat_round = process_stat_round_stub;
311	tool->time_conv = process_event_time_conv_stub;
312	tool->feature = process_event_op2_stub;
313#ifdef HAVE_ZSTD_SUPPORT
314	tool->compressed = perf_session__process_compressed_event;
315#else
316	tool->compressed = perf_session__process_compressed_event_stub;
317#endif
318	tool->finished_init = process_event_op2_stub;
319	tool->bpf_metadata = perf_event__process_bpf_metadata_stub;
320}
321
322bool perf_tool__compressed_is_stub(const struct perf_tool *tool)
323{
324	return tool->compressed == perf_session__process_compressed_event_stub;
325}
326
327#define CREATE_DELEGATE_SAMPLE(name) \
328	static int delegate_ ## name(const struct perf_tool *tool, \
329				     union perf_event *event, \
330				     struct perf_sample *sample, \
331				     struct evsel *evsel, \
332				     struct machine *machine) \
333	{								\
334		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \
335		struct perf_tool *delegate = del_tool->delegate;		\
336		return delegate->name(delegate, event, sample, evsel, machine);	\
337	}
338CREATE_DELEGATE_SAMPLE(read);
339CREATE_DELEGATE_SAMPLE(sample);
340CREATE_DELEGATE_SAMPLE(callchain_deferred);
341
342#define CREATE_DELEGATE_ATTR(name)					\
343	static int delegate_ ## name(const struct perf_tool *tool,	\
344				union perf_event *event,		\
345				struct evlist **pevlist)		\
346	{								\
347		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \
348		struct perf_tool *delegate = del_tool->delegate;		\
349		return delegate->name(delegate, event, pevlist);	\
350	}
351CREATE_DELEGATE_ATTR(attr);
352CREATE_DELEGATE_ATTR(event_update);
353
354#define CREATE_DELEGATE_OE(name)				   \
355	static int delegate_ ## name(const struct perf_tool *tool, \
356				     union perf_event *event,	   \
357				     struct ordered_events *oe)	   \
358	{								\
359		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \
360		struct perf_tool *delegate = del_tool->delegate;		\
361		return delegate->name(delegate, event, oe);	\
362	}
363CREATE_DELEGATE_OE(finished_round);
364
365#define CREATE_DELEGATE_OP(name)				   \
366	static int delegate_ ## name(const struct perf_tool *tool, \
367				     union perf_event *event, \
368				     struct perf_sample *sample, \
369				     struct machine *machine) \
370	{								\
371		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \
372		struct perf_tool *delegate = del_tool->delegate;		\
373		return delegate->name(delegate, event, sample, machine); \
374	}
375CREATE_DELEGATE_OP(aux);
376CREATE_DELEGATE_OP(aux_output_hw_id);
377CREATE_DELEGATE_OP(bpf);
378CREATE_DELEGATE_OP(cgroup);
379CREATE_DELEGATE_OP(comm);
380CREATE_DELEGATE_OP(context_switch);
381CREATE_DELEGATE_OP(exit);
382CREATE_DELEGATE_OP(fork);
383CREATE_DELEGATE_OP(itrace_start);
384CREATE_DELEGATE_OP(ksymbol);
385CREATE_DELEGATE_OP(lost);
386CREATE_DELEGATE_OP(lost_samples);
387CREATE_DELEGATE_OP(mmap);
388CREATE_DELEGATE_OP(mmap2);
389CREATE_DELEGATE_OP(namespaces);
390CREATE_DELEGATE_OP(text_poke);
391CREATE_DELEGATE_OP(throttle);
392CREATE_DELEGATE_OP(unthrottle);
393
394#define CREATE_DELEGATE_OP2(name)					\
395	static int delegate_ ## name(const struct perf_tool *tool,	\
396				     struct perf_session *session,	\
397				     union perf_event *event)		\
398	{								\
399		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \
400		struct perf_tool *delegate = del_tool->delegate;		\
401		return delegate->name(delegate, session, event);	\
402	}
403CREATE_DELEGATE_OP2(auxtrace_error);
404CREATE_DELEGATE_OP2(auxtrace_info);
405CREATE_DELEGATE_OP2(bpf_metadata);
406CREATE_DELEGATE_OP2(build_id);
407CREATE_DELEGATE_OP2(cpu_map);
408CREATE_DELEGATE_OP2(feature);
409CREATE_DELEGATE_OP2(finished_init);
410CREATE_DELEGATE_OP2(id_index);
411CREATE_DELEGATE_OP2(stat);
412CREATE_DELEGATE_OP2(stat_config);
413CREATE_DELEGATE_OP2(stat_round);
414CREATE_DELEGATE_OP2(thread_map);
415CREATE_DELEGATE_OP2(time_conv);
416CREATE_DELEGATE_OP2(tracing_data);
417
418#define CREATE_DELEGATE_OP3(name)					\
419	static s64 delegate_ ## name(const struct perf_tool *tool,	\
420				     struct perf_session *session,      \
421				     union perf_event *event)           \
422	{								\
423		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \
424		struct perf_tool *delegate = del_tool->delegate;	\
425		return delegate->name(delegate, session, event);	\
426	}
427CREATE_DELEGATE_OP3(auxtrace);
428
429#define CREATE_DELEGATE_OP4(name)					\
430	static int delegate_ ## name(const struct perf_tool *tool, \
431			struct perf_session *session, \
432			union perf_event *event, \
433			u64 data, \
434			const char *str) \
435	{								\
436		struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \
437		struct perf_tool *delegate = del_tool->delegate;		\
438		return delegate->name(delegate, session, event, data, str);	\
439	}
440CREATE_DELEGATE_OP4(compressed);
441
442void delegate_tool__init(struct delegate_tool *tool, struct perf_tool *delegate)
443{
444	tool->delegate = delegate;
445
446	tool->tool.ordered_events = delegate->ordered_events;
447	tool->tool.ordering_requires_timestamps = delegate->ordering_requires_timestamps;
448	tool->tool.namespace_events = delegate->namespace_events;
449	tool->tool.cgroup_events = delegate->cgroup_events;
450	tool->tool.no_warn = delegate->no_warn;
451	tool->tool.show_feat_hdr = delegate->show_feat_hdr;
452	tool->tool.merge_deferred_callchains = delegate->merge_deferred_callchains;
453
454	tool->tool.sample = delegate_sample;
455	tool->tool.read = delegate_read;
456
457	tool->tool.mmap = delegate_mmap;
458	tool->tool.mmap2 = delegate_mmap2;
459	tool->tool.comm = delegate_comm;
460	tool->tool.namespaces = delegate_namespaces;
461	tool->tool.cgroup = delegate_cgroup;
462	tool->tool.fork = delegate_fork;
463	tool->tool.exit = delegate_exit;
464	tool->tool.lost = delegate_lost;
465	tool->tool.lost_samples = delegate_lost_samples;
466	tool->tool.aux = delegate_aux;
467	tool->tool.itrace_start = delegate_itrace_start;
468	tool->tool.aux_output_hw_id = delegate_aux_output_hw_id;
469	tool->tool.context_switch = delegate_context_switch;
470	tool->tool.throttle = delegate_throttle;
471	tool->tool.unthrottle = delegate_unthrottle;
472	tool->tool.ksymbol = delegate_ksymbol;
473	tool->tool.bpf = delegate_bpf;
474	tool->tool.text_poke = delegate_text_poke;
475	tool->tool.callchain_deferred = delegate_callchain_deferred;
476
477	tool->tool.attr = delegate_attr;
478	tool->tool.event_update = delegate_event_update;
479
480	tool->tool.tracing_data = delegate_tracing_data;
481
482	tool->tool.finished_round = delegate_finished_round;
483
484	tool->tool.build_id = delegate_build_id;
485	tool->tool.id_index = delegate_id_index;
486	tool->tool.auxtrace_info = delegate_auxtrace_info;
487	tool->tool.auxtrace_error = delegate_auxtrace_error;
488	tool->tool.time_conv = delegate_time_conv;
489	tool->tool.thread_map = delegate_thread_map;
490	tool->tool.cpu_map = delegate_cpu_map;
491	tool->tool.stat_config = delegate_stat_config;
492	tool->tool.stat = delegate_stat;
493	tool->tool.stat_round = delegate_stat_round;
494	tool->tool.feature = delegate_feature;
495	tool->tool.finished_init = delegate_finished_init;
496	tool->tool.bpf_metadata = delegate_bpf_metadata;
497	tool->tool.compressed = delegate_compressed;
498	tool->tool.auxtrace = delegate_auxtrace;
499}