gdb/nat/linux-btrace.c

   1 /* Linux-dependent part of branch trace support for GDB, and GDBserver.
   2
   3    Copyright (C) 2013-2014 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 #ifdef GDBSERVER
  23 #include "server.h"
  24 #else
  25 #include "defs.h"
  26 #endif
  27
  28 #include "linux-btrace.h"
  29 #include "regcache.h"
  30 #include "gdbthread.h"
  31 #include "gdb_wait.h"
  32 #include "i386-cpuid.h"
  33
  34 #ifdef HAVE_SYS_SYSCALL_H
  35 #include <sys/syscall.h>
  36 #endif
  37
  38 #if HAVE_LINUX_PERF_EVENT_H && defined(SYS_perf_event_open)
  39
  40 #include <stdint.h>
  41 #include <unistd.h>
  42 #include <sys/mman.h>
  43 #include <sys/user.h>
  44 #include <sys/ptrace.h>
  45 #include <sys/types.h>
  46 #include <signal.h>
  47
  48 /* A branch trace record in perf_event.  */
  49 struct perf_event_bts
  50 {
  51   /* The linear address of the branch source.  */
  52   uint64_t from;
  53
  54   /* The linear address of the branch destination.  */
  55   uint64_t to;
  56 };
  57
  58 /* A perf_event branch trace sample.  */
  59 struct perf_event_sample
  60 {
  61   /* The perf_event sample header.  */
  62   struct perf_event_header header;
  63
  64   /* The perf_event branch tracing payload.  */
  65   struct perf_event_bts bts;
  66 };
  67
  68 /* Get the perf_event header.  */
  69
  70 static inline volatile struct perf_event_mmap_page *
  71 perf_event_header (struct btrace_target_info* tinfo)
  72 {
  73   return tinfo->buffer;
  74 }
  75
  76 /* Get the size of the perf_event mmap buffer.  */
  77
  78 static inline size_t
  79 perf_event_mmap_size (const struct btrace_target_info *tinfo)
  80 {
  81   /* The branch trace buffer is preceded by a configuration page.  */
  82   return (tinfo->size + 1) * PAGE_SIZE;
  83 }
  84
  85 /* Get the size of the perf_event buffer.  */
  86
  87 static inline size_t
  88 perf_event_buffer_size (struct btrace_target_info* tinfo)
  89 {
  90   return tinfo->size * PAGE_SIZE;
  91 }
  92
  93 /* Get the start address of the perf_event buffer.  */
  94
  95 static inline const uint8_t *
  96 perf_event_buffer_begin (struct btrace_target_info* tinfo)
  97 {
  98   return ((const uint8_t *) tinfo->buffer) + PAGE_SIZE;
  99 }
 100
 101 /* Get the end address of the perf_event buffer.  */
 102
 103 static inline const uint8_t *
 104 perf_event_buffer_end (struct btrace_target_info* tinfo)
 105 {
 106   return perf_event_buffer_begin (tinfo) + perf_event_buffer_size (tinfo);
 107 }
 108
 109 /* Check whether an address is in the kernel.  */
 110
 111 static inline int
 112 perf_event_is_kernel_addr (const struct btrace_target_info *tinfo,
 113                            uint64_t addr)
 114 {
 115   uint64_t mask;
 116
 117   /* If we don't know the size of a pointer, we can't check.  Let's assume it's
 118      not a kernel address in this case.  */
 119   if (tinfo->ptr_bits == 0)
 120     return 0;
 121
 122   /* A bit mask for the most significant bit in an address.  */
 123   mask = (uint64_t) 1 << (tinfo->ptr_bits - 1);
 124
 125   /* Check whether the most significant bit in the address is set.  */
 126   return (addr & mask) != 0;
 127 }
 128
 129 /* Check whether a perf event record should be skipped.  */
 130
 131 static inline int
 132 perf_event_skip_record (const struct btrace_target_info *tinfo,
 133                         const struct perf_event_bts *bts)
 134 {
 135   /* The hardware may report branches from kernel into user space.  Branches
 136      from user into kernel space will be suppressed.  We filter the former to
 137      provide a consistent branch trace excluding kernel.  */
 138   return perf_event_is_kernel_addr (tinfo, bts->from);
 139 }
 140
 141 /* Perform a few consistency checks on a perf event sample record.  This is
 142    meant to catch cases when we get out of sync with the perf event stream.  */
 143
 144 static inline int
 145 perf_event_sample_ok (const struct perf_event_sample *sample)
 146 {
 147   if (sample->header.type != PERF_RECORD_SAMPLE)
 148     return 0;
 149
 150   if (sample->header.size != sizeof (*sample))
 151     return 0;
 152
 153   return 1;
 154 }
 155
 156 /* Branch trace is collected in a circular buffer [begin; end) as pairs of from
 157    and to addresses (plus a header).
 158
 159    Start points into that buffer at the next sample position.
 160    We read the collected samples backwards from start.
 161
 162    While reading the samples, we convert the information into a list of blocks.
 163    For two adjacent samples s1 and s2, we form a block b such that b.begin =
 164    s1.to and b.end = s2.from.
 165
 166    In case the buffer overflows during sampling, one sample may have its lower
 167    part at the end and its upper part at the beginning of the buffer.  */
 168
 169 static VEC (btrace_block_s) *
 170 perf_event_read_bts (struct btrace_target_info* tinfo, const uint8_t *begin,
 171                      const uint8_t *end, const uint8_t *start, size_t size)
 172 {
 173   VEC (btrace_block_s) *btrace = NULL;
 174   struct perf_event_sample sample;
 175   size_t read = 0;
 176   struct btrace_block block = { 0, 0 };
 177   struct regcache *regcache;
 178
 179   gdb_assert (begin <= start);
 180   gdb_assert (start <= end);
 181
 182   /* The first block ends at the current pc.  */
 183 #ifdef GDBSERVER
 184   regcache = get_thread_regcache (find_thread_ptid (tinfo->ptid), 1);
 185 #else
 186   regcache = get_thread_regcache (tinfo->ptid);
 187 #endif
 188   block.end = regcache_read_pc (regcache);
 189
 190   /* The buffer may contain a partial record as its last entry (i.e. when the
 191      buffer size is not a multiple of the sample size).  */
 192   read = sizeof (sample) - 1;
 193
 194   for (; read < size; read += sizeof (sample))
 195     {
 196       const struct perf_event_sample *psample;
 197
 198       /* Find the next perf_event sample in a backwards traversal.  */
 199       start -= sizeof (sample);
 200
 201       /* If we're still inside the buffer, we're done.  */
 202       if (begin <= start)
 203         psample = (const struct perf_event_sample *) start;
 204       else
 205         {
 206           int missing;
 207
 208           /* We're to the left of the ring buffer, we will wrap around and
 209              reappear at the very right of the ring buffer.  */
 210
 211           missing = (begin - start);
 212           start = (end - missing);
 213
 214           /* If the entire sample is missing, we're done.  */
 215           if (missing == sizeof (sample))
 216             psample = (const struct perf_event_sample *) start;
 217           else
 218             {
 219               uint8_t *stack;
 220
 221               /* The sample wrapped around.  The lower part is at the end and
 222                  the upper part is at the beginning of the buffer.  */
 223               stack = (uint8_t *) &sample;
 224
 225               /* Copy the two parts so we have a contiguous sample.  */
 226               memcpy (stack, start, missing);
 227               memcpy (stack + missing, begin, sizeof (sample) - missing);
 228
 229               psample = &sample;
 230             }
 231         }
 232
 233       if (!perf_event_sample_ok (psample))
 234         {
 235           warning (_("Branch trace may be incomplete."));
 236           break;
 237         }
 238
 239       if (perf_event_skip_record (tinfo, &psample->bts))
 240         continue;
 241
 242       /* We found a valid sample, so we can complete the current block.  */
 243       block.begin = psample->bts.to;
 244
 245       VEC_safe_push (btrace_block_s, btrace, &block);
 246
 247       /* Start the next block.  */
 248       block.end = psample->bts.from;
 249     }
 250
 251   /* Push the last block (i.e. the first one of inferior execution), as well.
 252      We don't know where it ends, but we know where it starts.  If we're
 253      reading delta trace, we can fill in the start address later on.
 254      Otherwise we will prune it.  */
 255   block.begin = 0;
 256   VEC_safe_push (btrace_block_s, btrace, &block);
 257
 258   return btrace;
 259 }
 260
 261 /* Check whether the kernel supports branch tracing.  */
 262
 263 static int
 264 kernel_supports_btrace (void)
 265 {
 266   struct perf_event_attr attr;
 267   pid_t child, pid;
 268   int status, file;
 269
 270   errno = 0;
 271   child = fork ();
 272   switch (child)
 273     {
 274     case -1:
 275       warning (_("test branch tracing: cannot fork: %s."), strerror (errno));
 276       return 0;
 277
 278     case 0:
 279       status = ptrace (PTRACE_TRACEME, 0, NULL, NULL);
 280       if (status != 0)
 281         {
 282           warning (_("test branch tracing: cannot PTRACE_TRACEME: %s."),
 283                    strerror (errno));
 284           _exit (1);
 285         }
 286
 287       status = raise (SIGTRAP);
 288       if (status != 0)
 289         {
 290           warning (_("test branch tracing: cannot raise SIGTRAP: %s."),
 291                    strerror (errno));
 292           _exit (1);
 293         }
 294
 295       _exit (1);
 296
 297     default:
 298       pid = waitpid (child, &status, 0);
 299       if (pid != child)
 300         {
 301           warning (_("test branch tracing: bad pid %ld, error: %s."),
 302                    (long) pid, strerror (errno));
 303           return 0;
 304         }
 305
 306       if (!WIFSTOPPED (status))
 307         {
 308           warning (_("test branch tracing: expected stop. status: %d."),
 309                    status);
 310           return 0;
 311         }
 312
 313       memset (&attr, 0, sizeof (attr));
 314
 315       attr.type = PERF_TYPE_HARDWARE;
 316       attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
 317       attr.sample_period = 1;
 318       attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_ADDR;
 319       attr.exclude_kernel = 1;
 320       attr.exclude_hv = 1;
 321       attr.exclude_idle = 1;
 322
 323       file = syscall (SYS_perf_event_open, &attr, child, -1, -1, 0);
 324       if (file >= 0)
 325         close (file);
 326
 327       kill (child, SIGKILL);
 328       ptrace (PTRACE_KILL, child, NULL, NULL);
 329
 330       pid = waitpid (child, &status, 0);
 331       if (pid != child)
 332         {
 333           warning (_("test branch tracing: bad pid %ld, error: %s."),
 334                    (long) pid, strerror (errno));
 335           if (!WIFSIGNALED (status))
 336             warning (_("test branch tracing: expected killed. status: %d."),
 337                      status);
 338         }
 339
 340       return (file >= 0);
 341     }
 342 }
 343
 344 /* Check whether an Intel cpu supports branch tracing.  */
 345
 346 static int
 347 intel_supports_btrace (void)
 348 {
 349   unsigned int cpuid, model, family;
 350
 351   if (!i386_cpuid (1, &cpuid, NULL, NULL, NULL))
 352     return 0;
 353
 354   family = (cpuid >> 8) & 0xf;
 355   model = (cpuid >> 4) & 0xf;
 356
 357   switch (family)
 358     {
 359     case 0x6:
 360       model += (cpuid >> 12) & 0xf0;
 361
 362       switch (model)
 363         {
 364         case 0x1a: /* Nehalem */
 365         case 0x1f:
 366         case 0x1e:
 367         case 0x2e:
 368         case 0x25: /* Westmere */
 369         case 0x2c:
 370         case 0x2f:
 371         case 0x2a: /* Sandy Bridge */
 372         case 0x2d:
 373         case 0x3a: /* Ivy Bridge */
 374
 375           /* AAJ122: LBR, BTM, or BTS records may have incorrect branch
 376              "from" information afer an EIST transition, T-states, C1E, or
 377              Adaptive Thermal Throttling.  */
 378           return 0;
 379         }
 380     }
 381
 382   return 1;
 383 }
 384
 385 /* Check whether the cpu supports branch tracing.  */
 386
 387 static int
 388 cpu_supports_btrace (void)
 389 {
 390   unsigned int ebx, ecx, edx;
 391
 392   if (!i386_cpuid (0, NULL, &ebx, &ecx, &edx))
 393     return 0;
 394
 395   if (ebx == signature_INTEL_ebx && ecx == signature_INTEL_ecx
 396       && edx == signature_INTEL_edx)
 397     return intel_supports_btrace ();
 398
 399   /* Don't know about others.  Let's assume they do.  */
 400   return 1;
 401 }
 402
 403 /* See linux-btrace.h.  */
 404
 405 int
 406 linux_supports_btrace (struct target_ops *ops)
 407 {
 408   static int cached;
 409
 410   if (cached == 0)
 411     {
 412       if (!kernel_supports_btrace ())
 413         cached = -1;
 414       else if (!cpu_supports_btrace ())
 415         cached = -1;
 416       else
 417         cached = 1;
 418     }
 419
 420   return cached > 0;
 421 }
 422
 423 /* See linux-btrace.h.  */
 424
 425 struct btrace_target_info *
 426 linux_enable_btrace (ptid_t ptid)
 427 {
 428   struct btrace_target_info *tinfo;
 429   int pid, pg;
 430
 431   tinfo = xzalloc (sizeof (*tinfo));
 432   tinfo->ptid = ptid;
 433
 434   tinfo->attr.size = sizeof (tinfo->attr);
 435   tinfo->attr.type = PERF_TYPE_HARDWARE;
 436   tinfo->attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
 437   tinfo->attr.sample_period = 1;
 438
 439   /* We sample from and to address.  */
 440   tinfo->attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_ADDR;
 441
 442   tinfo->attr.exclude_kernel = 1;
 443   tinfo->attr.exclude_hv = 1;
 444   tinfo->attr.exclude_idle = 1;
 445
 446   tinfo->ptr_bits = 0;
 447
 448   pid = ptid_get_lwp (ptid);
 449   if (pid == 0)
 450     pid = ptid_get_pid (ptid);
 451
 452   errno = 0;
 453   tinfo->file = syscall (SYS_perf_event_open, &tinfo->attr, pid, -1, -1, 0);
 454   if (tinfo->file < 0)
 455     goto err;
 456
 457   /* We try to allocate as much buffer as we can get.
 458      We could allow the user to specify the size of the buffer, but then
 459      we'd leave this search for the maximum buffer size to him.  */
 460   for (pg = 4; pg >= 0; --pg)
 461     {
 462       /* The number of pages we request needs to be a power of two.  */
 463       tinfo->size = 1 << pg;
 464       tinfo->buffer = mmap (NULL, perf_event_mmap_size (tinfo),
 465                             PROT_READ, MAP_SHARED, tinfo->file, 0);
 466       if (tinfo->buffer == MAP_FAILED)
 467         continue;
 468
 469       return tinfo;
 470     }
 471
 472   /* We were not able to allocate any buffer.  */
 473   close (tinfo->file);
 474
 475  err:
 476   xfree (tinfo);
 477   return NULL;
 478 }
 479
 480 /* See linux-btrace.h.  */
 481
 482 enum btrace_error
 483 linux_disable_btrace (struct btrace_target_info *tinfo)
 484 {
 485   int errcode;
 486
 487   errno = 0;
 488   errcode = munmap (tinfo->buffer, perf_event_mmap_size (tinfo));
 489   if (errcode != 0)
 490     return BTRACE_ERR_UNKNOWN;
 491
 492   close (tinfo->file);
 493   xfree (tinfo);
 494
 495   return BTRACE_ERR_NONE;
 496 }
 497
 498 /* Check whether the branch trace has changed.  */
 499
 500 static int
 501 linux_btrace_has_changed (struct btrace_target_info *tinfo)
 502 {
 503   volatile struct perf_event_mmap_page *header = perf_event_header (tinfo);
 504
 505   return header->data_head != tinfo->data_head;
 506 }
 507
 508 /* See linux-btrace.h.  */
 509
 510 enum btrace_error
 511 linux_read_btrace (VEC (btrace_block_s) **btrace,
 512                    struct btrace_target_info *tinfo,
 513                    enum btrace_read_type type)
 514 {
 515   volatile struct perf_event_mmap_page *header;
 516   const uint8_t *begin, *end, *start;
 517   unsigned long data_head, data_tail, retries = 5;
 518   size_t buffer_size, size;
 519
 520   /* For delta reads, we return at least the partial last block containing
 521      the current PC.  */
 522   if (type == BTRACE_READ_NEW && !linux_btrace_has_changed (tinfo))
 523     return BTRACE_ERR_NONE;
 524
 525   header = perf_event_header (tinfo);
 526   buffer_size = perf_event_buffer_size (tinfo);
 527   data_tail = tinfo->data_head;
 528
 529   /* We may need to retry reading the trace.  See below.  */
 530   while (retries--)
 531     {
 532       data_head = header->data_head;
 533
 534       /* Delete any leftover trace from the previous iteration.  */
 535       VEC_free (btrace_block_s, *btrace);
 536
 537       if (type == BTRACE_READ_DELTA)
 538         {
 539           /* Determine the number of bytes to read and check for buffer
 540              overflows.  */
 541
 542           /* Check for data head overflows.  We might be able to recover from
 543              those but they are very unlikely and it's not really worth the
 544              effort, I think.  */
 545           if (data_head < data_tail)
 546             return BTRACE_ERR_OVERFLOW;
 547
 548           /* If the buffer is smaller than the trace delta, we overflowed.  */
 549           size = data_head - data_tail;
 550           if (buffer_size < size)
 551             return BTRACE_ERR_OVERFLOW;
 552         }
 553       else
 554         {
 555           /* Read the entire buffer.  */
 556           size = buffer_size;
 557
 558           /* Adjust the size if the buffer has not overflowed, yet.  */
 559           if (data_head < size)
 560             size = data_head;
 561         }
 562
 563       /* Data_head keeps growing; the buffer itself is circular.  */
 564       begin = perf_event_buffer_begin (tinfo);
 565       start = begin + data_head % buffer_size;
 566
 567       if (data_head <= buffer_size)
 568         end = start;
 569       else
 570         end = perf_event_buffer_end (tinfo);
 571
 572       *btrace = perf_event_read_bts (tinfo, begin, end, start, size);
 573
 574       /* The stopping thread notifies its ptracer before it is scheduled out.
 575          On multi-core systems, the debugger might therefore run while the
 576          kernel might be writing the last branch trace records.
 577
 578          Let's check whether the data head moved while we read the trace.  */
 579       if (data_head == header->data_head)
 580         break;
 581     }
 582
 583   tinfo->data_head = data_head;
 584
 585   /* Prune the incomplete last block (i.e. the first one of inferior execution)
 586      if we're not doing a delta read.  There is no way of filling in its zeroed
 587      BEGIN element.  */
 588   if (!VEC_empty (btrace_block_s, *btrace) && type != BTRACE_READ_DELTA)
 589     VEC_pop (btrace_block_s, *btrace);
 590
 591   return BTRACE_ERR_NONE;
 592 }
 593
 594 #else /* !HAVE_LINUX_PERF_EVENT_H */
 595
 596 /* See linux-btrace.h.  */
 597
 598 int
 599 linux_supports_btrace (struct target_ops *ops)
 600 {
 601   return 0;
 602 }
 603
 604 /* See linux-btrace.h.  */
 605
 606 struct btrace_target_info *
 607 linux_enable_btrace (ptid_t ptid)
 608 {
 609   return NULL;
 610 }
 611
 612 /* See linux-btrace.h.  */
 613
 614 enum btrace_error
 615 linux_disable_btrace (struct btrace_target_info *tinfo)
 616 {
 617   return BTRACE_ERR_NOT_SUPPORTED;
 618 }
 619
 620 /* See linux-btrace.h.  */
 621
 622 enum btrace_error
 623 linux_read_btrace (VEC (btrace_block_s) **btrace,
 624                    struct btrace_target_info *tinfo,
 625                    enum btrace_read_type type)
 626 {
 627   return BTRACE_ERR_NOT_SUPPORTED;
 628 }
 629
 630 #endif /* !HAVE_LINUX_PERF_EVENT_H */