1 #include <linux/kernel.h> 2 #include <traceevent/event-parse.h> 3 4 #include <byteswap.h> 5 #include <unistd.h> 6 #include <sys/types.h> 7 #include <sys/mman.h> 8 9 #include "evlist.h" 10 #include "evsel.h" 11 #include "session.h" 12 #include "tool.h" 13 #include "sort.h" 14 #include "util.h" 15 #include "cpumap.h" 16 #include "perf_regs.h" 17 #include "asm/bug.h" 18 19 static int machines__deliver_event(struct machines *machines, 20 struct perf_evlist *evlist, 21 union perf_event *event, 22 struct perf_sample *sample, 23 struct perf_tool *tool, u64 file_offset); 24 25 static int perf_session__open(struct perf_session *session) 26 { 27 struct perf_data_file *file = session->file; 28 29 if (perf_session__read_header(session) < 0) { 30 pr_err("incompatible file format (rerun with -v to learn more)"); 31 return -1; 32 } 33 34 if (perf_data_file__is_pipe(file)) 35 return 0; 36 37 if (!perf_evlist__valid_sample_type(session->evlist)) { 38 pr_err("non matching sample_type"); 39 return -1; 40 } 41 42 if (!perf_evlist__valid_sample_id_all(session->evlist)) { 43 pr_err("non matching sample_id_all"); 44 return -1; 45 } 46 47 if (!perf_evlist__valid_read_format(session->evlist)) { 48 pr_err("non matching read_format"); 49 return -1; 50 } 51 52 return 0; 53 } 54 55 void perf_session__set_id_hdr_size(struct perf_session *session) 56 { 57 u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist); 58 59 machines__set_id_hdr_size(&session->machines, id_hdr_size); 60 } 61 62 int perf_session__create_kernel_maps(struct perf_session *session) 63 { 64 int ret = machine__create_kernel_maps(&session->machines.host); 65 66 if (ret >= 0) 67 ret = machines__create_guest_kernel_maps(&session->machines); 68 return ret; 69 } 70 71 static void perf_session__destroy_kernel_maps(struct perf_session *session) 72 { 73 machines__destroy_kernel_maps(&session->machines); 74 } 75 76 static bool perf_session__has_comm_exec(struct perf_session *session) 77 { 78 struct perf_evsel *evsel; 79 80 evlist__for_each(session->evlist, evsel) { 81 if (evsel->attr.comm_exec) 82 return true; 83 } 84 85 return false; 86 } 87 88 static void perf_session__set_comm_exec(struct perf_session *session) 89 { 90 bool comm_exec = perf_session__has_comm_exec(session); 91 92 machines__set_comm_exec(&session->machines, comm_exec); 93 } 94 95 static int ordered_events__deliver_event(struct ordered_events *oe, 96 struct ordered_event *event) 97 { 98 struct perf_sample sample; 99 struct perf_session *session = container_of(oe, struct perf_session, 100 ordered_events); 101 int ret = perf_evlist__parse_sample(session->evlist, event->event, &sample); 102 103 if (ret) { 104 pr_err("Can't parse sample, err = %d\n", ret); 105 return ret; 106 } 107 108 return machines__deliver_event(&session->machines, session->evlist, event->event, 109 &sample, session->tool, event->file_offset); 110 } 111 112 struct perf_session *perf_session__new(struct perf_data_file *file, 113 bool repipe, struct perf_tool *tool) 114 { 115 struct perf_session *session = zalloc(sizeof(*session)); 116 117 if (!session) 118 goto out; 119 120 session->repipe = repipe; 121 session->tool = tool; 122 machines__init(&session->machines); 123 ordered_events__init(&session->ordered_events, ordered_events__deliver_event); 124 125 if (file) { 126 if (perf_data_file__open(file)) 127 goto out_delete; 128 129 session->file = file; 130 131 if (perf_data_file__is_read(file)) { 132 if (perf_session__open(session) < 0) 133 goto out_close; 134 135 perf_session__set_id_hdr_size(session); 136 perf_session__set_comm_exec(session); 137 } 138 } 139 140 if (!file || perf_data_file__is_write(file)) { 141 /* 142 * In O_RDONLY mode this will be performed when reading the 143 * kernel MMAP event, in perf_event__process_mmap(). 144 */ 145 if (perf_session__create_kernel_maps(session) < 0) 146 pr_warning("Cannot read kernel map\n"); 147 } 148 149 if (tool && tool->ordering_requires_timestamps && 150 tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) { 151 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n"); 152 tool->ordered_events = false; 153 } 154 155 return session; 156 157 out_close: 158 perf_data_file__close(file); 159 out_delete: 160 perf_session__delete(session); 161 out: 162 return NULL; 163 } 164 165 static void perf_session__delete_threads(struct perf_session *session) 166 { 167 machine__delete_threads(&session->machines.host); 168 } 169 170 static void perf_session_env__delete(struct perf_session_env *env) 171 { 172 zfree(&env->hostname); 173 zfree(&env->os_release); 174 zfree(&env->version); 175 zfree(&env->arch); 176 zfree(&env->cpu_desc); 177 zfree(&env->cpuid); 178 179 zfree(&env->cmdline); 180 zfree(&env->sibling_cores); 181 zfree(&env->sibling_threads); 182 zfree(&env->numa_nodes); 183 zfree(&env->pmu_mappings); 184 } 185 186 void perf_session__delete(struct perf_session *session) 187 { 188 perf_session__destroy_kernel_maps(session); 189 perf_session__delete_threads(session); 190 perf_session_env__delete(&session->header.env); 191 machines__exit(&session->machines); 192 if (session->file) 193 perf_data_file__close(session->file); 194 free(session); 195 } 196 197 static int process_event_synth_tracing_data_stub(struct perf_tool *tool 198 __maybe_unused, 199 union perf_event *event 200 __maybe_unused, 201 struct perf_session *session 202 __maybe_unused) 203 { 204 dump_printf(": unhandled!\n"); 205 return 0; 206 } 207 208 static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused, 209 union perf_event *event __maybe_unused, 210 struct perf_evlist **pevlist 211 __maybe_unused) 212 { 213 dump_printf(": unhandled!\n"); 214 return 0; 215 } 216 217 static int process_event_sample_stub(struct perf_tool *tool __maybe_unused, 218 union perf_event *event __maybe_unused, 219 struct perf_sample *sample __maybe_unused, 220 struct perf_evsel *evsel __maybe_unused, 221 struct machine *machine __maybe_unused) 222 { 223 dump_printf(": unhandled!\n"); 224 return 0; 225 } 226 227 static int process_event_stub(struct perf_tool *tool __maybe_unused, 228 union perf_event *event __maybe_unused, 229 struct perf_sample *sample __maybe_unused, 230 struct machine *machine __maybe_unused) 231 { 232 dump_printf(": unhandled!\n"); 233 return 0; 234 } 235 236 static int process_build_id_stub(struct perf_tool *tool __maybe_unused, 237 union perf_event *event __maybe_unused, 238 struct perf_session *session __maybe_unused) 239 { 240 dump_printf(": unhandled!\n"); 241 return 0; 242 } 243 244 static int process_finished_round_stub(struct perf_tool *tool __maybe_unused, 245 union perf_event *event __maybe_unused, 246 struct ordered_events *oe __maybe_unused) 247 { 248 dump_printf(": unhandled!\n"); 249 return 0; 250 } 251 252 static int process_finished_round(struct perf_tool *tool, 253 union perf_event *event, 254 struct ordered_events *oe); 255 256 static int process_id_index_stub(struct perf_tool *tool __maybe_unused, 257 union perf_event *event __maybe_unused, 258 struct perf_session *perf_session 259 __maybe_unused) 260 { 261 dump_printf(": unhandled!\n"); 262 return 0; 263 } 264 265 static int process_event_auxtrace_info_stub(struct perf_tool *tool __maybe_unused, 266 union perf_event *event __maybe_unused, 267 struct perf_session *session __maybe_unused) 268 { 269 dump_printf(": unhandled!\n"); 270 return 0; 271 } 272 273 static int skipn(int fd, off_t n) 274 { 275 char buf[4096]; 276 ssize_t ret; 277 278 while (n > 0) { 279 ret = read(fd, buf, min(n, (off_t)sizeof(buf))); 280 if (ret <= 0) 281 return ret; 282 n -= ret; 283 } 284 285 return 0; 286 } 287 288 static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused, 289 union perf_event *event, 290 struct perf_session *session 291 __maybe_unused) 292 { 293 dump_printf(": unhandled!\n"); 294 if (perf_data_file__is_pipe(session->file)) 295 skipn(perf_data_file__fd(session->file), event->auxtrace.size); 296 return event->auxtrace.size; 297 } 298 299 static 300 int process_event_auxtrace_error_stub(struct perf_tool *tool __maybe_unused, 301 union perf_event *event __maybe_unused, 302 struct perf_session *session __maybe_unused) 303 { 304 dump_printf(": unhandled!\n"); 305 return 0; 306 } 307 308 void perf_tool__fill_defaults(struct perf_tool *tool) 309 { 310 if (tool->sample == NULL) 311 tool->sample = process_event_sample_stub; 312 if (tool->mmap == NULL) 313 tool->mmap = process_event_stub; 314 if (tool->mmap2 == NULL) 315 tool->mmap2 = process_event_stub; 316 if (tool->comm == NULL) 317 tool->comm = process_event_stub; 318 if (tool->fork == NULL) 319 tool->fork = process_event_stub; 320 if (tool->exit == NULL) 321 tool->exit = process_event_stub; 322 if (tool->lost == NULL) 323 tool->lost = perf_event__process_lost; 324 if (tool->read == NULL) 325 tool->read = process_event_sample_stub; 326 if (tool->throttle == NULL) 327 tool->throttle = process_event_stub; 328 if (tool->unthrottle == NULL) 329 tool->unthrottle = process_event_stub; 330 if (tool->attr == NULL) 331 tool->attr = process_event_synth_attr_stub; 332 if (tool->tracing_data == NULL) 333 tool->tracing_data = process_event_synth_tracing_data_stub; 334 if (tool->build_id == NULL) 335 tool->build_id = process_build_id_stub; 336 if (tool->finished_round == NULL) { 337 if (tool->ordered_events) 338 tool->finished_round = process_finished_round; 339 else 340 tool->finished_round = process_finished_round_stub; 341 } 342 if (tool->id_index == NULL) 343 tool->id_index = process_id_index_stub; 344 if (tool->auxtrace_info == NULL) 345 tool->auxtrace_info = process_event_auxtrace_info_stub; 346 if (tool->auxtrace == NULL) 347 tool->auxtrace = process_event_auxtrace_stub; 348 if (tool->auxtrace_error == NULL) 349 tool->auxtrace_error = process_event_auxtrace_error_stub; 350 } 351 352 static void swap_sample_id_all(union perf_event *event, void *data) 353 { 354 void *end = (void *) event + event->header.size; 355 int size = end - data; 356 357 BUG_ON(size % sizeof(u64)); 358 mem_bswap_64(data, size); 359 } 360 361 static void perf_event__all64_swap(union perf_event *event, 362 bool sample_id_all __maybe_unused) 363 { 364 struct perf_event_header *hdr = &event->header; 365 mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr)); 366 } 367 368 static void perf_event__comm_swap(union perf_event *event, bool sample_id_all) 369 { 370 event->comm.pid = bswap_32(event->comm.pid); 371 event->comm.tid = bswap_32(event->comm.tid); 372 373 if (sample_id_all) { 374 void *data = &event->comm.comm; 375 376 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64)); 377 swap_sample_id_all(event, data); 378 } 379 } 380 381 static void perf_event__mmap_swap(union perf_event *event, 382 bool sample_id_all) 383 { 384 event->mmap.pid = bswap_32(event->mmap.pid); 385 event->mmap.tid = bswap_32(event->mmap.tid); 386 event->mmap.start = bswap_64(event->mmap.start); 387 event->mmap.len = bswap_64(event->mmap.len); 388 event->mmap.pgoff = bswap_64(event->mmap.pgoff); 389 390 if (sample_id_all) { 391 void *data = &event->mmap.filename; 392 393 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64)); 394 swap_sample_id_all(event, data); 395 } 396 } 397 398 static void perf_event__mmap2_swap(union perf_event *event, 399 bool sample_id_all) 400 { 401 event->mmap2.pid = bswap_32(event->mmap2.pid); 402 event->mmap2.tid = bswap_32(event->mmap2.tid); 403 event->mmap2.start = bswap_64(event->mmap2.start); 404 event->mmap2.len = bswap_64(event->mmap2.len); 405 event->mmap2.pgoff = bswap_64(event->mmap2.pgoff); 406 event->mmap2.maj = bswap_32(event->mmap2.maj); 407 event->mmap2.min = bswap_32(event->mmap2.min); 408 event->mmap2.ino = bswap_64(event->mmap2.ino); 409 410 if (sample_id_all) { 411 void *data = &event->mmap2.filename; 412 413 data += PERF_ALIGN(strlen(data) + 1, sizeof(u64)); 414 swap_sample_id_all(event, data); 415 } 416 } 417 static void perf_event__task_swap(union perf_event *event, bool sample_id_all) 418 { 419 event->fork.pid = bswap_32(event->fork.pid); 420 event->fork.tid = bswap_32(event->fork.tid); 421 event->fork.ppid = bswap_32(event->fork.ppid); 422 event->fork.ptid = bswap_32(event->fork.ptid); 423 event->fork.time = bswap_64(event->fork.time); 424 425 if (sample_id_all) 426 swap_sample_id_all(event, &event->fork + 1); 427 } 428 429 static void perf_event__read_swap(union perf_event *event, bool sample_id_all) 430 { 431 event->read.pid = bswap_32(event->read.pid); 432 event->read.tid = bswap_32(event->read.tid); 433 event->read.value = bswap_64(event->read.value); 434 event->read.time_enabled = bswap_64(event->read.time_enabled); 435 event->read.time_running = bswap_64(event->read.time_running); 436 event->read.id = bswap_64(event->read.id); 437 438 if (sample_id_all) 439 swap_sample_id_all(event, &event->read + 1); 440 } 441 442 static void perf_event__throttle_swap(union perf_event *event, 443 bool sample_id_all) 444 { 445 event->throttle.time = bswap_64(event->throttle.time); 446 event->throttle.id = bswap_64(event->throttle.id); 447 event->throttle.stream_id = bswap_64(event->throttle.stream_id); 448 449 if (sample_id_all) 450 swap_sample_id_all(event, &event->throttle + 1); 451 } 452 453 static u8 revbyte(u8 b) 454 { 455 int rev = (b >> 4) | ((b & 0xf) << 4); 456 rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2); 457 rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1); 458 return (u8) rev; 459 } 460 461 /* 462 * XXX this is hack in attempt to carry flags bitfield 463 * throught endian village. ABI says: 464 * 465 * Bit-fields are allocated from right to left (least to most significant) 466 * on little-endian implementations and from left to right (most to least 467 * significant) on big-endian implementations. 468 * 469 * The above seems to be byte specific, so we need to reverse each 470 * byte of the bitfield. 'Internet' also says this might be implementation 471 * specific and we probably need proper fix and carry perf_event_attr 472 * bitfield flags in separate data file FEAT_ section. Thought this seems 473 * to work for now. 474 */ 475 static void swap_bitfield(u8 *p, unsigned len) 476 { 477 unsigned i; 478 479 for (i = 0; i < len; i++) { 480 *p = revbyte(*p); 481 p++; 482 } 483 } 484 485 /* exported for swapping attributes in file header */ 486 void perf_event__attr_swap(struct perf_event_attr *attr) 487 { 488 attr->type = bswap_32(attr->type); 489 attr->size = bswap_32(attr->size); 490 attr->config = bswap_64(attr->config); 491 attr->sample_period = bswap_64(attr->sample_period); 492 attr->sample_type = bswap_64(attr->sample_type); 493 attr->read_format = bswap_64(attr->read_format); 494 attr->wakeup_events = bswap_32(attr->wakeup_events); 495 attr->bp_type = bswap_32(attr->bp_type); 496 attr->bp_addr = bswap_64(attr->bp_addr); 497 attr->bp_len = bswap_64(attr->bp_len); 498 attr->branch_sample_type = bswap_64(attr->branch_sample_type); 499 attr->sample_regs_user = bswap_64(attr->sample_regs_user); 500 attr->sample_stack_user = bswap_32(attr->sample_stack_user); 501 502 swap_bitfield((u8 *) (&attr->read_format + 1), sizeof(u64)); 503 } 504 505 static void perf_event__hdr_attr_swap(union perf_event *event, 506 bool sample_id_all __maybe_unused) 507 { 508 size_t size; 509 510 perf_event__attr_swap(&event->attr.attr); 511 512 size = event->header.size; 513 size -= (void *)&event->attr.id - (void *)event; 514 mem_bswap_64(event->attr.id, size); 515 } 516 517 static void perf_event__event_type_swap(union perf_event *event, 518 bool sample_id_all __maybe_unused) 519 { 520 event->event_type.event_type.event_id = 521 bswap_64(event->event_type.event_type.event_id); 522 } 523 524 static void perf_event__tracing_data_swap(union perf_event *event, 525 bool sample_id_all __maybe_unused) 526 { 527 event->tracing_data.size = bswap_32(event->tracing_data.size); 528 } 529 530 static void perf_event__auxtrace_info_swap(union perf_event *event, 531 bool sample_id_all __maybe_unused) 532 { 533 size_t size; 534 535 event->auxtrace_info.type = bswap_32(event->auxtrace_info.type); 536 537 size = event->header.size; 538 size -= (void *)&event->auxtrace_info.priv - (void *)event; 539 mem_bswap_64(event->auxtrace_info.priv, size); 540 } 541 542 static void perf_event__auxtrace_swap(union perf_event *event, 543 bool sample_id_all __maybe_unused) 544 { 545 event->auxtrace.size = bswap_64(event->auxtrace.size); 546 event->auxtrace.offset = bswap_64(event->auxtrace.offset); 547 event->auxtrace.reference = bswap_64(event->auxtrace.reference); 548 event->auxtrace.idx = bswap_32(event->auxtrace.idx); 549 event->auxtrace.tid = bswap_32(event->auxtrace.tid); 550 event->auxtrace.cpu = bswap_32(event->auxtrace.cpu); 551 } 552 553 static void perf_event__auxtrace_error_swap(union perf_event *event, 554 bool sample_id_all __maybe_unused) 555 { 556 event->auxtrace_error.type = bswap_32(event->auxtrace_error.type); 557 event->auxtrace_error.code = bswap_32(event->auxtrace_error.code); 558 event->auxtrace_error.cpu = bswap_32(event->auxtrace_error.cpu); 559 event->auxtrace_error.pid = bswap_32(event->auxtrace_error.pid); 560 event->auxtrace_error.tid = bswap_32(event->auxtrace_error.tid); 561 event->auxtrace_error.ip = bswap_64(event->auxtrace_error.ip); 562 } 563 564 typedef void (*perf_event__swap_op)(union perf_event *event, 565 bool sample_id_all); 566 567 static perf_event__swap_op perf_event__swap_ops[] = { 568 [PERF_RECORD_MMAP] = perf_event__mmap_swap, 569 [PERF_RECORD_MMAP2] = perf_event__mmap2_swap, 570 [PERF_RECORD_COMM] = perf_event__comm_swap, 571 [PERF_RECORD_FORK] = perf_event__task_swap, 572 [PERF_RECORD_EXIT] = perf_event__task_swap, 573 [PERF_RECORD_LOST] = perf_event__all64_swap, 574 [PERF_RECORD_READ] = perf_event__read_swap, 575 [PERF_RECORD_THROTTLE] = perf_event__throttle_swap, 576 [PERF_RECORD_UNTHROTTLE] = perf_event__throttle_swap, 577 [PERF_RECORD_SAMPLE] = perf_event__all64_swap, 578 [PERF_RECORD_HEADER_ATTR] = perf_event__hdr_attr_swap, 579 [PERF_RECORD_HEADER_EVENT_TYPE] = perf_event__event_type_swap, 580 [PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap, 581 [PERF_RECORD_HEADER_BUILD_ID] = NULL, 582 [PERF_RECORD_ID_INDEX] = perf_event__all64_swap, 583 [PERF_RECORD_AUXTRACE_INFO] = perf_event__auxtrace_info_swap, 584 [PERF_RECORD_AUXTRACE] = perf_event__auxtrace_swap, 585 [PERF_RECORD_AUXTRACE_ERROR] = perf_event__auxtrace_error_swap, 586 [PERF_RECORD_HEADER_MAX] = NULL, 587 }; 588 589 /* 590 * When perf record finishes a pass on every buffers, it records this pseudo 591 * event. 592 * We record the max timestamp t found in the pass n. 593 * Assuming these timestamps are monotonic across cpus, we know that if 594 * a buffer still has events with timestamps below t, they will be all 595 * available and then read in the pass n + 1. 596 * Hence when we start to read the pass n + 2, we can safely flush every 597 * events with timestamps below t. 598 * 599 * ============ PASS n ================= 600 * CPU 0 | CPU 1 601 * | 602 * cnt1 timestamps | cnt2 timestamps 603 * 1 | 2 604 * 2 | 3 605 * - | 4 <--- max recorded 606 * 607 * ============ PASS n + 1 ============== 608 * CPU 0 | CPU 1 609 * | 610 * cnt1 timestamps | cnt2 timestamps 611 * 3 | 5 612 * 4 | 6 613 * 5 | 7 <---- max recorded 614 * 615 * Flush every events below timestamp 4 616 * 617 * ============ PASS n + 2 ============== 618 * CPU 0 | CPU 1 619 * | 620 * cnt1 timestamps | cnt2 timestamps 621 * 6 | 8 622 * 7 | 9 623 * - | 10 624 * 625 * Flush every events below timestamp 7 626 * etc... 627 */ 628 static int process_finished_round(struct perf_tool *tool __maybe_unused, 629 union perf_event *event __maybe_unused, 630 struct ordered_events *oe) 631 { 632 return ordered_events__flush(oe, OE_FLUSH__ROUND); 633 } 634 635 int perf_session__queue_event(struct perf_session *s, union perf_event *event, 636 struct perf_sample *sample, u64 file_offset) 637 { 638 return ordered_events__queue(&s->ordered_events, event, sample, file_offset); 639 } 640 641 static void callchain__lbr_callstack_printf(struct perf_sample *sample) 642 { 643 struct ip_callchain *callchain = sample->callchain; 644 struct branch_stack *lbr_stack = sample->branch_stack; 645 u64 kernel_callchain_nr = callchain->nr; 646 unsigned int i; 647 648 for (i = 0; i < kernel_callchain_nr; i++) { 649 if (callchain->ips[i] == PERF_CONTEXT_USER) 650 break; 651 } 652 653 if ((i != kernel_callchain_nr) && lbr_stack->nr) { 654 u64 total_nr; 655 /* 656 * LBR callstack can only get user call chain, 657 * i is kernel call chain number, 658 * 1 is PERF_CONTEXT_USER. 659 * 660 * The user call chain is stored in LBR registers. 661 * LBR are pair registers. The caller is stored 662 * in "from" register, while the callee is stored 663 * in "to" register. 664 * For example, there is a call stack 665 * "A"->"B"->"C"->"D". 666 * The LBR registers will recorde like 667 * "C"->"D", "B"->"C", "A"->"B". 668 * So only the first "to" register and all "from" 669 * registers are needed to construct the whole stack. 670 */ 671 total_nr = i + 1 + lbr_stack->nr + 1; 672 kernel_callchain_nr = i + 1; 673 674 printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr); 675 676 for (i = 0; i < kernel_callchain_nr; i++) 677 printf("..... %2d: %016" PRIx64 "\n", 678 i, callchain->ips[i]); 679 680 printf("..... %2d: %016" PRIx64 "\n", 681 (int)(kernel_callchain_nr), lbr_stack->entries[0].to); 682 for (i = 0; i < lbr_stack->nr; i++) 683 printf("..... %2d: %016" PRIx64 "\n", 684 (int)(i + kernel_callchain_nr + 1), lbr_stack->entries[i].from); 685 } 686 } 687 688 static void callchain__printf(struct perf_evsel *evsel, 689 struct perf_sample *sample) 690 { 691 unsigned int i; 692 struct ip_callchain *callchain = sample->callchain; 693 694 if (has_branch_callstack(evsel)) 695 callchain__lbr_callstack_printf(sample); 696 697 printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr); 698 699 for (i = 0; i < callchain->nr; i++) 700 printf("..... %2d: %016" PRIx64 "\n", 701 i, callchain->ips[i]); 702 } 703 704 static void branch_stack__printf(struct perf_sample *sample) 705 { 706 uint64_t i; 707 708 printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr); 709 710 for (i = 0; i < sample->branch_stack->nr; i++) 711 printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 "\n", 712 i, sample->branch_stack->entries[i].from, 713 sample->branch_stack->entries[i].to); 714 } 715 716 static void regs_dump__printf(u64 mask, u64 *regs) 717 { 718 unsigned rid, i = 0; 719 720 for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) { 721 u64 val = regs[i++]; 722 723 printf(".... %-5s 0x%" PRIx64 "\n", 724 perf_reg_name(rid), val); 725 } 726 } 727 728 static const char *regs_abi[] = { 729 [PERF_SAMPLE_REGS_ABI_NONE] = "none", 730 [PERF_SAMPLE_REGS_ABI_32] = "32-bit", 731 [PERF_SAMPLE_REGS_ABI_64] = "64-bit", 732 }; 733 734 static inline const char *regs_dump_abi(struct regs_dump *d) 735 { 736 if (d->abi > PERF_SAMPLE_REGS_ABI_64) 737 return "unknown"; 738 739 return regs_abi[d->abi]; 740 } 741 742 static void regs__printf(const char *type, struct regs_dump *regs) 743 { 744 u64 mask = regs->mask; 745 746 printf("... %s regs: mask 0x%" PRIx64 " ABI %s\n", 747 type, 748 mask, 749 regs_dump_abi(regs)); 750 751 regs_dump__printf(mask, regs->regs); 752 } 753 754 static void regs_user__printf(struct perf_sample *sample) 755 { 756 struct regs_dump *user_regs = &sample->user_regs; 757 758 if (user_regs->regs) 759 regs__printf("user", user_regs); 760 } 761 762 static void regs_intr__printf(struct perf_sample *sample) 763 { 764 struct regs_dump *intr_regs = &sample->intr_regs; 765 766 if (intr_regs->regs) 767 regs__printf("intr", intr_regs); 768 } 769 770 static void stack_user__printf(struct stack_dump *dump) 771 { 772 printf("... ustack: size %" PRIu64 ", offset 0x%x\n", 773 dump->size, dump->offset); 774 } 775 776 static void perf_evlist__print_tstamp(struct perf_evlist *evlist, 777 union perf_event *event, 778 struct perf_sample *sample) 779 { 780 u64 sample_type = __perf_evlist__combined_sample_type(evlist); 781 782 if (event->header.type != PERF_RECORD_SAMPLE && 783 !perf_evlist__sample_id_all(evlist)) { 784 fputs("-1 -1 ", stdout); 785 return; 786 } 787 788 if ((sample_type & PERF_SAMPLE_CPU)) 789 printf("%u ", sample->cpu); 790 791 if (sample_type & PERF_SAMPLE_TIME) 792 printf("%" PRIu64 " ", sample->time); 793 } 794 795 static void sample_read__printf(struct perf_sample *sample, u64 read_format) 796 { 797 printf("... sample_read:\n"); 798 799 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) 800 printf("...... time enabled %016" PRIx64 "\n", 801 sample->read.time_enabled); 802 803 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) 804 printf("...... time running %016" PRIx64 "\n", 805 sample->read.time_running); 806 807 if (read_format & PERF_FORMAT_GROUP) { 808 u64 i; 809 810 printf(".... group nr %" PRIu64 "\n", sample->read.group.nr); 811 812 for (i = 0; i < sample->read.group.nr; i++) { 813 struct sample_read_value *value; 814 815 value = &sample->read.group.values[i]; 816 printf("..... id %016" PRIx64 817 ", value %016" PRIx64 "\n", 818 value->id, value->value); 819 } 820 } else 821 printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n", 822 sample->read.one.id, sample->read.one.value); 823 } 824 825 static void dump_event(struct perf_evlist *evlist, union perf_event *event, 826 u64 file_offset, struct perf_sample *sample) 827 { 828 if (!dump_trace) 829 return; 830 831 printf("\n%#" PRIx64 " [%#x]: event: %d\n", 832 file_offset, event->header.size, event->header.type); 833 834 trace_event(event); 835 836 if (sample) 837 perf_evlist__print_tstamp(evlist, event, sample); 838 839 printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset, 840 event->header.size, perf_event__name(event->header.type)); 841 } 842 843 static void dump_sample(struct perf_evsel *evsel, union perf_event *event, 844 struct perf_sample *sample) 845 { 846 u64 sample_type; 847 848 if (!dump_trace) 849 return; 850 851 printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n", 852 event->header.misc, sample->pid, sample->tid, sample->ip, 853 sample->period, sample->addr); 854 855 sample_type = evsel->attr.sample_type; 856 857 if (sample_type & PERF_SAMPLE_CALLCHAIN) 858 callchain__printf(evsel, sample); 859 860 if ((sample_type & PERF_SAMPLE_BRANCH_STACK) && !has_branch_callstack(evsel)) 861 branch_stack__printf(sample); 862 863 if (sample_type & PERF_SAMPLE_REGS_USER) 864 regs_user__printf(sample); 865 866 if (sample_type & PERF_SAMPLE_REGS_INTR) 867 regs_intr__printf(sample); 868 869 if (sample_type & PERF_SAMPLE_STACK_USER) 870 stack_user__printf(&sample->user_stack); 871 872 if (sample_type & PERF_SAMPLE_WEIGHT) 873 printf("... weight: %" PRIu64 "\n", sample->weight); 874 875 if (sample_type & PERF_SAMPLE_DATA_SRC) 876 printf(" . data_src: 0x%"PRIx64"\n", sample->data_src); 877 878 if (sample_type & PERF_SAMPLE_TRANSACTION) 879 printf("... transaction: %" PRIx64 "\n", sample->transaction); 880 881 if (sample_type & PERF_SAMPLE_READ) 882 sample_read__printf(sample, evsel->attr.read_format); 883 } 884 885 static struct machine *machines__find_for_cpumode(struct machines *machines, 886 union perf_event *event, 887 struct perf_sample *sample) 888 { 889 const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 890 struct machine *machine; 891 892 if (perf_guest && 893 ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) || 894 (cpumode == PERF_RECORD_MISC_GUEST_USER))) { 895 u32 pid; 896 897 if (event->header.type == PERF_RECORD_MMAP 898 || event->header.type == PERF_RECORD_MMAP2) 899 pid = event->mmap.pid; 900 else 901 pid = sample->pid; 902 903 machine = machines__find(machines, pid); 904 if (!machine) 905 machine = machines__find(machines, DEFAULT_GUEST_KERNEL_ID); 906 return machine; 907 } 908 909 return &machines->host; 910 } 911 912 static int deliver_sample_value(struct perf_evlist *evlist, 913 struct perf_tool *tool, 914 union perf_event *event, 915 struct perf_sample *sample, 916 struct sample_read_value *v, 917 struct machine *machine) 918 { 919 struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id); 920 921 if (sid) { 922 sample->id = v->id; 923 sample->period = v->value - sid->period; 924 sid->period = v->value; 925 } 926 927 if (!sid || sid->evsel == NULL) { 928 ++evlist->stats.nr_unknown_id; 929 return 0; 930 } 931 932 return tool->sample(tool, event, sample, sid->evsel, machine); 933 } 934 935 static int deliver_sample_group(struct perf_evlist *evlist, 936 struct perf_tool *tool, 937 union perf_event *event, 938 struct perf_sample *sample, 939 struct machine *machine) 940 { 941 int ret = -EINVAL; 942 u64 i; 943 944 for (i = 0; i < sample->read.group.nr; i++) { 945 ret = deliver_sample_value(evlist, tool, event, sample, 946 &sample->read.group.values[i], 947 machine); 948 if (ret) 949 break; 950 } 951 952 return ret; 953 } 954 955 static int 956 perf_evlist__deliver_sample(struct perf_evlist *evlist, 957 struct perf_tool *tool, 958 union perf_event *event, 959 struct perf_sample *sample, 960 struct perf_evsel *evsel, 961 struct machine *machine) 962 { 963 /* We know evsel != NULL. */ 964 u64 sample_type = evsel->attr.sample_type; 965 u64 read_format = evsel->attr.read_format; 966 967 /* Standard sample delievery. */ 968 if (!(sample_type & PERF_SAMPLE_READ)) 969 return tool->sample(tool, event, sample, evsel, machine); 970 971 /* For PERF_SAMPLE_READ we have either single or group mode. */ 972 if (read_format & PERF_FORMAT_GROUP) 973 return deliver_sample_group(evlist, tool, event, sample, 974 machine); 975 else 976 return deliver_sample_value(evlist, tool, event, sample, 977 &sample->read.one, machine); 978 } 979 980 static int machines__deliver_event(struct machines *machines, 981 struct perf_evlist *evlist, 982 union perf_event *event, 983 struct perf_sample *sample, 984 struct perf_tool *tool, u64 file_offset) 985 { 986 struct perf_evsel *evsel; 987 struct machine *machine; 988 989 dump_event(evlist, event, file_offset, sample); 990 991 evsel = perf_evlist__id2evsel(evlist, sample->id); 992 993 machine = machines__find_for_cpumode(machines, event, sample); 994 995 switch (event->header.type) { 996 case PERF_RECORD_SAMPLE: 997 dump_sample(evsel, event, sample); 998 if (evsel == NULL) { 999 ++evlist->stats.nr_unknown_id; 1000 return 0; 1001 } 1002 if (machine == NULL) { 1003 ++evlist->stats.nr_unprocessable_samples; 1004 return 0; 1005 } 1006 return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine); 1007 case PERF_RECORD_MMAP: 1008 return tool->mmap(tool, event, sample, machine); 1009 case PERF_RECORD_MMAP2: 1010 return tool->mmap2(tool, event, sample, machine); 1011 case PERF_RECORD_COMM: 1012 return tool->comm(tool, event, sample, machine); 1013 case PERF_RECORD_FORK: 1014 return tool->fork(tool, event, sample, machine); 1015 case PERF_RECORD_EXIT: 1016 return tool->exit(tool, event, sample, machine); 1017 case PERF_RECORD_LOST: 1018 if (tool->lost == perf_event__process_lost) 1019 evlist->stats.total_lost += event->lost.lost; 1020 return tool->lost(tool, event, sample, machine); 1021 case PERF_RECORD_READ: 1022 return tool->read(tool, event, sample, evsel, machine); 1023 case PERF_RECORD_THROTTLE: 1024 return tool->throttle(tool, event, sample, machine); 1025 case PERF_RECORD_UNTHROTTLE: 1026 return tool->unthrottle(tool, event, sample, machine); 1027 default: 1028 ++evlist->stats.nr_unknown_events; 1029 return -1; 1030 } 1031 } 1032 1033 static s64 perf_session__process_user_event(struct perf_session *session, 1034 union perf_event *event, 1035 u64 file_offset) 1036 { 1037 struct ordered_events *oe = &session->ordered_events; 1038 struct perf_tool *tool = session->tool; 1039 int fd = perf_data_file__fd(session->file); 1040 int err; 1041 1042 dump_event(session->evlist, event, file_offset, NULL); 1043 1044 /* These events are processed right away */ 1045 switch (event->header.type) { 1046 case PERF_RECORD_HEADER_ATTR: 1047 err = tool->attr(tool, event, &session->evlist); 1048 if (err == 0) { 1049 perf_session__set_id_hdr_size(session); 1050 perf_session__set_comm_exec(session); 1051 } 1052 return err; 1053 case PERF_RECORD_HEADER_EVENT_TYPE: 1054 /* 1055 * Depreceated, but we need to handle it for sake 1056 * of old data files create in pipe mode. 1057 */ 1058 return 0; 1059 case PERF_RECORD_HEADER_TRACING_DATA: 1060 /* setup for reading amidst mmap */ 1061 lseek(fd, file_offset, SEEK_SET); 1062 return tool->tracing_data(tool, event, session); 1063 case PERF_RECORD_HEADER_BUILD_ID: 1064 return tool->build_id(tool, event, session); 1065 case PERF_RECORD_FINISHED_ROUND: 1066 return tool->finished_round(tool, event, oe); 1067 case PERF_RECORD_ID_INDEX: 1068 return tool->id_index(tool, event, session); 1069 case PERF_RECORD_AUXTRACE_INFO: 1070 return tool->auxtrace_info(tool, event, session); 1071 case PERF_RECORD_AUXTRACE: 1072 /* setup for reading amidst mmap */ 1073 lseek(fd, file_offset + event->header.size, SEEK_SET); 1074 return tool->auxtrace(tool, event, session); 1075 case PERF_RECORD_AUXTRACE_ERROR: 1076 return tool->auxtrace_error(tool, event, session); 1077 default: 1078 return -EINVAL; 1079 } 1080 } 1081 1082 int perf_session__deliver_synth_event(struct perf_session *session, 1083 union perf_event *event, 1084 struct perf_sample *sample) 1085 { 1086 struct perf_evlist *evlist = session->evlist; 1087 struct perf_tool *tool = session->tool; 1088 1089 events_stats__inc(&evlist->stats, event->header.type); 1090 1091 if (event->header.type >= PERF_RECORD_USER_TYPE_START) 1092 return perf_session__process_user_event(session, event, 0); 1093 1094 return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0); 1095 } 1096 1097 static void event_swap(union perf_event *event, bool sample_id_all) 1098 { 1099 perf_event__swap_op swap; 1100 1101 swap = perf_event__swap_ops[event->header.type]; 1102 if (swap) 1103 swap(event, sample_id_all); 1104 } 1105 1106 int perf_session__peek_event(struct perf_session *session, off_t file_offset, 1107 void *buf, size_t buf_sz, 1108 union perf_event **event_ptr, 1109 struct perf_sample *sample) 1110 { 1111 union perf_event *event; 1112 size_t hdr_sz, rest; 1113 int fd; 1114 1115 if (session->one_mmap && !session->header.needs_swap) { 1116 event = file_offset - session->one_mmap_offset + 1117 session->one_mmap_addr; 1118 goto out_parse_sample; 1119 } 1120 1121 if (perf_data_file__is_pipe(session->file)) 1122 return -1; 1123 1124 fd = perf_data_file__fd(session->file); 1125 hdr_sz = sizeof(struct perf_event_header); 1126 1127 if (buf_sz < hdr_sz) 1128 return -1; 1129 1130 if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 || 1131 readn(fd, &buf, hdr_sz) != (ssize_t)hdr_sz) 1132 return -1; 1133 1134 event = (union perf_event *)buf; 1135 1136 if (session->header.needs_swap) 1137 perf_event_header__bswap(&event->header); 1138 1139 if (event->header.size < hdr_sz) 1140 return -1; 1141 1142 rest = event->header.size - hdr_sz; 1143 1144 if (readn(fd, &buf, rest) != (ssize_t)rest) 1145 return -1; 1146 1147 if (session->header.needs_swap) 1148 event_swap(event, perf_evlist__sample_id_all(session->evlist)); 1149 1150 out_parse_sample: 1151 1152 if (sample && event->header.type < PERF_RECORD_USER_TYPE_START && 1153 perf_evlist__parse_sample(session->evlist, event, sample)) 1154 return -1; 1155 1156 *event_ptr = event; 1157 1158 return 0; 1159 } 1160 1161 static s64 perf_session__process_event(struct perf_session *session, 1162 union perf_event *event, u64 file_offset) 1163 { 1164 struct perf_evlist *evlist = session->evlist; 1165 struct perf_tool *tool = session->tool; 1166 struct perf_sample sample; 1167 int ret; 1168 1169 if (session->header.needs_swap) 1170 event_swap(event, perf_evlist__sample_id_all(evlist)); 1171 1172 if (event->header.type >= PERF_RECORD_HEADER_MAX) 1173 return -EINVAL; 1174 1175 events_stats__inc(&evlist->stats, event->header.type); 1176 1177 if (event->header.type >= PERF_RECORD_USER_TYPE_START) 1178 return perf_session__process_user_event(session, event, file_offset); 1179 1180 /* 1181 * For all kernel events we get the sample data 1182 */ 1183 ret = perf_evlist__parse_sample(evlist, event, &sample); 1184 if (ret) 1185 return ret; 1186 1187 if (tool->ordered_events) { 1188 ret = perf_session__queue_event(session, event, &sample, file_offset); 1189 if (ret != -ETIME) 1190 return ret; 1191 } 1192 1193 return machines__deliver_event(&session->machines, evlist, event, 1194 &sample, tool, file_offset); 1195 } 1196 1197 void perf_event_header__bswap(struct perf_event_header *hdr) 1198 { 1199 hdr->type = bswap_32(hdr->type); 1200 hdr->misc = bswap_16(hdr->misc); 1201 hdr->size = bswap_16(hdr->size); 1202 } 1203 1204 struct thread *perf_session__findnew(struct perf_session *session, pid_t pid) 1205 { 1206 return machine__findnew_thread(&session->machines.host, -1, pid); 1207 } 1208 1209 static struct thread *perf_session__register_idle_thread(struct perf_session *session) 1210 { 1211 struct thread *thread; 1212 1213 thread = machine__findnew_thread(&session->machines.host, 0, 0); 1214 if (thread == NULL || thread__set_comm(thread, "swapper", 0)) { 1215 pr_err("problem inserting idle task.\n"); 1216 thread = NULL; 1217 } 1218 1219 return thread; 1220 } 1221 1222 static void perf_session__warn_about_errors(const struct perf_session *session) 1223 { 1224 const struct events_stats *stats = &session->evlist->stats; 1225 const struct ordered_events *oe = &session->ordered_events; 1226 1227 if (session->tool->lost == perf_event__process_lost && 1228 stats->nr_events[PERF_RECORD_LOST] != 0) { 1229 ui__warning("Processed %d events and lost %d chunks!\n\n" 1230 "Check IO/CPU overload!\n\n", 1231 stats->nr_events[0], 1232 stats->nr_events[PERF_RECORD_LOST]); 1233 } 1234 1235 if (stats->nr_unknown_events != 0) { 1236 ui__warning("Found %u unknown events!\n\n" 1237 "Is this an older tool processing a perf.data " 1238 "file generated by a more recent tool?\n\n" 1239 "If that is not the case, consider " 1240 "reporting to linux-kernel@vger.kernel.org.\n\n", 1241 stats->nr_unknown_events); 1242 } 1243 1244 if (stats->nr_unknown_id != 0) { 1245 ui__warning("%u samples with id not present in the header\n", 1246 stats->nr_unknown_id); 1247 } 1248 1249 if (stats->nr_invalid_chains != 0) { 1250 ui__warning("Found invalid callchains!\n\n" 1251 "%u out of %u events were discarded for this reason.\n\n" 1252 "Consider reporting to linux-kernel@vger.kernel.org.\n\n", 1253 stats->nr_invalid_chains, 1254 stats->nr_events[PERF_RECORD_SAMPLE]); 1255 } 1256 1257 if (stats->nr_unprocessable_samples != 0) { 1258 ui__warning("%u unprocessable samples recorded.\n" 1259 "Do you have a KVM guest running and not using 'perf kvm'?\n", 1260 stats->nr_unprocessable_samples); 1261 } 1262 1263 if (oe->nr_unordered_events != 0) 1264 ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events); 1265 } 1266 1267 volatile int session_done; 1268 1269 static int __perf_session__process_pipe_events(struct perf_session *session) 1270 { 1271 struct ordered_events *oe = &session->ordered_events; 1272 struct perf_tool *tool = session->tool; 1273 int fd = perf_data_file__fd(session->file); 1274 union perf_event *event; 1275 uint32_t size, cur_size = 0; 1276 void *buf = NULL; 1277 s64 skip = 0; 1278 u64 head; 1279 ssize_t err; 1280 void *p; 1281 1282 perf_tool__fill_defaults(tool); 1283 1284 head = 0; 1285 cur_size = sizeof(union perf_event); 1286 1287 buf = malloc(cur_size); 1288 if (!buf) 1289 return -errno; 1290 more: 1291 event = buf; 1292 err = readn(fd, event, sizeof(struct perf_event_header)); 1293 if (err <= 0) { 1294 if (err == 0) 1295 goto done; 1296 1297 pr_err("failed to read event header\n"); 1298 goto out_err; 1299 } 1300 1301 if (session->header.needs_swap) 1302 perf_event_header__bswap(&event->header); 1303 1304 size = event->header.size; 1305 if (size < sizeof(struct perf_event_header)) { 1306 pr_err("bad event header size\n"); 1307 goto out_err; 1308 } 1309 1310 if (size > cur_size) { 1311 void *new = realloc(buf, size); 1312 if (!new) { 1313 pr_err("failed to allocate memory to read event\n"); 1314 goto out_err; 1315 } 1316 buf = new; 1317 cur_size = size; 1318 event = buf; 1319 } 1320 p = event; 1321 p += sizeof(struct perf_event_header); 1322 1323 if (size - sizeof(struct perf_event_header)) { 1324 err = readn(fd, p, size - sizeof(struct perf_event_header)); 1325 if (err <= 0) { 1326 if (err == 0) { 1327 pr_err("unexpected end of event stream\n"); 1328 goto done; 1329 } 1330 1331 pr_err("failed to read event data\n"); 1332 goto out_err; 1333 } 1334 } 1335 1336 if ((skip = perf_session__process_event(session, event, head)) < 0) { 1337 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n", 1338 head, event->header.size, event->header.type); 1339 err = -EINVAL; 1340 goto out_err; 1341 } 1342 1343 head += size; 1344 1345 if (skip > 0) 1346 head += skip; 1347 1348 if (!session_done()) 1349 goto more; 1350 done: 1351 /* do the final flush for ordered samples */ 1352 err = ordered_events__flush(oe, OE_FLUSH__FINAL); 1353 out_err: 1354 free(buf); 1355 perf_session__warn_about_errors(session); 1356 ordered_events__free(&session->ordered_events); 1357 return err; 1358 } 1359 1360 static union perf_event * 1361 fetch_mmaped_event(struct perf_session *session, 1362 u64 head, size_t mmap_size, char *buf) 1363 { 1364 union perf_event *event; 1365 1366 /* 1367 * Ensure we have enough space remaining to read 1368 * the size of the event in the headers. 1369 */ 1370 if (head + sizeof(event->header) > mmap_size) 1371 return NULL; 1372 1373 event = (union perf_event *)(buf + head); 1374 1375 if (session->header.needs_swap) 1376 perf_event_header__bswap(&event->header); 1377 1378 if (head + event->header.size > mmap_size) { 1379 /* We're not fetching the event so swap back again */ 1380 if (session->header.needs_swap) 1381 perf_event_header__bswap(&event->header); 1382 return NULL; 1383 } 1384 1385 return event; 1386 } 1387 1388 /* 1389 * On 64bit we can mmap the data file in one go. No need for tiny mmap 1390 * slices. On 32bit we use 32MB. 1391 */ 1392 #if BITS_PER_LONG == 64 1393 #define MMAP_SIZE ULLONG_MAX 1394 #define NUM_MMAPS 1 1395 #else 1396 #define MMAP_SIZE (32 * 1024 * 1024ULL) 1397 #define NUM_MMAPS 128 1398 #endif 1399 1400 static int __perf_session__process_events(struct perf_session *session, 1401 u64 data_offset, u64 data_size, 1402 u64 file_size) 1403 { 1404 struct ordered_events *oe = &session->ordered_events; 1405 struct perf_tool *tool = session->tool; 1406 int fd = perf_data_file__fd(session->file); 1407 u64 head, page_offset, file_offset, file_pos, size; 1408 int err, mmap_prot, mmap_flags, map_idx = 0; 1409 size_t mmap_size; 1410 char *buf, *mmaps[NUM_MMAPS]; 1411 union perf_event *event; 1412 struct ui_progress prog; 1413 s64 skip; 1414 1415 perf_tool__fill_defaults(tool); 1416 1417 page_offset = page_size * (data_offset / page_size); 1418 file_offset = page_offset; 1419 head = data_offset - page_offset; 1420 1421 if (data_size && (data_offset + data_size < file_size)) 1422 file_size = data_offset + data_size; 1423 1424 ui_progress__init(&prog, file_size, "Processing events..."); 1425 1426 mmap_size = MMAP_SIZE; 1427 if (mmap_size > file_size) { 1428 mmap_size = file_size; 1429 session->one_mmap = true; 1430 } 1431 1432 memset(mmaps, 0, sizeof(mmaps)); 1433 1434 mmap_prot = PROT_READ; 1435 mmap_flags = MAP_SHARED; 1436 1437 if (session->header.needs_swap) { 1438 mmap_prot |= PROT_WRITE; 1439 mmap_flags = MAP_PRIVATE; 1440 } 1441 remap: 1442 buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd, 1443 file_offset); 1444 if (buf == MAP_FAILED) { 1445 pr_err("failed to mmap file\n"); 1446 err = -errno; 1447 goto out_err; 1448 } 1449 mmaps[map_idx] = buf; 1450 map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1); 1451 file_pos = file_offset + head; 1452 if (session->one_mmap) { 1453 session->one_mmap_addr = buf; 1454 session->one_mmap_offset = file_offset; 1455 } 1456 1457 more: 1458 event = fetch_mmaped_event(session, head, mmap_size, buf); 1459 if (!event) { 1460 if (mmaps[map_idx]) { 1461 munmap(mmaps[map_idx], mmap_size); 1462 mmaps[map_idx] = NULL; 1463 } 1464 1465 page_offset = page_size * (head / page_size); 1466 file_offset += page_offset; 1467 head -= page_offset; 1468 goto remap; 1469 } 1470 1471 size = event->header.size; 1472 1473 if (size < sizeof(struct perf_event_header) || 1474 (skip = perf_session__process_event(session, event, file_pos)) < 0) { 1475 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n", 1476 file_offset + head, event->header.size, 1477 event->header.type); 1478 err = -EINVAL; 1479 goto out_err; 1480 } 1481 1482 if (skip) 1483 size += skip; 1484 1485 head += size; 1486 file_pos += size; 1487 1488 ui_progress__update(&prog, size); 1489 1490 if (session_done()) 1491 goto out; 1492 1493 if (file_pos < file_size) 1494 goto more; 1495 1496 out: 1497 /* do the final flush for ordered samples */ 1498 err = ordered_events__flush(oe, OE_FLUSH__FINAL); 1499 out_err: 1500 ui_progress__finish(); 1501 perf_session__warn_about_errors(session); 1502 ordered_events__free(&session->ordered_events); 1503 session->one_mmap = false; 1504 return err; 1505 } 1506 1507 int perf_session__process_events(struct perf_session *session) 1508 { 1509 u64 size = perf_data_file__size(session->file); 1510 int err; 1511 1512 if (perf_session__register_idle_thread(session) == NULL) 1513 return -ENOMEM; 1514 1515 if (!perf_data_file__is_pipe(session->file)) 1516 err = __perf_session__process_events(session, 1517 session->header.data_offset, 1518 session->header.data_size, size); 1519 else 1520 err = __perf_session__process_pipe_events(session); 1521 1522 return err; 1523 } 1524 1525 bool perf_session__has_traces(struct perf_session *session, const char *msg) 1526 { 1527 struct perf_evsel *evsel; 1528 1529 evlist__for_each(session->evlist, evsel) { 1530 if (evsel->attr.type == PERF_TYPE_TRACEPOINT) 1531 return true; 1532 } 1533 1534 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg); 1535 return false; 1536 } 1537 1538 int maps__set_kallsyms_ref_reloc_sym(struct map **maps, 1539 const char *symbol_name, u64 addr) 1540 { 1541 char *bracket; 1542 enum map_type i; 1543 struct ref_reloc_sym *ref; 1544 1545 ref = zalloc(sizeof(struct ref_reloc_sym)); 1546 if (ref == NULL) 1547 return -ENOMEM; 1548 1549 ref->name = strdup(symbol_name); 1550 if (ref->name == NULL) { 1551 free(ref); 1552 return -ENOMEM; 1553 } 1554 1555 bracket = strchr(ref->name, ']'); 1556 if (bracket) 1557 *bracket = '\0'; 1558 1559 ref->addr = addr; 1560 1561 for (i = 0; i < MAP__NR_TYPES; ++i) { 1562 struct kmap *kmap = map__kmap(maps[i]); 1563 1564 if (!kmap) 1565 continue; 1566 kmap->ref_reloc_sym = ref; 1567 } 1568 1569 return 0; 1570 } 1571 1572 size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp) 1573 { 1574 return machines__fprintf_dsos(&session->machines, fp); 1575 } 1576 1577 size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp, 1578 bool (skip)(struct dso *dso, int parm), int parm) 1579 { 1580 return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm); 1581 } 1582 1583 size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp) 1584 { 1585 size_t ret = fprintf(fp, "Aggregated stats:\n"); 1586 1587 ret += events_stats__fprintf(&session->evlist->stats, fp); 1588 return ret; 1589 } 1590 1591 size_t perf_session__fprintf(struct perf_session *session, FILE *fp) 1592 { 1593 /* 1594 * FIXME: Here we have to actually print all the machines in this 1595 * session, not just the host... 1596 */ 1597 return machine__fprintf(&session->machines.host, fp); 1598 } 1599 1600 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session, 1601 unsigned int type) 1602 { 1603 struct perf_evsel *pos; 1604 1605 evlist__for_each(session->evlist, pos) { 1606 if (pos->attr.type == type) 1607 return pos; 1608 } 1609 return NULL; 1610 } 1611 1612 void perf_evsel__print_ip(struct perf_evsel *evsel, struct perf_sample *sample, 1613 struct addr_location *al, 1614 unsigned int print_opts, unsigned int stack_depth) 1615 { 1616 struct callchain_cursor_node *node; 1617 int print_ip = print_opts & PRINT_IP_OPT_IP; 1618 int print_sym = print_opts & PRINT_IP_OPT_SYM; 1619 int print_dso = print_opts & PRINT_IP_OPT_DSO; 1620 int print_symoffset = print_opts & PRINT_IP_OPT_SYMOFFSET; 1621 int print_oneline = print_opts & PRINT_IP_OPT_ONELINE; 1622 int print_srcline = print_opts & PRINT_IP_OPT_SRCLINE; 1623 char s = print_oneline ? ' ' : '\t'; 1624 1625 if (symbol_conf.use_callchain && sample->callchain) { 1626 struct addr_location node_al; 1627 1628 if (thread__resolve_callchain(al->thread, evsel, 1629 sample, NULL, NULL, 1630 PERF_MAX_STACK_DEPTH) != 0) { 1631 if (verbose) 1632 error("Failed to resolve callchain. Skipping\n"); 1633 return; 1634 } 1635 callchain_cursor_commit(&callchain_cursor); 1636 1637 if (print_symoffset) 1638 node_al = *al; 1639 1640 while (stack_depth) { 1641 u64 addr = 0; 1642 1643 node = callchain_cursor_current(&callchain_cursor); 1644 if (!node) 1645 break; 1646 1647 if (node->sym && node->sym->ignore) 1648 goto next; 1649 1650 if (print_ip) 1651 printf("%c%16" PRIx64, s, node->ip); 1652 1653 if (node->map) 1654 addr = node->map->map_ip(node->map, node->ip); 1655 1656 if (print_sym) { 1657 printf(" "); 1658 if (print_symoffset) { 1659 node_al.addr = addr; 1660 node_al.map = node->map; 1661 symbol__fprintf_symname_offs(node->sym, &node_al, stdout); 1662 } else 1663 symbol__fprintf_symname(node->sym, stdout); 1664 } 1665 1666 if (print_dso) { 1667 printf(" ("); 1668 map__fprintf_dsoname(node->map, stdout); 1669 printf(")"); 1670 } 1671 1672 if (print_srcline) 1673 map__fprintf_srcline(node->map, addr, "\n ", 1674 stdout); 1675 1676 if (!print_oneline) 1677 printf("\n"); 1678 1679 stack_depth--; 1680 next: 1681 callchain_cursor_advance(&callchain_cursor); 1682 } 1683 1684 } else { 1685 if (al->sym && al->sym->ignore) 1686 return; 1687 1688 if (print_ip) 1689 printf("%16" PRIx64, sample->ip); 1690 1691 if (print_sym) { 1692 printf(" "); 1693 if (print_symoffset) 1694 symbol__fprintf_symname_offs(al->sym, al, 1695 stdout); 1696 else 1697 symbol__fprintf_symname(al->sym, stdout); 1698 } 1699 1700 if (print_dso) { 1701 printf(" ("); 1702 map__fprintf_dsoname(al->map, stdout); 1703 printf(")"); 1704 } 1705 1706 if (print_srcline) 1707 map__fprintf_srcline(al->map, al->addr, "\n ", stdout); 1708 } 1709 } 1710 1711 int perf_session__cpu_bitmap(struct perf_session *session, 1712 const char *cpu_list, unsigned long *cpu_bitmap) 1713 { 1714 int i, err = -1; 1715 struct cpu_map *map; 1716 1717 for (i = 0; i < PERF_TYPE_MAX; ++i) { 1718 struct perf_evsel *evsel; 1719 1720 evsel = perf_session__find_first_evtype(session, i); 1721 if (!evsel) 1722 continue; 1723 1724 if (!(evsel->attr.sample_type & PERF_SAMPLE_CPU)) { 1725 pr_err("File does not contain CPU events. " 1726 "Remove -c option to proceed.\n"); 1727 return -1; 1728 } 1729 } 1730 1731 map = cpu_map__new(cpu_list); 1732 if (map == NULL) { 1733 pr_err("Invalid cpu_list\n"); 1734 return -1; 1735 } 1736 1737 for (i = 0; i < map->nr; i++) { 1738 int cpu = map->map[i]; 1739 1740 if (cpu >= MAX_NR_CPUS) { 1741 pr_err("Requested CPU %d too large. " 1742 "Consider raising MAX_NR_CPUS\n", cpu); 1743 goto out_delete_map; 1744 } 1745 1746 set_bit(cpu, cpu_bitmap); 1747 } 1748 1749 err = 0; 1750 1751 out_delete_map: 1752 cpu_map__delete(map); 1753 return err; 1754 } 1755 1756 void perf_session__fprintf_info(struct perf_session *session, FILE *fp, 1757 bool full) 1758 { 1759 struct stat st; 1760 int fd, ret; 1761 1762 if (session == NULL || fp == NULL) 1763 return; 1764 1765 fd = perf_data_file__fd(session->file); 1766 1767 ret = fstat(fd, &st); 1768 if (ret == -1) 1769 return; 1770 1771 fprintf(fp, "# ========\n"); 1772 fprintf(fp, "# captured on: %s", ctime(&st.st_ctime)); 1773 perf_header__fprintf_info(session, fp, full); 1774 fprintf(fp, "# ========\n#\n"); 1775 } 1776 1777 1778 int __perf_session__set_tracepoints_handlers(struct perf_session *session, 1779 const struct perf_evsel_str_handler *assocs, 1780 size_t nr_assocs) 1781 { 1782 struct perf_evsel *evsel; 1783 size_t i; 1784 int err; 1785 1786 for (i = 0; i < nr_assocs; i++) { 1787 /* 1788 * Adding a handler for an event not in the session, 1789 * just ignore it. 1790 */ 1791 evsel = perf_evlist__find_tracepoint_by_name(session->evlist, assocs[i].name); 1792 if (evsel == NULL) 1793 continue; 1794 1795 err = -EEXIST; 1796 if (evsel->handler != NULL) 1797 goto out; 1798 evsel->handler = assocs[i].handler; 1799 } 1800 1801 err = 0; 1802 out: 1803 return err; 1804 } 1805 1806 int perf_event__process_id_index(struct perf_tool *tool __maybe_unused, 1807 union perf_event *event, 1808 struct perf_session *session) 1809 { 1810 struct perf_evlist *evlist = session->evlist; 1811 struct id_index_event *ie = &event->id_index; 1812 size_t i, nr, max_nr; 1813 1814 max_nr = (ie->header.size - sizeof(struct id_index_event)) / 1815 sizeof(struct id_index_entry); 1816 nr = ie->nr; 1817 if (nr > max_nr) 1818 return -EINVAL; 1819 1820 if (dump_trace) 1821 fprintf(stdout, " nr: %zu\n", nr); 1822 1823 for (i = 0; i < nr; i++) { 1824 struct id_index_entry *e = &ie->entries[i]; 1825 struct perf_sample_id *sid; 1826 1827 if (dump_trace) { 1828 fprintf(stdout, " ... id: %"PRIu64, e->id); 1829 fprintf(stdout, " idx: %"PRIu64, e->idx); 1830 fprintf(stdout, " cpu: %"PRId64, e->cpu); 1831 fprintf(stdout, " tid: %"PRId64"\n", e->tid); 1832 } 1833 1834 sid = perf_evlist__id2sid(evlist, e->id); 1835 if (!sid) 1836 return -ENOENT; 1837 sid->idx = e->idx; 1838 sid->cpu = e->cpu; 1839 sid->tid = e->tid; 1840 } 1841 return 0; 1842 } 1843 1844 int perf_event__synthesize_id_index(struct perf_tool *tool, 1845 perf_event__handler_t process, 1846 struct perf_evlist *evlist, 1847 struct machine *machine) 1848 { 1849 union perf_event *ev; 1850 struct perf_evsel *evsel; 1851 size_t nr = 0, i = 0, sz, max_nr, n; 1852 int err; 1853 1854 pr_debug2("Synthesizing id index\n"); 1855 1856 max_nr = (UINT16_MAX - sizeof(struct id_index_event)) / 1857 sizeof(struct id_index_entry); 1858 1859 evlist__for_each(evlist, evsel) 1860 nr += evsel->ids; 1861 1862 n = nr > max_nr ? max_nr : nr; 1863 sz = sizeof(struct id_index_event) + n * sizeof(struct id_index_entry); 1864 ev = zalloc(sz); 1865 if (!ev) 1866 return -ENOMEM; 1867 1868 ev->id_index.header.type = PERF_RECORD_ID_INDEX; 1869 ev->id_index.header.size = sz; 1870 ev->id_index.nr = n; 1871 1872 evlist__for_each(evlist, evsel) { 1873 u32 j; 1874 1875 for (j = 0; j < evsel->ids; j++) { 1876 struct id_index_entry *e; 1877 struct perf_sample_id *sid; 1878 1879 if (i >= n) { 1880 err = process(tool, ev, NULL, machine); 1881 if (err) 1882 goto out_err; 1883 nr -= n; 1884 i = 0; 1885 } 1886 1887 e = &ev->id_index.entries[i++]; 1888 1889 e->id = evsel->id[j]; 1890 1891 sid = perf_evlist__id2sid(evlist, e->id); 1892 if (!sid) { 1893 free(ev); 1894 return -ENOENT; 1895 } 1896 1897 e->idx = sid->idx; 1898 e->cpu = sid->cpu; 1899 e->tid = sid->tid; 1900 } 1901 } 1902 1903 sz = sizeof(struct id_index_event) + nr * sizeof(struct id_index_entry); 1904 ev->id_index.header.size = sz; 1905 ev->id_index.nr = nr; 1906 1907 err = process(tool, ev, NULL, machine); 1908 out_err: 1909 free(ev); 1910 1911 return err; 1912 } 1913