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 16 static 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 83 static 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 91 static 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 99 static 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 110 int 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 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(const struct perf_tool *tool __maybe_unused, 152 struct perf_session *session __maybe_unused, 153 union perf_event *event) 154 { 155 dump_printf(": unhandled!\n"); 156 if (perf_data__is_pipe(session->data)) 157 skipn(perf_data__fd(session->data), event->auxtrace.size); 158 return event->auxtrace.size; 159 } 160 161 static int process_event_op2_stub(const struct perf_tool *tool __maybe_unused, 162 struct perf_session *session __maybe_unused, 163 union perf_event *event __maybe_unused) 164 { 165 dump_printf(": unhandled!\n"); 166 return 0; 167 } 168 169 170 static 171 int process_event_thread_map_stub(const struct perf_tool *tool __maybe_unused, 172 struct perf_session *session __maybe_unused, 173 union perf_event *event __maybe_unused) 174 { 175 if (dump_trace) 176 perf_event__fprintf_thread_map(event, stdout); 177 178 dump_printf(": unhandled!\n"); 179 return 0; 180 } 181 182 static 183 int process_event_cpu_map_stub(const struct perf_tool *tool __maybe_unused, 184 struct perf_session *session __maybe_unused, 185 union perf_event *event __maybe_unused) 186 { 187 if (dump_trace) 188 perf_event__fprintf_cpu_map(event, stdout); 189 190 dump_printf(": unhandled!\n"); 191 return 0; 192 } 193 194 static 195 int process_event_stat_config_stub(const struct perf_tool *tool __maybe_unused, 196 struct perf_session *session __maybe_unused, 197 union perf_event *event __maybe_unused) 198 { 199 if (dump_trace) 200 perf_event__fprintf_stat_config(event, stdout); 201 202 dump_printf(": unhandled!\n"); 203 return 0; 204 } 205 206 static int process_stat_stub(const struct perf_tool *tool __maybe_unused, 207 struct perf_session *perf_session __maybe_unused, 208 union perf_event *event) 209 { 210 if (dump_trace) 211 perf_event__fprintf_stat(event, stdout); 212 213 dump_printf(": unhandled!\n"); 214 return 0; 215 } 216 217 static int process_stat_round_stub(const struct perf_tool *tool __maybe_unused, 218 struct perf_session *perf_session __maybe_unused, 219 union perf_event *event) 220 { 221 if (dump_trace) 222 perf_event__fprintf_stat_round(event, stdout); 223 224 dump_printf(": unhandled!\n"); 225 return 0; 226 } 227 228 static int process_event_time_conv_stub(const struct perf_tool *tool __maybe_unused, 229 struct perf_session *perf_session __maybe_unused, 230 union perf_event *event) 231 { 232 if (dump_trace) 233 perf_event__fprintf_time_conv(event, stdout); 234 235 dump_printf(": unhandled!\n"); 236 return 0; 237 } 238 239 static int perf_session__process_compressed_event_stub(const struct perf_tool *tool __maybe_unused, 240 struct perf_session *session __maybe_unused, 241 union perf_event *event __maybe_unused, 242 u64 file_offset __maybe_unused, 243 const char *file_path __maybe_unused) 244 { 245 dump_printf(": unhandled!\n"); 246 return 0; 247 } 248 249 static int perf_event__process_bpf_metadata_stub(const struct perf_tool *tool __maybe_unused, 250 struct perf_session *perf_session __maybe_unused, 251 union perf_event *event) 252 { 253 if (dump_trace) 254 perf_event__fprintf_bpf_metadata(event, stdout); 255 dump_printf(": unhandled!\n"); 256 return 0; 257 } 258 static int process_schedstat_cpu_stub(const struct perf_tool *tool __maybe_unused, 259 struct perf_session *perf_session __maybe_unused, 260 union perf_event *event) 261 { 262 if (dump_trace) 263 perf_event__fprintf_schedstat_cpu(event, stdout); 264 dump_printf(": unhandled!\n"); 265 return 0; 266 } 267 268 static int process_schedstat_domain_stub(const struct perf_tool *tool __maybe_unused, 269 struct perf_session *perf_session __maybe_unused, 270 union perf_event *event) 271 { 272 if (dump_trace) 273 perf_event__fprintf_schedstat_domain(event, stdout); 274 dump_printf(": unhandled!\n"); 275 return 0; 276 } 277 278 void perf_tool__init(struct perf_tool *tool, bool ordered_events) 279 { 280 tool->ordered_events = ordered_events; 281 tool->ordering_requires_timestamps = false; 282 tool->namespace_events = false; 283 tool->cgroup_events = false; 284 tool->no_warn = false; 285 tool->show_feat_hdr = SHOW_FEAT_NO_HEADER; 286 tool->merge_deferred_callchains = true; 287 tool->dont_split_sample_group = false; 288 289 tool->sample = process_event_sample_stub; 290 tool->mmap = process_event_stub; 291 tool->mmap2 = process_event_stub; 292 tool->comm = process_event_stub; 293 tool->namespaces = process_event_stub; 294 tool->cgroup = process_event_stub; 295 tool->fork = process_event_stub; 296 tool->exit = process_event_stub; 297 tool->lost = perf_event__process_lost; 298 tool->lost_samples = perf_event__process_lost_samples; 299 tool->aux = perf_event__process_aux; 300 tool->itrace_start = perf_event__process_itrace_start; 301 tool->context_switch = perf_event__process_switch; 302 tool->ksymbol = perf_event__process_ksymbol; 303 tool->bpf = perf_event__process_bpf; 304 tool->text_poke = perf_event__process_text_poke; 305 tool->aux_output_hw_id = perf_event__process_aux_output_hw_id; 306 tool->read = process_event_sample_stub; 307 tool->throttle = process_event_stub; 308 tool->unthrottle = process_event_stub; 309 tool->callchain_deferred = process_event_sample_stub; 310 tool->attr = process_event_synth_attr_stub; 311 tool->event_update = process_event_synth_event_update_stub; 312 tool->tracing_data = process_event_synth_tracing_data_stub; 313 tool->build_id = process_event_op2_stub; 314 315 if (ordered_events) 316 tool->finished_round = perf_event__process_finished_round; 317 else 318 tool->finished_round = process_finished_round_stub; 319 320 tool->id_index = process_event_op2_stub; 321 tool->auxtrace_info = process_event_op2_stub; 322 tool->auxtrace = process_event_auxtrace_stub; 323 tool->auxtrace_error = process_event_op2_stub; 324 tool->thread_map = process_event_thread_map_stub; 325 tool->cpu_map = process_event_cpu_map_stub; 326 tool->stat_config = process_event_stat_config_stub; 327 tool->stat = process_stat_stub; 328 tool->stat_round = process_stat_round_stub; 329 tool->time_conv = process_event_time_conv_stub; 330 tool->feature = process_event_op2_stub; 331 #ifdef HAVE_ZSTD_SUPPORT 332 tool->compressed = perf_session__process_compressed_event; 333 #else 334 tool->compressed = perf_session__process_compressed_event_stub; 335 #endif 336 tool->finished_init = process_event_op2_stub; 337 tool->bpf_metadata = perf_event__process_bpf_metadata_stub; 338 tool->schedstat_cpu = process_schedstat_cpu_stub; 339 tool->schedstat_domain = process_schedstat_domain_stub; 340 } 341 342 bool perf_tool__compressed_is_stub(const struct perf_tool *tool) 343 { 344 return tool->compressed == perf_session__process_compressed_event_stub; 345 } 346 347 #define CREATE_DELEGATE_SAMPLE(name) \ 348 static int delegate_ ## name(const struct perf_tool *tool, \ 349 union perf_event *event, \ 350 struct perf_sample *sample, \ 351 struct machine *machine) \ 352 { \ 353 struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \ 354 struct perf_tool *delegate = del_tool->delegate; \ 355 return delegate->name(delegate, event, sample, machine); \ 356 } 357 CREATE_DELEGATE_SAMPLE(read); 358 CREATE_DELEGATE_SAMPLE(sample); 359 CREATE_DELEGATE_SAMPLE(callchain_deferred); 360 361 #define CREATE_DELEGATE_ATTR(name) \ 362 static int delegate_ ## name(const struct perf_tool *tool, \ 363 union perf_event *event, \ 364 struct evlist **pevlist) \ 365 { \ 366 struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \ 367 struct perf_tool *delegate = del_tool->delegate; \ 368 return delegate->name(delegate, event, pevlist); \ 369 } 370 CREATE_DELEGATE_ATTR(attr); 371 CREATE_DELEGATE_ATTR(event_update); 372 373 #define CREATE_DELEGATE_OE(name) \ 374 static int delegate_ ## name(const struct perf_tool *tool, \ 375 union perf_event *event, \ 376 struct ordered_events *oe) \ 377 { \ 378 struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \ 379 struct perf_tool *delegate = del_tool->delegate; \ 380 return delegate->name(delegate, event, oe); \ 381 } 382 CREATE_DELEGATE_OE(finished_round); 383 384 #define CREATE_DELEGATE_OP(name) \ 385 static int delegate_ ## name(const struct perf_tool *tool, \ 386 union perf_event *event, \ 387 struct perf_sample *sample, \ 388 struct machine *machine) \ 389 { \ 390 struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \ 391 struct perf_tool *delegate = del_tool->delegate; \ 392 return delegate->name(delegate, event, sample, machine); \ 393 } 394 CREATE_DELEGATE_OP(aux); 395 CREATE_DELEGATE_OP(aux_output_hw_id); 396 CREATE_DELEGATE_OP(bpf); 397 CREATE_DELEGATE_OP(cgroup); 398 CREATE_DELEGATE_OP(comm); 399 CREATE_DELEGATE_OP(context_switch); 400 CREATE_DELEGATE_OP(exit); 401 CREATE_DELEGATE_OP(fork); 402 CREATE_DELEGATE_OP(itrace_start); 403 CREATE_DELEGATE_OP(ksymbol); 404 CREATE_DELEGATE_OP(lost); 405 CREATE_DELEGATE_OP(lost_samples); 406 CREATE_DELEGATE_OP(mmap); 407 CREATE_DELEGATE_OP(mmap2); 408 CREATE_DELEGATE_OP(namespaces); 409 CREATE_DELEGATE_OP(text_poke); 410 CREATE_DELEGATE_OP(throttle); 411 CREATE_DELEGATE_OP(unthrottle); 412 413 #define CREATE_DELEGATE_OP2(name) \ 414 static int delegate_ ## name(const struct perf_tool *tool, \ 415 struct perf_session *session, \ 416 union perf_event *event) \ 417 { \ 418 struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \ 419 struct perf_tool *delegate = del_tool->delegate; \ 420 return delegate->name(delegate, session, event); \ 421 } 422 CREATE_DELEGATE_OP2(auxtrace_error); 423 CREATE_DELEGATE_OP2(auxtrace_info); 424 CREATE_DELEGATE_OP2(bpf_metadata); 425 CREATE_DELEGATE_OP2(build_id); 426 CREATE_DELEGATE_OP2(cpu_map); 427 CREATE_DELEGATE_OP2(feature); 428 CREATE_DELEGATE_OP2(finished_init); 429 CREATE_DELEGATE_OP2(id_index); 430 CREATE_DELEGATE_OP2(stat); 431 CREATE_DELEGATE_OP2(stat_config); 432 CREATE_DELEGATE_OP2(stat_round); 433 CREATE_DELEGATE_OP2(thread_map); 434 CREATE_DELEGATE_OP2(time_conv); 435 CREATE_DELEGATE_OP2(schedstat_cpu); 436 CREATE_DELEGATE_OP2(schedstat_domain); 437 CREATE_DELEGATE_OP2(tracing_data); 438 439 #define CREATE_DELEGATE_OP3(name) \ 440 static s64 delegate_ ## name(const struct perf_tool *tool, \ 441 struct perf_session *session, \ 442 union perf_event *event) \ 443 { \ 444 struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \ 445 struct perf_tool *delegate = del_tool->delegate; \ 446 return delegate->name(delegate, session, event); \ 447 } 448 CREATE_DELEGATE_OP3(auxtrace); 449 450 #define CREATE_DELEGATE_OP4(name) \ 451 static int delegate_ ## name(const struct perf_tool *tool, \ 452 struct perf_session *session, \ 453 union perf_event *event, \ 454 u64 data, \ 455 const char *str) \ 456 { \ 457 struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool); \ 458 struct perf_tool *delegate = del_tool->delegate; \ 459 return delegate->name(delegate, session, event, data, str); \ 460 } 461 CREATE_DELEGATE_OP4(compressed); 462 463 void delegate_tool__init(struct delegate_tool *tool, struct perf_tool *delegate) 464 { 465 tool->delegate = delegate; 466 467 tool->tool.ordered_events = delegate->ordered_events; 468 tool->tool.ordering_requires_timestamps = delegate->ordering_requires_timestamps; 469 tool->tool.namespace_events = delegate->namespace_events; 470 tool->tool.cgroup_events = delegate->cgroup_events; 471 tool->tool.no_warn = delegate->no_warn; 472 tool->tool.show_feat_hdr = delegate->show_feat_hdr; 473 tool->tool.merge_deferred_callchains = delegate->merge_deferred_callchains; 474 tool->tool.dont_split_sample_group = delegate->dont_split_sample_group; 475 476 tool->tool.sample = delegate_sample; 477 tool->tool.read = delegate_read; 478 479 tool->tool.mmap = delegate_mmap; 480 tool->tool.mmap2 = delegate_mmap2; 481 tool->tool.comm = delegate_comm; 482 tool->tool.namespaces = delegate_namespaces; 483 tool->tool.cgroup = delegate_cgroup; 484 tool->tool.fork = delegate_fork; 485 tool->tool.exit = delegate_exit; 486 tool->tool.lost = delegate_lost; 487 tool->tool.lost_samples = delegate_lost_samples; 488 tool->tool.aux = delegate_aux; 489 tool->tool.itrace_start = delegate_itrace_start; 490 tool->tool.aux_output_hw_id = delegate_aux_output_hw_id; 491 tool->tool.context_switch = delegate_context_switch; 492 tool->tool.throttle = delegate_throttle; 493 tool->tool.unthrottle = delegate_unthrottle; 494 tool->tool.ksymbol = delegate_ksymbol; 495 tool->tool.bpf = delegate_bpf; 496 tool->tool.text_poke = delegate_text_poke; 497 tool->tool.callchain_deferred = delegate_callchain_deferred; 498 499 tool->tool.attr = delegate_attr; 500 tool->tool.event_update = delegate_event_update; 501 502 tool->tool.tracing_data = delegate_tracing_data; 503 504 tool->tool.finished_round = delegate_finished_round; 505 506 tool->tool.build_id = delegate_build_id; 507 tool->tool.id_index = delegate_id_index; 508 tool->tool.auxtrace_info = delegate_auxtrace_info; 509 tool->tool.auxtrace_error = delegate_auxtrace_error; 510 tool->tool.time_conv = delegate_time_conv; 511 tool->tool.thread_map = delegate_thread_map; 512 tool->tool.cpu_map = delegate_cpu_map; 513 tool->tool.stat_config = delegate_stat_config; 514 tool->tool.stat = delegate_stat; 515 tool->tool.stat_round = delegate_stat_round; 516 tool->tool.feature = delegate_feature; 517 tool->tool.finished_init = delegate_finished_init; 518 tool->tool.bpf_metadata = delegate_bpf_metadata; 519 tool->tool.compressed = delegate_compressed; 520 tool->tool.auxtrace = delegate_auxtrace; 521 tool->tool.schedstat_cpu = delegate_schedstat_cpu; 522 tool->tool.schedstat_domain = delegate_schedstat_domain; 523 } 524