tools/perf/util/session.c

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