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) 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), 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, uint16_t e_machine) 989 { 990 u64 mask = regs->mask; 991 992 printf("... %s regs: mask 0x%" PRIx64 " ABI %s\n", 993 type, 994 mask, 995 regs_dump_abi(regs)); 996 997 regs_dump__printf(mask, regs->regs, e_machine); 998 } 999 1000 static void regs_user__printf(struct perf_sample *sample, uint16_t e_machine) 1001 { 1002 struct regs_dump *user_regs; 1003 1004 if (!sample->user_regs) 1005 return; 1006 1007 user_regs = perf_sample__user_regs(sample); 1008 1009 if (user_regs->regs) 1010 regs__printf("user", user_regs, e_machine); 1011 } 1012 1013 static void regs_intr__printf(struct perf_sample *sample, uint16_t e_machine) 1014 { 1015 struct regs_dump *intr_regs; 1016 1017 if (!sample->intr_regs) 1018 return; 1019 1020 intr_regs = perf_sample__intr_regs(sample); 1021 1022 if (intr_regs->regs) 1023 regs__printf("intr", intr_regs, e_machine); 1024 } 1025 1026 static void stack_user__printf(struct stack_dump *dump) 1027 { 1028 printf("... ustack: size %" PRIu64 ", offset 0x%x\n", 1029 dump->size, dump->offset); 1030 } 1031 1032 static void evlist__print_tstamp(struct evlist *evlist, union perf_event *event, struct perf_sample *sample) 1033 { 1034 u64 sample_type = __evlist__combined_sample_type(evlist); 1035 1036 if (event->header.type != PERF_RECORD_SAMPLE && 1037 !evlist__sample_id_all(evlist)) { 1038 fputs("-1 -1 ", stdout); 1039 return; 1040 } 1041 1042 if ((sample_type & PERF_SAMPLE_CPU)) 1043 printf("%u ", sample->cpu); 1044 1045 if (sample_type & PERF_SAMPLE_TIME) 1046 printf("%" PRIu64 " ", sample->time); 1047 } 1048 1049 static void sample_read__printf(struct perf_sample *sample, u64 read_format) 1050 { 1051 printf("... sample_read:\n"); 1052 1053 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) 1054 printf("...... time enabled %016" PRIx64 "\n", 1055 sample->read.time_enabled); 1056 1057 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) 1058 printf("...... time running %016" PRIx64 "\n", 1059 sample->read.time_running); 1060 1061 if (read_format & PERF_FORMAT_GROUP) { 1062 struct sample_read_value *value = sample->read.group.values; 1063 1064 printf(".... group nr %" PRIu64 "\n", sample->read.group.nr); 1065 1066 sample_read_group__for_each(value, sample->read.group.nr, read_format) { 1067 printf("..... id %016" PRIx64 1068 ", value %016" PRIx64, 1069 value->id, value->value); 1070 if (read_format & PERF_FORMAT_LOST) 1071 printf(", lost %" PRIu64, value->lost); 1072 printf("\n"); 1073 } 1074 } else { 1075 printf("..... id %016" PRIx64 ", value %016" PRIx64, 1076 sample->read.one.id, sample->read.one.value); 1077 if (read_format & PERF_FORMAT_LOST) 1078 printf(", lost %" PRIu64, sample->read.one.lost); 1079 printf("\n"); 1080 } 1081 } 1082 1083 static void dump_event(struct evlist *evlist, union perf_event *event, 1084 u64 file_offset, struct perf_sample *sample, 1085 const char *file_path) 1086 { 1087 if (!dump_trace) 1088 return; 1089 1090 printf("\n%#" PRIx64 "@%s [%#x]: event: %d\n", 1091 file_offset, file_path, event->header.size, event->header.type); 1092 1093 trace_event(event); 1094 if (event->header.type == PERF_RECORD_SAMPLE && evlist->trace_event_sample_raw) 1095 evlist->trace_event_sample_raw(evlist, event, sample); 1096 1097 if (sample) 1098 evlist__print_tstamp(evlist, event, sample); 1099 1100 printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset, 1101 event->header.size, perf_event__name(event->header.type)); 1102 } 1103 1104 char *get_page_size_name(u64 size, char *str) 1105 { 1106 if (!size || !unit_number__scnprintf(str, PAGE_SIZE_NAME_LEN, size)) 1107 snprintf(str, PAGE_SIZE_NAME_LEN, "%s", "N/A"); 1108 1109 return str; 1110 } 1111 1112 static void dump_sample(struct machine *machine, struct evsel *evsel, union perf_event *event, 1113 struct perf_sample *sample) 1114 { 1115 u64 sample_type; 1116 char str[PAGE_SIZE_NAME_LEN]; 1117 uint16_t e_machine = EM_NONE; 1118 1119 if (!dump_trace) 1120 return; 1121 1122 sample_type = evsel->core.attr.sample_type; 1123 1124 if (sample_type & (PERF_SAMPLE_REGS_USER | PERF_SAMPLE_REGS_INTR)) { 1125 struct thread *thread = machine__find_thread(machine, sample->pid, sample->pid); 1126 1127 e_machine = thread__e_machine(thread, machine); 1128 } 1129 1130 printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n", 1131 event->header.misc, sample->pid, sample->tid, sample->ip, 1132 sample->period, sample->addr); 1133 1134 if (evsel__has_callchain(evsel)) 1135 callchain__printf(evsel, sample); 1136 1137 if (evsel__has_br_stack(evsel)) 1138 branch_stack__printf(sample, evsel); 1139 1140 if (sample_type & PERF_SAMPLE_REGS_USER) 1141 regs_user__printf(sample, e_machine); 1142 1143 if (sample_type & PERF_SAMPLE_REGS_INTR) 1144 regs_intr__printf(sample, e_machine); 1145 1146 if (sample_type & PERF_SAMPLE_STACK_USER) 1147 stack_user__printf(&sample->user_stack); 1148 1149 if (sample_type & PERF_SAMPLE_WEIGHT_TYPE) { 1150 printf("... weight: %" PRIu64 "", sample->weight); 1151 if (sample_type & PERF_SAMPLE_WEIGHT_STRUCT) { 1152 printf(",0x%"PRIx16"", sample->ins_lat); 1153 printf(",0x%"PRIx16"", sample->weight3); 1154 } 1155 printf("\n"); 1156 } 1157 1158 if (sample_type & PERF_SAMPLE_DATA_SRC) 1159 printf(" . data_src: 0x%"PRIx64"\n", sample->data_src); 1160 1161 if (sample_type & PERF_SAMPLE_PHYS_ADDR) 1162 printf(" .. phys_addr: 0x%"PRIx64"\n", sample->phys_addr); 1163 1164 if (sample_type & PERF_SAMPLE_DATA_PAGE_SIZE) 1165 printf(" .. data page size: %s\n", get_page_size_name(sample->data_page_size, str)); 1166 1167 if (sample_type & PERF_SAMPLE_CODE_PAGE_SIZE) 1168 printf(" .. code page size: %s\n", get_page_size_name(sample->code_page_size, str)); 1169 1170 if (sample_type & PERF_SAMPLE_TRANSACTION) 1171 printf("... transaction: %" PRIx64 "\n", sample->transaction); 1172 1173 if (sample_type & PERF_SAMPLE_READ) 1174 sample_read__printf(sample, evsel->core.attr.read_format); 1175 } 1176 1177 static void dump_deferred_callchain(struct evsel *evsel, union perf_event *event, 1178 struct perf_sample *sample) 1179 { 1180 if (!dump_trace) 1181 return; 1182 1183 printf("(IP, 0x%x): %d/%d: %#" PRIx64 "\n", 1184 event->header.misc, sample->pid, sample->tid, sample->deferred_cookie); 1185 1186 if (evsel__has_callchain(evsel)) 1187 callchain__printf(evsel, sample); 1188 } 1189 1190 static void dump_read(struct evsel *evsel, union perf_event *event) 1191 { 1192 struct perf_record_read *read_event = &event->read; 1193 u64 read_format; 1194 1195 if (!dump_trace) 1196 return; 1197 1198 printf(": %d %d %s %" PRI_lu64 "\n", event->read.pid, event->read.tid, 1199 evsel__name(evsel), event->read.value); 1200 1201 if (!evsel) 1202 return; 1203 1204 read_format = evsel->core.attr.read_format; 1205 1206 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) 1207 printf("... time enabled : %" PRI_lu64 "\n", read_event->time_enabled); 1208 1209 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) 1210 printf("... time running : %" PRI_lu64 "\n", read_event->time_running); 1211 1212 if (read_format & PERF_FORMAT_ID) 1213 printf("... id : %" PRI_lu64 "\n", read_event->id); 1214 1215 if (read_format & PERF_FORMAT_LOST) 1216 printf("... lost : %" PRI_lu64 "\n", read_event->lost); 1217 } 1218 1219 static struct machine *machines__find_for_cpumode(struct machines *machines, 1220 union perf_event *event, 1221 struct perf_sample *sample) 1222 { 1223 if (perf_guest && 1224 ((sample->cpumode == PERF_RECORD_MISC_GUEST_KERNEL) || 1225 (sample->cpumode == PERF_RECORD_MISC_GUEST_USER))) { 1226 u32 pid; 1227 1228 if (sample->machine_pid) 1229 pid = sample->machine_pid; 1230 else if (event->header.type == PERF_RECORD_MMAP 1231 || event->header.type == PERF_RECORD_MMAP2) 1232 pid = event->mmap.pid; 1233 else 1234 pid = sample->pid; 1235 1236 /* 1237 * Guest code machine is created as needed and does not use 1238 * DEFAULT_GUEST_KERNEL_ID. 1239 */ 1240 if (symbol_conf.guest_code) 1241 return machines__findnew(machines, pid); 1242 1243 return machines__find_guest(machines, pid); 1244 } 1245 1246 return &machines->host; 1247 } 1248 1249 static int deliver_sample_value(struct evlist *evlist, 1250 const struct perf_tool *tool, 1251 union perf_event *event, 1252 struct perf_sample *sample, 1253 struct sample_read_value *v, 1254 struct machine *machine, 1255 bool per_thread) 1256 { 1257 struct perf_sample_id *sid = evlist__id2sid(evlist, v->id); 1258 struct evsel *evsel; 1259 u64 *storage = NULL; 1260 1261 if (sid) { 1262 storage = perf_sample_id__get_period_storage(sid, sample->tid, per_thread); 1263 } 1264 1265 if (storage) { 1266 sample->id = v->id; 1267 sample->period = v->value - *storage; 1268 *storage = v->value; 1269 } 1270 1271 if (!storage || sid->evsel == NULL) { 1272 ++evlist->stats.nr_unknown_id; 1273 return 0; 1274 } 1275 1276 /* 1277 * There's no reason to deliver sample 1278 * for zero period, bail out. 1279 */ 1280 if (!sample->period) 1281 return 0; 1282 1283 evsel = container_of(sid->evsel, struct evsel, core); 1284 return tool->sample(tool, event, sample, evsel, machine); 1285 } 1286 1287 static int deliver_sample_group(struct evlist *evlist, 1288 const struct perf_tool *tool, 1289 union perf_event *event, 1290 struct perf_sample *sample, 1291 struct machine *machine, 1292 u64 read_format, 1293 bool per_thread) 1294 { 1295 int ret = -EINVAL; 1296 struct sample_read_value *v = sample->read.group.values; 1297 1298 if (tool->dont_split_sample_group) 1299 return deliver_sample_value(evlist, tool, event, sample, v, machine, 1300 per_thread); 1301 1302 sample_read_group__for_each(v, sample->read.group.nr, read_format) { 1303 ret = deliver_sample_value(evlist, tool, event, sample, v, 1304 machine, per_thread); 1305 if (ret) 1306 break; 1307 } 1308 1309 return ret; 1310 } 1311 1312 static int evlist__deliver_sample(struct evlist *evlist, const struct perf_tool *tool, 1313 union perf_event *event, struct perf_sample *sample, 1314 struct evsel *evsel, struct machine *machine) 1315 { 1316 /* We know evsel != NULL. */ 1317 u64 sample_type = evsel->core.attr.sample_type; 1318 u64 read_format = evsel->core.attr.read_format; 1319 bool per_thread = perf_evsel__attr_has_per_thread_sample_period(&evsel->core); 1320 1321 /* Standard sample delivery. */ 1322 if (!(sample_type & PERF_SAMPLE_READ)) 1323 return tool->sample(tool, event, sample, evsel, machine); 1324 1325 /* For PERF_SAMPLE_READ we have either single or group mode. */ 1326 if (read_format & PERF_FORMAT_GROUP) 1327 return deliver_sample_group(evlist, tool, event, sample, 1328 machine, read_format, per_thread); 1329 else 1330 return deliver_sample_value(evlist, tool, event, sample, 1331 &sample->read.one, machine, 1332 per_thread); 1333 } 1334 1335 /* 1336 * Samples with deferred callchains should wait for the next matching 1337 * PERF_RECORD_CALLCHAIN_RECORD entries. Keep the events in a list and 1338 * deliver them once it finds the callchains. 1339 */ 1340 struct deferred_event { 1341 struct list_head list; 1342 union perf_event *event; 1343 }; 1344 1345 /* 1346 * This is called when a deferred callchain record comes up. Find all matching 1347 * samples, merge the callchains and process them. 1348 */ 1349 static int evlist__deliver_deferred_callchain(struct evlist *evlist, 1350 const struct perf_tool *tool, 1351 union perf_event *event, 1352 struct perf_sample *sample, 1353 struct machine *machine) 1354 { 1355 struct deferred_event *de, *tmp; 1356 struct evsel *evsel; 1357 int ret = 0; 1358 1359 if (!tool->merge_deferred_callchains) { 1360 evsel = evlist__id2evsel(evlist, sample->id); 1361 return tool->callchain_deferred(tool, event, sample, 1362 evsel, machine); 1363 } 1364 1365 list_for_each_entry_safe(de, tmp, &evlist->deferred_samples, list) { 1366 struct perf_sample orig_sample; 1367 1368 ret = evlist__parse_sample(evlist, de->event, &orig_sample); 1369 if (ret < 0) { 1370 pr_err("failed to parse original sample\n"); 1371 break; 1372 } 1373 1374 if (sample->tid != orig_sample.tid) 1375 continue; 1376 1377 if (event->callchain_deferred.cookie == orig_sample.deferred_cookie) 1378 sample__merge_deferred_callchain(&orig_sample, sample); 1379 else 1380 orig_sample.deferred_callchain = false; 1381 1382 evsel = evlist__id2evsel(evlist, orig_sample.id); 1383 ret = evlist__deliver_sample(evlist, tool, de->event, 1384 &orig_sample, evsel, machine); 1385 1386 if (orig_sample.deferred_callchain) 1387 free(orig_sample.callchain); 1388 1389 list_del(&de->list); 1390 free(de->event); 1391 free(de); 1392 1393 if (ret) 1394 break; 1395 } 1396 return ret; 1397 } 1398 1399 /* 1400 * This is called at the end of the data processing for the session. Flush the 1401 * remaining samples as there's no hope for matching deferred callchains. 1402 */ 1403 static int session__flush_deferred_samples(struct perf_session *session, 1404 const struct perf_tool *tool) 1405 { 1406 struct evlist *evlist = session->evlist; 1407 struct machine *machine = &session->machines.host; 1408 struct deferred_event *de, *tmp; 1409 struct evsel *evsel; 1410 int ret = 0; 1411 1412 list_for_each_entry_safe(de, tmp, &evlist->deferred_samples, list) { 1413 struct perf_sample sample; 1414 1415 ret = evlist__parse_sample(evlist, de->event, &sample); 1416 if (ret < 0) { 1417 pr_err("failed to parse original sample\n"); 1418 break; 1419 } 1420 1421 evsel = evlist__id2evsel(evlist, sample.id); 1422 ret = evlist__deliver_sample(evlist, tool, de->event, 1423 &sample, evsel, machine); 1424 1425 list_del(&de->list); 1426 free(de->event); 1427 free(de); 1428 1429 if (ret) 1430 break; 1431 } 1432 return ret; 1433 } 1434 1435 static int machines__deliver_event(struct machines *machines, 1436 struct evlist *evlist, 1437 union perf_event *event, 1438 struct perf_sample *sample, 1439 const struct perf_tool *tool, u64 file_offset, 1440 const char *file_path) 1441 { 1442 struct evsel *evsel; 1443 struct machine *machine; 1444 1445 dump_event(evlist, event, file_offset, sample, file_path); 1446 1447 evsel = evlist__id2evsel(evlist, sample->id); 1448 1449 machine = machines__find_for_cpumode(machines, event, sample); 1450 1451 switch (event->header.type) { 1452 case PERF_RECORD_SAMPLE: 1453 if (evsel == NULL) { 1454 ++evlist->stats.nr_unknown_id; 1455 return 0; 1456 } 1457 if (machine == NULL) { 1458 ++evlist->stats.nr_unprocessable_samples; 1459 dump_sample(machine, evsel, event, sample); 1460 return 0; 1461 } 1462 dump_sample(machine, evsel, event, sample); 1463 if (sample->deferred_callchain && tool->merge_deferred_callchains) { 1464 struct deferred_event *de = malloc(sizeof(*de)); 1465 size_t sz = event->header.size; 1466 1467 if (de == NULL) 1468 return -ENOMEM; 1469 1470 de->event = malloc(sz); 1471 if (de->event == NULL) { 1472 free(de); 1473 return -ENOMEM; 1474 } 1475 memcpy(de->event, event, sz); 1476 list_add_tail(&de->list, &evlist->deferred_samples); 1477 return 0; 1478 } 1479 return evlist__deliver_sample(evlist, tool, event, sample, evsel, machine); 1480 case PERF_RECORD_MMAP: 1481 return tool->mmap(tool, event, sample, machine); 1482 case PERF_RECORD_MMAP2: 1483 if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT) 1484 ++evlist->stats.nr_proc_map_timeout; 1485 return tool->mmap2(tool, event, sample, machine); 1486 case PERF_RECORD_COMM: 1487 return tool->comm(tool, event, sample, machine); 1488 case PERF_RECORD_NAMESPACES: 1489 return tool->namespaces(tool, event, sample, machine); 1490 case PERF_RECORD_CGROUP: 1491 return tool->cgroup(tool, event, sample, machine); 1492 case PERF_RECORD_FORK: 1493 return tool->fork(tool, event, sample, machine); 1494 case PERF_RECORD_EXIT: 1495 return tool->exit(tool, event, sample, machine); 1496 case PERF_RECORD_LOST: 1497 if (tool->lost == perf_event__process_lost) 1498 evlist->stats.total_lost += event->lost.lost; 1499 return tool->lost(tool, event, sample, machine); 1500 case PERF_RECORD_LOST_SAMPLES: 1501 if (event->header.misc & PERF_RECORD_MISC_LOST_SAMPLES_BPF) 1502 evlist->stats.total_dropped_samples += event->lost_samples.lost; 1503 else if (tool->lost_samples == perf_event__process_lost_samples) 1504 evlist->stats.total_lost_samples += event->lost_samples.lost; 1505 return tool->lost_samples(tool, event, sample, machine); 1506 case PERF_RECORD_READ: 1507 dump_read(evsel, event); 1508 return tool->read(tool, event, sample, evsel, machine); 1509 case PERF_RECORD_THROTTLE: 1510 return tool->throttle(tool, event, sample, machine); 1511 case PERF_RECORD_UNTHROTTLE: 1512 return tool->unthrottle(tool, event, sample, machine); 1513 case PERF_RECORD_AUX: 1514 if (tool->aux == perf_event__process_aux) { 1515 if (event->aux.flags & PERF_AUX_FLAG_TRUNCATED) 1516 evlist->stats.total_aux_lost += 1; 1517 if (event->aux.flags & PERF_AUX_FLAG_PARTIAL) 1518 evlist->stats.total_aux_partial += 1; 1519 if (event->aux.flags & PERF_AUX_FLAG_COLLISION) 1520 evlist->stats.total_aux_collision += 1; 1521 } 1522 return tool->aux(tool, event, sample, machine); 1523 case PERF_RECORD_ITRACE_START: 1524 return tool->itrace_start(tool, event, sample, machine); 1525 case PERF_RECORD_SWITCH: 1526 case PERF_RECORD_SWITCH_CPU_WIDE: 1527 return tool->context_switch(tool, event, sample, machine); 1528 case PERF_RECORD_KSYMBOL: 1529 return tool->ksymbol(tool, event, sample, machine); 1530 case PERF_RECORD_BPF_EVENT: 1531 return tool->bpf(tool, event, sample, machine); 1532 case PERF_RECORD_TEXT_POKE: 1533 return tool->text_poke(tool, event, sample, machine); 1534 case PERF_RECORD_AUX_OUTPUT_HW_ID: 1535 return tool->aux_output_hw_id(tool, event, sample, machine); 1536 case PERF_RECORD_CALLCHAIN_DEFERRED: 1537 dump_deferred_callchain(evsel, event, sample); 1538 return evlist__deliver_deferred_callchain(evlist, tool, event, 1539 sample, machine); 1540 default: 1541 ++evlist->stats.nr_unknown_events; 1542 return -1; 1543 } 1544 } 1545 1546 static int perf_session__deliver_event(struct perf_session *session, 1547 union perf_event *event, 1548 const struct perf_tool *tool, 1549 u64 file_offset, 1550 const char *file_path) 1551 { 1552 struct perf_sample sample; 1553 int ret; 1554 1555 perf_sample__init(&sample, /*all=*/false); 1556 ret = evlist__parse_sample(session->evlist, event, &sample); 1557 if (ret) { 1558 pr_err("Can't parse sample, err = %d\n", ret); 1559 goto out; 1560 } 1561 1562 ret = auxtrace__process_event(session, event, &sample, tool); 1563 if (ret < 0) 1564 goto out; 1565 if (ret > 0) { 1566 ret = 0; 1567 goto out; 1568 } 1569 1570 ret = machines__deliver_event(&session->machines, session->evlist, 1571 event, &sample, tool, file_offset, file_path); 1572 1573 if (dump_trace && sample.aux_sample.size) 1574 auxtrace__dump_auxtrace_sample(session, &sample); 1575 out: 1576 perf_sample__exit(&sample); 1577 return ret; 1578 } 1579 1580 static s64 perf_session__process_user_event(struct perf_session *session, 1581 union perf_event *event, 1582 u64 file_offset, 1583 const char *file_path) 1584 { 1585 struct ordered_events *oe = &session->ordered_events; 1586 const struct perf_tool *tool = session->tool; 1587 struct perf_sample sample; 1588 int fd = perf_data__fd(session->data); 1589 s64 err; 1590 1591 perf_sample__init(&sample, /*all=*/true); 1592 if ((event->header.type != PERF_RECORD_COMPRESSED && 1593 event->header.type != PERF_RECORD_COMPRESSED2) || 1594 perf_tool__compressed_is_stub(tool)) 1595 dump_event(session->evlist, event, file_offset, &sample, file_path); 1596 1597 /* These events are processed right away */ 1598 switch (event->header.type) { 1599 case PERF_RECORD_HEADER_ATTR: 1600 err = tool->attr(tool, event, &session->evlist); 1601 if (err == 0) { 1602 perf_session__set_id_hdr_size(session); 1603 perf_session__set_comm_exec(session); 1604 } 1605 break; 1606 case PERF_RECORD_EVENT_UPDATE: 1607 err = tool->event_update(tool, event, &session->evlist); 1608 break; 1609 case PERF_RECORD_HEADER_EVENT_TYPE: 1610 /* 1611 * Deprecated, but we need to handle it for sake 1612 * of old data files create in pipe mode. 1613 */ 1614 err = 0; 1615 break; 1616 case PERF_RECORD_HEADER_TRACING_DATA: 1617 /* 1618 * Setup for reading amidst mmap, but only when we 1619 * are in 'file' mode. The 'pipe' fd is in proper 1620 * place already. 1621 */ 1622 if (!perf_data__is_pipe(session->data)) 1623 lseek(fd, file_offset, SEEK_SET); 1624 err = tool->tracing_data(tool, session, event); 1625 break; 1626 case PERF_RECORD_HEADER_BUILD_ID: 1627 err = tool->build_id(tool, session, event); 1628 break; 1629 case PERF_RECORD_FINISHED_ROUND: 1630 err = tool->finished_round(tool, event, oe); 1631 break; 1632 case PERF_RECORD_ID_INDEX: 1633 err = tool->id_index(tool, session, event); 1634 break; 1635 case PERF_RECORD_AUXTRACE_INFO: 1636 err = tool->auxtrace_info(tool, session, event); 1637 break; 1638 case PERF_RECORD_AUXTRACE: 1639 /* 1640 * Setup for reading amidst mmap, but only when we 1641 * are in 'file' mode. The 'pipe' fd is in proper 1642 * place already. 1643 */ 1644 if (!perf_data__is_pipe(session->data)) 1645 lseek(fd, file_offset + event->header.size, SEEK_SET); 1646 err = tool->auxtrace(tool, session, event); 1647 break; 1648 case PERF_RECORD_AUXTRACE_ERROR: 1649 perf_session__auxtrace_error_inc(session, event); 1650 err = tool->auxtrace_error(tool, session, event); 1651 break; 1652 case PERF_RECORD_THREAD_MAP: 1653 err = tool->thread_map(tool, session, event); 1654 break; 1655 case PERF_RECORD_CPU_MAP: 1656 err = tool->cpu_map(tool, session, event); 1657 break; 1658 case PERF_RECORD_STAT_CONFIG: 1659 err = tool->stat_config(tool, session, event); 1660 break; 1661 case PERF_RECORD_STAT: 1662 err = tool->stat(tool, session, event); 1663 break; 1664 case PERF_RECORD_STAT_ROUND: 1665 err = tool->stat_round(tool, session, event); 1666 break; 1667 case PERF_RECORD_TIME_CONV: 1668 session->time_conv = event->time_conv; 1669 err = tool->time_conv(tool, session, event); 1670 break; 1671 case PERF_RECORD_HEADER_FEATURE: 1672 err = tool->feature(tool, session, event); 1673 break; 1674 case PERF_RECORD_COMPRESSED: 1675 case PERF_RECORD_COMPRESSED2: 1676 err = tool->compressed(tool, session, event, file_offset, file_path); 1677 if (err) 1678 dump_event(session->evlist, event, file_offset, &sample, file_path); 1679 break; 1680 case PERF_RECORD_FINISHED_INIT: 1681 err = tool->finished_init(tool, session, event); 1682 break; 1683 case PERF_RECORD_BPF_METADATA: 1684 err = tool->bpf_metadata(tool, session, event); 1685 break; 1686 case PERF_RECORD_SCHEDSTAT_CPU: 1687 err = tool->schedstat_cpu(tool, session, event); 1688 break; 1689 case PERF_RECORD_SCHEDSTAT_DOMAIN: 1690 err = tool->schedstat_domain(tool, session, event); 1691 break; 1692 default: 1693 err = -EINVAL; 1694 break; 1695 } 1696 perf_sample__exit(&sample); 1697 return err; 1698 } 1699 1700 int perf_session__deliver_synth_event(struct perf_session *session, 1701 union perf_event *event, 1702 struct perf_sample *sample) 1703 { 1704 struct evlist *evlist = session->evlist; 1705 const struct perf_tool *tool = session->tool; 1706 1707 events_stats__inc(&evlist->stats, event->header.type); 1708 1709 if (event->header.type >= PERF_RECORD_USER_TYPE_START) 1710 return perf_session__process_user_event(session, event, 0, NULL); 1711 1712 return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0, NULL); 1713 } 1714 1715 int perf_session__deliver_synth_attr_event(struct perf_session *session, 1716 const struct perf_event_attr *attr, 1717 u64 id) 1718 { 1719 union { 1720 struct { 1721 struct perf_record_header_attr attr; 1722 u64 ids[1]; 1723 } attr_id; 1724 union perf_event ev; 1725 } ev = { 1726 .attr_id.attr.header.type = PERF_RECORD_HEADER_ATTR, 1727 .attr_id.attr.header.size = sizeof(ev.attr_id), 1728 .attr_id.ids[0] = id, 1729 }; 1730 1731 if (attr->size != sizeof(ev.attr_id.attr.attr)) { 1732 pr_debug("Unexpected perf_event_attr size\n"); 1733 return -EINVAL; 1734 } 1735 ev.attr_id.attr.attr = *attr; 1736 return perf_session__deliver_synth_event(session, &ev.ev, NULL); 1737 } 1738 1739 static void event_swap(union perf_event *event, bool sample_id_all) 1740 { 1741 perf_event__swap_op swap; 1742 1743 swap = perf_event__swap_ops[event->header.type]; 1744 if (swap) 1745 swap(event, sample_id_all); 1746 } 1747 1748 int perf_session__peek_event(struct perf_session *session, off_t file_offset, 1749 void *buf, size_t buf_sz, 1750 union perf_event **event_ptr, 1751 struct perf_sample *sample) 1752 { 1753 union perf_event *event; 1754 size_t hdr_sz, rest; 1755 int fd; 1756 1757 if (session->one_mmap && !session->header.needs_swap) { 1758 event = file_offset - session->one_mmap_offset + 1759 session->one_mmap_addr; 1760 goto out_parse_sample; 1761 } 1762 1763 if (perf_data__is_pipe(session->data)) 1764 return -1; 1765 1766 fd = perf_data__fd(session->data); 1767 hdr_sz = sizeof(struct perf_event_header); 1768 1769 if (buf_sz < hdr_sz) 1770 return -1; 1771 1772 if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 || 1773 readn(fd, buf, hdr_sz) != (ssize_t)hdr_sz) 1774 return -1; 1775 1776 event = (union perf_event *)buf; 1777 1778 if (session->header.needs_swap) 1779 perf_event_header__bswap(&event->header); 1780 1781 if (event->header.size < hdr_sz || event->header.size > buf_sz) 1782 return -1; 1783 1784 buf += hdr_sz; 1785 rest = event->header.size - hdr_sz; 1786 1787 if (readn(fd, buf, rest) != (ssize_t)rest) 1788 return -1; 1789 1790 if (session->header.needs_swap) 1791 event_swap(event, evlist__sample_id_all(session->evlist)); 1792 1793 out_parse_sample: 1794 1795 if (sample && event->header.type < PERF_RECORD_USER_TYPE_START && 1796 evlist__parse_sample(session->evlist, event, sample)) 1797 return -1; 1798 1799 *event_ptr = event; 1800 1801 return 0; 1802 } 1803 1804 int perf_session__peek_events(struct perf_session *session, u64 offset, 1805 u64 size, peek_events_cb_t cb, void *data) 1806 { 1807 u64 max_offset = offset + size; 1808 char buf[PERF_SAMPLE_MAX_SIZE]; 1809 union perf_event *event; 1810 int err; 1811 1812 do { 1813 err = perf_session__peek_event(session, offset, buf, 1814 PERF_SAMPLE_MAX_SIZE, &event, 1815 NULL); 1816 if (err) 1817 return err; 1818 1819 err = cb(session, event, offset, data); 1820 if (err) 1821 return err; 1822 1823 offset += event->header.size; 1824 if (event->header.type == PERF_RECORD_AUXTRACE) 1825 offset += event->auxtrace.size; 1826 1827 } while (offset < max_offset); 1828 1829 return err; 1830 } 1831 1832 static s64 perf_session__process_event(struct perf_session *session, 1833 union perf_event *event, u64 file_offset, 1834 const char *file_path) 1835 { 1836 struct evlist *evlist = session->evlist; 1837 const struct perf_tool *tool = session->tool; 1838 int ret; 1839 1840 if (session->header.needs_swap) 1841 event_swap(event, evlist__sample_id_all(evlist)); 1842 1843 if (event->header.type >= PERF_RECORD_HEADER_MAX) { 1844 /* perf should not support unaligned event, stop here. */ 1845 if (event->header.size % sizeof(u64)) 1846 return -EINVAL; 1847 1848 /* This perf is outdated and does not support the latest event type. */ 1849 ui__warning("Unsupported header type %u, please consider updating perf.\n", 1850 event->header.type); 1851 /* Skip unsupported event by returning its size. */ 1852 return event->header.size; 1853 } 1854 1855 events_stats__inc(&evlist->stats, event->header.type); 1856 1857 if (event->header.type >= PERF_RECORD_USER_TYPE_START) 1858 return perf_session__process_user_event(session, event, file_offset, file_path); 1859 1860 if (tool->ordered_events) { 1861 u64 timestamp = -1ULL; 1862 1863 ret = evlist__parse_sample_timestamp(evlist, event, ×tamp); 1864 if (ret && ret != -1) 1865 return ret; 1866 1867 ret = perf_session__queue_event(session, event, timestamp, file_offset, file_path); 1868 if (ret != -ETIME) 1869 return ret; 1870 } 1871 1872 return perf_session__deliver_event(session, event, tool, file_offset, file_path); 1873 } 1874 1875 void perf_event_header__bswap(struct perf_event_header *hdr) 1876 { 1877 hdr->type = bswap_32(hdr->type); 1878 hdr->misc = bswap_16(hdr->misc); 1879 hdr->size = bswap_16(hdr->size); 1880 } 1881 1882 struct thread *perf_session__findnew(struct perf_session *session, pid_t pid) 1883 { 1884 return machine__findnew_thread(&session->machines.host, -1, pid); 1885 } 1886 1887 int perf_session__register_idle_thread(struct perf_session *session) 1888 { 1889 struct thread *thread = machine__idle_thread(&session->machines.host); 1890 1891 /* machine__idle_thread() got the thread, so put it */ 1892 thread__put(thread); 1893 return thread ? 0 : -1; 1894 } 1895 1896 static void 1897 perf_session__warn_order(const struct perf_session *session) 1898 { 1899 const struct ordered_events *oe = &session->ordered_events; 1900 struct evsel *evsel; 1901 bool should_warn = true; 1902 1903 evlist__for_each_entry(session->evlist, evsel) { 1904 if (evsel->core.attr.write_backward) 1905 should_warn = false; 1906 } 1907 1908 if (!should_warn) 1909 return; 1910 if (oe->nr_unordered_events != 0) 1911 ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events); 1912 } 1913 1914 static void perf_session__warn_about_errors(const struct perf_session *session) 1915 { 1916 const struct events_stats *stats = &session->evlist->stats; 1917 1918 if (session->tool->lost == perf_event__process_lost && 1919 stats->nr_events[PERF_RECORD_LOST] != 0) { 1920 ui__warning("Processed %d events and lost %d chunks!\n\n" 1921 "Check IO/CPU overload!\n\n", 1922 stats->nr_events[0], 1923 stats->nr_events[PERF_RECORD_LOST]); 1924 } 1925 1926 if (session->tool->lost_samples == perf_event__process_lost_samples) { 1927 double drop_rate; 1928 1929 drop_rate = (double)stats->total_lost_samples / 1930 (double) (stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples); 1931 if (drop_rate > 0.05) { 1932 ui__warning("Processed %" PRIu64 " samples and lost %3.2f%%!\n\n", 1933 stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples, 1934 drop_rate * 100.0); 1935 } 1936 } 1937 1938 if (session->tool->aux == perf_event__process_aux && 1939 stats->total_aux_lost != 0) { 1940 ui__warning("AUX data lost %" PRIu64 " times out of %u!\n\n", 1941 stats->total_aux_lost, 1942 stats->nr_events[PERF_RECORD_AUX]); 1943 } 1944 1945 if (session->tool->aux == perf_event__process_aux && 1946 stats->total_aux_partial != 0) { 1947 bool vmm_exclusive = false; 1948 1949 (void)sysfs__read_bool("module/kvm_intel/parameters/vmm_exclusive", 1950 &vmm_exclusive); 1951 1952 ui__warning("AUX data had gaps in it %" PRIu64 " times out of %u!\n\n" 1953 "Are you running a KVM guest in the background?%s\n\n", 1954 stats->total_aux_partial, 1955 stats->nr_events[PERF_RECORD_AUX], 1956 vmm_exclusive ? 1957 "\nReloading kvm_intel module with vmm_exclusive=0\n" 1958 "will reduce the gaps to only guest's timeslices." : 1959 ""); 1960 } 1961 1962 if (session->tool->aux == perf_event__process_aux && 1963 stats->total_aux_collision != 0) { 1964 ui__warning("AUX data detected collision %" PRIu64 " times out of %u!\n\n", 1965 stats->total_aux_collision, 1966 stats->nr_events[PERF_RECORD_AUX]); 1967 } 1968 1969 if (stats->nr_unknown_events != 0) { 1970 ui__warning("Found %u unknown events!\n\n" 1971 "Is this an older tool processing a perf.data " 1972 "file generated by a more recent tool?\n\n" 1973 "If that is not the case, consider " 1974 "reporting to linux-kernel@vger.kernel.org.\n\n", 1975 stats->nr_unknown_events); 1976 } 1977 1978 if (stats->nr_unknown_id != 0) { 1979 ui__warning("%u samples with id not present in the header\n", 1980 stats->nr_unknown_id); 1981 } 1982 1983 if (stats->nr_invalid_chains != 0) { 1984 ui__warning("Found invalid callchains!\n\n" 1985 "%u out of %u events were discarded for this reason.\n\n" 1986 "Consider reporting to linux-kernel@vger.kernel.org.\n\n", 1987 stats->nr_invalid_chains, 1988 stats->nr_events[PERF_RECORD_SAMPLE]); 1989 } 1990 1991 if (stats->nr_unprocessable_samples != 0) { 1992 ui__warning("%u unprocessable samples recorded.\n" 1993 "Do you have a KVM guest running and not using 'perf kvm'?\n", 1994 stats->nr_unprocessable_samples); 1995 } 1996 1997 perf_session__warn_order(session); 1998 1999 events_stats__auxtrace_error_warn(stats); 2000 2001 if (stats->nr_proc_map_timeout != 0) { 2002 ui__warning("%d map information files for pre-existing threads were\n" 2003 "not processed, if there are samples for addresses they\n" 2004 "will not be resolved, you may find out which are these\n" 2005 "threads by running with -v and redirecting the output\n" 2006 "to a file.\n" 2007 "The time limit to process proc map is too short?\n" 2008 "Increase it by --proc-map-timeout\n", 2009 stats->nr_proc_map_timeout); 2010 } 2011 } 2012 2013 static int perf_session__flush_thread_stack(struct thread *thread, 2014 void *p __maybe_unused) 2015 { 2016 return thread_stack__flush(thread); 2017 } 2018 2019 static int perf_session__flush_thread_stacks(struct perf_session *session) 2020 { 2021 return machines__for_each_thread(&session->machines, 2022 perf_session__flush_thread_stack, 2023 NULL); 2024 } 2025 2026 volatile sig_atomic_t session_done; 2027 2028 static int __perf_session__process_decomp_events(struct perf_session *session); 2029 2030 static int __perf_session__process_pipe_events(struct perf_session *session) 2031 { 2032 struct ordered_events *oe = &session->ordered_events; 2033 const struct perf_tool *tool = session->tool; 2034 struct ui_progress prog; 2035 union perf_event *event; 2036 uint32_t size, cur_size = 0; 2037 void *buf = NULL; 2038 s64 skip = 0; 2039 u64 head; 2040 ssize_t err; 2041 void *p; 2042 bool update_prog = false; 2043 2044 /* 2045 * If it's from a file saving pipe data (by redirection), it would have 2046 * a file name other than "-". Then we can get the total size and show 2047 * the progress. 2048 */ 2049 if (strcmp(session->data->path, "-") && session->data->file.size) { 2050 ui_progress__init_size(&prog, session->data->file.size, 2051 "Processing events..."); 2052 update_prog = true; 2053 } 2054 2055 head = 0; 2056 cur_size = sizeof(union perf_event); 2057 2058 buf = malloc(cur_size); 2059 if (!buf) 2060 return -errno; 2061 ordered_events__set_copy_on_queue(oe, true); 2062 more: 2063 event = buf; 2064 err = perf_data__read(session->data, event, 2065 sizeof(struct perf_event_header)); 2066 if (err <= 0) { 2067 if (err == 0) 2068 goto done; 2069 2070 pr_err("failed to read event header\n"); 2071 goto out_err; 2072 } 2073 2074 if (session->header.needs_swap) 2075 perf_event_header__bswap(&event->header); 2076 2077 size = event->header.size; 2078 if (size < sizeof(struct perf_event_header)) { 2079 pr_err("bad event header size\n"); 2080 goto out_err; 2081 } 2082 2083 if (size > cur_size) { 2084 void *new = realloc(buf, size); 2085 if (!new) { 2086 pr_err("failed to allocate memory to read event\n"); 2087 goto out_err; 2088 } 2089 buf = new; 2090 cur_size = size; 2091 event = buf; 2092 } 2093 p = event; 2094 p += sizeof(struct perf_event_header); 2095 2096 if (size - sizeof(struct perf_event_header)) { 2097 err = perf_data__read(session->data, p, 2098 size - sizeof(struct perf_event_header)); 2099 if (err <= 0) { 2100 if (err == 0) { 2101 pr_err("unexpected end of event stream\n"); 2102 goto done; 2103 } 2104 2105 pr_err("failed to read event data\n"); 2106 goto out_err; 2107 } 2108 } 2109 2110 if ((skip = perf_session__process_event(session, event, head, "pipe")) < 0) { 2111 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n", 2112 head, event->header.size, event->header.type); 2113 err = -EINVAL; 2114 goto out_err; 2115 } 2116 2117 head += size; 2118 2119 if (skip > 0) 2120 head += skip; 2121 2122 err = __perf_session__process_decomp_events(session); 2123 if (err) 2124 goto out_err; 2125 2126 if (update_prog) 2127 ui_progress__update(&prog, size); 2128 2129 if (!session_done()) 2130 goto more; 2131 done: 2132 /* do the final flush for ordered samples */ 2133 err = ordered_events__flush(oe, OE_FLUSH__FINAL); 2134 if (err) 2135 goto out_err; 2136 err = session__flush_deferred_samples(session, tool); 2137 if (err) 2138 goto out_err; 2139 err = auxtrace__flush_events(session, tool); 2140 if (err) 2141 goto out_err; 2142 err = perf_session__flush_thread_stacks(session); 2143 out_err: 2144 free(buf); 2145 if (update_prog) 2146 ui_progress__finish(); 2147 if (!tool->no_warn) 2148 perf_session__warn_about_errors(session); 2149 ordered_events__free(&session->ordered_events); 2150 auxtrace__free_events(session); 2151 return err; 2152 } 2153 2154 static union perf_event * 2155 prefetch_event(char *buf, u64 head, size_t mmap_size, 2156 bool needs_swap, union perf_event *error) 2157 { 2158 union perf_event *event; 2159 u16 event_size; 2160 2161 /* 2162 * Ensure we have enough space remaining to read 2163 * the size of the event in the headers. 2164 */ 2165 if (head + sizeof(event->header) > mmap_size) 2166 return NULL; 2167 2168 event = (union perf_event *)(buf + head); 2169 if (needs_swap) 2170 perf_event_header__bswap(&event->header); 2171 2172 event_size = event->header.size; 2173 if (head + event_size <= mmap_size) 2174 return event; 2175 2176 /* We're not fetching the event so swap back again */ 2177 if (needs_swap) 2178 perf_event_header__bswap(&event->header); 2179 2180 /* Check if the event fits into the next mmapped buf. */ 2181 if (event_size <= mmap_size - head % page_size) { 2182 /* Remap buf and fetch again. */ 2183 return NULL; 2184 } 2185 2186 /* Invalid input. Event size should never exceed mmap_size. */ 2187 pr_debug("%s: head=%#" PRIx64 " event->header.size=%#x, mmap_size=%#zx:" 2188 " fuzzed or compressed perf.data?\n", __func__, head, event_size, mmap_size); 2189 2190 return error; 2191 } 2192 2193 static union perf_event * 2194 fetch_mmaped_event(u64 head, size_t mmap_size, char *buf, bool needs_swap) 2195 { 2196 return prefetch_event(buf, head, mmap_size, needs_swap, ERR_PTR(-EINVAL)); 2197 } 2198 2199 static union perf_event * 2200 fetch_decomp_event(u64 head, size_t mmap_size, char *buf, bool needs_swap) 2201 { 2202 return prefetch_event(buf, head, mmap_size, needs_swap, NULL); 2203 } 2204 2205 static int __perf_session__process_decomp_events(struct perf_session *session) 2206 { 2207 s64 skip; 2208 u64 size; 2209 struct decomp *decomp = session->active_decomp->decomp_last; 2210 2211 if (!decomp) 2212 return 0; 2213 2214 while (decomp->head < decomp->size && !session_done()) { 2215 union perf_event *event = fetch_decomp_event(decomp->head, decomp->size, decomp->data, 2216 session->header.needs_swap); 2217 2218 if (!event) 2219 break; 2220 2221 size = event->header.size; 2222 2223 if (size < sizeof(struct perf_event_header) || 2224 (skip = perf_session__process_event(session, event, decomp->file_pos, 2225 decomp->file_path)) < 0) { 2226 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n", 2227 decomp->file_pos + decomp->head, event->header.size, event->header.type); 2228 return -EINVAL; 2229 } 2230 2231 if (skip) 2232 size += skip; 2233 2234 decomp->head += size; 2235 } 2236 2237 return 0; 2238 } 2239 2240 /* 2241 * On 64bit we can mmap the data file in one go. No need for tiny mmap 2242 * slices. On 32bit we use 32MB. 2243 */ 2244 #if BITS_PER_LONG == 64 2245 #define MMAP_SIZE ULLONG_MAX 2246 #define NUM_MMAPS 1 2247 #else 2248 #define MMAP_SIZE (32 * 1024 * 1024ULL) 2249 #define NUM_MMAPS 128 2250 #endif 2251 2252 struct reader; 2253 2254 typedef s64 (*reader_cb_t)(struct perf_session *session, 2255 union perf_event *event, 2256 u64 file_offset, 2257 const char *file_path); 2258 2259 struct reader { 2260 int fd; 2261 const char *path; 2262 u64 data_size; 2263 u64 data_offset; 2264 reader_cb_t process; 2265 bool in_place_update; 2266 char *mmaps[NUM_MMAPS]; 2267 size_t mmap_size; 2268 int mmap_idx; 2269 char *mmap_cur; 2270 u64 file_pos; 2271 u64 file_offset; 2272 u64 head; 2273 u64 size; 2274 bool done; 2275 struct zstd_data zstd_data; 2276 struct decomp_data decomp_data; 2277 }; 2278 2279 static int 2280 reader__init(struct reader *rd, bool *one_mmap) 2281 { 2282 u64 data_size = rd->data_size; 2283 char **mmaps = rd->mmaps; 2284 2285 rd->head = rd->data_offset; 2286 data_size += rd->data_offset; 2287 2288 rd->mmap_size = MMAP_SIZE; 2289 if (rd->mmap_size > data_size) { 2290 rd->mmap_size = data_size; 2291 if (one_mmap) 2292 *one_mmap = true; 2293 } 2294 2295 memset(mmaps, 0, sizeof(rd->mmaps)); 2296 2297 if (zstd_init(&rd->zstd_data, 0)) 2298 return -1; 2299 rd->decomp_data.zstd_decomp = &rd->zstd_data; 2300 2301 return 0; 2302 } 2303 2304 static void 2305 reader__release_decomp(struct reader *rd) 2306 { 2307 perf_decomp__release_events(rd->decomp_data.decomp); 2308 zstd_fini(&rd->zstd_data); 2309 } 2310 2311 static int 2312 reader__mmap(struct reader *rd, struct perf_session *session) 2313 { 2314 int mmap_prot, mmap_flags; 2315 char *buf, **mmaps = rd->mmaps; 2316 u64 page_offset; 2317 2318 mmap_prot = PROT_READ; 2319 mmap_flags = MAP_SHARED; 2320 2321 if (rd->in_place_update) { 2322 mmap_prot |= PROT_WRITE; 2323 } else if (session->header.needs_swap) { 2324 mmap_prot |= PROT_WRITE; 2325 mmap_flags = MAP_PRIVATE; 2326 } 2327 2328 if (mmaps[rd->mmap_idx]) { 2329 munmap(mmaps[rd->mmap_idx], rd->mmap_size); 2330 mmaps[rd->mmap_idx] = NULL; 2331 } 2332 2333 page_offset = page_size * (rd->head / page_size); 2334 rd->file_offset += page_offset; 2335 rd->head -= page_offset; 2336 2337 buf = mmap(NULL, rd->mmap_size, mmap_prot, mmap_flags, rd->fd, 2338 rd->file_offset); 2339 if (buf == MAP_FAILED) { 2340 pr_err("failed to mmap file\n"); 2341 return -errno; 2342 } 2343 mmaps[rd->mmap_idx] = rd->mmap_cur = buf; 2344 rd->mmap_idx = (rd->mmap_idx + 1) & (ARRAY_SIZE(rd->mmaps) - 1); 2345 rd->file_pos = rd->file_offset + rd->head; 2346 if (session->one_mmap) { 2347 session->one_mmap_addr = buf; 2348 session->one_mmap_offset = rd->file_offset; 2349 } 2350 2351 return 0; 2352 } 2353 2354 enum { 2355 READER_OK, 2356 READER_NODATA, 2357 }; 2358 2359 static int 2360 reader__read_event(struct reader *rd, struct perf_session *session, 2361 struct ui_progress *prog) 2362 { 2363 u64 size; 2364 int err = READER_OK; 2365 union perf_event *event; 2366 s64 skip; 2367 2368 event = fetch_mmaped_event(rd->head, rd->mmap_size, rd->mmap_cur, 2369 session->header.needs_swap); 2370 if (IS_ERR(event)) 2371 return PTR_ERR(event); 2372 2373 if (!event) 2374 return READER_NODATA; 2375 2376 size = event->header.size; 2377 2378 skip = -EINVAL; 2379 2380 if (size < sizeof(struct perf_event_header) || 2381 (skip = rd->process(session, event, rd->file_pos, rd->path)) < 0) { 2382 errno = -skip; 2383 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d [%m]\n", 2384 rd->file_offset + rd->head, event->header.size, 2385 event->header.type); 2386 err = skip; 2387 goto out; 2388 } 2389 2390 if (skip) 2391 size += skip; 2392 2393 rd->size += size; 2394 rd->head += size; 2395 rd->file_pos += size; 2396 2397 err = __perf_session__process_decomp_events(session); 2398 if (err) 2399 goto out; 2400 2401 ui_progress__update(prog, size); 2402 2403 out: 2404 return err; 2405 } 2406 2407 static inline bool 2408 reader__eof(struct reader *rd) 2409 { 2410 return (rd->file_pos >= rd->data_size + rd->data_offset); 2411 } 2412 2413 static int 2414 reader__process_events(struct reader *rd, struct perf_session *session, 2415 struct ui_progress *prog) 2416 { 2417 int err; 2418 2419 err = reader__init(rd, &session->one_mmap); 2420 if (err) 2421 goto out; 2422 2423 session->active_decomp = &rd->decomp_data; 2424 2425 remap: 2426 err = reader__mmap(rd, session); 2427 if (err) 2428 goto out; 2429 2430 more: 2431 err = reader__read_event(rd, session, prog); 2432 if (err < 0) 2433 goto out; 2434 else if (err == READER_NODATA) 2435 goto remap; 2436 2437 if (session_done()) 2438 goto out; 2439 2440 if (!reader__eof(rd)) 2441 goto more; 2442 2443 out: 2444 session->active_decomp = &session->decomp_data; 2445 return err; 2446 } 2447 2448 static s64 process_simple(struct perf_session *session, 2449 union perf_event *event, 2450 u64 file_offset, 2451 const char *file_path) 2452 { 2453 return perf_session__process_event(session, event, file_offset, file_path); 2454 } 2455 2456 static int __perf_session__process_events(struct perf_session *session) 2457 { 2458 struct reader rd = { 2459 .fd = perf_data__fd(session->data), 2460 .path = session->data->file.path, 2461 .data_size = session->header.data_size, 2462 .data_offset = session->header.data_offset, 2463 .process = process_simple, 2464 .in_place_update = session->data->in_place_update, 2465 }; 2466 struct ordered_events *oe = &session->ordered_events; 2467 const struct perf_tool *tool = session->tool; 2468 struct ui_progress prog; 2469 int err; 2470 2471 if (rd.data_size == 0) 2472 return -1; 2473 2474 ui_progress__init_size(&prog, rd.data_size, "Processing events..."); 2475 2476 err = reader__process_events(&rd, session, &prog); 2477 if (err) 2478 goto out_err; 2479 /* do the final flush for ordered samples */ 2480 err = ordered_events__flush(oe, OE_FLUSH__FINAL); 2481 if (err) 2482 goto out_err; 2483 err = auxtrace__flush_events(session, tool); 2484 if (err) 2485 goto out_err; 2486 err = session__flush_deferred_samples(session, tool); 2487 if (err) 2488 goto out_err; 2489 err = perf_session__flush_thread_stacks(session); 2490 out_err: 2491 ui_progress__finish(); 2492 if (!tool->no_warn) 2493 perf_session__warn_about_errors(session); 2494 /* 2495 * We may switching perf.data output, make ordered_events 2496 * reusable. 2497 */ 2498 ordered_events__reinit(&session->ordered_events); 2499 auxtrace__free_events(session); 2500 reader__release_decomp(&rd); 2501 session->one_mmap = false; 2502 return err; 2503 } 2504 2505 /* 2506 * Processing 2 MB of data from each reader in sequence, 2507 * because that's the way the ordered events sorting works 2508 * most efficiently. 2509 */ 2510 #define READER_MAX_SIZE (2 * 1024 * 1024) 2511 2512 /* 2513 * This function reads, merge and process directory data. 2514 * It assumens the version 1 of directory data, where each 2515 * data file holds per-cpu data, already sorted by kernel. 2516 */ 2517 static int __perf_session__process_dir_events(struct perf_session *session) 2518 { 2519 struct perf_data *data = session->data; 2520 const struct perf_tool *tool = session->tool; 2521 int i, ret, readers, nr_readers; 2522 struct ui_progress prog; 2523 u64 total_size = perf_data__size(session->data); 2524 struct reader *rd; 2525 2526 ui_progress__init_size(&prog, total_size, "Processing events..."); 2527 2528 nr_readers = 1; 2529 for (i = 0; i < data->dir.nr; i++) { 2530 if (data->dir.files[i].size) 2531 nr_readers++; 2532 } 2533 2534 rd = zalloc(nr_readers * sizeof(struct reader)); 2535 if (!rd) 2536 return -ENOMEM; 2537 2538 rd[0] = (struct reader) { 2539 .fd = perf_data__fd(session->data), 2540 .path = session->data->file.path, 2541 .data_size = session->header.data_size, 2542 .data_offset = session->header.data_offset, 2543 .process = process_simple, 2544 .in_place_update = session->data->in_place_update, 2545 }; 2546 ret = reader__init(&rd[0], NULL); 2547 if (ret) 2548 goto out_err; 2549 ret = reader__mmap(&rd[0], session); 2550 if (ret) 2551 goto out_err; 2552 readers = 1; 2553 2554 for (i = 0; i < data->dir.nr; i++) { 2555 if (!data->dir.files[i].size) 2556 continue; 2557 rd[readers] = (struct reader) { 2558 .fd = data->dir.files[i].fd, 2559 .path = data->dir.files[i].path, 2560 .data_size = data->dir.files[i].size, 2561 .data_offset = 0, 2562 .process = process_simple, 2563 .in_place_update = session->data->in_place_update, 2564 }; 2565 ret = reader__init(&rd[readers], NULL); 2566 if (ret) 2567 goto out_err; 2568 ret = reader__mmap(&rd[readers], session); 2569 if (ret) 2570 goto out_err; 2571 readers++; 2572 } 2573 2574 i = 0; 2575 while (readers) { 2576 if (session_done()) 2577 break; 2578 2579 if (rd[i].done) { 2580 i = (i + 1) % nr_readers; 2581 continue; 2582 } 2583 if (reader__eof(&rd[i])) { 2584 rd[i].done = true; 2585 readers--; 2586 continue; 2587 } 2588 2589 session->active_decomp = &rd[i].decomp_data; 2590 ret = reader__read_event(&rd[i], session, &prog); 2591 if (ret < 0) { 2592 goto out_err; 2593 } else if (ret == READER_NODATA) { 2594 ret = reader__mmap(&rd[i], session); 2595 if (ret) 2596 goto out_err; 2597 } 2598 2599 if (rd[i].size >= READER_MAX_SIZE) { 2600 rd[i].size = 0; 2601 i = (i + 1) % nr_readers; 2602 } 2603 } 2604 2605 ret = ordered_events__flush(&session->ordered_events, OE_FLUSH__FINAL); 2606 if (ret) 2607 goto out_err; 2608 2609 ret = session__flush_deferred_samples(session, tool); 2610 if (ret) 2611 goto out_err; 2612 2613 ret = perf_session__flush_thread_stacks(session); 2614 out_err: 2615 ui_progress__finish(); 2616 2617 if (!tool->no_warn) 2618 perf_session__warn_about_errors(session); 2619 2620 /* 2621 * We may switching perf.data output, make ordered_events 2622 * reusable. 2623 */ 2624 ordered_events__reinit(&session->ordered_events); 2625 2626 session->one_mmap = false; 2627 2628 session->active_decomp = &session->decomp_data; 2629 for (i = 0; i < nr_readers; i++) 2630 reader__release_decomp(&rd[i]); 2631 zfree(&rd); 2632 2633 return ret; 2634 } 2635 2636 int perf_session__process_events(struct perf_session *session) 2637 { 2638 if (perf_session__register_idle_thread(session) < 0) 2639 return -ENOMEM; 2640 2641 if (perf_data__is_pipe(session->data)) 2642 return __perf_session__process_pipe_events(session); 2643 2644 if (perf_data__is_dir(session->data) && session->data->dir.nr) 2645 return __perf_session__process_dir_events(session); 2646 2647 return __perf_session__process_events(session); 2648 } 2649 2650 bool perf_session__has_traces(struct perf_session *session, const char *msg) 2651 { 2652 struct evsel *evsel; 2653 2654 evlist__for_each_entry(session->evlist, evsel) { 2655 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) 2656 return true; 2657 } 2658 2659 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg); 2660 return false; 2661 } 2662 2663 bool perf_session__has_switch_events(struct perf_session *session) 2664 { 2665 struct evsel *evsel; 2666 2667 evlist__for_each_entry(session->evlist, evsel) { 2668 if (evsel->core.attr.context_switch) 2669 return true; 2670 } 2671 2672 return false; 2673 } 2674 2675 int map__set_kallsyms_ref_reloc_sym(struct map *map, const char *symbol_name, u64 addr) 2676 { 2677 char *bracket; 2678 struct ref_reloc_sym *ref; 2679 struct kmap *kmap; 2680 2681 ref = zalloc(sizeof(struct ref_reloc_sym)); 2682 if (ref == NULL) 2683 return -ENOMEM; 2684 2685 ref->name = strdup(symbol_name); 2686 if (ref->name == NULL) { 2687 free(ref); 2688 return -ENOMEM; 2689 } 2690 2691 bracket = strchr(ref->name, ']'); 2692 if (bracket) 2693 *bracket = '\0'; 2694 2695 ref->addr = addr; 2696 2697 kmap = map__kmap(map); 2698 if (kmap) 2699 kmap->ref_reloc_sym = ref; 2700 2701 return 0; 2702 } 2703 2704 size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp) 2705 { 2706 return machines__fprintf_dsos(&session->machines, fp); 2707 } 2708 2709 size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp, 2710 bool (skip)(struct dso *dso, int parm), int parm) 2711 { 2712 return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm); 2713 } 2714 2715 size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp) 2716 { 2717 size_t ret; 2718 const char *msg = ""; 2719 2720 if (perf_header__has_feat(&session->header, HEADER_AUXTRACE)) 2721 msg = " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)"; 2722 2723 ret = fprintf(fp, "\nAggregated stats:%s\n", msg); 2724 2725 ret += events_stats__fprintf(&session->evlist->stats, fp); 2726 return ret; 2727 } 2728 2729 size_t perf_session__fprintf(struct perf_session *session, FILE *fp) 2730 { 2731 /* 2732 * FIXME: Here we have to actually print all the machines in this 2733 * session, not just the host... 2734 */ 2735 return machine__fprintf(&session->machines.host, fp); 2736 } 2737 2738 void perf_session__dump_kmaps(struct perf_session *session) 2739 { 2740 int save_verbose = verbose; 2741 2742 fflush(stdout); 2743 fprintf(stderr, "Kernel and module maps:\n"); 2744 verbose = 0; /* Suppress verbose to print a summary only */ 2745 maps__fprintf(machine__kernel_maps(&session->machines.host), stderr); 2746 verbose = save_verbose; 2747 } 2748 2749 struct evsel *perf_session__find_first_evtype(struct perf_session *session, 2750 unsigned int type) 2751 { 2752 struct evsel *pos; 2753 2754 evlist__for_each_entry(session->evlist, pos) { 2755 if (pos->core.attr.type == type) 2756 return pos; 2757 } 2758 return NULL; 2759 } 2760 2761 int perf_session__cpu_bitmap(struct perf_session *session, 2762 const char *cpu_list, unsigned long *cpu_bitmap) 2763 { 2764 int i, err = -1; 2765 struct perf_cpu_map *map; 2766 int nr_cpus = min(perf_session__env(session)->nr_cpus_avail, MAX_NR_CPUS); 2767 struct perf_cpu cpu; 2768 2769 for (i = 0; i < PERF_TYPE_MAX; ++i) { 2770 struct evsel *evsel; 2771 2772 evsel = perf_session__find_first_evtype(session, i); 2773 if (!evsel) 2774 continue; 2775 2776 if (!(evsel->core.attr.sample_type & PERF_SAMPLE_CPU)) { 2777 pr_err("File does not contain CPU events. " 2778 "Remove -C option to proceed.\n"); 2779 return -1; 2780 } 2781 } 2782 2783 map = perf_cpu_map__new(cpu_list); 2784 if (map == NULL) { 2785 pr_err("Invalid cpu_list\n"); 2786 return -1; 2787 } 2788 2789 perf_cpu_map__for_each_cpu(cpu, i, map) { 2790 if (cpu.cpu >= nr_cpus) { 2791 pr_err("Requested CPU %d too large. " 2792 "Consider raising MAX_NR_CPUS\n", cpu.cpu); 2793 goto out_delete_map; 2794 } 2795 2796 __set_bit(cpu.cpu, cpu_bitmap); 2797 } 2798 2799 err = 0; 2800 2801 out_delete_map: 2802 perf_cpu_map__put(map); 2803 return err; 2804 } 2805 2806 void perf_session__fprintf_info(struct perf_session *session, FILE *fp, 2807 bool full) 2808 { 2809 if (session == NULL || fp == NULL) 2810 return; 2811 2812 fprintf(fp, "# ========\n"); 2813 perf_header__fprintf_info(session, fp, full); 2814 fprintf(fp, "# ========\n#\n"); 2815 } 2816 2817 static int perf_session__register_guest(struct perf_session *session, pid_t machine_pid) 2818 { 2819 struct machine *machine = machines__findnew(&session->machines, machine_pid); 2820 struct thread *thread; 2821 2822 if (!machine) 2823 return -ENOMEM; 2824 2825 machine->single_address_space = session->machines.host.single_address_space; 2826 2827 thread = machine__idle_thread(machine); 2828 if (!thread) 2829 return -ENOMEM; 2830 thread__put(thread); 2831 2832 machine->kallsyms_filename = perf_data__guest_kallsyms_name(session->data, machine_pid); 2833 2834 return 0; 2835 } 2836 2837 static int perf_session__set_guest_cpu(struct perf_session *session, pid_t pid, 2838 pid_t tid, int guest_cpu) 2839 { 2840 struct machine *machine = &session->machines.host; 2841 struct thread *thread = machine__findnew_thread(machine, pid, tid); 2842 2843 if (!thread) 2844 return -ENOMEM; 2845 thread__set_guest_cpu(thread, guest_cpu); 2846 thread__put(thread); 2847 2848 return 0; 2849 } 2850 2851 int perf_event__process_id_index(const struct perf_tool *tool __maybe_unused, 2852 struct perf_session *session, 2853 union perf_event *event) 2854 { 2855 struct evlist *evlist = session->evlist; 2856 struct perf_record_id_index *ie = &event->id_index; 2857 size_t sz = ie->header.size - sizeof(*ie); 2858 size_t i, nr, max_nr; 2859 size_t e1_sz = sizeof(struct id_index_entry); 2860 size_t e2_sz = sizeof(struct id_index_entry_2); 2861 size_t etot_sz = e1_sz + e2_sz; 2862 struct id_index_entry_2 *e2; 2863 pid_t last_pid = 0; 2864 2865 max_nr = sz / e1_sz; 2866 nr = ie->nr; 2867 if (nr > max_nr) { 2868 printf("Too big: nr %zu max_nr %zu\n", nr, max_nr); 2869 return -EINVAL; 2870 } 2871 2872 if (sz >= nr * etot_sz) { 2873 max_nr = sz / etot_sz; 2874 if (nr > max_nr) { 2875 printf("Too big2: nr %zu max_nr %zu\n", nr, max_nr); 2876 return -EINVAL; 2877 } 2878 e2 = (void *)ie + sizeof(*ie) + nr * e1_sz; 2879 } else { 2880 e2 = NULL; 2881 } 2882 2883 if (dump_trace) 2884 fprintf(stdout, " nr: %zu\n", nr); 2885 2886 for (i = 0; i < nr; i++, (e2 ? e2++ : 0)) { 2887 struct id_index_entry *e = &ie->entries[i]; 2888 struct perf_sample_id *sid; 2889 int ret; 2890 2891 if (dump_trace) { 2892 fprintf(stdout, " ... id: %"PRI_lu64, e->id); 2893 fprintf(stdout, " idx: %"PRI_lu64, e->idx); 2894 fprintf(stdout, " cpu: %"PRI_ld64, e->cpu); 2895 fprintf(stdout, " tid: %"PRI_ld64, e->tid); 2896 if (e2) { 2897 fprintf(stdout, " machine_pid: %"PRI_ld64, e2->machine_pid); 2898 fprintf(stdout, " vcpu: %"PRI_lu64"\n", e2->vcpu); 2899 } else { 2900 fprintf(stdout, "\n"); 2901 } 2902 } 2903 2904 sid = evlist__id2sid(evlist, e->id); 2905 if (!sid) 2906 return -ENOENT; 2907 2908 sid->idx = e->idx; 2909 sid->cpu.cpu = e->cpu; 2910 sid->tid = e->tid; 2911 2912 if (!e2) 2913 continue; 2914 2915 sid->machine_pid = e2->machine_pid; 2916 sid->vcpu.cpu = e2->vcpu; 2917 2918 if (!sid->machine_pid) 2919 continue; 2920 2921 if (sid->machine_pid != last_pid) { 2922 ret = perf_session__register_guest(session, sid->machine_pid); 2923 if (ret) 2924 return ret; 2925 last_pid = sid->machine_pid; 2926 perf_guest = true; 2927 } 2928 2929 ret = perf_session__set_guest_cpu(session, sid->machine_pid, e->tid, e2->vcpu); 2930 if (ret) 2931 return ret; 2932 } 2933 return 0; 2934 } 2935 2936 int perf_session__dsos_hit_all(struct perf_session *session) 2937 { 2938 struct rb_node *nd; 2939 int err; 2940 2941 err = machine__hit_all_dsos(&session->machines.host); 2942 if (err) 2943 return err; 2944 2945 for (nd = rb_first_cached(&session->machines.guests); nd; 2946 nd = rb_next(nd)) { 2947 struct machine *pos = rb_entry(nd, struct machine, rb_node); 2948 2949 err = machine__hit_all_dsos(pos); 2950 if (err) 2951 return err; 2952 } 2953 2954 return 0; 2955 } 2956 2957 struct perf_env *perf_session__env(struct perf_session *session) 2958 { 2959 return &session->header.env; 2960 } 2961 2962 static int perf_session__e_machine_cb(struct thread *thread, 2963 void *arg __maybe_unused) 2964 { 2965 uint16_t *result = arg; 2966 struct machine *machine = maps__machine(thread__maps(thread)); 2967 2968 *result = thread__e_machine(thread, machine); 2969 return *result != EM_NONE ? 1 : 0; 2970 } 2971 2972 /* 2973 * Note, a machine may have mixed 32-bit and 64-bit processes and so mixed 2974 * e_machines. Use thread__e_machine when this matters. 2975 */ 2976 uint16_t perf_session__e_machine(struct perf_session *session) 2977 { 2978 uint16_t e_machine = EM_NONE; 2979 2980 machines__for_each_thread(&session->machines, 2981 perf_session__e_machine_cb, 2982 &e_machine); 2983 2984 return e_machine == EM_NONE ? EM_HOST : e_machine; 2985 } 2986