1 /* Linux-dependent part of branch trace support for GDB, and GDBserver.
3 Copyright (C) 2013-2014 Free Software Foundation, Inc.
5 Contributed by Intel Corp. <markus.t.metzger@intel.com>
7 This file is part of GDB.
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.
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.
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/>. */
28 #include "linux-btrace.h"
29 #include "common-regcache.h"
30 #include "gdbthread.h"
32 #include "x86-cpuid.h"
34 #ifdef HAVE_SYS_SYSCALL_H
35 #include <sys/syscall.h>
38 #if HAVE_LINUX_PERF_EVENT_H && defined(SYS_perf_event_open)
44 #include <sys/ptrace.h>
45 #include <sys/types.h>
48 /* A branch trace record in perf_event. */
51 /* The linear address of the branch source. */
54 /* The linear address of the branch destination. */
58 /* A perf_event branch trace sample. */
59 struct perf_event_sample
61 /* The perf_event sample header. */
62 struct perf_event_header header;
64 /* The perf_event branch tracing payload. */
65 struct perf_event_bts bts;
68 /* Get the perf_event header. */
70 static inline volatile struct perf_event_mmap_page *
71 perf_event_header (struct btrace_target_info* tinfo)
76 /* Get the size of the perf_event mmap buffer. */
79 perf_event_mmap_size (const struct btrace_target_info *tinfo)
81 /* The branch trace buffer is preceded by a configuration page. */
82 return (tinfo->size + 1) * PAGE_SIZE;
85 /* Get the size of the perf_event buffer. */
88 perf_event_buffer_size (struct btrace_target_info* tinfo)
90 return tinfo->size * PAGE_SIZE;
93 /* Get the start address of the perf_event buffer. */
95 static inline const uint8_t *
96 perf_event_buffer_begin (struct btrace_target_info* tinfo)
98 return ((const uint8_t *) tinfo->buffer) + PAGE_SIZE;
101 /* Get the end address of the perf_event buffer. */
103 static inline const uint8_t *
104 perf_event_buffer_end (struct btrace_target_info* tinfo)
106 return perf_event_buffer_begin (tinfo) + perf_event_buffer_size (tinfo);
109 /* Check whether an address is in the kernel. */
112 perf_event_is_kernel_addr (const struct btrace_target_info *tinfo,
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)
122 /* A bit mask for the most significant bit in an address. */
123 mask = (uint64_t) 1 << (tinfo->ptr_bits - 1);
125 /* Check whether the most significant bit in the address is set. */
126 return (addr & mask) != 0;
129 /* Check whether a perf event record should be skipped. */
132 perf_event_skip_record (const struct btrace_target_info *tinfo,
133 const struct perf_event_bts *bts)
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);
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. */
145 perf_event_sample_ok (const struct perf_event_sample *sample)
147 if (sample->header.type != PERF_RECORD_SAMPLE)
150 if (sample->header.size != sizeof (*sample))
156 /* Branch trace is collected in a circular buffer [begin; end) as pairs of from
157 and to addresses (plus a header).
159 Start points into that buffer at the next sample position.
160 We read the collected samples backwards from start.
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.
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. */
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)
173 VEC (btrace_block_s) *btrace = NULL;
174 struct perf_event_sample sample;
176 struct btrace_block block = { 0, 0 };
177 struct regcache *regcache;
179 gdb_assert (begin <= start);
180 gdb_assert (start <= end);
182 /* The first block ends at the current pc. */
183 regcache = get_thread_regcache_for_ptid (tinfo->ptid);
184 block.end = regcache_read_pc (regcache);
186 /* The buffer may contain a partial record as its last entry (i.e. when the
187 buffer size is not a multiple of the sample size). */
188 read = sizeof (sample) - 1;
190 for (; read < size; read += sizeof (sample))
192 const struct perf_event_sample *psample;
194 /* Find the next perf_event sample in a backwards traversal. */
195 start -= sizeof (sample);
197 /* If we're still inside the buffer, we're done. */
199 psample = (const struct perf_event_sample *) start;
204 /* We're to the left of the ring buffer, we will wrap around and
205 reappear at the very right of the ring buffer. */
207 missing = (begin - start);
208 start = (end - missing);
210 /* If the entire sample is missing, we're done. */
211 if (missing == sizeof (sample))
212 psample = (const struct perf_event_sample *) start;
217 /* The sample wrapped around. The lower part is at the end and
218 the upper part is at the beginning of the buffer. */
219 stack = (uint8_t *) &sample;
221 /* Copy the two parts so we have a contiguous sample. */
222 memcpy (stack, start, missing);
223 memcpy (stack + missing, begin, sizeof (sample) - missing);
229 if (!perf_event_sample_ok (psample))
231 warning (_("Branch trace may be incomplete."));
235 if (perf_event_skip_record (tinfo, &psample->bts))
238 /* We found a valid sample, so we can complete the current block. */
239 block.begin = psample->bts.to;
241 VEC_safe_push (btrace_block_s, btrace, &block);
243 /* Start the next block. */
244 block.end = psample->bts.from;
247 /* Push the last block (i.e. the first one of inferior execution), as well.
248 We don't know where it ends, but we know where it starts. If we're
249 reading delta trace, we can fill in the start address later on.
250 Otherwise we will prune it. */
252 VEC_safe_push (btrace_block_s, btrace, &block);
257 /* Check whether the kernel supports branch tracing. */
260 kernel_supports_btrace (void)
262 struct perf_event_attr attr;
271 warning (_("test branch tracing: cannot fork: %s."), strerror (errno));
275 status = ptrace (PTRACE_TRACEME, 0, NULL, NULL);
278 warning (_("test branch tracing: cannot PTRACE_TRACEME: %s."),
283 status = raise (SIGTRAP);
286 warning (_("test branch tracing: cannot raise SIGTRAP: %s."),
294 pid = waitpid (child, &status, 0);
297 warning (_("test branch tracing: bad pid %ld, error: %s."),
298 (long) pid, strerror (errno));
302 if (!WIFSTOPPED (status))
304 warning (_("test branch tracing: expected stop. status: %d."),
309 memset (&attr, 0, sizeof (attr));
311 attr.type = PERF_TYPE_HARDWARE;
312 attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
313 attr.sample_period = 1;
314 attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_ADDR;
315 attr.exclude_kernel = 1;
317 attr.exclude_idle = 1;
319 file = syscall (SYS_perf_event_open, &attr, child, -1, -1, 0);
323 kill (child, SIGKILL);
324 ptrace (PTRACE_KILL, child, NULL, NULL);
326 pid = waitpid (child, &status, 0);
329 warning (_("test branch tracing: bad pid %ld, error: %s."),
330 (long) pid, strerror (errno));
331 if (!WIFSIGNALED (status))
332 warning (_("test branch tracing: expected killed. status: %d."),
340 /* Check whether an Intel cpu supports branch tracing. */
343 intel_supports_btrace (void)
345 unsigned int cpuid, model, family;
347 if (!x86_cpuid (1, &cpuid, NULL, NULL, NULL))
350 family = (cpuid >> 8) & 0xf;
351 model = (cpuid >> 4) & 0xf;
356 model += (cpuid >> 12) & 0xf0;
360 case 0x1a: /* Nehalem */
364 case 0x25: /* Westmere */
367 case 0x2a: /* Sandy Bridge */
369 case 0x3a: /* Ivy Bridge */
371 /* AAJ122: LBR, BTM, or BTS records may have incorrect branch
372 "from" information afer an EIST transition, T-states, C1E, or
373 Adaptive Thermal Throttling. */
381 /* Check whether the cpu supports branch tracing. */
384 cpu_supports_btrace (void)
386 unsigned int ebx, ecx, edx;
388 if (!x86_cpuid (0, NULL, &ebx, &ecx, &edx))
391 if (ebx == signature_INTEL_ebx && ecx == signature_INTEL_ecx
392 && edx == signature_INTEL_edx)
393 return intel_supports_btrace ();
395 /* Don't know about others. Let's assume they do. */
399 /* See linux-btrace.h. */
402 linux_supports_btrace (struct target_ops *ops)
408 if (!kernel_supports_btrace ())
410 else if (!cpu_supports_btrace ())
419 /* See linux-btrace.h. */
421 struct btrace_target_info *
422 linux_enable_btrace (ptid_t ptid)
424 struct btrace_target_info *tinfo;
427 tinfo = xzalloc (sizeof (*tinfo));
430 tinfo->attr.size = sizeof (tinfo->attr);
431 tinfo->attr.type = PERF_TYPE_HARDWARE;
432 tinfo->attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
433 tinfo->attr.sample_period = 1;
435 /* We sample from and to address. */
436 tinfo->attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_ADDR;
438 tinfo->attr.exclude_kernel = 1;
439 tinfo->attr.exclude_hv = 1;
440 tinfo->attr.exclude_idle = 1;
444 pid = ptid_get_lwp (ptid);
446 pid = ptid_get_pid (ptid);
449 tinfo->file = syscall (SYS_perf_event_open, &tinfo->attr, pid, -1, -1, 0);
453 /* We try to allocate as much buffer as we can get.
454 We could allow the user to specify the size of the buffer, but then
455 we'd leave this search for the maximum buffer size to him. */
456 for (pg = 4; pg >= 0; --pg)
458 /* The number of pages we request needs to be a power of two. */
459 tinfo->size = 1 << pg;
460 tinfo->buffer = mmap (NULL, perf_event_mmap_size (tinfo),
461 PROT_READ, MAP_SHARED, tinfo->file, 0);
462 if (tinfo->buffer == MAP_FAILED)
468 /* We were not able to allocate any buffer. */
476 /* See linux-btrace.h. */
479 linux_disable_btrace (struct btrace_target_info *tinfo)
484 errcode = munmap (tinfo->buffer, perf_event_mmap_size (tinfo));
486 return BTRACE_ERR_UNKNOWN;
491 return BTRACE_ERR_NONE;
494 /* Check whether the branch trace has changed. */
497 linux_btrace_has_changed (struct btrace_target_info *tinfo)
499 volatile struct perf_event_mmap_page *header = perf_event_header (tinfo);
501 return header->data_head != tinfo->data_head;
504 /* See linux-btrace.h. */
507 linux_read_btrace (VEC (btrace_block_s) **btrace,
508 struct btrace_target_info *tinfo,
509 enum btrace_read_type type)
511 volatile struct perf_event_mmap_page *header;
512 const uint8_t *begin, *end, *start;
513 unsigned long data_head, data_tail, retries = 5;
514 size_t buffer_size, size;
516 /* For delta reads, we return at least the partial last block containing
518 if (type == BTRACE_READ_NEW && !linux_btrace_has_changed (tinfo))
519 return BTRACE_ERR_NONE;
521 header = perf_event_header (tinfo);
522 buffer_size = perf_event_buffer_size (tinfo);
523 data_tail = tinfo->data_head;
525 /* We may need to retry reading the trace. See below. */
528 data_head = header->data_head;
530 /* Delete any leftover trace from the previous iteration. */
531 VEC_free (btrace_block_s, *btrace);
533 if (type == BTRACE_READ_DELTA)
535 /* Determine the number of bytes to read and check for buffer
538 /* Check for data head overflows. We might be able to recover from
539 those but they are very unlikely and it's not really worth the
541 if (data_head < data_tail)
542 return BTRACE_ERR_OVERFLOW;
544 /* If the buffer is smaller than the trace delta, we overflowed. */
545 size = data_head - data_tail;
546 if (buffer_size < size)
547 return BTRACE_ERR_OVERFLOW;
551 /* Read the entire buffer. */
554 /* Adjust the size if the buffer has not overflowed, yet. */
555 if (data_head < size)
559 /* Data_head keeps growing; the buffer itself is circular. */
560 begin = perf_event_buffer_begin (tinfo);
561 start = begin + data_head % buffer_size;
563 if (data_head <= buffer_size)
566 end = perf_event_buffer_end (tinfo);
568 *btrace = perf_event_read_bts (tinfo, begin, end, start, size);
570 /* The stopping thread notifies its ptracer before it is scheduled out.
571 On multi-core systems, the debugger might therefore run while the
572 kernel might be writing the last branch trace records.
574 Let's check whether the data head moved while we read the trace. */
575 if (data_head == header->data_head)
579 tinfo->data_head = data_head;
581 /* Prune the incomplete last block (i.e. the first one of inferior execution)
582 if we're not doing a delta read. There is no way of filling in its zeroed
584 if (!VEC_empty (btrace_block_s, *btrace) && type != BTRACE_READ_DELTA)
585 VEC_pop (btrace_block_s, *btrace);
587 return BTRACE_ERR_NONE;
590 #else /* !HAVE_LINUX_PERF_EVENT_H */
592 /* See linux-btrace.h. */
595 linux_supports_btrace (struct target_ops *ops)
600 /* See linux-btrace.h. */
602 struct btrace_target_info *
603 linux_enable_btrace (ptid_t ptid)
608 /* See linux-btrace.h. */
611 linux_disable_btrace (struct btrace_target_info *tinfo)
613 return BTRACE_ERR_NOT_SUPPORTED;
616 /* See linux-btrace.h. */
619 linux_read_btrace (VEC (btrace_block_s) **btrace,
620 struct btrace_target_info *tinfo,
621 enum btrace_read_type type)
623 return BTRACE_ERR_NOT_SUPPORTED;
626 #endif /* !HAVE_LINUX_PERF_EVENT_H */