Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2#include "data.h"
3#include "debug.h"
4#include "header.h"
5#include "session.h"
6#include "stat.h"
7#include "tool.h"
8#include "tsc.h"
9#include <sys/mman.h>
10#include <unistd.h>
11
12#ifdef HAVE_ZSTD_SUPPORT
13static int perf_session__process_compressed_event(struct perf_session *session,
14 union perf_event *event, u64 file_offset,
15 const char *file_path)
16{
17 void *src;
18 size_t decomp_size, src_size;
19 u64 decomp_last_rem = 0;
20 size_t mmap_len, decomp_len = session->header.env.comp_mmap_len;
21 struct decomp *decomp, *decomp_last = session->active_decomp->decomp_last;
22
23 if (decomp_last) {
24 decomp_last_rem = decomp_last->size - decomp_last->head;
25 decomp_len += decomp_last_rem;
26 }
27
28 mmap_len = sizeof(struct decomp) + decomp_len;
29 decomp = mmap(NULL, mmap_len, PROT_READ|PROT_WRITE,
30 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
31 if (decomp == MAP_FAILED) {
32 pr_err("Couldn't allocate memory for decompression\n");
33 return -1;
34 }
35
36 decomp->file_pos = file_offset;
37 decomp->file_path = file_path;
38 decomp->mmap_len = mmap_len;
39 decomp->head = 0;
40
41 if (decomp_last_rem) {
42 memcpy(decomp->data, &(decomp_last->data[decomp_last->head]), decomp_last_rem);
43 decomp->size = decomp_last_rem;
44 }
45
46 if (event->header.type == PERF_RECORD_COMPRESSED) {
47 src = (void *)event + sizeof(struct perf_record_compressed);
48 src_size = event->pack.header.size - sizeof(struct perf_record_compressed);
49 } else if (event->header.type == PERF_RECORD_COMPRESSED2) {
50 src = (void *)event + sizeof(struct perf_record_compressed2);
51 src_size = event->pack2.data_size;
52 } else {
53 return -1;
54 }
55
56 decomp_size = zstd_decompress_stream(session->active_decomp->zstd_decomp, src, src_size,
57 &(decomp->data[decomp_last_rem]), decomp_len - decomp_last_rem);
58 if (!decomp_size) {
59 munmap(decomp, mmap_len);
60 pr_err("Couldn't decompress data\n");
61 return -1;
62 }
63
64 decomp->size += decomp_size;
65
66 if (session->active_decomp->decomp == NULL)
67 session->active_decomp->decomp = decomp;
68 else
69 session->active_decomp->decomp_last->next = decomp;
70
71 session->active_decomp->decomp_last = decomp;
72
73 pr_debug("decomp (B): %zd to %zd\n", src_size, decomp_size);
74
75 return 0;
76}
77#endif
78
79static int process_event_synth_tracing_data_stub(struct perf_session *session
80 __maybe_unused,
81 union perf_event *event
82 __maybe_unused)
83{
84 dump_printf(": unhandled!\n");
85 return 0;
86}
87
88static int process_event_synth_attr_stub(const struct perf_tool *tool __maybe_unused,
89 union perf_event *event __maybe_unused,
90 struct evlist **pevlist
91 __maybe_unused)
92{
93 dump_printf(": unhandled!\n");
94 return 0;
95}
96
97static int process_event_synth_event_update_stub(const struct perf_tool *tool __maybe_unused,
98 union perf_event *event __maybe_unused,
99 struct evlist **pevlist
100 __maybe_unused)
101{
102 if (dump_trace)
103 perf_event__fprintf_event_update(event, stdout);
104
105 dump_printf(": unhandled!\n");
106 return 0;
107}
108
109int process_event_sample_stub(const struct perf_tool *tool __maybe_unused,
110 union perf_event *event __maybe_unused,
111 struct perf_sample *sample __maybe_unused,
112 struct evsel *evsel __maybe_unused,
113 struct machine *machine __maybe_unused)
114{
115 dump_printf(": unhandled!\n");
116 return 0;
117}
118
119static int process_event_stub(const struct perf_tool *tool __maybe_unused,
120 union perf_event *event __maybe_unused,
121 struct perf_sample *sample __maybe_unused,
122 struct machine *machine __maybe_unused)
123{
124 dump_printf(": unhandled!\n");
125 return 0;
126}
127
128static int process_finished_round_stub(const struct perf_tool *tool __maybe_unused,
129 union perf_event *event __maybe_unused,
130 struct ordered_events *oe __maybe_unused)
131{
132 dump_printf(": unhandled!\n");
133 return 0;
134}
135
136static int skipn(int fd, off_t n)
137{
138 char buf[4096];
139 ssize_t ret;
140
141 while (n > 0) {
142 ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
143 if (ret <= 0)
144 return ret;
145 n -= ret;
146 }
147
148 return 0;
149}
150
151static s64 process_event_auxtrace_stub(struct perf_session *session __maybe_unused,
152 union perf_event *event)
153{
154 dump_printf(": unhandled!\n");
155 if (perf_data__is_pipe(session->data))
156 skipn(perf_data__fd(session->data), event->auxtrace.size);
157 return event->auxtrace.size;
158}
159
160static int process_event_op2_stub(struct perf_session *session __maybe_unused,
161 union perf_event *event __maybe_unused)
162{
163 dump_printf(": unhandled!\n");
164 return 0;
165}
166
167
168static
169int process_event_thread_map_stub(struct perf_session *session __maybe_unused,
170 union perf_event *event __maybe_unused)
171{
172 if (dump_trace)
173 perf_event__fprintf_thread_map(event, stdout);
174
175 dump_printf(": unhandled!\n");
176 return 0;
177}
178
179static
180int process_event_cpu_map_stub(struct perf_session *session __maybe_unused,
181 union perf_event *event __maybe_unused)
182{
183 if (dump_trace)
184 perf_event__fprintf_cpu_map(event, stdout);
185
186 dump_printf(": unhandled!\n");
187 return 0;
188}
189
190static
191int process_event_stat_config_stub(struct perf_session *session __maybe_unused,
192 union perf_event *event __maybe_unused)
193{
194 if (dump_trace)
195 perf_event__fprintf_stat_config(event, stdout);
196
197 dump_printf(": unhandled!\n");
198 return 0;
199}
200
201static int process_stat_stub(struct perf_session *perf_session __maybe_unused,
202 union perf_event *event)
203{
204 if (dump_trace)
205 perf_event__fprintf_stat(event, stdout);
206
207 dump_printf(": unhandled!\n");
208 return 0;
209}
210
211static int process_stat_round_stub(struct perf_session *perf_session __maybe_unused,
212 union perf_event *event)
213{
214 if (dump_trace)
215 perf_event__fprintf_stat_round(event, stdout);
216
217 dump_printf(": unhandled!\n");
218 return 0;
219}
220
221static int process_event_time_conv_stub(struct perf_session *perf_session __maybe_unused,
222 union perf_event *event)
223{
224 if (dump_trace)
225 perf_event__fprintf_time_conv(event, stdout);
226
227 dump_printf(": unhandled!\n");
228 return 0;
229}
230
231static int perf_session__process_compressed_event_stub(struct perf_session *session __maybe_unused,
232 union perf_event *event __maybe_unused,
233 u64 file_offset __maybe_unused,
234 const char *file_path __maybe_unused)
235{
236 dump_printf(": unhandled!\n");
237 return 0;
238}
239
240void perf_tool__init(struct perf_tool *tool, bool ordered_events)
241{
242 tool->ordered_events = ordered_events;
243 tool->ordering_requires_timestamps = false;
244 tool->namespace_events = false;
245 tool->cgroup_events = false;
246 tool->no_warn = false;
247 tool->show_feat_hdr = SHOW_FEAT_NO_HEADER;
248
249 tool->sample = process_event_sample_stub;
250 tool->mmap = process_event_stub;
251 tool->mmap2 = process_event_stub;
252 tool->comm = process_event_stub;
253 tool->namespaces = process_event_stub;
254 tool->cgroup = process_event_stub;
255 tool->fork = process_event_stub;
256 tool->exit = process_event_stub;
257 tool->lost = perf_event__process_lost;
258 tool->lost_samples = perf_event__process_lost_samples;
259 tool->aux = perf_event__process_aux;
260 tool->itrace_start = perf_event__process_itrace_start;
261 tool->context_switch = perf_event__process_switch;
262 tool->ksymbol = perf_event__process_ksymbol;
263 tool->bpf = perf_event__process_bpf;
264 tool->text_poke = perf_event__process_text_poke;
265 tool->aux_output_hw_id = perf_event__process_aux_output_hw_id;
266 tool->read = process_event_sample_stub;
267 tool->throttle = process_event_stub;
268 tool->unthrottle = process_event_stub;
269 tool->attr = process_event_synth_attr_stub;
270 tool->event_update = process_event_synth_event_update_stub;
271 tool->tracing_data = process_event_synth_tracing_data_stub;
272 tool->build_id = process_event_op2_stub;
273
274 if (ordered_events)
275 tool->finished_round = perf_event__process_finished_round;
276 else
277 tool->finished_round = process_finished_round_stub;
278
279 tool->id_index = process_event_op2_stub;
280 tool->auxtrace_info = process_event_op2_stub;
281 tool->auxtrace = process_event_auxtrace_stub;
282 tool->auxtrace_error = process_event_op2_stub;
283 tool->thread_map = process_event_thread_map_stub;
284 tool->cpu_map = process_event_cpu_map_stub;
285 tool->stat_config = process_event_stat_config_stub;
286 tool->stat = process_stat_stub;
287 tool->stat_round = process_stat_round_stub;
288 tool->time_conv = process_event_time_conv_stub;
289 tool->feature = process_event_op2_stub;
290#ifdef HAVE_ZSTD_SUPPORT
291 tool->compressed = perf_session__process_compressed_event;
292#else
293 tool->compressed = perf_session__process_compressed_event_stub;
294#endif
295 tool->finished_init = process_event_op2_stub;
296}
297
298bool perf_tool__compressed_is_stub(const struct perf_tool *tool)
299{
300 return tool->compressed == perf_session__process_compressed_event_stub;
301}