]> Git Repo - J-linux.git/blob - tools/perf/util/tool.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / tools / perf / util / tool.c
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
13 static 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         src = (void *)event + sizeof(struct perf_record_compressed);
47         src_size = event->pack.header.size - sizeof(struct perf_record_compressed);
48
49         decomp_size = zstd_decompress_stream(session->active_decomp->zstd_decomp, src, src_size,
50                                 &(decomp->data[decomp_last_rem]), decomp_len - decomp_last_rem);
51         if (!decomp_size) {
52                 munmap(decomp, mmap_len);
53                 pr_err("Couldn't decompress data\n");
54                 return -1;
55         }
56
57         decomp->size += decomp_size;
58
59         if (session->active_decomp->decomp == NULL)
60                 session->active_decomp->decomp = decomp;
61         else
62                 session->active_decomp->decomp_last->next = decomp;
63
64         session->active_decomp->decomp_last = decomp;
65
66         pr_debug("decomp (B): %zd to %zd\n", src_size, decomp_size);
67
68         return 0;
69 }
70 #endif
71
72 static int process_event_synth_tracing_data_stub(struct perf_session *session
73                                                  __maybe_unused,
74                                                  union perf_event *event
75                                                  __maybe_unused)
76 {
77         dump_printf(": unhandled!\n");
78         return 0;
79 }
80
81 static int process_event_synth_attr_stub(const struct perf_tool *tool __maybe_unused,
82                                          union perf_event *event __maybe_unused,
83                                          struct evlist **pevlist
84                                          __maybe_unused)
85 {
86         dump_printf(": unhandled!\n");
87         return 0;
88 }
89
90 static int process_event_synth_event_update_stub(const struct perf_tool *tool __maybe_unused,
91                                                  union perf_event *event __maybe_unused,
92                                                  struct evlist **pevlist
93                                                  __maybe_unused)
94 {
95         if (dump_trace)
96                 perf_event__fprintf_event_update(event, stdout);
97
98         dump_printf(": unhandled!\n");
99         return 0;
100 }
101
102 int process_event_sample_stub(const struct perf_tool *tool __maybe_unused,
103                               union perf_event *event __maybe_unused,
104                               struct perf_sample *sample __maybe_unused,
105                               struct evsel *evsel __maybe_unused,
106                               struct machine *machine __maybe_unused)
107 {
108         dump_printf(": unhandled!\n");
109         return 0;
110 }
111
112 static int process_event_stub(const struct perf_tool *tool __maybe_unused,
113                               union perf_event *event __maybe_unused,
114                               struct perf_sample *sample __maybe_unused,
115                               struct machine *machine __maybe_unused)
116 {
117         dump_printf(": unhandled!\n");
118         return 0;
119 }
120
121 static int process_finished_round_stub(const struct perf_tool *tool __maybe_unused,
122                                        union perf_event *event __maybe_unused,
123                                        struct ordered_events *oe __maybe_unused)
124 {
125         dump_printf(": unhandled!\n");
126         return 0;
127 }
128
129 static int skipn(int fd, off_t n)
130 {
131         char buf[4096];
132         ssize_t ret;
133
134         while (n > 0) {
135                 ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
136                 if (ret <= 0)
137                         return ret;
138                 n -= ret;
139         }
140
141         return 0;
142 }
143
144 static s64 process_event_auxtrace_stub(struct perf_session *session __maybe_unused,
145                                        union perf_event *event)
146 {
147         dump_printf(": unhandled!\n");
148         if (perf_data__is_pipe(session->data))
149                 skipn(perf_data__fd(session->data), event->auxtrace.size);
150         return event->auxtrace.size;
151 }
152
153 static int process_event_op2_stub(struct perf_session *session __maybe_unused,
154                                   union perf_event *event __maybe_unused)
155 {
156         dump_printf(": unhandled!\n");
157         return 0;
158 }
159
160
161 static
162 int process_event_thread_map_stub(struct perf_session *session __maybe_unused,
163                                   union perf_event *event __maybe_unused)
164 {
165         if (dump_trace)
166                 perf_event__fprintf_thread_map(event, stdout);
167
168         dump_printf(": unhandled!\n");
169         return 0;
170 }
171
172 static
173 int process_event_cpu_map_stub(struct perf_session *session __maybe_unused,
174                                union perf_event *event __maybe_unused)
175 {
176         if (dump_trace)
177                 perf_event__fprintf_cpu_map(event, stdout);
178
179         dump_printf(": unhandled!\n");
180         return 0;
181 }
182
183 static
184 int process_event_stat_config_stub(struct perf_session *session __maybe_unused,
185                                    union perf_event *event __maybe_unused)
186 {
187         if (dump_trace)
188                 perf_event__fprintf_stat_config(event, stdout);
189
190         dump_printf(": unhandled!\n");
191         return 0;
192 }
193
194 static int process_stat_stub(struct perf_session *perf_session __maybe_unused,
195                              union perf_event *event)
196 {
197         if (dump_trace)
198                 perf_event__fprintf_stat(event, stdout);
199
200         dump_printf(": unhandled!\n");
201         return 0;
202 }
203
204 static int process_stat_round_stub(struct perf_session *perf_session __maybe_unused,
205                                    union perf_event *event)
206 {
207         if (dump_trace)
208                 perf_event__fprintf_stat_round(event, stdout);
209
210         dump_printf(": unhandled!\n");
211         return 0;
212 }
213
214 static int process_event_time_conv_stub(struct perf_session *perf_session __maybe_unused,
215                                         union perf_event *event)
216 {
217         if (dump_trace)
218                 perf_event__fprintf_time_conv(event, stdout);
219
220         dump_printf(": unhandled!\n");
221         return 0;
222 }
223
224 static int perf_session__process_compressed_event_stub(struct perf_session *session __maybe_unused,
225                                                        union perf_event *event __maybe_unused,
226                                                        u64 file_offset __maybe_unused,
227                                                        const char *file_path __maybe_unused)
228 {
229         dump_printf(": unhandled!\n");
230         return 0;
231 }
232
233 void perf_tool__init(struct perf_tool *tool, bool ordered_events)
234 {
235         tool->ordered_events = ordered_events;
236         tool->ordering_requires_timestamps = false;
237         tool->namespace_events = false;
238         tool->cgroup_events = false;
239         tool->no_warn = false;
240         tool->show_feat_hdr = SHOW_FEAT_NO_HEADER;
241
242         tool->sample = process_event_sample_stub;
243         tool->mmap = process_event_stub;
244         tool->mmap2 = process_event_stub;
245         tool->comm = process_event_stub;
246         tool->namespaces = process_event_stub;
247         tool->cgroup = process_event_stub;
248         tool->fork = process_event_stub;
249         tool->exit = process_event_stub;
250         tool->lost = perf_event__process_lost;
251         tool->lost_samples = perf_event__process_lost_samples;
252         tool->aux = perf_event__process_aux;
253         tool->itrace_start = perf_event__process_itrace_start;
254         tool->context_switch = perf_event__process_switch;
255         tool->ksymbol = perf_event__process_ksymbol;
256         tool->bpf = perf_event__process_bpf;
257         tool->text_poke = perf_event__process_text_poke;
258         tool->aux_output_hw_id = perf_event__process_aux_output_hw_id;
259         tool->read = process_event_sample_stub;
260         tool->throttle = process_event_stub;
261         tool->unthrottle = process_event_stub;
262         tool->attr = process_event_synth_attr_stub;
263         tool->event_update = process_event_synth_event_update_stub;
264         tool->tracing_data = process_event_synth_tracing_data_stub;
265         tool->build_id = process_event_op2_stub;
266
267         if (ordered_events)
268                 tool->finished_round = perf_event__process_finished_round;
269         else
270                 tool->finished_round = process_finished_round_stub;
271
272         tool->id_index = process_event_op2_stub;
273         tool->auxtrace_info = process_event_op2_stub;
274         tool->auxtrace = process_event_auxtrace_stub;
275         tool->auxtrace_error = process_event_op2_stub;
276         tool->thread_map = process_event_thread_map_stub;
277         tool->cpu_map = process_event_cpu_map_stub;
278         tool->stat_config = process_event_stat_config_stub;
279         tool->stat = process_stat_stub;
280         tool->stat_round = process_stat_round_stub;
281         tool->time_conv = process_event_time_conv_stub;
282         tool->feature = process_event_op2_stub;
283 #ifdef HAVE_ZSTD_SUPPORT
284         tool->compressed = perf_session__process_compressed_event;
285 #else
286         tool->compressed = perf_session__process_compressed_event_stub;
287 #endif
288         tool->finished_init = process_event_op2_stub;
289 }
290
291 bool perf_tool__compressed_is_stub(const struct perf_tool *tool)
292 {
293         return tool->compressed == perf_session__process_compressed_event_stub;
294 }
This page took 0.041523 seconds and 4 git commands to generate.