diff options
Diffstat (limited to 'gdb/common/linux-btrace.c')
-rw-r--r-- | gdb/common/linux-btrace.c | 425 |
1 files changed, 425 insertions, 0 deletions
diff --git a/gdb/common/linux-btrace.c b/gdb/common/linux-btrace.c new file mode 100644 index 0000000..2f8c1cf --- /dev/null +++ b/gdb/common/linux-btrace.c @@ -0,0 +1,425 @@ +/* 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" + +#if HAVE_LINUX_PERF_EVENT_H + +#include <errno.h> +#include <string.h> +#include <stdint.h> +#include <unistd.h> +#include <sys/syscall.h> +#include <sys/mman.h> +#include <sys/user.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; +} + +/* See linux-btrace.h. */ + +int +linux_supports_btrace (void) +{ + return 1; +} + +/* 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 */ |