/home/stan/gdb/src/gdb/common/linux-btrace.c

Go to the documentation of this file.

/* Linux-dependent part of branch trace support for GDB, and GDBserver.

   Copyright (C) 2013 Free Software Foundation, Inc.

   Contributed by Intel Corp. <markus.t.metzger@intel.com>

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#ifdef GDBSERVER
#include "server.h"
#else
#include "defs.h"
#endif

#include "linux-btrace.h"
#include "common-utils.h"
#include "gdb_assert.h"
#include "regcache.h"
#include "gdbthread.h"
#include "gdb_wait.h"
#include "i386-cpuid.h"

#ifdef HAVE_SYS_SYSCALL_H
#include <sys/syscall.h>
#endif

#if HAVE_LINUX_PERF_EVENT_H && defined(SYS_perf_event_open)

#include <errno.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/user.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <signal.h>

/* A branch trace record in perf_event.  */
struct perf_event_bts
{
  /* The linear address of the branch source.  */
  uint64_t from;

  /* The linear address of the branch destination.  */
  uint64_t to;
};

/* A perf_event branch trace sample.  */
struct perf_event_sample
{
  /* The perf_event sample header.  */
  struct perf_event_header header;

  /* The perf_event branch tracing payload.  */
  struct perf_event_bts bts;
};

/* Get the perf_event header.  */

static inline volatile struct perf_event_mmap_page *
perf_event_header (struct btrace_target_info* tinfo)
{
  return tinfo->buffer;
}

/* Get the size of the perf_event mmap buffer.  */

static inline size_t
perf_event_mmap_size (const struct btrace_target_info *tinfo)
{
  /* The branch trace buffer is preceded by a configuration page.  */
  return (tinfo->size + 1) * PAGE_SIZE;
}

/* Get the size of the perf_event buffer.  */

static inline size_t
perf_event_buffer_size (struct btrace_target_info* tinfo)
{
  return tinfo->size * PAGE_SIZE;
}

/* Get the start address of the perf_event buffer.  */

static inline const uint8_t *
perf_event_buffer_begin (struct btrace_target_info* tinfo)
{
  return ((const uint8_t *) tinfo->buffer) + PAGE_SIZE;
}

/* Get the end address of the perf_event buffer.  */

static inline const uint8_t *
perf_event_buffer_end (struct btrace_target_info* tinfo)
{
  return perf_event_buffer_begin (tinfo) + perf_event_buffer_size (tinfo);
}

/* Check whether an address is in the kernel.  */

static inline int
perf_event_is_kernel_addr (const struct btrace_target_info *tinfo,
                           uint64_t addr)
{
  uint64_t mask;

  /* If we don't know the size of a pointer, we can't check.  Let's assume it's
     not a kernel address in this case.  */
  if (tinfo->ptr_bits == 0)
    return 0;

  /* A bit mask for the most significant bit in an address.  */
  mask = (uint64_t) 1 << (tinfo->ptr_bits - 1);

  /* Check whether the most significant bit in the address is set.  */
  return (addr & mask) != 0;
}

/* Check whether a perf event record should be skipped.  */

static inline int
perf_event_skip_record (const struct btrace_target_info *tinfo,
                        const struct perf_event_bts *bts)
{
  /* The hardware may report branches from kernel into user space.  Branches
     from user into kernel space will be suppressed.  We filter the former to
     provide a consistent branch trace excluding kernel.  */
  return perf_event_is_kernel_addr (tinfo, bts->from);
}

/* Perform a few consistency checks on a perf event sample record.  This is
   meant to catch cases when we get out of sync with the perf event stream.  */

static inline int
perf_event_sample_ok (const struct perf_event_sample *sample)
{
  if (sample->header.type != PERF_RECORD_SAMPLE)
    return 0;

  if (sample->header.size != sizeof (*sample))
    return 0;

  return 1;
}

/* Branch trace is collected in a circular buffer [begin; end) as pairs of from
   and to addresses (plus a header).

   Start points into that buffer at the next sample position.
   We read the collected samples backwards from start.

   While reading the samples, we convert the information into a list of blocks.
   For two adjacent samples s1 and s2, we form a block b such that b.begin =
   s1.to and b.end = s2.from.

   In case the buffer overflows during sampling, one sample may have its lower
   part at the end and its upper part at the beginning of the buffer.  */

static VEC (btrace_block_s) *
perf_event_read_bts (struct btrace_target_info* tinfo, const uint8_t *begin,
                     const uint8_t *end, const uint8_t *start)
{
  VEC (btrace_block_s) *btrace = NULL;
  struct perf_event_sample sample;
  size_t read = 0, size = (end - begin);
  struct btrace_block block = { 0, 0 };
  struct regcache *regcache;

  gdb_assert (begin <= start);
  gdb_assert (start <= end);

  /* The first block ends at the current pc.  */
#ifdef GDBSERVER
  regcache = get_thread_regcache (find_thread_ptid (tinfo->ptid), 1);
#else
  regcache = get_thread_regcache (tinfo->ptid);
#endif
  block.end = regcache_read_pc (regcache);

  /* The buffer may contain a partial record as its last entry (i.e. when the
     buffer size is not a multiple of the sample size).  */
  read = sizeof (sample) - 1;

  for (; read < size; read += sizeof (sample))
    {
      const struct perf_event_sample *psample;

      /* Find the next perf_event sample in a backwards traversal.  */
      start -= sizeof (sample);

      /* If we're still inside the buffer, we're done.  */
      if (begin <= start)
        psample = (const struct perf_event_sample *) start;
      else
        {
          int missing;

          /* We're to the left of the ring buffer, we will wrap around and
             reappear at the very right of the ring buffer.  */

          missing = (begin - start);
          start = (end - missing);

          /* If the entire sample is missing, we're done.  */
          if (missing == sizeof (sample))
            psample = (const struct perf_event_sample *) start;
          else
            {
              uint8_t *stack;

              /* The sample wrapped around.  The lower part is at the end and
                 the upper part is at the beginning of the buffer.  */
              stack = (uint8_t *) &sample;

              /* Copy the two parts so we have a contiguous sample.  */
              memcpy (stack, start, missing);
              memcpy (stack + missing, begin, sizeof (sample) - missing);

              psample = &sample;
            }
        }

      if (!perf_event_sample_ok (psample))
        {
          warning (_("Branch trace may be incomplete."));
          break;
        }

      if (perf_event_skip_record (tinfo, &psample->bts))
        continue;

      /* We found a valid sample, so we can complete the current block.  */
      block.begin = psample->bts.to;

      VEC_safe_push (btrace_block_s, btrace, &block);

      /* Start the next block.  */
      block.end = psample->bts.from;
    }

  return btrace;
}

/* Check whether the kernel supports branch tracing.  */

static int
kernel_supports_btrace (void)
{
  struct perf_event_attr attr;
  pid_t child, pid;
  int status, file;

  errno = 0;
  child = fork ();
  switch (child)
    {
    case -1:
      warning (_("test branch tracing: cannot fork: %s."), strerror (errno));
      return 0;

    case 0:
      status = ptrace (PTRACE_TRACEME, 0, NULL, NULL);
      if (status != 0)
        {
          warning (_("test branch tracing: cannot PTRACE_TRACEME: %s."),
                   strerror (errno));
          _exit (1);
        }

      status = raise (SIGTRAP);
      if (status != 0)
        {
          warning (_("test branch tracing: cannot raise SIGTRAP: %s."),
                   strerror (errno));
          _exit (1);
        }

      _exit (1);

    default:
      pid = waitpid (child, &status, 0);
      if (pid != child)
        {
          warning (_("test branch tracing: bad pid %ld, error: %s."),
                   (long) pid, strerror (errno));
          return 0;
        }

      if (!WIFSTOPPED (status))
        {
          warning (_("test branch tracing: expected stop. status: %d."),
                   status);
          return 0;
        }

      memset (&attr, 0, sizeof (attr));

      attr.type = PERF_TYPE_HARDWARE;
      attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
      attr.sample_period = 1;
      attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_ADDR;
      attr.exclude_kernel = 1;
      attr.exclude_hv = 1;
      attr.exclude_idle = 1;

      file = syscall (SYS_perf_event_open, &attr, child, -1, -1, 0);
      if (file >= 0)
        close (file);

      kill (child, SIGKILL);
      ptrace (PTRACE_KILL, child, NULL, NULL);

      pid = waitpid (child, &status, 0);
      if (pid != child)
        {
          warning (_("test branch tracing: bad pid %ld, error: %s."),
                   (long) pid, strerror (errno));
          if (!WIFSIGNALED (status))
            warning (_("test branch tracing: expected killed. status: %d."),
                     status);
        }

      return (file >= 0);
    }
}

/* Check whether an Intel cpu supports branch tracing.  */

static int
intel_supports_btrace (void)
{
  unsigned int cpuid, model, family;

  if (!i386_cpuid (1, &cpuid, NULL, NULL, NULL))
    return 0;

  family = (cpuid >> 8) & 0xf;
  model = (cpuid >> 4) & 0xf;

  switch (family)
    {
    case 0x6:
      model += (cpuid >> 12) & 0xf0;

      switch (model)
        {
        case 0x1a: /* Nehalem */
        case 0x1f:
        case 0x1e:
        case 0x2e:
        case 0x25: /* Westmere */
        case 0x2c:
        case 0x2f:
        case 0x2a: /* Sandy Bridge */
        case 0x2d:
        case 0x3a: /* Ivy Bridge */

          /* AAJ122: LBR, BTM, or BTS records may have incorrect branch
             "from" information afer an EIST transition, T-states, C1E, or
             Adaptive Thermal Throttling.  */
          return 0;
        }
    }

  return 1;
}

/* Check whether the cpu supports branch tracing.  */

static int
cpu_supports_btrace (void)
{
  unsigned int ebx, ecx, edx;

  if (!i386_cpuid (0, NULL, &ebx, &ecx, &edx))
    return 0;

  if (ebx == signature_INTEL_ebx && ecx == signature_INTEL_ecx
      && edx == signature_INTEL_edx)
    return intel_supports_btrace ();

  /* Don't know about others.  Let's assume they do.  */
  return 1;
}

/* See linux-btrace.h.  */

int
linux_supports_btrace (void)
{
  static int cached;

  if (cached == 0)
    {
      if (!kernel_supports_btrace ())
        cached = -1;
      else if (!cpu_supports_btrace ())
        cached = -1;
      else
        cached = 1;
    }

  return cached > 0;
}

/* See linux-btrace.h.  */

struct btrace_target_info *
linux_enable_btrace (ptid_t ptid)
{
  struct btrace_target_info *tinfo;
  int pid;

  tinfo = xzalloc (sizeof (*tinfo));
  tinfo->ptid = ptid;

  tinfo->attr.size = sizeof (tinfo->attr);
  tinfo->attr.type = PERF_TYPE_HARDWARE;
  tinfo->attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
  tinfo->attr.sample_period = 1;

  /* We sample from and to address.  */
  tinfo->attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_ADDR;

  tinfo->attr.exclude_kernel = 1;
  tinfo->attr.exclude_hv = 1;
  tinfo->attr.exclude_idle = 1;

  tinfo->ptr_bits = 0;

  pid = ptid_get_lwp (ptid);
  if (pid == 0)
    pid = ptid_get_pid (ptid);

  errno = 0;
  tinfo->file = syscall (SYS_perf_event_open, &tinfo->attr, pid, -1, -1, 0);
  if (tinfo->file < 0)
    goto err;

  /* We hard-code the trace buffer size.
     At some later time, we should make this configurable.  */
  tinfo->size = 1;
  tinfo->buffer = mmap (NULL, perf_event_mmap_size (tinfo),
                        PROT_READ, MAP_SHARED, tinfo->file, 0);
  if (tinfo->buffer == MAP_FAILED)
    goto err_file;

  return tinfo;

 err_file:
  close (tinfo->file);

 err:
  xfree (tinfo);
  return NULL;
}

/* See linux-btrace.h.  */

int
linux_disable_btrace (struct btrace_target_info *tinfo)
{
  int errcode;

  errno = 0;
  errcode = munmap (tinfo->buffer, perf_event_mmap_size (tinfo));
  if (errcode != 0)
    return errno;

  close (tinfo->file);
  xfree (tinfo);

  return 0;
}

/* Check whether the branch trace has changed.  */

static int
linux_btrace_has_changed (struct btrace_target_info *tinfo)
{
  volatile struct perf_event_mmap_page *header = perf_event_header (tinfo);

  return header->data_head != tinfo->data_head;
}

/* See linux-btrace.h.  */

VEC (btrace_block_s) *
linux_read_btrace (struct btrace_target_info *tinfo,
                   enum btrace_read_type type)
{
  VEC (btrace_block_s) *btrace = NULL;
  volatile struct perf_event_mmap_page *header;
  const uint8_t *begin, *end, *start;
  unsigned long data_head, retries = 5;
  size_t buffer_size;

  if (type == btrace_read_new && !linux_btrace_has_changed (tinfo))
    return NULL;

  header = perf_event_header (tinfo);
  buffer_size = perf_event_buffer_size (tinfo);

  /* We may need to retry reading the trace.  See below.  */
  while (retries--)
    {
      data_head = header->data_head;

      /* If there's new trace, let's read it.  */
      if (data_head != tinfo->data_head)
        {
          /* Data_head keeps growing; the buffer itself is circular.  */
          begin = perf_event_buffer_begin (tinfo);
          start = begin + data_head % buffer_size;

          if (data_head <= buffer_size)
            end = start;
          else
            end = perf_event_buffer_end (tinfo);

          btrace = perf_event_read_bts (tinfo, begin, end, start);
        }

      /* The stopping thread notifies its ptracer before it is scheduled out.
         On multi-core systems, the debugger might therefore run while the
         kernel might be writing the last branch trace records.

         Let's check whether the data head moved while we read the trace.  */
      if (data_head == header->data_head)
        break;
    }

  tinfo->data_head = data_head;

  return btrace;
}

#else /* !HAVE_LINUX_PERF_EVENT_H */

/* See linux-btrace.h.  */

int
linux_supports_btrace (void)
{
  return 0;
}

/* See linux-btrace.h.  */

struct btrace_target_info *
linux_enable_btrace (ptid_t ptid)
{
  return NULL;
}

/* See linux-btrace.h.  */

int
linux_disable_btrace (struct btrace_target_info *tinfo)
{
  return ENOSYS;
}

/* See linux-btrace.h.  */

VEC (btrace_block_s) *
linux_read_btrace (struct btrace_target_info *tinfo,
                   enum btrace_read_type type)
{
  return NULL;
}

#endif /* !HAVE_LINUX_PERF_EVENT_H */