1 // SPDX-License-Identifier: GPL-2.0 2 #include <errno.h> 3 #include <signal.h> 4 #include <inttypes.h> 5 #include <linux/err.h> 6 #include <linux/kernel.h> 7 #include <linux/zalloc.h> 8 #include <api/fs/fs.h> 9 10 #include <byteswap.h> 11 #include <unistd.h> 12 #include <sys/types.h> 13 #include <sys/mman.h> 14 #include <perf/cpumap.h> 15 #include <perf/event.h> 16 17 #include "map_symbol.h" 18 #include "branch.h" 19 #include "debug.h" 20 #include "dwarf-regs.h" 21 #include "env.h" 22 #include "evlist.h" 23 #include "evsel.h" 24 #include "memswap.h" 25 #include "map.h" 26 #include "symbol.h" 27 #include "session.h" 28 #include "tool.h" 29 #include "perf_regs.h" 30 #include "asm/bug.h" 31 #include "auxtrace.h" 32 #include "thread.h" 33 #include "thread-stack.h" 34 #include "sample-raw.h" 35 #include "stat.h" 36 #include "tsc.h" 37 #include "ui/progress.h" 38 #include "util.h" 39 #include "arch/common.h" 40 #include "units.h" 41 #include "annotate.h" 42 #include "perf.h" 43 #include <internal/lib.h> 44 45 static int perf_session__deliver_event(struct perf_session *session, 46 union perf_event *event, 47 const struct perf_tool *tool, 48 u64 file_offset, 49 const char *file_path); 50 51 static int perf_session__open(struct perf_session *session) 52 { 53 struct perf_data *data = session->data; 54 55 if (perf_session__read_header(session) < 0) { 56 pr_err("incompatible file format (rerun with -v to learn more)\n"); 57 return -1; 58 } 59 60 if (perf_header__has_feat(&session->header, HEADER_AUXTRACE)) { 61 /* Auxiliary events may reference exited threads, hold onto dead ones. */ 62 symbol_conf.keep_exited_threads = true; 63 } 64 65 if (perf_data__is_pipe(data)) 66 return 0; 67 68 if (perf_header__has_feat(&session->header, HEADER_STAT)) 69 return 0; 70 71 if (!evlist__valid_sample_type(session->evlist)) { 72 pr_err("non matching sample_type\n"); 73 return -1; 74 } 75 76 if (!evlist__valid_sample_id_all(session->evlist)) { 77 pr_err("non matching sample_id_all\n"); 78 return -1; 79 } 80 81 if (!evlist__valid_read_format(session->evlist)) { 82 pr_err("non matching read_format\n"); 83 return -1; 84 } 85 86 return 0; 87 } 88 89 void perf_session__set_id_hdr_size(struct perf_session *session) 90 { 91 u16 id_hdr_size = evlist__id_hdr_size(session->evlist); 92 93 machines__set_id_hdr_size(&session->machines, id_hdr_size); 94 } 95 96 int perf_session__create_kernel_maps(struct perf_session *session) 97 { 98 int ret = machine__create_kernel_maps(&session->machines.host); 99 100 if (ret >= 0) 101 ret = machines__create_guest_kernel_maps(&session->machines); 102 return ret; 103 } 104 105 static void perf_session__destroy_kernel_maps(struct perf_session *session) 106 { 107 machines__destroy_kernel_maps(&session->machines); 108 } 109 110 static bool perf_session__has_comm_exec(struct perf_session *session) 111 { 112 struct evsel *evsel; 113 114 evlist__for_each_entry(session->evlist, evsel) { 115 if (evsel->core.attr.comm_exec) 116 return true; 117 } 118 119 return false; 120 } 121 122 static void perf_session__set_comm_exec(struct perf_session *session) 123 { 124 bool comm_exec = perf_session__has_comm_exec(session); 125 126 machines__set_comm_exec(&session->machines, comm_exec); 127 } 128 129 static int ordered_events__deliver_event(struct ordered_events *oe, 130 struct ordered_event *event) 131 { 132 struct perf_session *session = container_of(oe, struct perf_session, 133 ordered_events); 134 135 return perf_session__deliver_event(session, event->event, 136 session->tool, event->file_offset, 137 event->file_path); 138 } 139 140 struct perf_session *__perf_session__new(struct perf_data *data, 141 struct perf_tool *tool, 142 bool trace_event_repipe, 143 struct perf_env *host_env) 144 { 145 int ret = -ENOMEM; 146 struct perf_session *session = zalloc(sizeof(*session)); 147 148 if (!session) 149 goto out; 150 151 session->trace_event_repipe = trace_event_repipe; 152 session->tool = tool; 153 session->decomp_data.zstd_decomp = &session->zstd_data; 154 session->active_decomp = &session->decomp_data; 155 INIT_LIST_HEAD(&session->auxtrace_index); 156 machines__init(&session->machines); 157 ordered_events__init(&session->ordered_events, 158 ordered_events__deliver_event, NULL); 159 160 perf_env__init(&session->header.env); 161 if (data) { 162 ret = perf_data__open(data); 163 if (ret < 0) 164 goto out_delete; 165 166 session->data = data; 167 168 if (perf_data__is_read(data)) { 169 ret = perf_session__open(session); 170 if (ret < 0) 171 goto out_delete; 172 173 /* 174 * set session attributes that are present in perf.data 175 * but not in pipe-mode. 176 */ 177 if (!data->is_pipe) { 178 perf_session__set_id_hdr_size(session); 179 perf_session__set_comm_exec(session); 180 } 181 182 evlist__init_trace_event_sample_raw(session->evlist, &session->header.env); 183 184 /* Open the directory data. */ 185 if (data->is_dir) { 186 ret = perf_data__open_dir(data); 187 if (ret) 188 goto out_delete; 189 } 190 191 if (!symbol_conf.kallsyms_name && 192 !symbol_conf.vmlinux_name) 193 symbol_conf.kallsyms_name = perf_data__kallsyms_name(data); 194 } 195 } else { 196 assert(host_env != NULL); 197 session->machines.host.env = host_env; 198 } 199 if (session->evlist) 200 session->evlist->session = session; 201 202 session->machines.host.single_address_space = 203 perf_env__single_address_space(session->machines.host.env); 204 205 if (!data || perf_data__is_write(data)) { 206 /* 207 * In O_RDONLY mode this will be performed when reading the 208 * kernel MMAP event, in perf_event__process_mmap(). 209 */ 210 if (perf_session__create_kernel_maps(session) < 0) 211 pr_warning("Cannot read kernel map\n"); 212 } 213 214 /* 215 * In pipe-mode, evlist is empty until PERF_RECORD_HEADER_ATTR is 216 * processed, so evlist__sample_id_all is not meaningful here. 217 */ 218 if ((!data || !data->is_pipe) && tool && tool->ordering_requires_timestamps && 219 tool->ordered_events && !evlist__sample_id_all(session->evlist)) { 220 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n"); 221 tool->ordered_events = false; 222 } 223 224 return session; 225 226 out_delete: 227 perf_session__delete(session); 228 out: 229 return ERR_PTR(ret); 230 } 231 232 static void perf_decomp__release_events(struct decomp *next) 233 { 234 struct decomp *decomp; 235 size_t mmap_len; 236 237 do { 238 decomp = next; 239 if (decomp == NULL) 240 break; 241 next = decomp->next; 242 mmap_len = decomp->mmap_len; 243 munmap(decomp, mmap_len); 244 } while (1); 245 } 246 247 void perf_session__delete(struct perf_session *session) 248 { 249 if (session == NULL) 250 return; 251 auxtrace__free(session); 252 auxtrace_index__free(&session->auxtrace_index); 253 debuginfo_cache__delete(); 254 perf_session__destroy_kernel_maps(session); 255 perf_decomp__release_events(session->decomp_data.decomp); 256 perf_env__exit(&session->header.env); 257 machines__exit(&session->machines); 258 if (session->data) { 259 if (perf_data__is_read(session->data)) 260 evlist__delete(session->evlist); 261 perf_data__close(session->data); 262 } 263 #ifdef HAVE_LIBTRACEEVENT 264 trace_event__cleanup(&session->tevent); 265 #endif 266 free(session); 267 } 268 269 static void swap_sample_id_all(union perf_event *event, void *data) 270 { 271 void *end = (void *) event + event->header.size; 272 int size = end - data; 273 274 BUG_ON(size % sizeof(u64)); 275 mem_bswap_64(data, size); 276 } 277 278 static void perf_event__all64_swap(union perf_event *event, 279 bool sample_id_all __maybe_unused) 280 { 281 struct perf_event_header *hdr = &event->header; 282 mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr)); 283 } 284 285 static void perf_event__comm_swap(union perf_event *event, bool sample_id_all) 286 { 287 event->comm.pid = bswap_32(event->comm.pid); 288 event->comm.tid = bswap_32(event->comm.tid); 289 290 if (sample_id_all) { 291 void *data = &event->comm.comm; 292 293 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64)); 294 swap_sample_id_all(event, data); 295 } 296 } 297 298 static void perf_event__mmap_swap(union perf_event *event, 299 bool sample_id_all) 300 { 301 event->mmap.pid = bswap_32(event->mmap.pid); 302 event->mmap.tid = bswap_32(event->mmap.tid); 303 event->mmap.start = bswap_64(event->mmap.start); 304 event->mmap.len = bswap_64(event->mmap.len); 305 event->mmap.pgoff = bswap_64(event->mmap.pgoff); 306 307 if (sample_id_all) { 308 void *data = &event->mmap.filename; 309 310 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64)); 311 swap_sample_id_all(event, data); 312 } 313 } 314 315 static void perf_event__mmap2_swap(union perf_event *event, 316 bool sample_id_all) 317 { 318 event->mmap2.pid = bswap_32(event->mmap2.pid); 319 event->mmap2.tid = bswap_32(event->mmap2.tid); 320 event->mmap2.start = bswap_64(event->mmap2.start); 321 event->mmap2.len = bswap_64(event->mmap2.len); 322 event->mmap2.pgoff = bswap_64(event->mmap2.pgoff); 323 324 if (!(event->header.misc & PERF_RECORD_MISC_MMAP_BUILD_ID)) { 325 event->mmap2.maj = bswap_32(event->mmap2.maj); 326 event->mmap2.min = bswap_32(event->mmap2.min); 327 event->mmap2.ino = bswap_64(event->mmap2.ino); 328 event->mmap2.ino_generation = bswap_64(event->mmap2.ino_generation); 329 } 330 331 if (sample_id_all) { 332 void *data = &event->mmap2.filename; 333 334 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64)); 335 swap_sample_id_all(event, data); 336 } 337 } 338 static void perf_event__task_swap(union perf_event *event, bool sample_id_all) 339 { 340 event->fork.pid = bswap_32(event->fork.pid); 341 event->fork.tid = bswap_32(event->fork.tid); 342 event->fork.ppid = bswap_32(event->fork.ppid); 343 event->fork.ptid = bswap_32(event->fork.ptid); 344 event->fork.time = bswap_64(event->fork.time); 345 346 if (sample_id_all) 347 swap_sample_id_all(event, &event->fork + 1); 348 } 349 350 static void perf_event__read_swap(union perf_event *event, bool sample_id_all) 351 { 352 event->read.pid = bswap_32(event->read.pid); 353 event->read.tid = bswap_32(event->read.tid); 354 event->read.value = bswap_64(event->read.value); 355 event->read.time_enabled = bswap_64(event->read.time_enabled); 356 event->read.time_running = bswap_64(event->read.time_running); 357 event->read.id = bswap_64(event->read.id); 358 359 if (sample_id_all) 360 swap_sample_id_all(event, &event->read + 1); 361 } 362 363 static void perf_event__aux_swap(union perf_event *event, bool sample_id_all) 364 { 365 event->aux.aux_offset = bswap_64(event->aux.aux_offset); 366 event->aux.aux_size = bswap_64(event->aux.aux_size); 367 event->aux.flags = bswap_64(event->aux.flags); 368 369 if (sample_id_all) 370 swap_sample_id_all(event, &event->aux + 1); 371 } 372 373 static void perf_event__itrace_start_swap(union perf_event *event, 374 bool sample_id_all) 375 { 376 event->itrace_start.pid = bswap_32(event->itrace_start.pid); 377 event->itrace_start.tid = bswap_32(event->itrace_start.tid); 378 379 if (sample_id_all) 380 swap_sample_id_all(event, &event->itrace_start + 1); 381 } 382 383 static void perf_event__switch_swap(union perf_event *event, bool sample_id_all) 384 { 385 if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) { 386 event->context_switch.next_prev_pid = 387 bswap_32(event->context_switch.next_prev_pid); 388 event->context_switch.next_prev_tid = 389 bswap_32(event->context_switch.next_prev_tid); 390 } 391 392 if (sample_id_all) 393 swap_sample_id_all(event, &event->context_switch + 1); 394 } 395 396 static void perf_event__text_poke_swap(union perf_event *event, bool sample_id_all) 397 { 398 event->text_poke.addr = bswap_64(event->text_poke.addr); 399 event->text_poke.old_len = bswap_16(event->text_poke.old_len); 400 event->text_poke.new_len = bswap_16(event->text_poke.new_len); 401 402 if (sample_id_all) { 403 size_t len = sizeof(event->text_poke.old_len) + 404 sizeof(event->text_poke.new_len) + 405 event->text_poke.old_len + 406 event->text_poke.new_len; 407 void *data = &event->text_poke.old_len; 408 409 data += PERF_ALIGN(len, sizeof(u64)); 410 swap_sample_id_all(event, data); 411 } 412 } 413 414 static void perf_event__throttle_swap(union perf_event *event, 415 bool sample_id_all) 416 { 417 event->throttle.time = bswap_64(event->throttle.time); 418 event->throttle.id = bswap_64(event->throttle.id); 419 event->throttle.stream_id = bswap_64(event->throttle.stream_id); 420 421 if (sample_id_all) 422 swap_sample_id_all(event, &event->throttle + 1); 423 } 424 425 static void perf_event__namespaces_swap(union perf_event *event, 426 bool sample_id_all) 427 { 428 u64 i; 429 430 event->namespaces.pid = bswap_32(event->namespaces.pid); 431 event->namespaces.tid = bswap_32(event->namespaces.tid); 432 event->namespaces.nr_namespaces = bswap_64(event->namespaces.nr_namespaces); 433 434 for (i = 0; i < event->namespaces.nr_namespaces; i++) { 435 struct perf_ns_link_info *ns = &event->namespaces.link_info[i]; 436 437 ns->dev = bswap_64(ns->dev); 438 ns->ino = bswap_64(ns->ino); 439 } 440 441 if (sample_id_all) 442 swap_sample_id_all(event, &event->namespaces.link_info[i]); 443 } 444 445 static void perf_event__cgroup_swap(union perf_event *event, bool sample_id_all) 446 { 447 event->cgroup.id = bswap_64(event->cgroup.id); 448 449 if (sample_id_all) { 450 void *data = &event->cgroup.path; 451 452 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64)); 453 swap_sample_id_all(event, data); 454 } 455 } 456 457 static u8 revbyte(u8 b) 458 { 459 int rev = (b >> 4) | ((b & 0xf) << 4); 460 rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2); 461 rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1); 462 return (u8) rev; 463 } 464 465 /* 466 * XXX this is hack in attempt to carry flags bitfield 467 * through endian village. ABI says: 468 * 469 * Bit-fields are allocated from right to left (least to most significant) 470 * on little-endian implementations and from left to right (most to least 471 * significant) on big-endian implementations. 472 * 473 * The above seems to be byte specific, so we need to reverse each 474 * byte of the bitfield. 'Internet' also says this might be implementation 475 * specific and we probably need proper fix and carry perf_event_attr 476 * bitfield flags in separate data file FEAT_ section. Thought this seems 477 * to work for now. 478 */ 479 static void swap_bitfield(u8 *p, unsigned len) 480 { 481 unsigned i; 482 483 for (i = 0; i < len; i++) { 484 *p = revbyte(*p); 485 p++; 486 } 487 } 488 489 /* exported for swapping attributes in file header */ 490 void perf_event__attr_swap(struct perf_event_attr *attr) 491 { 492 attr->type = bswap_32(attr->type); 493 attr->size = bswap_32(attr->size); 494 495 #define bswap_safe(f, n) \ 496 (attr->size > (offsetof(struct perf_event_attr, f) + \ 497 sizeof(attr->f) * (n))) 498 #define bswap_field(f, sz) \ 499 do { \ 500 if (bswap_safe(f, 0)) \ 501 attr->f = bswap_##sz(attr->f); \ 502 } while(0) 503 #define bswap_field_16(f) bswap_field(f, 16) 504 #define bswap_field_32(f) bswap_field(f, 32) 505 #define bswap_field_64(f) bswap_field(f, 64) 506 507 bswap_field_64(config); 508 bswap_field_64(sample_period); 509 bswap_field_64(sample_type); 510 bswap_field_64(read_format); 511 bswap_field_32(wakeup_events); 512 bswap_field_32(bp_type); 513 bswap_field_64(bp_addr); 514 bswap_field_64(bp_len); 515 bswap_field_64(branch_sample_type); 516 bswap_field_64(sample_regs_user); 517 bswap_field_32(sample_stack_user); 518 bswap_field_32(aux_watermark); 519 bswap_field_16(sample_max_stack); 520 bswap_field_32(aux_sample_size); 521 522 /* 523 * After read_format are bitfields. Check read_format because 524 * we are unable to use offsetof on bitfield. 525 */ 526 if (bswap_safe(read_format, 1)) 527 swap_bitfield((u8 *) (&attr->read_format + 1), 528 sizeof(u64)); 529 #undef bswap_field_64 530 #undef bswap_field_32 531 #undef bswap_field 532 #undef bswap_safe 533 } 534 535 static void perf_event__hdr_attr_swap(union perf_event *event, 536 bool sample_id_all __maybe_unused) 537 { 538 size_t size; 539 540 perf_event__attr_swap(&event->attr.attr); 541 542 size = event->header.size; 543 size -= perf_record_header_attr_id(event) - (void *)event; 544 mem_bswap_64(perf_record_header_attr_id(event), size); 545 } 546 547 static void perf_event__event_update_swap(union perf_event *event, 548 bool sample_id_all __maybe_unused) 549 { 550 event->event_update.type = bswap_64(event->event_update.type); 551 event->event_update.id = bswap_64(event->event_update.id); 552 } 553 554 static void perf_event__event_type_swap(union perf_event *event, 555 bool sample_id_all __maybe_unused) 556 { 557 event->event_type.event_type.event_id = 558 bswap_64(event->event_type.event_type.event_id); 559 } 560 561 static void perf_event__tracing_data_swap(union perf_event *event, 562 bool sample_id_all __maybe_unused) 563 { 564 event->tracing_data.size = bswap_32(event->tracing_data.size); 565 } 566 567 static void perf_event__auxtrace_info_swap(union perf_event *event, 568 bool sample_id_all __maybe_unused) 569 { 570 size_t size; 571 572 event->auxtrace_info.type = bswap_32(event->auxtrace_info.type); 573 574 size = event->header.size; 575 size -= (void *)&event->auxtrace_info.priv - (void *)event; 576 mem_bswap_64(event->auxtrace_info.priv, size); 577 } 578 579 static void perf_event__auxtrace_swap(union perf_event *event, 580 bool sample_id_all __maybe_unused) 581 { 582 event->auxtrace.size = bswap_64(event->auxtrace.size); 583 event->auxtrace.offset = bswap_64(event->auxtrace.offset); 584 event->auxtrace.reference = bswap_64(event->auxtrace.reference); 585 event->auxtrace.idx = bswap_32(event->auxtrace.idx); 586 event->auxtrace.tid = bswap_32(event->auxtrace.tid); 587 event->auxtrace.cpu = bswap_32(event->auxtrace.cpu); 588 } 589 590 static void perf_event__auxtrace_error_swap(union perf_event *event, 591 bool sample_id_all __maybe_unused) 592 { 593 event->auxtrace_error.type = bswap_32(event->auxtrace_error.type); 594 event->auxtrace_error.code = bswap_32(event->auxtrace_error.code); 595 event->auxtrace_error.cpu = bswap_32(event->auxtrace_error.cpu); 596 event->auxtrace_error.pid = bswap_32(event->auxtrace_error.pid); 597 event->auxtrace_error.tid = bswap_32(event->auxtrace_error.tid); 598 event->auxtrace_error.fmt = bswap_32(event->auxtrace_error.fmt); 599 event->auxtrace_error.ip = bswap_64(event->auxtrace_error.ip); 600 if (event->auxtrace_error.fmt) 601 event->auxtrace_error.time = bswap_64(event->auxtrace_error.time); 602 if (event->auxtrace_error.fmt >= 2) { 603 event->auxtrace_error.machine_pid = bswap_32(event->auxtrace_error.machine_pid); 604 event->auxtrace_error.vcpu = bswap_32(event->auxtrace_error.vcpu); 605 } 606 } 607 608 static void perf_event__thread_map_swap(union perf_event *event, 609 bool sample_id_all __maybe_unused) 610 { 611 unsigned i; 612 613 event->thread_map.nr = bswap_64(event->thread_map.nr); 614 615 for (i = 0; i < event->thread_map.nr; i++) 616 event->thread_map.entries[i].pid = bswap_64(event->thread_map.entries[i].pid); 617 } 618 619 static void perf_event__cpu_map_swap(union perf_event *event, 620 bool sample_id_all __maybe_unused) 621 { 622 struct perf_record_cpu_map_data *data = &event->cpu_map.data; 623 624 data->type = bswap_16(data->type); 625 626 switch (data->type) { 627 case PERF_CPU_MAP__CPUS: 628 data->cpus_data.nr = bswap_16(data->cpus_data.nr); 629 630 for (unsigned i = 0; i < data->cpus_data.nr; i++) 631 data->cpus_data.cpu[i] = bswap_16(data->cpus_data.cpu[i]); 632 break; 633 case PERF_CPU_MAP__MASK: 634 data->mask32_data.long_size = bswap_16(data->mask32_data.long_size); 635 636 switch (data->mask32_data.long_size) { 637 case 4: 638 data->mask32_data.nr = bswap_16(data->mask32_data.nr); 639 for (unsigned i = 0; i < data->mask32_data.nr; i++) 640 data->mask32_data.mask[i] = bswap_32(data->mask32_data.mask[i]); 641 break; 642 case 8: 643 data->mask64_data.nr = bswap_16(data->mask64_data.nr); 644 for (unsigned i = 0; i < data->mask64_data.nr; i++) 645 data->mask64_data.mask[i] = bswap_64(data->mask64_data.mask[i]); 646 break; 647 default: 648 pr_err("cpu_map swap: unsupported long size\n"); 649 } 650 break; 651 case PERF_CPU_MAP__RANGE_CPUS: 652 data->range_cpu_data.start_cpu = bswap_16(data->range_cpu_data.start_cpu); 653 data->range_cpu_data.end_cpu = bswap_16(data->range_cpu_data.end_cpu); 654 break; 655 default: 656 break; 657 } 658 } 659 660 static void perf_event__stat_config_swap(union perf_event *event, 661 bool sample_id_all __maybe_unused) 662 { 663 u64 size; 664 665 size = bswap_64(event->stat_config.nr) * sizeof(event->stat_config.data[0]); 666 size += 1; /* nr item itself */ 667 mem_bswap_64(&event->stat_config.nr, size); 668 } 669 670 static void perf_event__stat_swap(union perf_event *event, 671 bool sample_id_all __maybe_unused) 672 { 673 event->stat.id = bswap_64(event->stat.id); 674 event->stat.thread = bswap_32(event->stat.thread); 675 event->stat.cpu = bswap_32(event->stat.cpu); 676 event->stat.val = bswap_64(event->stat.val); 677 event->stat.ena = bswap_64(event->stat.ena); 678 event->stat.run = bswap_64(event->stat.run); 679 } 680 681 static void perf_event__stat_round_swap(union perf_event *event, 682 bool sample_id_all __maybe_unused) 683 { 684 event->stat_round.type = bswap_64(event->stat_round.type); 685 event->stat_round.time = bswap_64(event->stat_round.time); 686 } 687 688 static void perf_event__time_conv_swap(union perf_event *event, 689 bool sample_id_all __maybe_unused) 690 { 691 event->time_conv.time_shift = bswap_64(event->time_conv.time_shift); 692 event->time_conv.time_mult = bswap_64(event->time_conv.time_mult); 693 event->time_conv.time_zero = bswap_64(event->time_conv.time_zero); 694 695 if (event_contains(event->time_conv, time_cycles)) { 696 event->time_conv.time_cycles = bswap_64(event->time_conv.time_cycles); 697 event->time_conv.time_mask = bswap_64(event->time_conv.time_mask); 698 } 699 } 700 701 static void 702 perf_event__schedstat_cpu_swap(union perf_event *event __maybe_unused, 703 bool sample_id_all __maybe_unused) 704 { 705 /* FIXME */ 706 } 707 708 static void 709 perf_event__schedstat_domain_swap(union perf_event *event __maybe_unused, 710 bool sample_id_all __maybe_unused) 711 { 712 /* FIXME */ 713 } 714 715 typedef void (*perf_event__swap_op)(union perf_event *event, 716 bool sample_id_all); 717 718 static perf_event__swap_op perf_event__swap_ops[] = { 719 [PERF_RECORD_MMAP] = perf_event__mmap_swap, 720 [PERF_RECORD_MMAP2] = perf_event__mmap2_swap, 721 [PERF_RECORD_COMM] = perf_event__comm_swap, 722 [PERF_RECORD_FORK] = perf_event__task_swap, 723 [PERF_RECORD_EXIT] = perf_event__task_swap, 724 [PERF_RECORD_LOST] = perf_event__all64_swap, 725 [PERF_RECORD_READ] = perf_event__read_swap, 726 [PERF_RECORD_THROTTLE] = perf_event__throttle_swap, 727 [PERF_RECORD_UNTHROTTLE] = perf_event__throttle_swap, 728 [PERF_RECORD_SAMPLE] = perf_event__all64_swap, 729 [PERF_RECORD_AUX] = perf_event__aux_swap, 730 [PERF_RECORD_ITRACE_START] = perf_event__itrace_start_swap, 731 [PERF_RECORD_LOST_SAMPLES] = perf_event__all64_swap, 732 [PERF_RECORD_SWITCH] = perf_event__switch_swap, 733 [PERF_RECORD_SWITCH_CPU_WIDE] = perf_event__switch_swap, 734 [PERF_RECORD_NAMESPACES] = perf_event__namespaces_swap, 735 [PERF_RECORD_CGROUP] = perf_event__cgroup_swap, 736 [PERF_RECORD_TEXT_POKE] = perf_event__text_poke_swap, 737 [PERF_RECORD_AUX_OUTPUT_HW_ID] = perf_event__all64_swap, 738 [PERF_RECORD_CALLCHAIN_DEFERRED] = perf_event__all64_swap, 739 [PERF_RECORD_HEADER_ATTR] = perf_event__hdr_attr_swap, 740 [PERF_RECORD_HEADER_EVENT_TYPE] = perf_event__event_type_swap, 741 [PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap, 742 [PERF_RECORD_HEADER_BUILD_ID] = NULL, 743 [PERF_RECORD_ID_INDEX] = perf_event__all64_swap, 744 [PERF_RECORD_AUXTRACE_INFO] = perf_event__auxtrace_info_swap, 745 [PERF_RECORD_AUXTRACE] = perf_event__auxtrace_swap, 746 [PERF_RECORD_AUXTRACE_ERROR] = perf_event__auxtrace_error_swap, 747 [PERF_RECORD_THREAD_MAP] = perf_event__thread_map_swap, 748 [PERF_RECORD_CPU_MAP] = perf_event__cpu_map_swap, 749 [PERF_RECORD_STAT_CONFIG] = perf_event__stat_config_swap, 750 [PERF_RECORD_STAT] = perf_event__stat_swap, 751 [PERF_RECORD_STAT_ROUND] = perf_event__stat_round_swap, 752 [PERF_RECORD_EVENT_UPDATE] = perf_event__event_update_swap, 753 [PERF_RECORD_TIME_CONV] = perf_event__time_conv_swap, 754 [PERF_RECORD_SCHEDSTAT_CPU] = perf_event__schedstat_cpu_swap, 755 [PERF_RECORD_SCHEDSTAT_DOMAIN] = perf_event__schedstat_domain_swap, 756 [PERF_RECORD_HEADER_MAX] = NULL, 757 }; 758 759 /* 760 * When perf record finishes a pass on every buffers, it records this pseudo 761 * event. 762 * We record the max timestamp t found in the pass n. 763 * Assuming these timestamps are monotonic across cpus, we know that if 764 * a buffer still has events with timestamps below t, they will be all 765 * available and then read in the pass n + 1. 766 * Hence when we start to read the pass n + 2, we can safely flush every 767 * events with timestamps below t. 768 * 769 * ============ PASS n ================= 770 * CPU 0 | CPU 1 771 * | 772 * cnt1 timestamps | cnt2 timestamps 773 * 1 | 2 774 * 2 | 3 775 * - | 4 <--- max recorded 776 * 777 * ============ PASS n + 1 ============== 778 * CPU 0 | CPU 1 779 * | 780 * cnt1 timestamps | cnt2 timestamps 781 * 3 | 5 782 * 4 | 6 783 * 5 | 7 <---- max recorded 784 * 785 * Flush every events below timestamp 4 786 * 787 * ============ PASS n + 2 ============== 788 * CPU 0 | CPU 1 789 * | 790 * cnt1 timestamps | cnt2 timestamps 791 * 6 | 8 792 * 7 | 9 793 * - | 10 794 * 795 * Flush every events below timestamp 7 796 * etc... 797 */ 798 int perf_event__process_finished_round(const struct perf_tool *tool __maybe_unused, 799 union perf_event *event __maybe_unused, 800 struct ordered_events *oe) 801 { 802 if (dump_trace) 803 fprintf(stdout, "\n"); 804 return ordered_events__flush(oe, OE_FLUSH__ROUND); 805 } 806 807 int perf_session__queue_event(struct perf_session *s, union perf_event *event, 808 u64 timestamp, u64 file_offset, const char *file_path) 809 { 810 return ordered_events__queue(&s->ordered_events, event, timestamp, file_offset, file_path); 811 } 812 813 static void callchain__lbr_callstack_printf(struct perf_sample *sample) 814 { 815 struct ip_callchain *callchain = sample->callchain; 816 struct branch_stack *lbr_stack = sample->branch_stack; 817 struct branch_entry *entries = perf_sample__branch_entries(sample); 818 u64 kernel_callchain_nr = callchain->nr; 819 unsigned int i; 820 821 for (i = 0; i < kernel_callchain_nr; i++) { 822 if (callchain->ips[i] == PERF_CONTEXT_USER) 823 break; 824 } 825 826 if ((i != kernel_callchain_nr) && lbr_stack->nr) { 827 u64 total_nr; 828 /* 829 * LBR callstack can only get user call chain, 830 * i is kernel call chain number, 831 * 1 is PERF_CONTEXT_USER. 832 * 833 * The user call chain is stored in LBR registers. 834 * LBR are pair registers. The caller is stored 835 * in "from" register, while the callee is stored 836 * in "to" register. 837 * For example, there is a call stack 838 * "A"->"B"->"C"->"D". 839 * The LBR registers will be recorded like 840 * "C"->"D", "B"->"C", "A"->"B". 841 * So only the first "to" register and all "from" 842 * registers are needed to construct the whole stack. 843 */ 844 total_nr = i + 1 + lbr_stack->nr + 1; 845 kernel_callchain_nr = i + 1; 846 847 printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr); 848 849 for (i = 0; i < kernel_callchain_nr; i++) 850 printf("..... %2d: %016" PRIx64 "\n", 851 i, callchain->ips[i]); 852 853 printf("..... %2d: %016" PRIx64 "\n", 854 (int)(kernel_callchain_nr), entries[0].to); 855 for (i = 0; i < lbr_stack->nr; i++) 856 printf("..... %2d: %016" PRIx64 "\n", 857 (int)(i + kernel_callchain_nr + 1), entries[i].from); 858 } 859 } 860 861 static const char *callchain_context_str(u64 ip) 862 { 863 switch (ip) { 864 case PERF_CONTEXT_HV: 865 return " (PERF_CONTEXT_HV)"; 866 case PERF_CONTEXT_KERNEL: 867 return " (PERF_CONTEXT_KERNEL)"; 868 case PERF_CONTEXT_USER: 869 return " (PERF_CONTEXT_USER)"; 870 case PERF_CONTEXT_GUEST: 871 return " (PERF_CONTEXT_GUEST)"; 872 case PERF_CONTEXT_GUEST_KERNEL: 873 return " (PERF_CONTEXT_GUEST_KERNEL)"; 874 case PERF_CONTEXT_GUEST_USER: 875 return " (PERF_CONTEXT_GUEST_USER)"; 876 case PERF_CONTEXT_USER_DEFERRED: 877 return " (PERF_CONTEXT_USER_DEFERRED)"; 878 default: 879 return ""; 880 } 881 } 882 883 static void callchain__printf(struct evsel *evsel, 884 struct perf_sample *sample) 885 { 886 unsigned int i; 887 struct ip_callchain *callchain = sample->callchain; 888 889 if (evsel__has_branch_callstack(evsel)) 890 callchain__lbr_callstack_printf(sample); 891 892 printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr); 893 894 for (i = 0; i < callchain->nr; i++) 895 printf("..... %2d: %016" PRIx64 "%s\n", 896 i, callchain->ips[i], 897 callchain_context_str(callchain->ips[i])); 898 899 if (sample->deferred_callchain) 900 printf("...... (deferred)\n"); 901 } 902 903 static void branch_stack__printf(struct perf_sample *sample, 904 struct evsel *evsel) 905 { 906 struct branch_entry *entries = perf_sample__branch_entries(sample); 907 bool callstack = evsel__has_branch_callstack(evsel); 908 u64 *branch_stack_cntr = sample->branch_stack_cntr; 909 uint64_t i; 910 911 if (!callstack) { 912 printf("%s: nr:%" PRIu64 "\n", "... branch stack", sample->branch_stack->nr); 913 } else { 914 /* the reason of adding 1 to nr is because after expanding 915 * branch stack it generates nr + 1 callstack records. e.g., 916 * B()->C() 917 * A()->B() 918 * the final callstack should be: 919 * C() 920 * B() 921 * A() 922 */ 923 printf("%s: nr:%" PRIu64 "\n", "... branch callstack", sample->branch_stack->nr+1); 924 } 925 926 for (i = 0; i < sample->branch_stack->nr; i++) { 927 struct branch_entry *e = &entries[i]; 928 929 if (!callstack) { 930 printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 " %hu cycles %s%s%s%s %x %s %s\n", 931 i, e->from, e->to, 932 (unsigned short)e->flags.cycles, 933 e->flags.mispred ? "M" : " ", 934 e->flags.predicted ? "P" : " ", 935 e->flags.abort ? "A" : " ", 936 e->flags.in_tx ? "T" : " ", 937 (unsigned)e->flags.reserved, 938 get_branch_type(e), 939 e->flags.spec ? branch_spec_desc(e->flags.spec) : ""); 940 } else { 941 if (i == 0) { 942 printf("..... %2"PRIu64": %016" PRIx64 "\n" 943 "..... %2"PRIu64": %016" PRIx64 "\n", 944 i, e->to, i+1, e->from); 945 } else { 946 printf("..... %2"PRIu64": %016" PRIx64 "\n", i+1, e->from); 947 } 948 } 949 } 950 951 if (branch_stack_cntr) { 952 unsigned int br_cntr_width, br_cntr_nr; 953 954 perf_env__find_br_cntr_info(evsel__env(evsel), &br_cntr_nr, &br_cntr_width); 955 printf("... branch stack counters: nr:%" PRIu64 " (counter width: %u max counter nr:%u)\n", 956 sample->branch_stack->nr, br_cntr_width, br_cntr_nr); 957 for (i = 0; i < sample->branch_stack->nr; i++) 958 printf("..... %2"PRIu64": %016" PRIx64 "\n", i, branch_stack_cntr[i]); 959 } 960 } 961 962 static void regs_dump__printf(u64 mask, u64 *regs, uint16_t e_machine, uint32_t e_flags) 963 { 964 unsigned rid, i = 0; 965 966 for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) { 967 u64 val = regs[i++]; 968 969 printf(".... %-5s 0x%016" PRIx64 "\n", 970 perf_reg_name(rid, e_machine, e_flags), val); 971 } 972 } 973 974 static const char *regs_abi[] = { 975 [PERF_SAMPLE_REGS_ABI_NONE] = "none", 976 [PERF_SAMPLE_REGS_ABI_32] = "32-bit", 977 [PERF_SAMPLE_REGS_ABI_64] = "64-bit", 978 }; 979 980 static inline const char *regs_dump_abi(struct regs_dump *d) 981 { 982 if (d->abi > PERF_SAMPLE_REGS_ABI_64) 983 return "unknown"; 984 985 return regs_abi[d->abi]; 986 } 987 988 static void regs__printf(const char *type, struct regs_dump *regs, 989 uint16_t e_machine, uint32_t e_flags) 990 { 991 u64 mask = regs->mask; 992 993 printf("... %s regs: mask 0x%" PRIx64 " ABI %s\n", 994 type, 995 mask, 996 regs_dump_abi(regs)); 997 998 regs_dump__printf(mask, regs->regs, e_machine, e_flags); 999 } 1000 1001 static void regs_user__printf(struct perf_sample *sample, uint16_t e_machine, uint32_t e_flags) 1002 { 1003 struct regs_dump *user_regs; 1004 1005 if (!sample->user_regs) 1006 return; 1007 1008 user_regs = perf_sample__user_regs(sample); 1009 1010 if (user_regs->regs) 1011 regs__printf("user", user_regs, e_machine, e_flags); 1012 } 1013 1014 static void regs_intr__printf(struct perf_sample *sample, uint16_t e_machine, uint32_t e_flags) 1015 { 1016 struct regs_dump *intr_regs; 1017 1018 if (!sample->intr_regs) 1019 return; 1020 1021 intr_regs = perf_sample__intr_regs(sample); 1022 1023 if (intr_regs->regs) 1024 regs__printf("intr", intr_regs, e_machine, e_flags); 1025 } 1026 1027 static void stack_user__printf(struct stack_dump *dump) 1028 { 1029 printf("... ustack: size %" PRIu64 ", offset 0x%x\n", 1030 dump->size, dump->offset); 1031 } 1032 1033 static void evlist__print_tstamp(struct evlist *evlist, union perf_event *event, struct perf_sample *sample) 1034 { 1035 u64 sample_type = __evlist__combined_sample_type(evlist); 1036 1037 if (event->header.type != PERF_RECORD_SAMPLE && 1038 !evlist__sample_id_all(evlist)) { 1039 fputs("-1 -1 ", stdout); 1040 return; 1041 } 1042 1043 if ((sample_type & PERF_SAMPLE_CPU)) 1044 printf("%u ", sample->cpu); 1045 1046 if (sample_type & PERF_SAMPLE_TIME) 1047 printf("%" PRIu64 " ", sample->time); 1048 } 1049 1050 static void sample_read__printf(struct perf_sample *sample, u64 read_format) 1051 { 1052 printf("... sample_read:\n"); 1053 1054 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) 1055 printf("...... time enabled %016" PRIx64 "\n", 1056 sample->read.time_enabled); 1057 1058 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) 1059 printf("...... time running %016" PRIx64 "\n", 1060 sample->read.time_running); 1061 1062 if (read_format & PERF_FORMAT_GROUP) { 1063 struct sample_read_value *value = sample->read.group.values; 1064 1065 printf(".... group nr %" PRIu64 "\n", sample->read.group.nr); 1066 1067 sample_read_group__for_each(value, sample->read.group.nr, read_format) { 1068 printf("..... id %016" PRIx64 1069 ", value %016" PRIx64, 1070 value->id, value->value); 1071 if (read_format & PERF_FORMAT_LOST) 1072 printf(", lost %" PRIu64, value->lost); 1073 printf("\n"); 1074 } 1075 } else { 1076 printf("..... id %016" PRIx64 ", value %016" PRIx64, 1077 sample->read.one.id, sample->read.one.value); 1078 if (read_format & PERF_FORMAT_LOST) 1079 printf(", lost %" PRIu64, sample->read.one.lost); 1080 printf("\n"); 1081 } 1082 } 1083 1084 static void dump_event(struct evlist *evlist, union perf_event *event, 1085 u64 file_offset, struct perf_sample *sample, 1086 const char *file_path) 1087 { 1088 if (!dump_trace) 1089 return; 1090 1091 printf("\n%#" PRIx64 "@%s [%#x]: event: %d\n", 1092 file_offset, file_path, event->header.size, event->header.type); 1093 1094 trace_event(event); 1095 if (event->header.type == PERF_RECORD_SAMPLE && evlist->trace_event_sample_raw) 1096 evlist->trace_event_sample_raw(evlist, event, sample); 1097 1098 if (sample) 1099 evlist__print_tstamp(evlist, event, sample); 1100 1101 printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset, 1102 event->header.size, perf_event__name(event->header.type)); 1103 } 1104 1105 char *get_page_size_name(u64 size, char *str) 1106 { 1107 if (!size || !unit_number__scnprintf(str, PAGE_SIZE_NAME_LEN, size)) 1108 snprintf(str, PAGE_SIZE_NAME_LEN, "%s", "N/A"); 1109 1110 return str; 1111 } 1112 1113 static void dump_sample(struct machine *machine, struct evsel *evsel, union perf_event *event, 1114 struct perf_sample *sample) 1115 { 1116 u64 sample_type; 1117 char str[PAGE_SIZE_NAME_LEN]; 1118 uint16_t e_machine = EM_NONE; 1119 uint32_t e_flags = 0; 1120 1121 if (!dump_trace) 1122 return; 1123 1124 sample_type = evsel->core.attr.sample_type; 1125 1126 if (sample_type & (PERF_SAMPLE_REGS_USER | PERF_SAMPLE_REGS_INTR)) { 1127 struct thread *thread = machine__find_thread(machine, sample->pid, sample->pid); 1128 1129 e_machine = thread__e_machine(thread, machine, &e_flags); 1130 } 1131 1132 printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n", 1133 event->header.misc, sample->pid, sample->tid, sample->ip, 1134 sample->period, sample->addr); 1135 1136 if (evsel__has_callchain(evsel)) 1137 callchain__printf(evsel, sample); 1138 1139 if (evsel__has_br_stack(evsel)) 1140 branch_stack__printf(sample, evsel); 1141 1142 if (sample_type & PERF_SAMPLE_REGS_USER) 1143 regs_user__printf(sample, e_machine, e_flags); 1144 1145 if (sample_type & PERF_SAMPLE_REGS_INTR) 1146 regs_intr__printf(sample, e_machine, e_flags); 1147 1148 if (sample_type & PERF_SAMPLE_STACK_USER) 1149 stack_user__printf(&sample->user_stack); 1150 1151 if (sample_type & PERF_SAMPLE_WEIGHT_TYPE) { 1152 printf("... weight: %" PRIu64 "", sample->weight); 1153 if (sample_type & PERF_SAMPLE_WEIGHT_STRUCT) { 1154 printf(",0x%"PRIx16"", sample->ins_lat); 1155 printf(",0x%"PRIx16"", sample->weight3); 1156 } 1157 printf("\n"); 1158 } 1159 1160 if (sample_type & PERF_SAMPLE_DATA_SRC) 1161 printf(" . data_src: 0x%"PRIx64"\n", sample->data_src); 1162 1163 if (sample_type & PERF_SAMPLE_PHYS_ADDR) 1164 printf(" .. phys_addr: 0x%"PRIx64"\n", sample->phys_addr); 1165 1166 if (sample_type & PERF_SAMPLE_DATA_PAGE_SIZE) 1167 printf(" .. data page size: %s\n", get_page_size_name(sample->data_page_size, str)); 1168 1169 if (sample_type & PERF_SAMPLE_CODE_PAGE_SIZE) 1170 printf(" .. code page size: %s\n", get_page_size_name(sample->code_page_size, str)); 1171 1172 if (sample_type & PERF_SAMPLE_TRANSACTION) 1173 printf("... transaction: %" PRIx64 "\n", sample->transaction); 1174 1175 if (sample_type & PERF_SAMPLE_READ) 1176 sample_read__printf(sample, evsel->core.attr.read_format); 1177 } 1178 1179 static void dump_deferred_callchain(struct evsel *evsel, union perf_event *event, 1180 struct perf_sample *sample) 1181 { 1182 if (!dump_trace) 1183 return; 1184 1185 printf("(IP, 0x%x): %d/%d: %#" PRIx64 "\n", 1186 event->header.misc, sample->pid, sample->tid, sample->deferred_cookie); 1187 1188 if (evsel__has_callchain(evsel)) 1189 callchain__printf(evsel, sample); 1190 } 1191 1192 static void dump_read(struct evsel *evsel, union perf_event *event) 1193 { 1194 struct perf_record_read *read_event = &event->read; 1195 u64 read_format; 1196 1197 if (!dump_trace) 1198 return; 1199 1200 printf(": %d %d %s %" PRI_lu64 "\n", event->read.pid, event->read.tid, 1201 evsel__name(evsel), event->read.value); 1202 1203 if (!evsel) 1204 return; 1205 1206 read_format = evsel->core.attr.read_format; 1207 1208 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) 1209 printf("... time enabled : %" PRI_lu64 "\n", read_event->time_enabled); 1210 1211 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) 1212 printf("... time running : %" PRI_lu64 "\n", read_event->time_running); 1213 1214 if (read_format & PERF_FORMAT_ID) 1215 printf("... id : %" PRI_lu64 "\n", read_event->id); 1216 1217 if (read_format & PERF_FORMAT_LOST) 1218 printf("... lost : %" PRI_lu64 "\n", read_event->lost); 1219 } 1220 1221 static struct machine *machines__find_for_cpumode(struct machines *machines, 1222 union perf_event *event, 1223 struct perf_sample *sample) 1224 { 1225 if (perf_guest && 1226 ((sample->cpumode == PERF_RECORD_MISC_GUEST_KERNEL) || 1227 (sample->cpumode == PERF_RECORD_MISC_GUEST_USER))) { 1228 u32 pid; 1229 1230 if (sample->machine_pid) 1231 pid = sample->machine_pid; 1232 else if (event->header.type == PERF_RECORD_MMAP 1233 || event->header.type == PERF_RECORD_MMAP2) 1234 pid = event->mmap.pid; 1235 else 1236 pid = sample->pid; 1237 1238 /* 1239 * Guest code machine is created as needed and does not use 1240 * DEFAULT_GUEST_KERNEL_ID. 1241 */ 1242 if (symbol_conf.guest_code) 1243 return machines__findnew(machines, pid); 1244 1245 return machines__find_guest(machines, pid); 1246 } 1247 1248 return &machines->host; 1249 } 1250 1251 static int deliver_sample_value(struct evlist *evlist, 1252 const struct perf_tool *tool, 1253 union perf_event *event, 1254 struct perf_sample *sample, 1255 struct sample_read_value *v, 1256 struct machine *machine, 1257 bool per_thread) 1258 { 1259 struct perf_sample_id *sid = evlist__id2sid(evlist, v->id); 1260 struct evsel *evsel; 1261 u64 *storage = NULL; 1262 1263 if (sid) { 1264 storage = perf_sample_id__get_period_storage(sid, sample->tid, per_thread); 1265 } 1266 1267 if (storage) { 1268 sample->id = v->id; 1269 sample->period = v->value - *storage; 1270 *storage = v->value; 1271 } 1272 1273 if (!storage || sid->evsel == NULL) { 1274 ++evlist->stats.nr_unknown_id; 1275 return 0; 1276 } 1277 1278 /* 1279 * There's no reason to deliver sample 1280 * for zero period, bail out. 1281 */ 1282 if (!sample->period) 1283 return 0; 1284 1285 evsel = container_of(sid->evsel, struct evsel, core); 1286 return tool->sample(tool, event, sample, evsel, machine); 1287 } 1288 1289 static int deliver_sample_group(struct evlist *evlist, 1290 const struct perf_tool *tool, 1291 union perf_event *event, 1292 struct perf_sample *sample, 1293 struct machine *machine, 1294 u64 read_format, 1295 bool per_thread) 1296 { 1297 int ret = -EINVAL; 1298 struct sample_read_value *v = sample->read.group.values; 1299 1300 if (tool->dont_split_sample_group) 1301 return deliver_sample_value(evlist, tool, event, sample, v, machine, 1302 per_thread); 1303 1304 sample_read_group__for_each(v, sample->read.group.nr, read_format) { 1305 ret = deliver_sample_value(evlist, tool, event, sample, v, 1306 machine, per_thread); 1307 if (ret) 1308 break; 1309 } 1310 1311 return ret; 1312 } 1313 1314 static int evlist__deliver_sample(struct evlist *evlist, const struct perf_tool *tool, 1315 union perf_event *event, struct perf_sample *sample, 1316 struct evsel *evsel, struct machine *machine) 1317 { 1318 /* We know evsel != NULL. */ 1319 u64 sample_type = evsel->core.attr.sample_type; 1320 u64 read_format = evsel->core.attr.read_format; 1321 bool per_thread = perf_evsel__attr_has_per_thread_sample_period(&evsel->core); 1322 1323 /* Standard sample delivery. */ 1324 if (!(sample_type & PERF_SAMPLE_READ)) 1325 return tool->sample(tool, event, sample, evsel, machine); 1326 1327 /* For PERF_SAMPLE_READ we have either single or group mode. */ 1328 if (read_format & PERF_FORMAT_GROUP) 1329 return deliver_sample_group(evlist, tool, event, sample, 1330 machine, read_format, per_thread); 1331 else 1332 return deliver_sample_value(evlist, tool, event, sample, 1333 &sample->read.one, machine, 1334 per_thread); 1335 } 1336 1337 /* 1338 * Samples with deferred callchains should wait for the next matching 1339 * PERF_RECORD_CALLCHAIN_RECORD entries. Keep the events in a list and 1340 * deliver them once it finds the callchains. 1341 */ 1342 struct deferred_event { 1343 struct list_head list; 1344 union perf_event *event; 1345 }; 1346 1347 /* 1348 * This is called when a deferred callchain record comes up. Find all matching 1349 * samples, merge the callchains and process them. 1350 */ 1351 static int evlist__deliver_deferred_callchain(struct evlist *evlist, 1352 const struct perf_tool *tool, 1353 union perf_event *event, 1354 struct perf_sample *sample, 1355 struct machine *machine) 1356 { 1357 struct deferred_event *de, *tmp; 1358 struct evsel *evsel; 1359 int ret = 0; 1360 1361 if (!tool->merge_deferred_callchains) { 1362 evsel = evlist__id2evsel(evlist, sample->id); 1363 return tool->callchain_deferred(tool, event, sample, 1364 evsel, machine); 1365 } 1366 1367 list_for_each_entry_safe(de, tmp, &evlist->deferred_samples, list) { 1368 struct perf_sample orig_sample; 1369 1370 ret = evlist__parse_sample(evlist, de->event, &orig_sample); 1371 if (ret < 0) { 1372 pr_err("failed to parse original sample\n"); 1373 break; 1374 } 1375 1376 if (sample->tid != orig_sample.tid) 1377 continue; 1378 1379 if (event->callchain_deferred.cookie == orig_sample.deferred_cookie) 1380 sample__merge_deferred_callchain(&orig_sample, sample); 1381 else 1382 orig_sample.deferred_callchain = false; 1383 1384 evsel = evlist__id2evsel(evlist, orig_sample.id); 1385 ret = evlist__deliver_sample(evlist, tool, de->event, 1386 &orig_sample, evsel, machine); 1387 1388 if (orig_sample.deferred_callchain) 1389 free(orig_sample.callchain); 1390 1391 list_del(&de->list); 1392 free(de->event); 1393 free(de); 1394 1395 if (ret) 1396 break; 1397 } 1398 return ret; 1399 } 1400 1401 /* 1402 * This is called at the end of the data processing for the session. Flush the 1403 * remaining samples as there's no hope for matching deferred callchains. 1404 */ 1405 static int session__flush_deferred_samples(struct perf_session *session, 1406 const struct perf_tool *tool) 1407 { 1408 struct evlist *evlist = session->evlist; 1409 struct machine *machine = &session->machines.host; 1410 struct deferred_event *de, *tmp; 1411 struct evsel *evsel; 1412 int ret = 0; 1413 1414 list_for_each_entry_safe(de, tmp, &evlist->deferred_samples, list) { 1415 struct perf_sample sample; 1416 1417 ret = evlist__parse_sample(evlist, de->event, &sample); 1418 if (ret < 0) { 1419 pr_err("failed to parse original sample\n"); 1420 break; 1421 } 1422 1423 evsel = evlist__id2evsel(evlist, sample.id); 1424 ret = evlist__deliver_sample(evlist, tool, de->event, 1425 &sample, evsel, machine); 1426 1427 list_del(&de->list); 1428 free(de->event); 1429 free(de); 1430 1431 if (ret) 1432 break; 1433 } 1434 return ret; 1435 } 1436 1437 static int machines__deliver_event(struct machines *machines, 1438 struct evlist *evlist, 1439 union perf_event *event, 1440 struct perf_sample *sample, 1441 const struct perf_tool *tool, u64 file_offset, 1442 const char *file_path) 1443 { 1444 struct evsel *evsel; 1445 struct machine *machine; 1446 1447 dump_event(evlist, event, file_offset, sample, file_path); 1448 1449 evsel = evlist__id2evsel(evlist, sample->id); 1450 1451 machine = machines__find_for_cpumode(machines, event, sample); 1452 1453 switch (event->header.type) { 1454 case PERF_RECORD_SAMPLE: 1455 if (evsel == NULL) { 1456 ++evlist->stats.nr_unknown_id; 1457 return 0; 1458 } 1459 if (machine == NULL) { 1460 ++evlist->stats.nr_unprocessable_samples; 1461 dump_sample(machine, evsel, event, sample); 1462 return 0; 1463 } 1464 dump_sample(machine, evsel, event, sample); 1465 if (sample->deferred_callchain && tool->merge_deferred_callchains) { 1466 struct deferred_event *de = malloc(sizeof(*de)); 1467 size_t sz = event->header.size; 1468 1469 if (de == NULL) 1470 return -ENOMEM; 1471 1472 de->event = malloc(sz); 1473 if (de->event == NULL) { 1474 free(de); 1475 return -ENOMEM; 1476 } 1477 memcpy(de->event, event, sz); 1478 list_add_tail(&de->list, &evlist->deferred_samples); 1479 return 0; 1480 } 1481 return evlist__deliver_sample(evlist, tool, event, sample, evsel, machine); 1482 case PERF_RECORD_MMAP: 1483 return tool->mmap(tool, event, sample, machine); 1484 case PERF_RECORD_MMAP2: 1485 if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT) 1486 ++evlist->stats.nr_proc_map_timeout; 1487 return tool->mmap2(tool, event, sample, machine); 1488 case PERF_RECORD_COMM: 1489 return tool->comm(tool, event, sample, machine); 1490 case PERF_RECORD_NAMESPACES: 1491 return tool->namespaces(tool, event, sample, machine); 1492 case PERF_RECORD_CGROUP: 1493 return tool->cgroup(tool, event, sample, machine); 1494 case PERF_RECORD_FORK: 1495 return tool->fork(tool, event, sample, machine); 1496 case PERF_RECORD_EXIT: 1497 return tool->exit(tool, event, sample, machine); 1498 case PERF_RECORD_LOST: 1499 if (tool->lost == perf_event__process_lost) 1500 evlist->stats.total_lost += event->lost.lost; 1501 return tool->lost(tool, event, sample, machine); 1502 case PERF_RECORD_LOST_SAMPLES: 1503 if (event->header.misc & PERF_RECORD_MISC_LOST_SAMPLES_BPF) 1504 evlist->stats.total_dropped_samples += event->lost_samples.lost; 1505 else if (tool->lost_samples == perf_event__process_lost_samples) 1506 evlist->stats.total_lost_samples += event->lost_samples.lost; 1507 return tool->lost_samples(tool, event, sample, machine); 1508 case PERF_RECORD_READ: 1509 dump_read(evsel, event); 1510 return tool->read(tool, event, sample, evsel, machine); 1511 case PERF_RECORD_THROTTLE: 1512 return tool->throttle(tool, event, sample, machine); 1513 case PERF_RECORD_UNTHROTTLE: 1514 return tool->unthrottle(tool, event, sample, machine); 1515 case PERF_RECORD_AUX: 1516 if (tool->aux == perf_event__process_aux) { 1517 if (event->aux.flags & PERF_AUX_FLAG_TRUNCATED) 1518 evlist->stats.total_aux_lost += 1; 1519 if (event->aux.flags & PERF_AUX_FLAG_PARTIAL) 1520 evlist->stats.total_aux_partial += 1; 1521 if (event->aux.flags & PERF_AUX_FLAG_COLLISION) 1522 evlist->stats.total_aux_collision += 1; 1523 } 1524 return tool->aux(tool, event, sample, machine); 1525 case PERF_RECORD_ITRACE_START: 1526 return tool->itrace_start(tool, event, sample, machine); 1527 case PERF_RECORD_SWITCH: 1528 case PERF_RECORD_SWITCH_CPU_WIDE: 1529 return tool->context_switch(tool, event, sample, machine); 1530 case PERF_RECORD_KSYMBOL: 1531 return tool->ksymbol(tool, event, sample, machine); 1532 case PERF_RECORD_BPF_EVENT: 1533 return tool->bpf(tool, event, sample, machine); 1534 case PERF_RECORD_TEXT_POKE: 1535 return tool->text_poke(tool, event, sample, machine); 1536 case PERF_RECORD_AUX_OUTPUT_HW_ID: 1537 return tool->aux_output_hw_id(tool, event, sample, machine); 1538 case PERF_RECORD_CALLCHAIN_DEFERRED: 1539 dump_deferred_callchain(evsel, event, sample); 1540 return evlist__deliver_deferred_callchain(evlist, tool, event, 1541 sample, machine); 1542 default: 1543 ++evlist->stats.nr_unknown_events; 1544 return -1; 1545 } 1546 } 1547 1548 static int perf_session__deliver_event(struct perf_session *session, 1549 union perf_event *event, 1550 const struct perf_tool *tool, 1551 u64 file_offset, 1552 const char *file_path) 1553 { 1554 struct perf_sample sample; 1555 int ret; 1556 1557 perf_sample__init(&sample, /*all=*/false); 1558 ret = evlist__parse_sample(session->evlist, event, &sample); 1559 if (ret) { 1560 pr_err("Can't parse sample, err = %d\n", ret); 1561 goto out; 1562 } 1563 1564 ret = auxtrace__process_event(session, event, &sample, tool); 1565 if (ret < 0) 1566 goto out; 1567 if (ret > 0) { 1568 ret = 0; 1569 goto out; 1570 } 1571 1572 ret = machines__deliver_event(&session->machines, session->evlist, 1573 event, &sample, tool, file_offset, file_path); 1574 1575 if (dump_trace && sample.aux_sample.size) 1576 auxtrace__dump_auxtrace_sample(session, &sample); 1577 out: 1578 perf_sample__exit(&sample); 1579 return ret; 1580 } 1581 1582 static s64 perf_session__process_user_event(struct perf_session *session, 1583 union perf_event *event, 1584 u64 file_offset, 1585 const char *file_path) 1586 { 1587 struct ordered_events *oe = &session->ordered_events; 1588 const struct perf_tool *tool = session->tool; 1589 struct perf_sample sample; 1590 int fd = perf_data__fd(session->data); 1591 s64 err; 1592 1593 perf_sample__init(&sample, /*all=*/true); 1594 if ((event->header.type != PERF_RECORD_COMPRESSED && 1595 event->header.type != PERF_RECORD_COMPRESSED2) || 1596 perf_tool__compressed_is_stub(tool)) 1597 dump_event(session->evlist, event, file_offset, &sample, file_path); 1598 1599 /* These events are processed right away */ 1600 switch (event->header.type) { 1601 case PERF_RECORD_HEADER_ATTR: 1602 err = tool->attr(tool, event, &session->evlist); 1603 if (err == 0) { 1604 perf_session__set_id_hdr_size(session); 1605 perf_session__set_comm_exec(session); 1606 } 1607 break; 1608 case PERF_RECORD_EVENT_UPDATE: 1609 err = tool->event_update(tool, event, &session->evlist); 1610 break; 1611 case PERF_RECORD_HEADER_EVENT_TYPE: 1612 /* 1613 * Deprecated, but we need to handle it for sake 1614 * of old data files create in pipe mode. 1615 */ 1616 err = 0; 1617 break; 1618 case PERF_RECORD_HEADER_TRACING_DATA: 1619 /* 1620 * Setup for reading amidst mmap, but only when we 1621 * are in 'file' mode. The 'pipe' fd is in proper 1622 * place already. 1623 */ 1624 if (!perf_data__is_pipe(session->data)) 1625 lseek(fd, file_offset, SEEK_SET); 1626 err = tool->tracing_data(tool, session, event); 1627 break; 1628 case PERF_RECORD_HEADER_BUILD_ID: 1629 err = tool->build_id(tool, session, event); 1630 break; 1631 case PERF_RECORD_FINISHED_ROUND: 1632 err = tool->finished_round(tool, event, oe); 1633 break; 1634 case PERF_RECORD_ID_INDEX: 1635 err = tool->id_index(tool, session, event); 1636 break; 1637 case PERF_RECORD_AUXTRACE_INFO: 1638 err = tool->auxtrace_info(tool, session, event); 1639 break; 1640 case PERF_RECORD_AUXTRACE: 1641 /* 1642 * Setup for reading amidst mmap, but only when we 1643 * are in 'file' mode. The 'pipe' fd is in proper 1644 * place already. 1645 */ 1646 if (!perf_data__is_pipe(session->data)) 1647 lseek(fd, file_offset + event->header.size, SEEK_SET); 1648 err = tool->auxtrace(tool, session, event); 1649 break; 1650 case PERF_RECORD_AUXTRACE_ERROR: 1651 perf_session__auxtrace_error_inc(session, event); 1652 err = tool->auxtrace_error(tool, session, event); 1653 break; 1654 case PERF_RECORD_THREAD_MAP: 1655 err = tool->thread_map(tool, session, event); 1656 break; 1657 case PERF_RECORD_CPU_MAP: 1658 err = tool->cpu_map(tool, session, event); 1659 break; 1660 case PERF_RECORD_STAT_CONFIG: 1661 err = tool->stat_config(tool, session, event); 1662 break; 1663 case PERF_RECORD_STAT: 1664 err = tool->stat(tool, session, event); 1665 break; 1666 case PERF_RECORD_STAT_ROUND: 1667 err = tool->stat_round(tool, session, event); 1668 break; 1669 case PERF_RECORD_TIME_CONV: 1670 session->time_conv = event->time_conv; 1671 err = tool->time_conv(tool, session, event); 1672 break; 1673 case PERF_RECORD_HEADER_FEATURE: 1674 err = tool->feature(tool, session, event); 1675 break; 1676 case PERF_RECORD_COMPRESSED: 1677 case PERF_RECORD_COMPRESSED2: 1678 err = tool->compressed(tool, session, event, file_offset, file_path); 1679 if (err) 1680 dump_event(session->evlist, event, file_offset, &sample, file_path); 1681 break; 1682 case PERF_RECORD_FINISHED_INIT: 1683 err = tool->finished_init(tool, session, event); 1684 break; 1685 case PERF_RECORD_BPF_METADATA: 1686 err = tool->bpf_metadata(tool, session, event); 1687 break; 1688 case PERF_RECORD_SCHEDSTAT_CPU: 1689 err = tool->schedstat_cpu(tool, session, event); 1690 break; 1691 case PERF_RECORD_SCHEDSTAT_DOMAIN: 1692 err = tool->schedstat_domain(tool, session, event); 1693 break; 1694 default: 1695 err = -EINVAL; 1696 break; 1697 } 1698 perf_sample__exit(&sample); 1699 return err; 1700 } 1701 1702 int perf_session__deliver_synth_event(struct perf_session *session, 1703 union perf_event *event, 1704 struct perf_sample *sample) 1705 { 1706 struct evlist *evlist = session->evlist; 1707 const struct perf_tool *tool = session->tool; 1708 1709 events_stats__inc(&evlist->stats, event->header.type); 1710 1711 if (event->header.type >= PERF_RECORD_USER_TYPE_START) 1712 return perf_session__process_user_event(session, event, 0, NULL); 1713 1714 return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0, NULL); 1715 } 1716 1717 int perf_session__deliver_synth_attr_event(struct perf_session *session, 1718 const struct perf_event_attr *attr, 1719 u64 id) 1720 { 1721 union { 1722 struct { 1723 struct perf_record_header_attr attr; 1724 u64 ids[1]; 1725 } attr_id; 1726 union perf_event ev; 1727 } ev = { 1728 .attr_id.attr.header.type = PERF_RECORD_HEADER_ATTR, 1729 .attr_id.attr.header.size = sizeof(ev.attr_id), 1730 .attr_id.ids[0] = id, 1731 }; 1732 1733 if (attr->size != sizeof(ev.attr_id.attr.attr)) { 1734 pr_debug("Unexpected perf_event_attr size\n"); 1735 return -EINVAL; 1736 } 1737 ev.attr_id.attr.attr = *attr; 1738 return perf_session__deliver_synth_event(session, &ev.ev, NULL); 1739 } 1740 1741 static void event_swap(union perf_event *event, bool sample_id_all) 1742 { 1743 perf_event__swap_op swap; 1744 1745 swap = perf_event__swap_ops[event->header.type]; 1746 if (swap) 1747 swap(event, sample_id_all); 1748 } 1749 1750 int perf_session__peek_event(struct perf_session *session, off_t file_offset, 1751 void *buf, size_t buf_sz, 1752 union perf_event **event_ptr, 1753 struct perf_sample *sample) 1754 { 1755 union perf_event *event; 1756 size_t hdr_sz, rest; 1757 int fd; 1758 1759 if (session->one_mmap && !session->header.needs_swap) { 1760 event = file_offset - session->one_mmap_offset + 1761 session->one_mmap_addr; 1762 goto out_parse_sample; 1763 } 1764 1765 if (perf_data__is_pipe(session->data)) 1766 return -1; 1767 1768 fd = perf_data__fd(session->data); 1769 hdr_sz = sizeof(struct perf_event_header); 1770 1771 if (buf_sz < hdr_sz) 1772 return -1; 1773 1774 if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 || 1775 readn(fd, buf, hdr_sz) != (ssize_t)hdr_sz) 1776 return -1; 1777 1778 event = (union perf_event *)buf; 1779 1780 if (session->header.needs_swap) 1781 perf_event_header__bswap(&event->header); 1782 1783 if (event->header.size < hdr_sz || event->header.size > buf_sz) 1784 return -1; 1785 1786 buf += hdr_sz; 1787 rest = event->header.size - hdr_sz; 1788 1789 if (readn(fd, buf, rest) != (ssize_t)rest) 1790 return -1; 1791 1792 if (session->header.needs_swap) 1793 event_swap(event, evlist__sample_id_all(session->evlist)); 1794 1795 out_parse_sample: 1796 1797 if (sample && event->header.type < PERF_RECORD_USER_TYPE_START && 1798 evlist__parse_sample(session->evlist, event, sample)) 1799 return -1; 1800 1801 *event_ptr = event; 1802 1803 return 0; 1804 } 1805 1806 int perf_session__peek_events(struct perf_session *session, u64 offset, 1807 u64 size, peek_events_cb_t cb, void *data) 1808 { 1809 u64 max_offset = offset + size; 1810 char buf[PERF_SAMPLE_MAX_SIZE]; 1811 union perf_event *event; 1812 int err; 1813 1814 do { 1815 err = perf_session__peek_event(session, offset, buf, 1816 PERF_SAMPLE_MAX_SIZE, &event, 1817 NULL); 1818 if (err) 1819 return err; 1820 1821 err = cb(session, event, offset, data); 1822 if (err) 1823 return err; 1824 1825 offset += event->header.size; 1826 if (event->header.type == PERF_RECORD_AUXTRACE) 1827 offset += event->auxtrace.size; 1828 1829 } while (offset < max_offset); 1830 1831 return err; 1832 } 1833 1834 static s64 perf_session__process_event(struct perf_session *session, 1835 union perf_event *event, u64 file_offset, 1836 const char *file_path) 1837 { 1838 struct evlist *evlist = session->evlist; 1839 const struct perf_tool *tool = session->tool; 1840 int ret; 1841 1842 if (session->header.needs_swap) 1843 event_swap(event, evlist__sample_id_all(evlist)); 1844 1845 if (event->header.type >= PERF_RECORD_HEADER_MAX) { 1846 /* perf should not support unaligned event, stop here. */ 1847 if (event->header.size % sizeof(u64)) 1848 return -EINVAL; 1849 1850 /* This perf is outdated and does not support the latest event type. */ 1851 ui__warning("Unsupported header type %u, please consider updating perf.\n", 1852 event->header.type); 1853 /* Skip unsupported event by returning its size. */ 1854 return event->header.size; 1855 } 1856 1857 events_stats__inc(&evlist->stats, event->header.type); 1858 1859 if (event->header.type >= PERF_RECORD_USER_TYPE_START) 1860 return perf_session__process_user_event(session, event, file_offset, file_path); 1861 1862 if (tool->ordered_events) { 1863 u64 timestamp = -1ULL; 1864 1865 ret = evlist__parse_sample_timestamp(evlist, event, ×tamp); 1866 if (ret && ret != -1) 1867 return ret; 1868 1869 ret = perf_session__queue_event(session, event, timestamp, file_offset, file_path); 1870 if (ret != -ETIME) 1871 return ret; 1872 } 1873 1874 return perf_session__deliver_event(session, event, tool, file_offset, file_path); 1875 } 1876 1877 void perf_event_header__bswap(struct perf_event_header *hdr) 1878 { 1879 hdr->type = bswap_32(hdr->type); 1880 hdr->misc = bswap_16(hdr->misc); 1881 hdr->size = bswap_16(hdr->size); 1882 } 1883 1884 struct thread *perf_session__findnew(struct perf_session *session, pid_t pid) 1885 { 1886 return machine__findnew_thread(&session->machines.host, -1, pid); 1887 } 1888 1889 int perf_session__register_idle_thread(struct perf_session *session) 1890 { 1891 struct thread *thread = machine__idle_thread(&session->machines.host); 1892 1893 /* machine__idle_thread() got the thread, so put it */ 1894 thread__put(thread); 1895 return thread ? 0 : -1; 1896 } 1897 1898 static void 1899 perf_session__warn_order(const struct perf_session *session) 1900 { 1901 const struct ordered_events *oe = &session->ordered_events; 1902 struct evsel *evsel; 1903 bool should_warn = true; 1904 1905 evlist__for_each_entry(session->evlist, evsel) { 1906 if (evsel->core.attr.write_backward) 1907 should_warn = false; 1908 } 1909 1910 if (!should_warn) 1911 return; 1912 if (oe->nr_unordered_events != 0) 1913 ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events); 1914 } 1915 1916 static void perf_session__warn_about_errors(const struct perf_session *session) 1917 { 1918 const struct events_stats *stats = &session->evlist->stats; 1919 1920 if (session->tool->lost == perf_event__process_lost && 1921 stats->nr_events[PERF_RECORD_LOST] != 0) { 1922 ui__warning("Processed %d events and lost %d chunks!\n\n" 1923 "Check IO/CPU overload!\n\n", 1924 stats->nr_events[0], 1925 stats->nr_events[PERF_RECORD_LOST]); 1926 } 1927 1928 if (session->tool->lost_samples == perf_event__process_lost_samples) { 1929 double drop_rate; 1930 1931 drop_rate = (double)stats->total_lost_samples / 1932 (double) (stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples); 1933 if (drop_rate > 0.05) { 1934 ui__warning("Processed %" PRIu64 " samples and lost %3.2f%%!\n\n", 1935 stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples, 1936 drop_rate * 100.0); 1937 } 1938 } 1939 1940 if (session->tool->aux == perf_event__process_aux && 1941 stats->total_aux_lost != 0) { 1942 ui__warning("AUX data lost %" PRIu64 " times out of %u!\n\n", 1943 stats->total_aux_lost, 1944 stats->nr_events[PERF_RECORD_AUX]); 1945 } 1946 1947 if (session->tool->aux == perf_event__process_aux && 1948 stats->total_aux_partial != 0) { 1949 bool vmm_exclusive = false; 1950 1951 (void)sysfs__read_bool("module/kvm_intel/parameters/vmm_exclusive", 1952 &vmm_exclusive); 1953 1954 ui__warning("AUX data had gaps in it %" PRIu64 " times out of %u!\n\n" 1955 "Are you running a KVM guest in the background?%s\n\n", 1956 stats->total_aux_partial, 1957 stats->nr_events[PERF_RECORD_AUX], 1958 vmm_exclusive ? 1959 "\nReloading kvm_intel module with vmm_exclusive=0\n" 1960 "will reduce the gaps to only guest's timeslices." : 1961 ""); 1962 } 1963 1964 if (session->tool->aux == perf_event__process_aux && 1965 stats->total_aux_collision != 0) { 1966 ui__warning("AUX data detected collision %" PRIu64 " times out of %u!\n\n", 1967 stats->total_aux_collision, 1968 stats->nr_events[PERF_RECORD_AUX]); 1969 } 1970 1971 if (stats->nr_unknown_events != 0) { 1972 ui__warning("Found %u unknown events!\n\n" 1973 "Is this an older tool processing a perf.data " 1974 "file generated by a more recent tool?\n\n" 1975 "If that is not the case, consider " 1976 "reporting to linux-kernel@vger.kernel.org.\n\n", 1977 stats->nr_unknown_events); 1978 } 1979 1980 if (stats->nr_unknown_id != 0) { 1981 ui__warning("%u samples with id not present in the header\n", 1982 stats->nr_unknown_id); 1983 } 1984 1985 if (stats->nr_invalid_chains != 0) { 1986 ui__warning("Found invalid callchains!\n\n" 1987 "%u out of %u events were discarded for this reason.\n\n" 1988 "Consider reporting to linux-kernel@vger.kernel.org.\n\n", 1989 stats->nr_invalid_chains, 1990 stats->nr_events[PERF_RECORD_SAMPLE]); 1991 } 1992 1993 if (stats->nr_unprocessable_samples != 0) { 1994 ui__warning("%u unprocessable samples recorded.\n" 1995 "Do you have a KVM guest running and not using 'perf kvm'?\n", 1996 stats->nr_unprocessable_samples); 1997 } 1998 1999 perf_session__warn_order(session); 2000 2001 events_stats__auxtrace_error_warn(stats); 2002 2003 if (stats->nr_proc_map_timeout != 0) { 2004 ui__warning("%d map information files for pre-existing threads were\n" 2005 "not processed, if there are samples for addresses they\n" 2006 "will not be resolved, you may find out which are these\n" 2007 "threads by running with -v and redirecting the output\n" 2008 "to a file.\n" 2009 "The time limit to process proc map is too short?\n" 2010 "Increase it by --proc-map-timeout\n", 2011 stats->nr_proc_map_timeout); 2012 } 2013 } 2014 2015 static int perf_session__flush_thread_stack(struct thread *thread, 2016 void *p __maybe_unused) 2017 { 2018 return thread_stack__flush(thread); 2019 } 2020 2021 static int perf_session__flush_thread_stacks(struct perf_session *session) 2022 { 2023 return machines__for_each_thread(&session->machines, 2024 perf_session__flush_thread_stack, 2025 NULL); 2026 } 2027 2028 volatile sig_atomic_t session_done; 2029 2030 static int __perf_session__process_decomp_events(struct perf_session *session); 2031 2032 static int __perf_session__process_pipe_events(struct perf_session *session) 2033 { 2034 struct ordered_events *oe = &session->ordered_events; 2035 const struct perf_tool *tool = session->tool; 2036 struct ui_progress prog; 2037 union perf_event *event; 2038 uint32_t size, cur_size = 0; 2039 void *buf = NULL; 2040 s64 skip = 0; 2041 u64 head; 2042 ssize_t err; 2043 void *p; 2044 bool update_prog = false; 2045 2046 /* 2047 * If it's from a file saving pipe data (by redirection), it would have 2048 * a file name other than "-". Then we can get the total size and show 2049 * the progress. 2050 */ 2051 if (strcmp(session->data->path, "-") && session->data->file.size) { 2052 ui_progress__init_size(&prog, session->data->file.size, 2053 "Processing events..."); 2054 update_prog = true; 2055 } 2056 2057 head = 0; 2058 cur_size = sizeof(union perf_event); 2059 2060 buf = malloc(cur_size); 2061 if (!buf) 2062 return -errno; 2063 ordered_events__set_copy_on_queue(oe, true); 2064 more: 2065 event = buf; 2066 err = perf_data__read(session->data, event, 2067 sizeof(struct perf_event_header)); 2068 if (err <= 0) { 2069 if (err == 0) 2070 goto done; 2071 2072 pr_err("failed to read event header\n"); 2073 goto out_err; 2074 } 2075 2076 if (session->header.needs_swap) 2077 perf_event_header__bswap(&event->header); 2078 2079 size = event->header.size; 2080 if (size < sizeof(struct perf_event_header)) { 2081 pr_err("bad event header size\n"); 2082 goto out_err; 2083 } 2084 2085 if (size > cur_size) { 2086 void *new = realloc(buf, size); 2087 if (!new) { 2088 pr_err("failed to allocate memory to read event\n"); 2089 goto out_err; 2090 } 2091 buf = new; 2092 cur_size = size; 2093 event = buf; 2094 } 2095 p = event; 2096 p += sizeof(struct perf_event_header); 2097 2098 if (size - sizeof(struct perf_event_header)) { 2099 err = perf_data__read(session->data, p, 2100 size - sizeof(struct perf_event_header)); 2101 if (err <= 0) { 2102 if (err == 0) { 2103 pr_err("unexpected end of event stream\n"); 2104 goto done; 2105 } 2106 2107 pr_err("failed to read event data\n"); 2108 goto out_err; 2109 } 2110 } 2111 2112 if ((skip = perf_session__process_event(session, event, head, "pipe")) < 0) { 2113 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n", 2114 head, event->header.size, event->header.type); 2115 err = -EINVAL; 2116 goto out_err; 2117 } 2118 2119 head += size; 2120 2121 if (skip > 0) 2122 head += skip; 2123 2124 err = __perf_session__process_decomp_events(session); 2125 if (err) 2126 goto out_err; 2127 2128 if (update_prog) 2129 ui_progress__update(&prog, size); 2130 2131 if (!session_done()) 2132 goto more; 2133 done: 2134 /* do the final flush for ordered samples */ 2135 err = ordered_events__flush(oe, OE_FLUSH__FINAL); 2136 if (err) 2137 goto out_err; 2138 err = session__flush_deferred_samples(session, tool); 2139 if (err) 2140 goto out_err; 2141 err = auxtrace__flush_events(session, tool); 2142 if (err) 2143 goto out_err; 2144 err = perf_session__flush_thread_stacks(session); 2145 out_err: 2146 free(buf); 2147 if (update_prog) 2148 ui_progress__finish(); 2149 if (!tool->no_warn) 2150 perf_session__warn_about_errors(session); 2151 ordered_events__free(&session->ordered_events); 2152 auxtrace__free_events(session); 2153 return err; 2154 } 2155 2156 static union perf_event * 2157 prefetch_event(char *buf, u64 head, size_t mmap_size, 2158 bool needs_swap, union perf_event *error) 2159 { 2160 union perf_event *event; 2161 u16 event_size; 2162 2163 /* 2164 * Ensure we have enough space remaining to read 2165 * the size of the event in the headers. 2166 */ 2167 if (head + sizeof(event->header) > mmap_size) 2168 return NULL; 2169 2170 event = (union perf_event *)(buf + head); 2171 if (needs_swap) 2172 perf_event_header__bswap(&event->header); 2173 2174 event_size = event->header.size; 2175 if (head + event_size <= mmap_size) 2176 return event; 2177 2178 /* We're not fetching the event so swap back again */ 2179 if (needs_swap) 2180 perf_event_header__bswap(&event->header); 2181 2182 /* Check if the event fits into the next mmapped buf. */ 2183 if (event_size <= mmap_size - head % page_size) { 2184 /* Remap buf and fetch again. */ 2185 return NULL; 2186 } 2187 2188 /* Invalid input. Event size should never exceed mmap_size. */ 2189 pr_debug("%s: head=%#" PRIx64 " event->header.size=%#x, mmap_size=%#zx:" 2190 " fuzzed or compressed perf.data?\n", __func__, head, event_size, mmap_size); 2191 2192 return error; 2193 } 2194 2195 static union perf_event * 2196 fetch_mmaped_event(u64 head, size_t mmap_size, char *buf, bool needs_swap) 2197 { 2198 return prefetch_event(buf, head, mmap_size, needs_swap, ERR_PTR(-EINVAL)); 2199 } 2200 2201 static union perf_event * 2202 fetch_decomp_event(u64 head, size_t mmap_size, char *buf, bool needs_swap) 2203 { 2204 return prefetch_event(buf, head, mmap_size, needs_swap, NULL); 2205 } 2206 2207 static int __perf_session__process_decomp_events(struct perf_session *session) 2208 { 2209 s64 skip; 2210 u64 size; 2211 struct decomp *decomp = session->active_decomp->decomp_last; 2212 2213 if (!decomp) 2214 return 0; 2215 2216 while (decomp->head < decomp->size && !session_done()) { 2217 union perf_event *event = fetch_decomp_event(decomp->head, decomp->size, decomp->data, 2218 session->header.needs_swap); 2219 2220 if (!event) 2221 break; 2222 2223 size = event->header.size; 2224 2225 if (size < sizeof(struct perf_event_header) || 2226 (skip = perf_session__process_event(session, event, decomp->file_pos, 2227 decomp->file_path)) < 0) { 2228 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n", 2229 decomp->file_pos + decomp->head, event->header.size, event->header.type); 2230 return -EINVAL; 2231 } 2232 2233 if (skip) 2234 size += skip; 2235 2236 decomp->head += size; 2237 } 2238 2239 return 0; 2240 } 2241 2242 /* 2243 * On 64bit we can mmap the data file in one go. No need for tiny mmap 2244 * slices. On 32bit we use 32MB. 2245 */ 2246 #if BITS_PER_LONG == 64 2247 #define MMAP_SIZE ULLONG_MAX 2248 #define NUM_MMAPS 1 2249 #else 2250 #define MMAP_SIZE (32 * 1024 * 1024ULL) 2251 #define NUM_MMAPS 128 2252 #endif 2253 2254 struct reader; 2255 2256 typedef s64 (*reader_cb_t)(struct perf_session *session, 2257 union perf_event *event, 2258 u64 file_offset, 2259 const char *file_path); 2260 2261 struct reader { 2262 int fd; 2263 const char *path; 2264 u64 data_size; 2265 u64 data_offset; 2266 reader_cb_t process; 2267 bool in_place_update; 2268 char *mmaps[NUM_MMAPS]; 2269 size_t mmap_size; 2270 int mmap_idx; 2271 char *mmap_cur; 2272 u64 file_pos; 2273 u64 file_offset; 2274 u64 head; 2275 u64 size; 2276 bool done; 2277 struct zstd_data zstd_data; 2278 struct decomp_data decomp_data; 2279 }; 2280 2281 static int 2282 reader__init(struct reader *rd, bool *one_mmap) 2283 { 2284 u64 data_size = rd->data_size; 2285 char **mmaps = rd->mmaps; 2286 2287 rd->head = rd->data_offset; 2288 data_size += rd->data_offset; 2289 2290 rd->mmap_size = MMAP_SIZE; 2291 if (rd->mmap_size > data_size) { 2292 rd->mmap_size = data_size; 2293 if (one_mmap) 2294 *one_mmap = true; 2295 } 2296 2297 memset(mmaps, 0, sizeof(rd->mmaps)); 2298 2299 if (zstd_init(&rd->zstd_data, 0)) 2300 return -1; 2301 rd->decomp_data.zstd_decomp = &rd->zstd_data; 2302 2303 return 0; 2304 } 2305 2306 static void 2307 reader__release_decomp(struct reader *rd) 2308 { 2309 perf_decomp__release_events(rd->decomp_data.decomp); 2310 zstd_fini(&rd->zstd_data); 2311 } 2312 2313 static int 2314 reader__mmap(struct reader *rd, struct perf_session *session) 2315 { 2316 int mmap_prot, mmap_flags; 2317 char *buf, **mmaps = rd->mmaps; 2318 u64 page_offset; 2319 2320 mmap_prot = PROT_READ; 2321 mmap_flags = MAP_SHARED; 2322 2323 if (rd->in_place_update) { 2324 mmap_prot |= PROT_WRITE; 2325 } else if (session->header.needs_swap) { 2326 mmap_prot |= PROT_WRITE; 2327 mmap_flags = MAP_PRIVATE; 2328 } 2329 2330 if (mmaps[rd->mmap_idx]) { 2331 munmap(mmaps[rd->mmap_idx], rd->mmap_size); 2332 mmaps[rd->mmap_idx] = NULL; 2333 } 2334 2335 page_offset = page_size * (rd->head / page_size); 2336 rd->file_offset += page_offset; 2337 rd->head -= page_offset; 2338 2339 buf = mmap(NULL, rd->mmap_size, mmap_prot, mmap_flags, rd->fd, 2340 rd->file_offset); 2341 if (buf == MAP_FAILED) { 2342 pr_err("failed to mmap file\n"); 2343 return -errno; 2344 } 2345 mmaps[rd->mmap_idx] = rd->mmap_cur = buf; 2346 rd->mmap_idx = (rd->mmap_idx + 1) & (ARRAY_SIZE(rd->mmaps) - 1); 2347 rd->file_pos = rd->file_offset + rd->head; 2348 if (session->one_mmap) { 2349 session->one_mmap_addr = buf; 2350 session->one_mmap_offset = rd->file_offset; 2351 } 2352 2353 return 0; 2354 } 2355 2356 enum { 2357 READER_OK, 2358 READER_NODATA, 2359 }; 2360 2361 static int 2362 reader__read_event(struct reader *rd, struct perf_session *session, 2363 struct ui_progress *prog) 2364 { 2365 u64 size; 2366 int err = READER_OK; 2367 union perf_event *event; 2368 s64 skip; 2369 2370 event = fetch_mmaped_event(rd->head, rd->mmap_size, rd->mmap_cur, 2371 session->header.needs_swap); 2372 if (IS_ERR(event)) 2373 return PTR_ERR(event); 2374 2375 if (!event) 2376 return READER_NODATA; 2377 2378 size = event->header.size; 2379 2380 skip = -EINVAL; 2381 2382 if (size < sizeof(struct perf_event_header) || 2383 (skip = rd->process(session, event, rd->file_pos, rd->path)) < 0) { 2384 errno = -skip; 2385 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d [%m]\n", 2386 rd->file_offset + rd->head, event->header.size, 2387 event->header.type); 2388 err = skip; 2389 goto out; 2390 } 2391 2392 if (skip) 2393 size += skip; 2394 2395 rd->size += size; 2396 rd->head += size; 2397 rd->file_pos += size; 2398 2399 err = __perf_session__process_decomp_events(session); 2400 if (err) 2401 goto out; 2402 2403 ui_progress__update(prog, size); 2404 2405 out: 2406 return err; 2407 } 2408 2409 static inline bool 2410 reader__eof(struct reader *rd) 2411 { 2412 return (rd->file_pos >= rd->data_size + rd->data_offset); 2413 } 2414 2415 static int 2416 reader__process_events(struct reader *rd, struct perf_session *session, 2417 struct ui_progress *prog) 2418 { 2419 int err; 2420 2421 err = reader__init(rd, &session->one_mmap); 2422 if (err) 2423 goto out; 2424 2425 session->active_decomp = &rd->decomp_data; 2426 2427 remap: 2428 err = reader__mmap(rd, session); 2429 if (err) 2430 goto out; 2431 2432 more: 2433 err = reader__read_event(rd, session, prog); 2434 if (err < 0) 2435 goto out; 2436 else if (err == READER_NODATA) 2437 goto remap; 2438 2439 if (session_done()) 2440 goto out; 2441 2442 if (!reader__eof(rd)) 2443 goto more; 2444 2445 out: 2446 session->active_decomp = &session->decomp_data; 2447 return err; 2448 } 2449 2450 static s64 process_simple(struct perf_session *session, 2451 union perf_event *event, 2452 u64 file_offset, 2453 const char *file_path) 2454 { 2455 return perf_session__process_event(session, event, file_offset, file_path); 2456 } 2457 2458 static int __perf_session__process_events(struct perf_session *session) 2459 { 2460 struct reader rd = { 2461 .fd = perf_data__fd(session->data), 2462 .path = session->data->file.path, 2463 .data_size = session->header.data_size, 2464 .data_offset = session->header.data_offset, 2465 .process = process_simple, 2466 .in_place_update = session->data->in_place_update, 2467 }; 2468 struct ordered_events *oe = &session->ordered_events; 2469 const struct perf_tool *tool = session->tool; 2470 struct ui_progress prog; 2471 int err; 2472 2473 if (rd.data_size == 0) 2474 return -1; 2475 2476 ui_progress__init_size(&prog, rd.data_size, "Processing events..."); 2477 2478 err = reader__process_events(&rd, session, &prog); 2479 if (err) 2480 goto out_err; 2481 /* do the final flush for ordered samples */ 2482 err = ordered_events__flush(oe, OE_FLUSH__FINAL); 2483 if (err) 2484 goto out_err; 2485 err = auxtrace__flush_events(session, tool); 2486 if (err) 2487 goto out_err; 2488 err = session__flush_deferred_samples(session, tool); 2489 if (err) 2490 goto out_err; 2491 err = perf_session__flush_thread_stacks(session); 2492 out_err: 2493 ui_progress__finish(); 2494 if (!tool->no_warn) 2495 perf_session__warn_about_errors(session); 2496 /* 2497 * We may switching perf.data output, make ordered_events 2498 * reusable. 2499 */ 2500 ordered_events__reinit(&session->ordered_events); 2501 auxtrace__free_events(session); 2502 reader__release_decomp(&rd); 2503 session->one_mmap = false; 2504 return err; 2505 } 2506 2507 /* 2508 * Processing 2 MB of data from each reader in sequence, 2509 * because that's the way the ordered events sorting works 2510 * most efficiently. 2511 */ 2512 #define READER_MAX_SIZE (2 * 1024 * 1024) 2513 2514 /* 2515 * This function reads, merge and process directory data. 2516 * It assumens the version 1 of directory data, where each 2517 * data file holds per-cpu data, already sorted by kernel. 2518 */ 2519 static int __perf_session__process_dir_events(struct perf_session *session) 2520 { 2521 struct perf_data *data = session->data; 2522 const struct perf_tool *tool = session->tool; 2523 int i, ret, readers, nr_readers; 2524 struct ui_progress prog; 2525 u64 total_size = perf_data__size(session->data); 2526 struct reader *rd; 2527 2528 ui_progress__init_size(&prog, total_size, "Processing events..."); 2529 2530 nr_readers = 1; 2531 for (i = 0; i < data->dir.nr; i++) { 2532 if (data->dir.files[i].size) 2533 nr_readers++; 2534 } 2535 2536 rd = zalloc(nr_readers * sizeof(struct reader)); 2537 if (!rd) 2538 return -ENOMEM; 2539 2540 rd[0] = (struct reader) { 2541 .fd = perf_data__fd(session->data), 2542 .path = session->data->file.path, 2543 .data_size = session->header.data_size, 2544 .data_offset = session->header.data_offset, 2545 .process = process_simple, 2546 .in_place_update = session->data->in_place_update, 2547 }; 2548 ret = reader__init(&rd[0], NULL); 2549 if (ret) 2550 goto out_err; 2551 ret = reader__mmap(&rd[0], session); 2552 if (ret) 2553 goto out_err; 2554 readers = 1; 2555 2556 for (i = 0; i < data->dir.nr; i++) { 2557 if (!data->dir.files[i].size) 2558 continue; 2559 rd[readers] = (struct reader) { 2560 .fd = data->dir.files[i].fd, 2561 .path = data->dir.files[i].path, 2562 .data_size = data->dir.files[i].size, 2563 .data_offset = 0, 2564 .process = process_simple, 2565 .in_place_update = session->data->in_place_update, 2566 }; 2567 ret = reader__init(&rd[readers], NULL); 2568 if (ret) 2569 goto out_err; 2570 ret = reader__mmap(&rd[readers], session); 2571 if (ret) 2572 goto out_err; 2573 readers++; 2574 } 2575 2576 i = 0; 2577 while (readers) { 2578 if (session_done()) 2579 break; 2580 2581 if (rd[i].done) { 2582 i = (i + 1) % nr_readers; 2583 continue; 2584 } 2585 if (reader__eof(&rd[i])) { 2586 rd[i].done = true; 2587 readers--; 2588 continue; 2589 } 2590 2591 session->active_decomp = &rd[i].decomp_data; 2592 ret = reader__read_event(&rd[i], session, &prog); 2593 if (ret < 0) { 2594 goto out_err; 2595 } else if (ret == READER_NODATA) { 2596 ret = reader__mmap(&rd[i], session); 2597 if (ret) 2598 goto out_err; 2599 } 2600 2601 if (rd[i].size >= READER_MAX_SIZE) { 2602 rd[i].size = 0; 2603 i = (i + 1) % nr_readers; 2604 } 2605 } 2606 2607 ret = ordered_events__flush(&session->ordered_events, OE_FLUSH__FINAL); 2608 if (ret) 2609 goto out_err; 2610 2611 ret = session__flush_deferred_samples(session, tool); 2612 if (ret) 2613 goto out_err; 2614 2615 ret = perf_session__flush_thread_stacks(session); 2616 out_err: 2617 ui_progress__finish(); 2618 2619 if (!tool->no_warn) 2620 perf_session__warn_about_errors(session); 2621 2622 /* 2623 * We may switching perf.data output, make ordered_events 2624 * reusable. 2625 */ 2626 ordered_events__reinit(&session->ordered_events); 2627 2628 session->one_mmap = false; 2629 2630 session->active_decomp = &session->decomp_data; 2631 for (i = 0; i < nr_readers; i++) 2632 reader__release_decomp(&rd[i]); 2633 zfree(&rd); 2634 2635 return ret; 2636 } 2637 2638 int perf_session__process_events(struct perf_session *session) 2639 { 2640 if (perf_session__register_idle_thread(session) < 0) 2641 return -ENOMEM; 2642 2643 if (perf_data__is_pipe(session->data)) 2644 return __perf_session__process_pipe_events(session); 2645 2646 if (perf_data__is_dir(session->data) && session->data->dir.nr) 2647 return __perf_session__process_dir_events(session); 2648 2649 return __perf_session__process_events(session); 2650 } 2651 2652 bool perf_session__has_traces(struct perf_session *session, const char *msg) 2653 { 2654 struct evsel *evsel; 2655 2656 evlist__for_each_entry(session->evlist, evsel) { 2657 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) 2658 return true; 2659 } 2660 2661 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg); 2662 return false; 2663 } 2664 2665 bool perf_session__has_switch_events(struct perf_session *session) 2666 { 2667 struct evsel *evsel; 2668 2669 evlist__for_each_entry(session->evlist, evsel) { 2670 if (evsel->core.attr.context_switch) 2671 return true; 2672 } 2673 2674 return false; 2675 } 2676 2677 int map__set_kallsyms_ref_reloc_sym(struct map *map, const char *symbol_name, u64 addr) 2678 { 2679 char *bracket, *name; 2680 struct ref_reloc_sym *ref; 2681 struct kmap *kmap; 2682 2683 ref = zalloc(sizeof(struct ref_reloc_sym)); 2684 if (ref == NULL) 2685 return -ENOMEM; 2686 2687 ref->name = name = strdup(symbol_name); 2688 if (ref->name == NULL) { 2689 free(ref); 2690 return -ENOMEM; 2691 } 2692 2693 bracket = strchr(name, ']'); 2694 if (bracket) 2695 *bracket = '\0'; 2696 2697 ref->addr = addr; 2698 2699 kmap = map__kmap(map); 2700 if (kmap) 2701 kmap->ref_reloc_sym = ref; 2702 2703 return 0; 2704 } 2705 2706 size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp) 2707 { 2708 return machines__fprintf_dsos(&session->machines, fp); 2709 } 2710 2711 size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp, 2712 bool (skip)(struct dso *dso, int parm), int parm) 2713 { 2714 return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm); 2715 } 2716 2717 size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp) 2718 { 2719 size_t ret; 2720 const char *msg = ""; 2721 2722 if (perf_header__has_feat(&session->header, HEADER_AUXTRACE)) 2723 msg = " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)"; 2724 2725 ret = fprintf(fp, "\nAggregated stats:%s\n", msg); 2726 2727 ret += events_stats__fprintf(&session->evlist->stats, fp); 2728 return ret; 2729 } 2730 2731 size_t perf_session__fprintf(struct perf_session *session, FILE *fp) 2732 { 2733 size_t ret = machine__fprintf(&session->machines.host, fp); 2734 2735 for (struct rb_node *nd = rb_first_cached(&session->machines.guests); nd; nd = rb_next(nd)) { 2736 struct machine *pos = rb_entry(nd, struct machine, rb_node); 2737 2738 ret += machine__fprintf(pos, fp); 2739 } 2740 return ret; 2741 } 2742 2743 void perf_session__dump_kmaps(struct perf_session *session) 2744 { 2745 int save_verbose = verbose; 2746 2747 fflush(stdout); 2748 fprintf(stderr, "Kernel and module maps:\n"); 2749 verbose = 0; /* Suppress verbose to print a summary only */ 2750 maps__fprintf(machine__kernel_maps(&session->machines.host), stderr); 2751 verbose = save_verbose; 2752 } 2753 2754 struct evsel *perf_session__find_first_evtype(struct perf_session *session, 2755 unsigned int type) 2756 { 2757 struct evsel *pos; 2758 2759 evlist__for_each_entry(session->evlist, pos) { 2760 if (pos->core.attr.type == type) 2761 return pos; 2762 } 2763 return NULL; 2764 } 2765 2766 int perf_session__cpu_bitmap(struct perf_session *session, 2767 const char *cpu_list, unsigned long *cpu_bitmap) 2768 { 2769 int i, err = -1; 2770 struct perf_cpu_map *map; 2771 int nr_cpus = min(perf_session__env(session)->nr_cpus_avail, MAX_NR_CPUS); 2772 struct perf_cpu cpu; 2773 2774 for (i = 0; i < PERF_TYPE_MAX; ++i) { 2775 struct evsel *evsel; 2776 2777 evsel = perf_session__find_first_evtype(session, i); 2778 if (!evsel) 2779 continue; 2780 2781 if (!(evsel->core.attr.sample_type & PERF_SAMPLE_CPU)) { 2782 pr_err("File does not contain CPU events. " 2783 "Remove -C option to proceed.\n"); 2784 return -1; 2785 } 2786 } 2787 2788 map = perf_cpu_map__new(cpu_list); 2789 if (map == NULL) { 2790 pr_err("Invalid cpu_list\n"); 2791 return -1; 2792 } 2793 2794 perf_cpu_map__for_each_cpu(cpu, i, map) { 2795 if (cpu.cpu >= nr_cpus) { 2796 pr_err("Requested CPU %d too large. " 2797 "Consider raising MAX_NR_CPUS\n", cpu.cpu); 2798 goto out_delete_map; 2799 } 2800 2801 __set_bit(cpu.cpu, cpu_bitmap); 2802 } 2803 2804 err = 0; 2805 2806 out_delete_map: 2807 perf_cpu_map__put(map); 2808 return err; 2809 } 2810 2811 void perf_session__fprintf_info(struct perf_session *session, FILE *fp, 2812 bool full) 2813 { 2814 if (session == NULL || fp == NULL) 2815 return; 2816 2817 fprintf(fp, "# ========\n"); 2818 perf_header__fprintf_info(session, fp, full); 2819 fprintf(fp, "# ========\n#\n"); 2820 } 2821 2822 static int perf_session__register_guest(struct perf_session *session, pid_t machine_pid) 2823 { 2824 struct machine *machine = machines__findnew(&session->machines, machine_pid); 2825 struct thread *thread; 2826 2827 if (!machine) 2828 return -ENOMEM; 2829 2830 machine->single_address_space = session->machines.host.single_address_space; 2831 2832 thread = machine__idle_thread(machine); 2833 if (!thread) 2834 return -ENOMEM; 2835 thread__put(thread); 2836 2837 machine->kallsyms_filename = perf_data__guest_kallsyms_name(session->data, machine_pid); 2838 2839 return 0; 2840 } 2841 2842 static int perf_session__set_guest_cpu(struct perf_session *session, pid_t pid, 2843 pid_t tid, int guest_cpu) 2844 { 2845 struct machine *machine = &session->machines.host; 2846 struct thread *thread = machine__findnew_thread(machine, pid, tid); 2847 2848 if (!thread) 2849 return -ENOMEM; 2850 thread__set_guest_cpu(thread, guest_cpu); 2851 thread__put(thread); 2852 2853 return 0; 2854 } 2855 2856 int perf_event__process_id_index(const struct perf_tool *tool __maybe_unused, 2857 struct perf_session *session, 2858 union perf_event *event) 2859 { 2860 struct evlist *evlist = session->evlist; 2861 struct perf_record_id_index *ie = &event->id_index; 2862 size_t sz = ie->header.size - sizeof(*ie); 2863 size_t i, nr, max_nr; 2864 size_t e1_sz = sizeof(struct id_index_entry); 2865 size_t e2_sz = sizeof(struct id_index_entry_2); 2866 size_t etot_sz = e1_sz + e2_sz; 2867 struct id_index_entry_2 *e2; 2868 pid_t last_pid = 0; 2869 2870 max_nr = sz / e1_sz; 2871 nr = ie->nr; 2872 if (nr > max_nr) { 2873 printf("Too big: nr %zu max_nr %zu\n", nr, max_nr); 2874 return -EINVAL; 2875 } 2876 2877 if (sz >= nr * etot_sz) { 2878 max_nr = sz / etot_sz; 2879 if (nr > max_nr) { 2880 printf("Too big2: nr %zu max_nr %zu\n", nr, max_nr); 2881 return -EINVAL; 2882 } 2883 e2 = (void *)ie + sizeof(*ie) + nr * e1_sz; 2884 } else { 2885 e2 = NULL; 2886 } 2887 2888 if (dump_trace) 2889 fprintf(stdout, " nr: %zu\n", nr); 2890 2891 for (i = 0; i < nr; i++, (e2 ? e2++ : 0)) { 2892 struct id_index_entry *e = &ie->entries[i]; 2893 struct perf_sample_id *sid; 2894 int ret; 2895 2896 if (dump_trace) { 2897 fprintf(stdout, " ... id: %"PRI_lu64, e->id); 2898 fprintf(stdout, " idx: %"PRI_lu64, e->idx); 2899 fprintf(stdout, " cpu: %"PRI_ld64, e->cpu); 2900 fprintf(stdout, " tid: %"PRI_ld64, e->tid); 2901 if (e2) { 2902 fprintf(stdout, " machine_pid: %"PRI_ld64, e2->machine_pid); 2903 fprintf(stdout, " vcpu: %"PRI_lu64"\n", e2->vcpu); 2904 } else { 2905 fprintf(stdout, "\n"); 2906 } 2907 } 2908 2909 sid = evlist__id2sid(evlist, e->id); 2910 if (!sid) 2911 return -ENOENT; 2912 2913 sid->idx = e->idx; 2914 sid->cpu.cpu = e->cpu; 2915 sid->tid = e->tid; 2916 2917 if (!e2) 2918 continue; 2919 2920 sid->machine_pid = e2->machine_pid; 2921 sid->vcpu.cpu = e2->vcpu; 2922 2923 if (!sid->machine_pid) 2924 continue; 2925 2926 if (sid->machine_pid != last_pid) { 2927 ret = perf_session__register_guest(session, sid->machine_pid); 2928 if (ret) 2929 return ret; 2930 last_pid = sid->machine_pid; 2931 perf_guest = true; 2932 } 2933 2934 ret = perf_session__set_guest_cpu(session, sid->machine_pid, e->tid, e2->vcpu); 2935 if (ret) 2936 return ret; 2937 } 2938 return 0; 2939 } 2940 2941 int perf_session__dsos_hit_all(struct perf_session *session) 2942 { 2943 struct rb_node *nd; 2944 int err; 2945 2946 err = machine__hit_all_dsos(&session->machines.host); 2947 if (err) 2948 return err; 2949 2950 for (nd = rb_first_cached(&session->machines.guests); nd; 2951 nd = rb_next(nd)) { 2952 struct machine *pos = rb_entry(nd, struct machine, rb_node); 2953 2954 err = machine__hit_all_dsos(pos); 2955 if (err) 2956 return err; 2957 } 2958 2959 return 0; 2960 } 2961 2962 struct perf_env *perf_session__env(struct perf_session *session) 2963 { 2964 return &session->header.env; 2965 } 2966 2967 struct perf_session__e_machine_cb_args { 2968 uint32_t e_flags; 2969 uint16_t e_machine; 2970 }; 2971 2972 static int perf_session__e_machine_cb(struct thread *thread, void *_args) 2973 { 2974 struct perf_session__e_machine_cb_args *args = _args; 2975 2976 args->e_machine = thread__e_machine(thread, /*machine=*/NULL, &args->e_flags); 2977 return args->e_machine != EM_NONE ? 1 : 0; 2978 } 2979 2980 /* 2981 * Note, a machine may have mixed 32-bit and 64-bit processes and so mixed 2982 * e_machines. Use thread__e_machine when this matters. 2983 */ 2984 uint16_t perf_session__e_machine(struct perf_session *session, uint32_t *e_flags) 2985 { 2986 struct perf_session__e_machine_cb_args args = { 2987 .e_machine = EM_NONE, 2988 }; 2989 struct perf_env *env; 2990 2991 if (!session) { 2992 /* Default to assuming a host machine. */ 2993 if (e_flags) 2994 *e_flags = EF_HOST; 2995 2996 return EM_HOST; 2997 } 2998 2999 env = perf_session__env(session); 3000 if (env && env->e_machine != EM_NONE) { 3001 if (e_flags) 3002 *e_flags = env->e_flags; 3003 3004 return env->e_machine; 3005 } 3006 3007 machines__for_each_thread(&session->machines, 3008 perf_session__e_machine_cb, 3009 &args); 3010 3011 if (args.e_machine != EM_NONE) { 3012 if (env) { 3013 env->e_machine = args.e_machine; 3014 env->e_flags = args.e_flags; 3015 } 3016 if (e_flags) 3017 *e_flags = args.e_flags; 3018 3019 return args.e_machine; 3020 } 3021 3022 /* 3023 * Couldn't determine from the perf_env or current set of 3024 * threads. Default to the host. 3025 */ 3026 if (e_flags) 3027 *e_flags = EF_HOST; 3028 3029 return EM_HOST; 3030 } 3031