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