tools/perf/util/intel-bts.c

   1 /*
   2  * intel-bts.c: Intel Processor Trace support
   3  * Copyright (c) 2013-2015, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  */
  15
  16 #include <endian.h>
  17 #include <errno.h>
  18 #include <byteswap.h>
  19 #include <inttypes.h>
  20 #include <linux/kernel.h>
  21 #include <linux/types.h>
  22 #include <linux/bitops.h>
  23 #include <linux/log2.h>
  24
  25 #include "cpumap.h"
  26 #include "color.h"
  27 #include "evsel.h"
  28 #include "evlist.h"
  29 #include "machine.h"
  30 #include "map.h"
  31 #include "symbol.h"
  32 #include "session.h"
  33 #include "util.h"
  34 #include "thread.h"
  35 #include "thread-stack.h"
  36 #include "debug.h"
  37 #include "tsc.h"
  38 #include "auxtrace.h"
  39 #include "intel-pt-decoder/intel-pt-insn-decoder.h"
  40 #include "intel-bts.h"
  41
  42 #define MAX_TIMESTAMP (~0ULL)
  43
  44 #define INTEL_BTS_ERR_NOINSN  5
  45 #define INTEL_BTS_ERR_LOST    9
  46
  47 #if __BYTE_ORDER == __BIG_ENDIAN
  48 #define le64_to_cpu bswap_64
  49 #else
  50 #define le64_to_cpu
  51 #endif
  52
  53 struct intel_bts {
  54         struct auxtrace                 auxtrace;
  55         struct auxtrace_queues          queues;
  56         struct auxtrace_heap            heap;
  57         u32                             auxtrace_type;
  58         struct perf_session             *session;
  59         struct machine                  *machine;
  60         bool                            sampling_mode;
  61         bool                            snapshot_mode;
  62         bool                            data_queued;
  63         u32                             pmu_type;
  64         struct perf_tsc_conversion      tc;
  65         bool                            cap_user_time_zero;
  66         struct itrace_synth_opts        synth_opts;
  67         bool                            sample_branches;
  68         u32                             branches_filter;
  69         u64                             branches_sample_type;
  70         u64                             branches_id;
  71         size_t                          branches_event_size;
  72         unsigned long                   num_events;
  73 };
  74
  75 struct intel_bts_queue {
  76         struct intel_bts        *bts;
  77         unsigned int            queue_nr;
  78         struct auxtrace_buffer  *buffer;
  79         bool                    on_heap;
  80         bool                    done;
  81         pid_t                   pid;
  82         pid_t                   tid;
  83         int                     cpu;
  84         u64                     time;
  85         struct intel_pt_insn    intel_pt_insn;
  86         u32                     sample_flags;
  87 };
  88
  89 struct branch {
  90         u64 from;
  91         u64 to;
  92         u64 misc;
  93 };
  94
  95 static void intel_bts_dump(struct intel_bts *bts __maybe_unused,
  96                            unsigned char *buf, size_t len)
  97 {
  98         struct branch *branch;
  99         size_t i, pos = 0, br_sz = sizeof(struct branch), sz;
 100         const char *color = PERF_COLOR_BLUE;
 101
 102         color_fprintf(stdout, color,
 103                       ". ... Intel BTS data: size %zu bytes\n",
 104                       len);
 105
 106         while (len) {
 107                 if (len >= br_sz)
 108                         sz = br_sz;
 109                 else
 110                         sz = len;
 111                 printf(".");
 112                 color_fprintf(stdout, color, "  %08x: ", pos);
 113                 for (i = 0; i < sz; i++)
 114                         color_fprintf(stdout, color, " %02x", buf[i]);
 115                 for (; i < br_sz; i++)
 116                         color_fprintf(stdout, color, "   ");
 117                 if (len >= br_sz) {
 118                         branch = (struct branch *)buf;
 119                         color_fprintf(stdout, color, " %"PRIx64" -> %"PRIx64" %s\n",
 120                                       le64_to_cpu(branch->from),
 121                                       le64_to_cpu(branch->to),
 122                                       le64_to_cpu(branch->misc) & 0x10 ?
 123                                                         "pred" : "miss");
 124                 } else {
 125                         color_fprintf(stdout, color, " Bad record!\n");
 126                 }
 127                 pos += sz;
 128                 buf += sz;
 129                 len -= sz;
 130         }
 131 }
 132
 133 static void intel_bts_dump_event(struct intel_bts *bts, unsigned char *buf,
 134                                  size_t len)
 135 {
 136         printf(".\n");
 137         intel_bts_dump(bts, buf, len);
 138 }
 139
 140 static int intel_bts_lost(struct intel_bts *bts, struct perf_sample *sample)
 141 {
 142         union perf_event event;
 143         int err;
 144
 145         auxtrace_synth_error(&event.auxtrace_error, PERF_AUXTRACE_ERROR_ITRACE,
 146                              INTEL_BTS_ERR_LOST, sample->cpu, sample->pid,
 147                              sample->tid, 0, "Lost trace data", sample->time);
 148
 149         err = perf_session__deliver_synth_event(bts->session, &event, NULL);
 150         if (err)
 151                 pr_err("Intel BTS: failed to deliver error event, error %d\n",
 152                        err);
 153
 154         return err;
 155 }
 156
 157 static struct intel_bts_queue *intel_bts_alloc_queue(struct intel_bts *bts,
 158                                                      unsigned int queue_nr)
 159 {
 160         struct intel_bts_queue *btsq;
 161
 162         btsq = zalloc(sizeof(struct intel_bts_queue));
 163         if (!btsq)
 164                 return NULL;
 165
 166         btsq->bts = bts;
 167         btsq->queue_nr = queue_nr;
 168         btsq->pid = -1;
 169         btsq->tid = -1;
 170         btsq->cpu = -1;
 171
 172         return btsq;
 173 }
 174
 175 static int intel_bts_setup_queue(struct intel_bts *bts,
 176                                  struct auxtrace_queue *queue,
 177                                  unsigned int queue_nr)
 178 {
 179         struct intel_bts_queue *btsq = queue->priv;
 180
 181         if (list_empty(&queue->head))
 182                 return 0;
 183
 184         if (!btsq) {
 185                 btsq = intel_bts_alloc_queue(bts, queue_nr);
 186                 if (!btsq)
 187                         return -ENOMEM;
 188                 queue->priv = btsq;
 189
 190                 if (queue->cpu != -1)
 191                         btsq->cpu = queue->cpu;
 192                 btsq->tid = queue->tid;
 193         }
 194
 195         if (bts->sampling_mode)
 196                 return 0;
 197
 198         if (!btsq->on_heap && !btsq->buffer) {
 199                 int ret;
 200
 201                 btsq->buffer = auxtrace_buffer__next(queue, NULL);
 202                 if (!btsq->buffer)
 203                         return 0;
 204
 205                 ret = auxtrace_heap__add(&bts->heap, queue_nr,
 206                                          btsq->buffer->reference);
 207                 if (ret)
 208                         return ret;
 209                 btsq->on_heap = true;
 210         }
 211
 212         return 0;
 213 }
 214
 215 static int intel_bts_setup_queues(struct intel_bts *bts)
 216 {
 217         unsigned int i;
 218         int ret;
 219
 220         for (i = 0; i < bts->queues.nr_queues; i++) {
 221                 ret = intel_bts_setup_queue(bts, &bts->queues.queue_array[i],
 222                                             i);
 223                 if (ret)
 224                         return ret;
 225         }
 226         return 0;
 227 }
 228
 229 static inline int intel_bts_update_queues(struct intel_bts *bts)
 230 {
 231         if (bts->queues.new_data) {
 232                 bts->queues.new_data = false;
 233                 return intel_bts_setup_queues(bts);
 234         }
 235         return 0;
 236 }
 237
 238 static unsigned char *intel_bts_find_overlap(unsigned char *buf_a, size_t len_a,
 239                                              unsigned char *buf_b, size_t len_b)
 240 {
 241         size_t offs, len;
 242
 243         if (len_a > len_b)
 244                 offs = len_a - len_b;
 245         else
 246                 offs = 0;
 247
 248         for (; offs < len_a; offs += sizeof(struct branch)) {
 249                 len = len_a - offs;
 250                 if (!memcmp(buf_a + offs, buf_b, len))
 251                         return buf_b + len;
 252         }
 253
 254         return buf_b;
 255 }
 256
 257 static int intel_bts_do_fix_overlap(struct auxtrace_queue *queue,
 258                                     struct auxtrace_buffer *b)
 259 {
 260         struct auxtrace_buffer *a;
 261         void *start;
 262
 263         if (b->list.prev == &queue->head)
 264                 return 0;
 265         a = list_entry(b->list.prev, struct auxtrace_buffer, list);
 266         start = intel_bts_find_overlap(a->data, a->size, b->data, b->size);
 267         if (!start)
 268                 return -EINVAL;
 269         b->use_size = b->data + b->size - start;
 270         b->use_data = start;
 271         return 0;
 272 }
 273
 274 static inline u8 intel_bts_cpumode(struct intel_bts *bts, uint64_t ip)
 275 {
 276         return machine__kernel_ip(bts->machine, ip) ?
 277                PERF_RECORD_MISC_KERNEL :
 278                PERF_RECORD_MISC_USER;
 279 }
 280
 281 static int intel_bts_synth_branch_sample(struct intel_bts_queue *btsq,
 282                                          struct branch *branch)
 283 {
 284         int ret;
 285         struct intel_bts *bts = btsq->bts;
 286         union perf_event event;
 287         struct perf_sample sample = { .ip = 0, };
 288
 289         if (bts->synth_opts.initial_skip &&
 290             bts->num_events++ <= bts->synth_opts.initial_skip)
 291                 return 0;
 292
 293         sample.ip = le64_to_cpu(branch->from);
 294         sample.cpumode = intel_bts_cpumode(bts, sample.ip);
 295         sample.pid = btsq->pid;
 296         sample.tid = btsq->tid;
 297         sample.addr = le64_to_cpu(branch->to);
 298         sample.id = btsq->bts->branches_id;
 299         sample.stream_id = btsq->bts->branches_id;
 300         sample.period = 1;
 301         sample.cpu = btsq->cpu;
 302         sample.flags = btsq->sample_flags;
 303         sample.insn_len = btsq->intel_pt_insn.length;
 304         memcpy(sample.insn, btsq->intel_pt_insn.buf, INTEL_PT_INSN_BUF_SZ);
 305
 306         event.sample.header.type = PERF_RECORD_SAMPLE;
 307         event.sample.header.misc = sample.cpumode;
 308         event.sample.header.size = sizeof(struct perf_event_header);
 309
 310         if (bts->synth_opts.inject) {
 311                 event.sample.header.size = bts->branches_event_size;
 312                 ret = perf_event__synthesize_sample(&event,
 313                                                     bts->branches_sample_type,
 314                                                     0, &sample);
 315                 if (ret)
 316                         return ret;
 317         }
 318
 319         ret = perf_session__deliver_synth_event(bts->session, &event, &sample);
 320         if (ret)
 321                 pr_err("Intel BTS: failed to deliver branch event, error %d\n",
 322                        ret);
 323
 324         return ret;
 325 }
 326
 327 static int intel_bts_get_next_insn(struct intel_bts_queue *btsq, u64 ip)
 328 {
 329         struct machine *machine = btsq->bts->machine;
 330         struct thread *thread;
 331         unsigned char buf[INTEL_PT_INSN_BUF_SZ];
 332         ssize_t len;
 333         bool x86_64;
 334         int err = -1;
 335
 336         thread = machine__find_thread(machine, -1, btsq->tid);
 337         if (!thread)
 338                 return -1;
 339
 340         len = thread__memcpy(thread, machine, buf, ip, INTEL_PT_INSN_BUF_SZ, &x86_64);
 341         if (len <= 0)
 342                 goto out_put;
 343
 344         if (intel_pt_get_insn(buf, len, x86_64, &btsq->intel_pt_insn))
 345                 goto out_put;
 346
 347         err = 0;
 348 out_put:
 349         thread__put(thread);
 350         return err;
 351 }
 352
 353 static int intel_bts_synth_error(struct intel_bts *bts, int cpu, pid_t pid,
 354                                  pid_t tid, u64 ip)
 355 {
 356         union perf_event event;
 357         int err;
 358
 359         auxtrace_synth_error(&event.auxtrace_error, PERF_AUXTRACE_ERROR_ITRACE,
 360                              INTEL_BTS_ERR_NOINSN, cpu, pid, tid, ip,
 361                              "Failed to get instruction", 0);
 362
 363         err = perf_session__deliver_synth_event(bts->session, &event, NULL);
 364         if (err)
 365                 pr_err("Intel BTS: failed to deliver error event, error %d\n",
 366                        err);
 367
 368         return err;
 369 }
 370
 371 static int intel_bts_get_branch_type(struct intel_bts_queue *btsq,
 372                                      struct branch *branch)
 373 {
 374         int err;
 375
 376         if (!branch->from) {
 377                 if (branch->to)
 378                         btsq->sample_flags = PERF_IP_FLAG_BRANCH |
 379                                              PERF_IP_FLAG_TRACE_BEGIN;
 380                 else
 381                         btsq->sample_flags = 0;
 382                 btsq->intel_pt_insn.length = 0;
 383         } else if (!branch->to) {
 384                 btsq->sample_flags = PERF_IP_FLAG_BRANCH |
 385                                      PERF_IP_FLAG_TRACE_END;
 386                 btsq->intel_pt_insn.length = 0;
 387         } else {
 388                 err = intel_bts_get_next_insn(btsq, branch->from);
 389                 if (err) {
 390                         btsq->sample_flags = 0;
 391                         btsq->intel_pt_insn.length = 0;
 392                         if (!btsq->bts->synth_opts.errors)
 393                                 return 0;
 394                         err = intel_bts_synth_error(btsq->bts, btsq->cpu,
 395                                                     btsq->pid, btsq->tid,
 396                                                     branch->from);
 397                         return err;
 398                 }
 399                 btsq->sample_flags = intel_pt_insn_type(btsq->intel_pt_insn.op);
 400                 /* Check for an async branch into the kernel */
 401                 if (!machine__kernel_ip(btsq->bts->machine, branch->from) &&
 402                     machine__kernel_ip(btsq->bts->machine, branch->to) &&
 403                     btsq->sample_flags != (PERF_IP_FLAG_BRANCH |
 404                                            PERF_IP_FLAG_CALL |
 405                                            PERF_IP_FLAG_SYSCALLRET))
 406                         btsq->sample_flags = PERF_IP_FLAG_BRANCH |
 407                                              PERF_IP_FLAG_CALL |
 408                                              PERF_IP_FLAG_ASYNC |
 409                                              PERF_IP_FLAG_INTERRUPT;
 410         }
 411
 412         return 0;
 413 }
 414
 415 static int intel_bts_process_buffer(struct intel_bts_queue *btsq,
 416                                     struct auxtrace_buffer *buffer,
 417                                     struct thread *thread)
 418 {
 419         struct branch *branch;
 420         size_t sz, bsz = sizeof(struct branch);
 421         u32 filter = btsq->bts->branches_filter;
 422         int err = 0;
 423
 424         if (buffer->use_data) {
 425                 sz = buffer->use_size;
 426                 branch = buffer->use_data;
 427         } else {
 428                 sz = buffer->size;
 429                 branch = buffer->data;
 430         }
 431
 432         if (!btsq->bts->sample_branches)
 433                 return 0;
 434
 435         for (; sz > bsz; branch += 1, sz -= bsz) {
 436                 if (!branch->from && !branch->to)
 437                         continue;
 438                 intel_bts_get_branch_type(btsq, branch);
 439                 if (btsq->bts->synth_opts.thread_stack)
 440                         thread_stack__event(thread, btsq->cpu, btsq->sample_flags,
 441                                             le64_to_cpu(branch->from),
 442                                             le64_to_cpu(branch->to),
 443                                             btsq->intel_pt_insn.length,
 444                                             buffer->buffer_nr + 1);
 445                 if (filter && !(filter & btsq->sample_flags))
 446                         continue;
 447                 err = intel_bts_synth_branch_sample(btsq, branch);
 448                 if (err)
 449                         break;
 450         }
 451         return err;
 452 }
 453
 454 static int intel_bts_process_queue(struct intel_bts_queue *btsq, u64 *timestamp)
 455 {
 456         struct auxtrace_buffer *buffer = btsq->buffer, *old_buffer = buffer;
 457         struct auxtrace_queue *queue;
 458         struct thread *thread;
 459         int err;
 460
 461         if (btsq->done)
 462                 return 1;
 463
 464         if (btsq->pid == -1) {
 465                 thread = machine__find_thread(btsq->bts->machine, -1,
 466                                               btsq->tid);
 467                 if (thread)
 468                         btsq->pid = thread->pid_;
 469         } else {
 470                 thread = machine__findnew_thread(btsq->bts->machine, btsq->pid,
 471                                                  btsq->tid);
 472         }
 473
 474         queue = &btsq->bts->queues.queue_array[btsq->queue_nr];
 475
 476         if (!buffer)
 477                 buffer = auxtrace_buffer__next(queue, NULL);
 478
 479         if (!buffer) {
 480                 if (!btsq->bts->sampling_mode)
 481                         btsq->done = 1;
 482                 err = 1;
 483                 goto out_put;
 484         }
 485
 486         /* Currently there is no support for split buffers */
 487         if (buffer->consecutive) {
 488                 err = -EINVAL;
 489                 goto out_put;
 490         }
 491
 492         if (!buffer->data) {
 493                 int fd = perf_data__fd(btsq->bts->session->data);
 494
 495                 buffer->data = auxtrace_buffer__get_data(buffer, fd);
 496                 if (!buffer->data) {
 497                         err = -ENOMEM;
 498                         goto out_put;
 499                 }
 500         }
 501
 502         if (btsq->bts->snapshot_mode && !buffer->consecutive &&
 503             intel_bts_do_fix_overlap(queue, buffer)) {
 504                 err = -ENOMEM;
 505                 goto out_put;
 506         }
 507
 508         if (!btsq->bts->synth_opts.callchain &&
 509             !btsq->bts->synth_opts.thread_stack && thread &&
 510             (!old_buffer || btsq->bts->sampling_mode ||
 511              (btsq->bts->snapshot_mode && !buffer->consecutive)))
 512                 thread_stack__set_trace_nr(thread, btsq->cpu, buffer->buffer_nr + 1);
 513
 514         err = intel_bts_process_buffer(btsq, buffer, thread);
 515
 516         auxtrace_buffer__drop_data(buffer);
 517
 518         btsq->buffer = auxtrace_buffer__next(queue, buffer);
 519         if (btsq->buffer) {
 520                 if (timestamp)
 521                         *timestamp = btsq->buffer->reference;
 522         } else {
 523                 if (!btsq->bts->sampling_mode)
 524                         btsq->done = 1;
 525         }
 526 out_put:
 527         thread__put(thread);
 528         return err;
 529 }
 530
 531 static int intel_bts_flush_queue(struct intel_bts_queue *btsq)
 532 {
 533         u64 ts = 0;
 534         int ret;
 535
 536         while (1) {
 537                 ret = intel_bts_process_queue(btsq, &ts);
 538                 if (ret < 0)
 539                         return ret;
 540                 if (ret)
 541                         break;
 542         }
 543         return 0;
 544 }
 545
 546 static int intel_bts_process_tid_exit(struct intel_bts *bts, pid_t tid)
 547 {
 548         struct auxtrace_queues *queues = &bts->queues;
 549         unsigned int i;
 550
 551         for (i = 0; i < queues->nr_queues; i++) {
 552                 struct auxtrace_queue *queue = &bts->queues.queue_array[i];
 553                 struct intel_bts_queue *btsq = queue->priv;
 554
 555                 if (btsq && btsq->tid == tid)
 556                         return intel_bts_flush_queue(btsq);
 557         }
 558         return 0;
 559 }
 560
 561 static int intel_bts_process_queues(struct intel_bts *bts, u64 timestamp)
 562 {
 563         while (1) {
 564                 unsigned int queue_nr;
 565                 struct auxtrace_queue *queue;
 566                 struct intel_bts_queue *btsq;
 567                 u64 ts = 0;
 568                 int ret;
 569
 570                 if (!bts->heap.heap_cnt)
 571                         return 0;
 572
 573                 if (bts->heap.heap_array[0].ordinal > timestamp)
 574                         return 0;
 575
 576                 queue_nr = bts->heap.heap_array[0].queue_nr;
 577                 queue = &bts->queues.queue_array[queue_nr];
 578                 btsq = queue->priv;
 579
 580                 auxtrace_heap__pop(&bts->heap);
 581
 582                 ret = intel_bts_process_queue(btsq, &ts);
 583                 if (ret < 0) {
 584                         auxtrace_heap__add(&bts->heap, queue_nr, ts);
 585                         return ret;
 586                 }
 587
 588                 if (!ret) {
 589                         ret = auxtrace_heap__add(&bts->heap, queue_nr, ts);
 590                         if (ret < 0)
 591                                 return ret;
 592                 } else {
 593                         btsq->on_heap = false;
 594                 }
 595         }
 596
 597         return 0;
 598 }
 599
 600 static int intel_bts_process_event(struct perf_session *session,
 601                                    union perf_event *event,
 602                                    struct perf_sample *sample,
 603                                    struct perf_tool *tool)
 604 {
 605         struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
 606                                              auxtrace);
 607         u64 timestamp;
 608         int err;
 609
 610         if (dump_trace)
 611                 return 0;
 612
 613         if (!tool->ordered_events) {
 614                 pr_err("Intel BTS requires ordered events\n");
 615                 return -EINVAL;
 616         }
 617
 618         if (sample->time && sample->time != (u64)-1)
 619                 timestamp = perf_time_to_tsc(sample->time, &bts->tc);
 620         else
 621                 timestamp = 0;
 622
 623         err = intel_bts_update_queues(bts);
 624         if (err)
 625                 return err;
 626
 627         err = intel_bts_process_queues(bts, timestamp);
 628         if (err)
 629                 return err;
 630         if (event->header.type == PERF_RECORD_EXIT) {
 631                 err = intel_bts_process_tid_exit(bts, event->fork.tid);
 632                 if (err)
 633                         return err;
 634         }
 635
 636         if (event->header.type == PERF_RECORD_AUX &&
 637             (event->aux.flags & PERF_AUX_FLAG_TRUNCATED) &&
 638             bts->synth_opts.errors)
 639                 err = intel_bts_lost(bts, sample);
 640
 641         return err;
 642 }
 643
 644 static int intel_bts_process_auxtrace_event(struct perf_session *session,
 645                                             union perf_event *event,
 646                                             struct perf_tool *tool __maybe_unused)
 647 {
 648         struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
 649                                              auxtrace);
 650
 651         if (bts->sampling_mode)
 652                 return 0;
 653
 654         if (!bts->data_queued) {
 655                 struct auxtrace_buffer *buffer;
 656                 off_t data_offset;
 657                 int fd = perf_data__fd(session->data);
 658                 int err;
 659
 660                 if (perf_data__is_pipe(session->data)) {
 661                         data_offset = 0;
 662                 } else {
 663                         data_offset = lseek(fd, 0, SEEK_CUR);
 664                         if (data_offset == -1)
 665                                 return -errno;
 666                 }
 667
 668                 err = auxtrace_queues__add_event(&bts->queues, session, event,
 669                                                  data_offset, &buffer);
 670                 if (err)
 671                         return err;
 672
 673                 /* Dump here now we have copied a piped trace out of the pipe */
 674                 if (dump_trace) {
 675                         if (auxtrace_buffer__get_data(buffer, fd)) {
 676                                 intel_bts_dump_event(bts, buffer->data,
 677                                                      buffer->size);
 678                                 auxtrace_buffer__put_data(buffer);
 679                         }
 680                 }
 681         }
 682
 683         return 0;
 684 }
 685
 686 static int intel_bts_flush(struct perf_session *session,
 687                            struct perf_tool *tool __maybe_unused)
 688 {
 689         struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
 690                                              auxtrace);
 691         int ret;
 692
 693         if (dump_trace || bts->sampling_mode)
 694                 return 0;
 695
 696         if (!tool->ordered_events)
 697                 return -EINVAL;
 698
 699         ret = intel_bts_update_queues(bts);
 700         if (ret < 0)
 701                 return ret;
 702
 703         return intel_bts_process_queues(bts, MAX_TIMESTAMP);
 704 }
 705
 706 static void intel_bts_free_queue(void *priv)
 707 {
 708         struct intel_bts_queue *btsq = priv;
 709
 710         if (!btsq)
 711                 return;
 712         free(btsq);
 713 }
 714
 715 static void intel_bts_free_events(struct perf_session *session)
 716 {
 717         struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
 718                                              auxtrace);
 719         struct auxtrace_queues *queues = &bts->queues;
 720         unsigned int i;
 721
 722         for (i = 0; i < queues->nr_queues; i++) {
 723                 intel_bts_free_queue(queues->queue_array[i].priv);
 724                 queues->queue_array[i].priv = NULL;
 725         }
 726         auxtrace_queues__free(queues);
 727 }
 728
 729 static void intel_bts_free(struct perf_session *session)
 730 {
 731         struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
 732                                              auxtrace);
 733
 734         auxtrace_heap__free(&bts->heap);
 735         intel_bts_free_events(session);
 736         session->auxtrace = NULL;
 737         free(bts);
 738 }
 739
 740 struct intel_bts_synth {
 741         struct perf_tool dummy_tool;
 742         struct perf_session *session;
 743 };
 744
 745 static int intel_bts_event_synth(struct perf_tool *tool,
 746                                  union perf_event *event,
 747                                  struct perf_sample *sample __maybe_unused,
 748                                  struct machine *machine __maybe_unused)
 749 {
 750         struct intel_bts_synth *intel_bts_synth =
 751                         container_of(tool, struct intel_bts_synth, dummy_tool);
 752
 753         return perf_session__deliver_synth_event(intel_bts_synth->session,
 754                                                  event, NULL);
 755 }
 756
 757 static int intel_bts_synth_event(struct perf_session *session,
 758                                  struct perf_event_attr *attr, u64 id)
 759 {
 760         struct intel_bts_synth intel_bts_synth;
 761
 762         memset(&intel_bts_synth, 0, sizeof(struct intel_bts_synth));
 763         intel_bts_synth.session = session;
 764
 765         return perf_event__synthesize_attr(&intel_bts_synth.dummy_tool, attr, 1,
 766                                            &id, intel_bts_event_synth);
 767 }
 768
 769 static int intel_bts_synth_events(struct intel_bts *bts,
 770                                   struct perf_session *session)
 771 {
 772         struct perf_evlist *evlist = session->evlist;
 773         struct perf_evsel *evsel;
 774         struct perf_event_attr attr;
 775         bool found = false;
 776         u64 id;
 777         int err;
 778
 779         evlist__for_each_entry(evlist, evsel) {
 780                 if (evsel->attr.type == bts->pmu_type && evsel->ids) {
 781                         found = true;
 782                         break;
 783                 }
 784         }
 785
 786         if (!found) {
 787                 pr_debug("There are no selected events with Intel BTS data\n");
 788                 return 0;
 789         }
 790
 791         memset(&attr, 0, sizeof(struct perf_event_attr));
 792         attr.size = sizeof(struct perf_event_attr);
 793         attr.type = PERF_TYPE_HARDWARE;
 794         attr.sample_type = evsel->attr.sample_type & PERF_SAMPLE_MASK;
 795         attr.sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID |
 796                             PERF_SAMPLE_PERIOD;
 797         attr.sample_type &= ~(u64)PERF_SAMPLE_TIME;
 798         attr.sample_type &= ~(u64)PERF_SAMPLE_CPU;
 799         attr.exclude_user = evsel->attr.exclude_user;
 800         attr.exclude_kernel = evsel->attr.exclude_kernel;
 801         attr.exclude_hv = evsel->attr.exclude_hv;
 802         attr.exclude_host = evsel->attr.exclude_host;
 803         attr.exclude_guest = evsel->attr.exclude_guest;
 804         attr.sample_id_all = evsel->attr.sample_id_all;
 805         attr.read_format = evsel->attr.read_format;
 806
 807         id = evsel->id[0] + 1000000000;
 808         if (!id)
 809                 id = 1;
 810
 811         if (bts->synth_opts.branches) {
 812                 attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
 813                 attr.sample_period = 1;
 814                 attr.sample_type |= PERF_SAMPLE_ADDR;
 815                 pr_debug("Synthesizing 'branches' event with id %" PRIu64 " sample type %#" PRIx64 "\n",
 816                          id, (u64)attr.sample_type);
 817                 err = intel_bts_synth_event(session, &attr, id);
 818                 if (err) {
 819                         pr_err("%s: failed to synthesize 'branches' event type\n",
 820                                __func__);
 821                         return err;
 822                 }
 823                 bts->sample_branches = true;
 824                 bts->branches_sample_type = attr.sample_type;
 825                 bts->branches_id = id;
 826                 /*
 827                  * We only use sample types from PERF_SAMPLE_MASK so we can use
 828                  * __perf_evsel__sample_size() here.
 829                  */
 830                 bts->branches_event_size = sizeof(struct sample_event) +
 831                                 __perf_evsel__sample_size(attr.sample_type);
 832         }
 833
 834         return 0;
 835 }
 836
 837 static const char * const intel_bts_info_fmts[] = {
 838         [INTEL_BTS_PMU_TYPE]            = "  PMU Type           %"PRId64"\n",
 839         [INTEL_BTS_TIME_SHIFT]          = "  Time Shift         %"PRIu64"\n",
 840         [INTEL_BTS_TIME_MULT]           = "  Time Muliplier     %"PRIu64"\n",
 841         [INTEL_BTS_TIME_ZERO]           = "  Time Zero          %"PRIu64"\n",
 842         [INTEL_BTS_CAP_USER_TIME_ZERO]  = "  Cap Time Zero      %"PRId64"\n",
 843         [INTEL_BTS_SNAPSHOT_MODE]       = "  Snapshot mode      %"PRId64"\n",
 844 };
 845
 846 static void intel_bts_print_info(u64 *arr, int start, int finish)
 847 {
 848         int i;
 849
 850         if (!dump_trace)
 851                 return;
 852
 853         for (i = start; i <= finish; i++)
 854                 fprintf(stdout, intel_bts_info_fmts[i], arr[i]);
 855 }
 856
 857 int intel_bts_process_auxtrace_info(union perf_event *event,
 858                                     struct perf_session *session)
 859 {
 860         struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
 861         size_t min_sz = sizeof(u64) * INTEL_BTS_SNAPSHOT_MODE;
 862         struct intel_bts *bts;
 863         int err;
 864
 865         if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event) +
 866                                         min_sz)
 867                 return -EINVAL;
 868
 869         bts = zalloc(sizeof(struct intel_bts));
 870         if (!bts)
 871                 return -ENOMEM;
 872
 873         err = auxtrace_queues__init(&bts->queues);
 874         if (err)
 875                 goto err_free;
 876
 877         bts->session = session;
 878         bts->machine = &session->machines.host; /* No kvm support */
 879         bts->auxtrace_type = auxtrace_info->type;
 880         bts->pmu_type = auxtrace_info->priv[INTEL_BTS_PMU_TYPE];
 881         bts->tc.time_shift = auxtrace_info->priv[INTEL_BTS_TIME_SHIFT];
 882         bts->tc.time_mult = auxtrace_info->priv[INTEL_BTS_TIME_MULT];
 883         bts->tc.time_zero = auxtrace_info->priv[INTEL_BTS_TIME_ZERO];
 884         bts->cap_user_time_zero =
 885                         auxtrace_info->priv[INTEL_BTS_CAP_USER_TIME_ZERO];
 886         bts->snapshot_mode = auxtrace_info->priv[INTEL_BTS_SNAPSHOT_MODE];
 887
 888         bts->sampling_mode = false;
 889
 890         bts->auxtrace.process_event = intel_bts_process_event;
 891         bts->auxtrace.process_auxtrace_event = intel_bts_process_auxtrace_event;
 892         bts->auxtrace.flush_events = intel_bts_flush;
 893         bts->auxtrace.free_events = intel_bts_free_events;
 894         bts->auxtrace.free = intel_bts_free;
 895         session->auxtrace = &bts->auxtrace;
 896
 897         intel_bts_print_info(&auxtrace_info->priv[0], INTEL_BTS_PMU_TYPE,
 898                              INTEL_BTS_SNAPSHOT_MODE);
 899
 900         if (dump_trace)
 901                 return 0;
 902
 903         if (session->itrace_synth_opts && session->itrace_synth_opts->set) {
 904                 bts->synth_opts = *session->itrace_synth_opts;
 905         } else {
 906                 itrace_synth_opts__set_default(&bts->synth_opts,
 907                                 session->itrace_synth_opts->default_no_sample);
 908                 if (session->itrace_synth_opts)
 909                         bts->synth_opts.thread_stack =
 910                                 session->itrace_synth_opts->thread_stack;
 911         }
 912
 913         if (bts->synth_opts.calls)
 914                 bts->branches_filter |= PERF_IP_FLAG_CALL | PERF_IP_FLAG_ASYNC |
 915                                         PERF_IP_FLAG_TRACE_END;
 916         if (bts->synth_opts.returns)
 917                 bts->branches_filter |= PERF_IP_FLAG_RETURN |
 918                                         PERF_IP_FLAG_TRACE_BEGIN;
 919
 920         err = intel_bts_synth_events(bts, session);
 921         if (err)
 922                 goto err_free_queues;
 923
 924         err = auxtrace_queues__process_index(&bts->queues, session);
 925         if (err)
 926                 goto err_free_queues;
 927
 928         if (bts->queues.populated)
 929                 bts->data_queued = true;
 930
 931         return 0;
 932
 933 err_free_queues:
 934         auxtrace_queues__free(&bts->queues);
 935         session->auxtrace = NULL;
 936 err_free:
 937         free(bts);
 938         return err;
 939 }