gdb/nat/linux-btrace.c

   1 /* Linux-dependent part of branch trace support for GDB, and GDBserver.
   2
   3    Copyright (C) 2013-2015 Free Software Foundation, Inc.
   4
   5    Contributed by Intel Corp. <markus.t.metzger@intel.com>
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "common-defs.h"
  23 #include "linux-btrace.h"
  24 #include "common-regcache.h"
  25 #include "gdb_wait.h"
  26 #include "x86-cpuid.h"
  27 #include "filestuff.h"
  28
  29 #include <inttypes.h>
  30
  31 #ifdef HAVE_SYS_SYSCALL_H
  32 #include <sys/syscall.h>
  33 #endif
  34
  35 #if HAVE_LINUX_PERF_EVENT_H && defined(SYS_perf_event_open)
  36 #include <unistd.h>
  37 #include <sys/mman.h>
  38 #include <sys/user.h>
  39 #include "nat/gdb_ptrace.h"
  40 #include <sys/types.h>
  41 #include <signal.h>
  42
  43 /* A branch trace record in perf_event.  */
  44 struct perf_event_bts
  45 {
  46   /* The linear address of the branch source.  */
  47   uint64_t from;
  48
  49   /* The linear address of the branch destination.  */
  50   uint64_t to;
  51 };
  52
  53 /* A perf_event branch trace sample.  */
  54 struct perf_event_sample
  55 {
  56   /* The perf_event sample header.  */
  57   struct perf_event_header header;
  58
  59   /* The perf_event branch tracing payload.  */
  60   struct perf_event_bts bts;
  61 };
  62
  63 /* Identify the cpu we're running on.  */
  64 static struct btrace_cpu
  65 btrace_this_cpu (void)
  66 {
  67   struct btrace_cpu cpu;
  68   unsigned int eax, ebx, ecx, edx;
  69   int ok;
  70
  71   memset (&cpu, 0, sizeof (cpu));
  72
  73   ok = x86_cpuid (0, &eax, &ebx, &ecx, &edx);
  74   if (ok != 0)
  75     {
  76       if (ebx == signature_INTEL_ebx && ecx == signature_INTEL_ecx
  77           && edx == signature_INTEL_edx)
  78         {
  79           unsigned int cpuid, ignore;
  80
  81           ok = x86_cpuid (1, &cpuid, &ignore, &ignore, &ignore);
  82           if (ok != 0)
  83             {
  84               cpu.vendor = CV_INTEL;
  85
  86               cpu.family = (cpuid >> 8) & 0xf;
  87               cpu.model = (cpuid >> 4) & 0xf;
  88
  89               if (cpu.family == 0x6)
  90                 cpu.model += (cpuid >> 12) & 0xf0;
  91             }
  92         }
  93     }
  94
  95   return cpu;
  96 }
  97
  98 /* Return non-zero if there is new data in PEVENT; zero otherwise.  */
  99
 100 static int
 101 perf_event_new_data (const struct perf_event_buffer *pev)
 102 {
 103   return *pev->data_head != pev->last_head;
 104 }
 105
 106 /* Try to determine the size of a pointer in bits for the OS.
 107
 108    This is the same as the size of a pointer for the inferior process
 109    except when a 32-bit inferior is running on a 64-bit OS.  */
 110
 111 /* Copy the last SIZE bytes from PEV ending at DATA_HEAD and return a pointer
 112    to the memory holding the copy.
 113    The caller is responsible for freeing the memory.  */
 114
 115 static gdb_byte *
 116 perf_event_read (const struct perf_event_buffer *pev, __u64 data_head,
 117                  size_t size)
 118 {
 119   const gdb_byte *begin, *end, *start, *stop;
 120   gdb_byte *buffer;
 121   size_t buffer_size;
 122   __u64 data_tail;
 123
 124   if (size == 0)
 125     return NULL;
 126
 127   gdb_assert (size <= data_head);
 128   data_tail = data_head - size;
 129
 130   buffer_size = pev->size;
 131   begin = pev->mem;
 132   start = begin + data_tail % buffer_size;
 133   stop = begin + data_head % buffer_size;
 134
 135   buffer = xmalloc (size);
 136
 137   if (start < stop)
 138     memcpy (buffer, start, stop - start);
 139   else
 140     {
 141       end = begin + buffer_size;
 142
 143       memcpy (buffer, start, end - start);
 144       memcpy (buffer + (end - start), begin, stop - begin);
 145     }
 146
 147   return buffer;
 148 }
 149
 150 /* Copy the perf event buffer data from PEV.
 151    Store a pointer to the copy into DATA and its size in SIZE.  */
 152
 153 static void
 154 perf_event_read_all (struct perf_event_buffer *pev, gdb_byte **data,
 155                      size_t *psize)
 156 {
 157   size_t size;
 158   __u64 data_head;
 159
 160   data_head = *pev->data_head;
 161
 162   size = pev->size;
 163   if (data_head < size)
 164     size = (size_t) data_head;
 165
 166   *data = perf_event_read (pev, data_head, size);
 167   *psize = size;
 168
 169   pev->last_head = data_head;
 170 }
 171
 172 /* Determine the event type.
 173    Returns zero on success and fills in TYPE; returns -1 otherwise.  */
 174
 175 static int
 176 perf_event_pt_event_type (int *type)
 177 {
 178   FILE *file;
 179   int found;
 180
 181   file = fopen ("/sys/bus/event_source/devices/intel_pt/type", "r");
 182   if (file == NULL)
 183     return -1;
 184
 185   found = fscanf (file, "%d", type);
 186
 187   fclose (file);
 188
 189   if (found == 1)
 190     return 0;
 191   return -1;
 192 }
 193
 194 /* Try to determine the start address of the Linux kernel.  */
 195
 196 static uint64_t
 197 linux_determine_kernel_start (void)
 198 {
 199   static uint64_t kernel_start;
 200   static int cached;
 201   FILE *file;
 202
 203   if (cached != 0)
 204     return kernel_start;
 205
 206   cached = 1;
 207
 208   file = gdb_fopen_cloexec ("/proc/kallsyms", "r");
 209   if (file == NULL)
 210     return kernel_start;
 211
 212   while (!feof (file))
 213     {
 214       char buffer[1024], symbol[8], *line;
 215       uint64_t addr;
 216       int match;
 217
 218       line = fgets (buffer, sizeof (buffer), file);
 219       if (line == NULL)
 220         break;
 221
 222       match = sscanf (line, "%" SCNx64 " %*[tT] %7s", &addr, symbol);
 223       if (match != 2)
 224         continue;
 225
 226       if (strcmp (symbol, "_text") == 0)
 227         {
 228           kernel_start = addr;
 229           break;
 230         }
 231     }
 232
 233   fclose (file);
 234
 235   return kernel_start;
 236 }
 237
 238 /* Check whether an address is in the kernel.  */
 239
 240 static inline int
 241 perf_event_is_kernel_addr (uint64_t addr)
 242 {
 243   uint64_t kernel_start;
 244
 245   kernel_start = linux_determine_kernel_start ();
 246   if (kernel_start != 0ull)
 247     return (addr >= kernel_start);
 248
 249   /* If we don't know the kernel's start address, let's check the most
 250      significant bit.  This will work at least for 64-bit kernels.  */
 251   return ((addr & (1ull << 63)) != 0);
 252 }
 253
 254 /* Check whether a perf event record should be skipped.  */
 255
 256 static inline int
 257 perf_event_skip_bts_record (const struct perf_event_bts *bts)
 258 {
 259   /* The hardware may report branches from kernel into user space.  Branches
 260      from user into kernel space will be suppressed.  We filter the former to
 261      provide a consistent branch trace excluding kernel.  */
 262   return perf_event_is_kernel_addr (bts->from);
 263 }
 264
 265 /* Perform a few consistency checks on a perf event sample record.  This is
 266    meant to catch cases when we get out of sync with the perf event stream.  */
 267
 268 static inline int
 269 perf_event_sample_ok (const struct perf_event_sample *sample)
 270 {
 271   if (sample->header.type != PERF_RECORD_SAMPLE)
 272     return 0;
 273
 274   if (sample->header.size != sizeof (*sample))
 275     return 0;
 276
 277   return 1;
 278 }
 279
 280 /* Branch trace is collected in a circular buffer [begin; end) as pairs of from
 281    and to addresses (plus a header).
 282
 283    Start points into that buffer at the next sample position.
 284    We read the collected samples backwards from start.
 285
 286    While reading the samples, we convert the information into a list of blocks.
 287    For two adjacent samples s1 and s2, we form a block b such that b.begin =
 288    s1.to and b.end = s2.from.
 289
 290    In case the buffer overflows during sampling, one sample may have its lower
 291    part at the end and its upper part at the beginning of the buffer.  */
 292
 293 static VEC (btrace_block_s) *
 294 perf_event_read_bts (struct btrace_target_info* tinfo, const uint8_t *begin,
 295                      const uint8_t *end, const uint8_t *start, size_t size)
 296 {
 297   VEC (btrace_block_s) *btrace = NULL;
 298   struct perf_event_sample sample;
 299   size_t read = 0;
 300   struct btrace_block block = { 0, 0 };
 301   struct regcache *regcache;
 302
 303   gdb_assert (begin <= start);
 304   gdb_assert (start <= end);
 305
 306   /* The first block ends at the current pc.  */
 307   regcache = get_thread_regcache_for_ptid (tinfo->ptid);
 308   block.end = regcache_read_pc (regcache);
 309
 310   /* The buffer may contain a partial record as its last entry (i.e. when the
 311      buffer size is not a multiple of the sample size).  */
 312   read = sizeof (sample) - 1;
 313
 314   for (; read < size; read += sizeof (sample))
 315     {
 316       const struct perf_event_sample *psample;
 317
 318       /* Find the next perf_event sample in a backwards traversal.  */
 319       start -= sizeof (sample);
 320
 321       /* If we're still inside the buffer, we're done.  */
 322       if (begin <= start)
 323         psample = (const struct perf_event_sample *) start;
 324       else
 325         {
 326           int missing;
 327
 328           /* We're to the left of the ring buffer, we will wrap around and
 329              reappear at the very right of the ring buffer.  */
 330
 331           missing = (begin - start);
 332           start = (end - missing);
 333
 334           /* If the entire sample is missing, we're done.  */
 335           if (missing == sizeof (sample))
 336             psample = (const struct perf_event_sample *) start;
 337           else
 338             {
 339               uint8_t *stack;
 340
 341               /* The sample wrapped around.  The lower part is at the end and
 342                  the upper part is at the beginning of the buffer.  */
 343               stack = (uint8_t *) &sample;
 344
 345               /* Copy the two parts so we have a contiguous sample.  */
 346               memcpy (stack, start, missing);
 347               memcpy (stack + missing, begin, sizeof (sample) - missing);
 348
 349               psample = &sample;
 350             }
 351         }
 352
 353       if (!perf_event_sample_ok (psample))
 354         {
 355           warning (_("Branch trace may be incomplete."));
 356           break;
 357         }
 358
 359       if (perf_event_skip_bts_record (&psample->bts))
 360         continue;
 361
 362       /* We found a valid sample, so we can complete the current block.  */
 363       block.begin = psample->bts.to;
 364
 365       VEC_safe_push (btrace_block_s, btrace, &block);
 366
 367       /* Start the next block.  */
 368       block.end = psample->bts.from;
 369     }
 370
 371   /* Push the last block (i.e. the first one of inferior execution), as well.
 372      We don't know where it ends, but we know where it starts.  If we're
 373      reading delta trace, we can fill in the start address later on.
 374      Otherwise we will prune it.  */
 375   block.begin = 0;
 376   VEC_safe_push (btrace_block_s, btrace, &block);
 377
 378   return btrace;
 379 }
 380
 381 /* Check whether the kernel supports BTS.  */
 382
 383 static int
 384 kernel_supports_bts (void)
 385 {
 386   struct perf_event_attr attr;
 387   pid_t child, pid;
 388   int status, file;
 389
 390   errno = 0;
 391   child = fork ();
 392   switch (child)
 393     {
 394     case -1:
 395       warning (_("test bts: cannot fork: %s."), safe_strerror (errno));
 396       return 0;
 397
 398     case 0:
 399       status = ptrace (PTRACE_TRACEME, 0, NULL, NULL);
 400       if (status != 0)
 401         {
 402           warning (_("test bts: cannot PTRACE_TRACEME: %s."),
 403                    safe_strerror (errno));
 404           _exit (1);
 405         }
 406
 407       status = raise (SIGTRAP);
 408       if (status != 0)
 409         {
 410           warning (_("test bts: cannot raise SIGTRAP: %s."),
 411                    safe_strerror (errno));
 412           _exit (1);
 413         }
 414
 415       _exit (1);
 416
 417     default:
 418       pid = waitpid (child, &status, 0);
 419       if (pid != child)
 420         {
 421           warning (_("test bts: bad pid %ld, error: %s."),
 422                    (long) pid, safe_strerror (errno));
 423           return 0;
 424         }
 425
 426       if (!WIFSTOPPED (status))
 427         {
 428           warning (_("test bts: expected stop. status: %d."),
 429                    status);
 430           return 0;
 431         }
 432
 433       memset (&attr, 0, sizeof (attr));
 434
 435       attr.type = PERF_TYPE_HARDWARE;
 436       attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
 437       attr.sample_period = 1;
 438       attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_ADDR;
 439       attr.exclude_kernel = 1;
 440       attr.exclude_hv = 1;
 441       attr.exclude_idle = 1;
 442
 443       file = syscall (SYS_perf_event_open, &attr, child, -1, -1, 0);
 444       if (file >= 0)
 445         close (file);
 446
 447       kill (child, SIGKILL);
 448       ptrace (PTRACE_KILL, child, NULL, NULL);
 449
 450       pid = waitpid (child, &status, 0);
 451       if (pid != child)
 452         {
 453           warning (_("test bts: bad pid %ld, error: %s."),
 454                    (long) pid, safe_strerror (errno));
 455           if (!WIFSIGNALED (status))
 456             warning (_("test bts: expected killed. status: %d."),
 457                      status);
 458         }
 459
 460       return (file >= 0);
 461     }
 462 }
 463
 464 /* Check whether the kernel supports Intel(R) Processor Trace.  */
 465
 466 static int
 467 kernel_supports_pt (void)
 468 {
 469   struct perf_event_attr attr;
 470   pid_t child, pid;
 471   int status, file, type;
 472
 473   errno = 0;
 474   child = fork ();
 475   switch (child)
 476     {
 477     case -1:
 478       warning (_("test pt: cannot fork: %s."), safe_strerror (errno));
 479       return 0;
 480
 481     case 0:
 482       status = ptrace (PTRACE_TRACEME, 0, NULL, NULL);
 483       if (status != 0)
 484         {
 485           warning (_("test pt: cannot PTRACE_TRACEME: %s."),
 486                    safe_strerror (errno));
 487           _exit (1);
 488         }
 489
 490       status = raise (SIGTRAP);
 491       if (status != 0)
 492         {
 493           warning (_("test pt: cannot raise SIGTRAP: %s."),
 494                    safe_strerror (errno));
 495           _exit (1);
 496         }
 497
 498       _exit (1);
 499
 500     default:
 501       pid = waitpid (child, &status, 0);
 502       if (pid != child)
 503         {
 504           warning (_("test pt: bad pid %ld, error: %s."),
 505                    (long) pid, safe_strerror (errno));
 506           return 0;
 507         }
 508
 509       if (!WIFSTOPPED (status))
 510         {
 511           warning (_("test pt: expected stop. status: %d."),
 512                    status);
 513           return 0;
 514         }
 515
 516       status = perf_event_pt_event_type (&type);
 517       if (status != 0)
 518         file = -1;
 519       else
 520         {
 521           memset (&attr, 0, sizeof (attr));
 522
 523           attr.size = sizeof (attr);
 524           attr.type = type;
 525           attr.exclude_kernel = 1;
 526           attr.exclude_hv = 1;
 527           attr.exclude_idle = 1;
 528
 529           file = syscall (SYS_perf_event_open, &attr, child, -1, -1, 0);
 530           if (file >= 0)
 531             close (file);
 532         }
 533
 534       kill (child, SIGKILL);
 535       ptrace (PTRACE_KILL, child, NULL, NULL);
 536
 537       pid = waitpid (child, &status, 0);
 538       if (pid != child)
 539         {
 540           warning (_("test pt: bad pid %ld, error: %s."),
 541                    (long) pid, safe_strerror (errno));
 542           if (!WIFSIGNALED (status))
 543             warning (_("test pt: expected killed. status: %d."),
 544                      status);
 545         }
 546
 547       return (file >= 0);
 548     }
 549 }
 550
 551 /* Check whether an Intel cpu supports BTS.  */
 552
 553 static int
 554 intel_supports_bts (const struct btrace_cpu *cpu)
 555 {
 556   switch (cpu->family)
 557     {
 558     case 0x6:
 559       switch (cpu->model)
 560         {
 561         case 0x1a: /* Nehalem */
 562         case 0x1f:
 563         case 0x1e:
 564         case 0x2e:
 565         case 0x25: /* Westmere */
 566         case 0x2c:
 567         case 0x2f:
 568         case 0x2a: /* Sandy Bridge */
 569         case 0x2d:
 570         case 0x3a: /* Ivy Bridge */
 571
 572           /* AAJ122: LBR, BTM, or BTS records may have incorrect branch
 573              "from" information afer an EIST transition, T-states, C1E, or
 574              Adaptive Thermal Throttling.  */
 575           return 0;
 576         }
 577     }
 578
 579   return 1;
 580 }
 581
 582 /* Check whether the cpu supports BTS.  */
 583
 584 static int
 585 cpu_supports_bts (void)
 586 {
 587   struct btrace_cpu cpu;
 588
 589   cpu = btrace_this_cpu ();
 590   switch (cpu.vendor)
 591     {
 592     default:
 593       /* Don't know about others.  Let's assume they do.  */
 594       return 1;
 595
 596     case CV_INTEL:
 597       return intel_supports_bts (&cpu);
 598     }
 599 }
 600
 601 /* Check whether the linux target supports BTS.  */
 602
 603 static int
 604 linux_supports_bts (void)
 605 {
 606   static int cached;
 607
 608   if (cached == 0)
 609     {
 610       if (!kernel_supports_bts ())
 611         cached = -1;
 612       else if (!cpu_supports_bts ())
 613         cached = -1;
 614       else
 615         cached = 1;
 616     }
 617
 618   return cached > 0;
 619 }
 620
 621 /* Check whether the linux target supports Intel(R) Processor Trace.  */
 622
 623 static int
 624 linux_supports_pt (void)
 625 {
 626   static int cached;
 627
 628   if (cached == 0)
 629     {
 630       if (!kernel_supports_pt ())
 631         cached = -1;
 632       else
 633         cached = 1;
 634     }
 635
 636   return cached > 0;
 637 }
 638
 639 /* See linux-btrace.h.  */
 640
 641 int
 642 linux_supports_btrace (struct target_ops *ops, enum btrace_format format)
 643 {
 644   switch (format)
 645     {
 646     case BTRACE_FORMAT_NONE:
 647       return 0;
 648
 649     case BTRACE_FORMAT_BTS:
 650       return linux_supports_bts ();
 651
 652     case BTRACE_FORMAT_PT:
 653       return linux_supports_pt ();
 654     }
 655
 656   internal_error (__FILE__, __LINE__, _("Unknown branch trace format"));
 657 }
 658
 659 /* Enable branch tracing in BTS format.  */
 660
 661 static struct btrace_target_info *
 662 linux_enable_bts (ptid_t ptid, const struct btrace_config_bts *conf)
 663 {
 664   struct perf_event_mmap_page *header;
 665   struct btrace_target_info *tinfo;
 666   struct btrace_tinfo_bts *bts;
 667   size_t size, pages;
 668   __u64 data_offset;
 669   int pid, pg;
 670
 671   tinfo = XCNEW (struct btrace_target_info);
 672   tinfo->ptid = ptid;
 673
 674   tinfo->conf.format = BTRACE_FORMAT_BTS;
 675   bts = &tinfo->variant.bts;
 676
 677   bts->attr.size = sizeof (bts->attr);
 678   bts->attr.type = PERF_TYPE_HARDWARE;
 679   bts->attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
 680   bts->attr.sample_period = 1;
 681
 682   /* We sample from and to address.  */
 683   bts->attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_ADDR;
 684
 685   bts->attr.exclude_kernel = 1;
 686   bts->attr.exclude_hv = 1;
 687   bts->attr.exclude_idle = 1;
 688
 689   pid = ptid_get_lwp (ptid);
 690   if (pid == 0)
 691     pid = ptid_get_pid (ptid);
 692
 693   errno = 0;
 694   bts->file = syscall (SYS_perf_event_open, &bts->attr, pid, -1, -1, 0);
 695   if (bts->file < 0)
 696     goto err_out;
 697
 698   /* Convert the requested size in bytes to pages (rounding up).  */
 699   pages = ((size_t) conf->size / PAGE_SIZE
 700            + ((conf->size % PAGE_SIZE) == 0 ? 0 : 1));
 701   /* We need at least one page.  */
 702   if (pages == 0)
 703     pages = 1;
 704
 705   /* The buffer size can be requested in powers of two pages.  Adjust PAGES
 706      to the next power of two.  */
 707   for (pg = 0; pages != ((size_t) 1 << pg); ++pg)
 708     if ((pages & ((size_t) 1 << pg)) != 0)
 709       pages += ((size_t) 1 << pg);
 710
 711   /* We try to allocate the requested size.
 712      If that fails, try to get as much as we can.  */
 713   for (; pages > 0; pages >>= 1)
 714     {
 715       size_t length;
 716       __u64 data_size;
 717
 718       data_size = (__u64) pages * PAGE_SIZE;
 719
 720       /* Don't ask for more than we can represent in the configuration.  */
 721       if ((__u64) UINT_MAX < data_size)
 722         continue;
 723
 724       size = (size_t) data_size;
 725       length = size + PAGE_SIZE;
 726
 727       /* Check for overflows.  */
 728       if ((__u64) length != data_size + PAGE_SIZE)
 729         continue;
 730
 731       /* The number of pages we request needs to be a power of two.  */
 732       header = mmap (NULL, length, PROT_READ, MAP_SHARED, bts->file, 0);
 733       if (header != MAP_FAILED)
 734         break;
 735     }
 736
 737   if (pages == 0)
 738     goto err_file;
 739
 740   data_offset = PAGE_SIZE;
 741
 742 #if defined (PERF_ATTR_SIZE_VER5)
 743   if (offsetof (struct perf_event_mmap_page, data_size) <= header->size)
 744     {
 745       __u64 data_size;
 746
 747       data_offset = header->data_offset;
 748       data_size = header->data_size;
 749
 750       size = (unsigned int) data_size;
 751
 752       /* Check for overflows.  */
 753       if ((__u64) size != data_size)
 754         {
 755           munmap ((void *) header, size + PAGE_SIZE);
 756           goto err_file;
 757         }
 758     }
 759 #endif /* defined (PERF_ATTR_SIZE_VER5) */
 760
 761   bts->header = header;
 762   bts->bts.mem = ((const uint8_t *) header) + data_offset;
 763   bts->bts.size = size;
 764   bts->bts.data_head = &header->data_head;
 765   bts->bts.last_head = 0ull;
 766
 767   tinfo->conf.bts.size = (unsigned int) size;
 768   return tinfo;
 769
 770  err_file:
 771   /* We were not able to allocate any buffer.  */
 772   close (bts->file);
 773
 774  err_out:
 775   xfree (tinfo);
 776   return NULL;
 777 }
 778
 779 #if defined (PERF_ATTR_SIZE_VER5)
 780
 781 /* Enable branch tracing in Intel(R) Processor Trace format.  */
 782
 783 static struct btrace_target_info *
 784 linux_enable_pt (ptid_t ptid, const struct btrace_config_pt *conf)
 785 {
 786   struct perf_event_mmap_page *header;
 787   struct btrace_target_info *tinfo;
 788   struct btrace_tinfo_pt *pt;
 789   size_t pages, size;
 790   int pid, pg, errcode, type;
 791
 792   if (conf->size == 0)
 793     return NULL;
 794
 795   errcode = perf_event_pt_event_type (&type);
 796   if (errcode != 0)
 797     return NULL;
 798
 799   pid = ptid_get_lwp (ptid);
 800   if (pid == 0)
 801     pid = ptid_get_pid (ptid);
 802
 803   tinfo = XCNEW (struct btrace_target_info);
 804   tinfo->ptid = ptid;
 805
 806   tinfo->conf.format = BTRACE_FORMAT_PT;
 807   pt = &tinfo->variant.pt;
 808
 809   pt->attr.size = sizeof (pt->attr);
 810   pt->attr.type = type;
 811
 812   pt->attr.exclude_kernel = 1;
 813   pt->attr.exclude_hv = 1;
 814   pt->attr.exclude_idle = 1;
 815
 816   errno = 0;
 817   pt->file = syscall (SYS_perf_event_open, &pt->attr, pid, -1, -1, 0);
 818   if (pt->file < 0)
 819     goto err;
 820
 821   /* Allocate the configuration page. */
 822   header = mmap (NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
 823                  pt->file, 0);
 824   if (header == MAP_FAILED)
 825     goto err_file;
 826
 827   header->aux_offset = header->data_offset + header->data_size;
 828
 829   /* Convert the requested size in bytes to pages (rounding up).  */
 830   pages = ((size_t) conf->size / PAGE_SIZE
 831            + ((conf->size % PAGE_SIZE) == 0 ? 0 : 1));
 832   /* We need at least one page.  */
 833   if (pages == 0)
 834     pages = 1;
 835
 836   /* The buffer size can be requested in powers of two pages.  Adjust PAGES
 837      to the next power of two.  */
 838   for (pg = 0; pages != ((size_t) 1 << pg); ++pg)
 839     if ((pages & ((size_t) 1 << pg)) != 0)
 840       pages += ((size_t) 1 << pg);
 841
 842   /* We try to allocate the requested size.
 843      If that fails, try to get as much as we can.  */
 844   for (; pages > 0; pages >>= 1)
 845     {
 846       size_t length;
 847       __u64 data_size;
 848
 849       data_size = (__u64) pages * PAGE_SIZE;
 850
 851       /* Don't ask for more than we can represent in the configuration.  */
 852       if ((__u64) UINT_MAX < data_size)
 853         continue;
 854
 855       size = (size_t) data_size;
 856
 857       /* Check for overflows.  */
 858       if ((__u64) size != data_size)
 859         continue;
 860
 861       header->aux_size = data_size;
 862       length = size;
 863
 864       pt->pt.mem = mmap (NULL, length, PROT_READ, MAP_SHARED, pt->file,
 865                          header->aux_offset);
 866       if (pt->pt.mem != MAP_FAILED)
 867         break;
 868     }
 869
 870   if (pages == 0)
 871     goto err_conf;
 872
 873   pt->header = header;
 874   pt->pt.size = size;
 875   pt->pt.data_head = &header->aux_head;
 876
 877   tinfo->conf.pt.size = (unsigned int) size;
 878   return tinfo;
 879
 880  err_conf:
 881   munmap((void *) header, PAGE_SIZE);
 882
 883  err_file:
 884   close (pt->file);
 885
 886  err:
 887   xfree (tinfo);
 888   return NULL;
 889 }
 890
 891 #else /* !defined (PERF_ATTR_SIZE_VER5) */
 892
 893 static struct btrace_target_info *
 894 linux_enable_pt (ptid_t ptid, const struct btrace_config_pt *conf)
 895 {
 896   errno = EOPNOTSUPP;
 897   return NULL;
 898 }
 899
 900 #endif /* !defined (PERF_ATTR_SIZE_VER5) */
 901
 902 /* See linux-btrace.h.  */
 903
 904 struct btrace_target_info *
 905 linux_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
 906 {
 907   struct btrace_target_info *tinfo;
 908
 909   tinfo = NULL;
 910   switch (conf->format)
 911     {
 912     case BTRACE_FORMAT_NONE:
 913       break;
 914
 915     case BTRACE_FORMAT_BTS:
 916       tinfo = linux_enable_bts (ptid, &conf->bts);
 917       break;
 918
 919     case BTRACE_FORMAT_PT:
 920       tinfo = linux_enable_pt (ptid, &conf->pt);
 921       break;
 922     }
 923
 924   return tinfo;
 925 }
 926
 927 /* Disable BTS tracing.  */
 928
 929 static enum btrace_error
 930 linux_disable_bts (struct btrace_tinfo_bts *tinfo)
 931 {
 932   munmap((void *) tinfo->header, tinfo->bts.size + PAGE_SIZE);
 933   close (tinfo->file);
 934
 935   return BTRACE_ERR_NONE;
 936 }
 937
 938 /* Disable Intel(R) Processor Trace tracing.  */
 939
 940 static enum btrace_error
 941 linux_disable_pt (struct btrace_tinfo_pt *tinfo)
 942 {
 943   munmap((void *) tinfo->pt.mem, tinfo->pt.size);
 944   munmap((void *) tinfo->header, PAGE_SIZE);
 945   close (tinfo->file);
 946
 947   return BTRACE_ERR_NONE;
 948 }
 949
 950 /* See linux-btrace.h.  */
 951
 952 enum btrace_error
 953 linux_disable_btrace (struct btrace_target_info *tinfo)
 954 {
 955   enum btrace_error errcode;
 956
 957   errcode = BTRACE_ERR_NOT_SUPPORTED;
 958   switch (tinfo->conf.format)
 959     {
 960     case BTRACE_FORMAT_NONE:
 961       break;
 962
 963     case BTRACE_FORMAT_BTS:
 964       errcode = linux_disable_bts (&tinfo->variant.bts);
 965       break;
 966
 967     case BTRACE_FORMAT_PT:
 968       errcode = linux_disable_pt (&tinfo->variant.pt);
 969       break;
 970     }
 971
 972   if (errcode == BTRACE_ERR_NONE)
 973     xfree (tinfo);
 974
 975   return errcode;
 976 }
 977
 978 /* Read branch trace data in BTS format for the thread given by TINFO into
 979    BTRACE using the TYPE reading method.  */
 980
 981 static enum btrace_error
 982 linux_read_bts (struct btrace_data_bts *btrace,
 983                 struct btrace_target_info *tinfo,
 984                 enum btrace_read_type type)
 985 {
 986   struct perf_event_buffer *pevent;
 987   const uint8_t *begin, *end, *start;
 988   size_t buffer_size, size;
 989   __u64 data_head, data_tail;
 990   unsigned int retries = 5;
 991
 992   pevent = &tinfo->variant.bts.bts;
 993
 994   /* For delta reads, we return at least the partial last block containing
 995      the current PC.  */
 996   if (type == BTRACE_READ_NEW && !perf_event_new_data (pevent))
 997     return BTRACE_ERR_NONE;
 998
 999   buffer_size = pevent->size;
1000   data_tail = pevent->last_head;
1001
1002   /* We may need to retry reading the trace.  See below.  */
1003   while (retries--)
1004     {
1005       data_head = *pevent->data_head;
1006
1007       /* Delete any leftover trace from the previous iteration.  */
1008       VEC_free (btrace_block_s, btrace->blocks);
1009
1010       if (type == BTRACE_READ_DELTA)
1011         {
1012           __u64 data_size;
1013
1014           /* Determine the number of bytes to read and check for buffer
1015              overflows.  */
1016
1017           /* Check for data head overflows.  We might be able to recover from
1018              those but they are very unlikely and it's not really worth the
1019              effort, I think.  */
1020           if (data_head < data_tail)
1021             return BTRACE_ERR_OVERFLOW;
1022
1023           /* If the buffer is smaller than the trace delta, we overflowed.  */
1024           data_size = data_head - data_tail;
1025           if (buffer_size < data_size)
1026             return BTRACE_ERR_OVERFLOW;
1027
1028           /* DATA_SIZE <= BUFFER_SIZE and therefore fits into a size_t.  */
1029           size = (size_t) data_size;
1030         }
1031       else
1032         {
1033           /* Read the entire buffer.  */
1034           size = buffer_size;
1035
1036           /* Adjust the size if the buffer has not overflowed, yet.  */
1037           if (data_head < size)
1038             size = (size_t) data_head;
1039         }
1040
1041       /* Data_head keeps growing; the buffer itself is circular.  */
1042       begin = pevent->mem;
1043       start = begin + data_head % buffer_size;
1044
1045       if (data_head <= buffer_size)
1046         end = start;
1047       else
1048         end = begin + pevent->size;
1049
1050       btrace->blocks = perf_event_read_bts (tinfo, begin, end, start, size);
1051
1052       /* The stopping thread notifies its ptracer before it is scheduled out.
1053          On multi-core systems, the debugger might therefore run while the
1054          kernel might be writing the last branch trace records.
1055
1056          Let's check whether the data head moved while we read the trace.  */
1057       if (data_head == *pevent->data_head)
1058         break;
1059     }
1060
1061   pevent->last_head = data_head;
1062
1063   /* Prune the incomplete last block (i.e. the first one of inferior execution)
1064      if we're not doing a delta read.  There is no way of filling in its zeroed
1065      BEGIN element.  */
1066   if (!VEC_empty (btrace_block_s, btrace->blocks)
1067       && type != BTRACE_READ_DELTA)
1068     VEC_pop (btrace_block_s, btrace->blocks);
1069
1070   return BTRACE_ERR_NONE;
1071 }
1072
1073 /* Fill in the Intel(R) Processor Trace configuration information.  */
1074
1075 static void
1076 linux_fill_btrace_pt_config (struct btrace_data_pt_config *conf)
1077 {
1078   conf->cpu = btrace_this_cpu ();
1079 }
1080
1081 /* Read branch trace data in Intel(R) Processor Trace format for the thread
1082    given by TINFO into BTRACE using the TYPE reading method.  */
1083
1084 static enum btrace_error
1085 linux_read_pt (struct btrace_data_pt *btrace,
1086                struct btrace_target_info *tinfo,
1087                enum btrace_read_type type)
1088 {
1089   struct perf_event_buffer *pt;
1090
1091   pt = &tinfo->variant.pt.pt;
1092
1093   linux_fill_btrace_pt_config (&btrace->config);
1094
1095   switch (type)
1096     {
1097     case BTRACE_READ_DELTA:
1098       /* We don't support delta reads.  The data head (i.e. aux_head) wraps
1099          around to stay inside the aux buffer.  */
1100       return BTRACE_ERR_NOT_SUPPORTED;
1101
1102     case BTRACE_READ_NEW:
1103       if (!perf_event_new_data (pt))
1104         return BTRACE_ERR_NONE;
1105
1106       /* Fall through.  */
1107     case BTRACE_READ_ALL:
1108       perf_event_read_all (pt, &btrace->data, &btrace->size);
1109       return BTRACE_ERR_NONE;
1110     }
1111
1112   internal_error (__FILE__, __LINE__, _("Unkown btrace read type."));
1113 }
1114
1115 /* See linux-btrace.h.  */
1116
1117 enum btrace_error
1118 linux_read_btrace (struct btrace_data *btrace,
1119                    struct btrace_target_info *tinfo,
1120                    enum btrace_read_type type)
1121 {
1122   switch (tinfo->conf.format)
1123     {
1124     case BTRACE_FORMAT_NONE:
1125       return BTRACE_ERR_NOT_SUPPORTED;
1126
1127     case BTRACE_FORMAT_BTS:
1128       /* We read btrace in BTS format.  */
1129       btrace->format = BTRACE_FORMAT_BTS;
1130       btrace->variant.bts.blocks = NULL;
1131
1132       return linux_read_bts (&btrace->variant.bts, tinfo, type);
1133
1134     case BTRACE_FORMAT_PT:
1135       /* We read btrace in Intel(R) Processor Trace format.  */
1136       btrace->format = BTRACE_FORMAT_PT;
1137       btrace->variant.pt.data = NULL;
1138       btrace->variant.pt.size = 0;
1139
1140       return linux_read_pt (&btrace->variant.pt, tinfo, type);
1141     }
1142
1143   internal_error (__FILE__, __LINE__, _("Unkown branch trace format."));
1144 }
1145
1146 /* See linux-btrace.h.  */
1147
1148 const struct btrace_config *
1149 linux_btrace_conf (const struct btrace_target_info *tinfo)
1150 {
1151   return &tinfo->conf;
1152 }
1153
1154 #else /* !HAVE_LINUX_PERF_EVENT_H */
1155
1156 /* See linux-btrace.h.  */
1157
1158 int
1159 linux_supports_btrace (struct target_ops *ops, enum btrace_format format)
1160 {
1161   return 0;
1162 }
1163
1164 /* See linux-btrace.h.  */
1165
1166 struct btrace_target_info *
1167 linux_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
1168 {
1169   return NULL;
1170 }
1171
1172 /* See linux-btrace.h.  */
1173
1174 enum btrace_error
1175 linux_disable_btrace (struct btrace_target_info *tinfo)
1176 {
1177   return BTRACE_ERR_NOT_SUPPORTED;
1178 }
1179
1180 /* See linux-btrace.h.  */
1181
1182 enum btrace_error
1183 linux_read_btrace (struct btrace_data *btrace,
1184                    struct btrace_target_info *tinfo,
1185                    enum btrace_read_type type)
1186 {
1187   return BTRACE_ERR_NOT_SUPPORTED;
1188 }
1189
1190 /* See linux-btrace.h.  */
1191
1192 const struct btrace_config *
1193 linux_btrace_conf (const struct btrace_target_info *tinfo)
1194 {
1195   return NULL;
1196 }
1197
1198 #endif /* !HAVE_LINUX_PERF_EVENT_H */