tools/perf/util/session.c

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