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 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 79 static 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 88 static 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 97 static 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 109 int 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 119 static 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 128 static 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 136 static 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 151 static 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 160 static 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 168 static 169 int 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 179 static 180 int 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 190 static 191 int 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 201 static 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 211 static 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 221 static 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 231 static 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 240 void 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 298 bool perf_tool__compressed_is_stub(const struct perf_tool *tool) 299 { 300 return tool->compressed == perf_session__process_compressed_event_stub; 301 } 302