1 /* Linux-dependent part of branch trace support for GDB, and GDBserver.
3 Copyright (C) 2013-2015 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/>. */
22 #include "common-defs.h"
23 #include "linux-btrace.h"
24 #include "common-regcache.h"
26 #include "x86-cpuid.h"
28 #ifdef HAVE_SYS_SYSCALL_H
29 #include <sys/syscall.h>
32 #if HAVE_LINUX_PERF_EVENT_H && defined(SYS_perf_event_open)
38 #include <sys/ptrace.h>
39 #include <sys/types.h>
42 /* A branch trace record in perf_event. */
45 /* The linear address of the branch source. */
48 /* The linear address of the branch destination. */
52 /* A perf_event branch trace sample. */
53 struct perf_event_sample
55 /* The perf_event sample header. */
56 struct perf_event_header header
;
58 /* The perf_event branch tracing payload. */
59 struct perf_event_bts bts
;
62 /* Get the perf_event header. */
64 static inline volatile struct perf_event_mmap_page
*
65 perf_event_header (struct btrace_target_info
* tinfo
)
70 /* Get the size of the perf_event mmap buffer. */
73 perf_event_mmap_size (const struct btrace_target_info
*tinfo
)
75 /* The branch trace buffer is preceded by a configuration page. */
76 return (tinfo
->size
+ 1) * PAGE_SIZE
;
79 /* Get the size of the perf_event buffer. */
82 perf_event_buffer_size (struct btrace_target_info
* tinfo
)
84 return tinfo
->size
* PAGE_SIZE
;
87 /* Get the start address of the perf_event buffer. */
89 static inline const uint8_t *
90 perf_event_buffer_begin (struct btrace_target_info
* tinfo
)
92 return ((const uint8_t *) tinfo
->buffer
) + PAGE_SIZE
;
95 /* Get the end address of the perf_event buffer. */
97 static inline const uint8_t *
98 perf_event_buffer_end (struct btrace_target_info
* tinfo
)
100 return perf_event_buffer_begin (tinfo
) + perf_event_buffer_size (tinfo
);
103 /* Check whether an address is in the kernel. */
106 perf_event_is_kernel_addr (const struct btrace_target_info
*tinfo
,
111 /* If we don't know the size of a pointer, we can't check. Let's assume it's
112 not a kernel address in this case. */
113 if (tinfo
->ptr_bits
== 0)
116 /* A bit mask for the most significant bit in an address. */
117 mask
= (uint64_t) 1 << (tinfo
->ptr_bits
- 1);
119 /* Check whether the most significant bit in the address is set. */
120 return (addr
& mask
) != 0;
123 /* Check whether a perf event record should be skipped. */
126 perf_event_skip_record (const struct btrace_target_info
*tinfo
,
127 const struct perf_event_bts
*bts
)
129 /* The hardware may report branches from kernel into user space. Branches
130 from user into kernel space will be suppressed. We filter the former to
131 provide a consistent branch trace excluding kernel. */
132 return perf_event_is_kernel_addr (tinfo
, bts
->from
);
135 /* Perform a few consistency checks on a perf event sample record. This is
136 meant to catch cases when we get out of sync with the perf event stream. */
139 perf_event_sample_ok (const struct perf_event_sample
*sample
)
141 if (sample
->header
.type
!= PERF_RECORD_SAMPLE
)
144 if (sample
->header
.size
!= sizeof (*sample
))
150 /* Branch trace is collected in a circular buffer [begin; end) as pairs of from
151 and to addresses (plus a header).
153 Start points into that buffer at the next sample position.
154 We read the collected samples backwards from start.
156 While reading the samples, we convert the information into a list of blocks.
157 For two adjacent samples s1 and s2, we form a block b such that b.begin =
158 s1.to and b.end = s2.from.
160 In case the buffer overflows during sampling, one sample may have its lower
161 part at the end and its upper part at the beginning of the buffer. */
163 static VEC (btrace_block_s
) *
164 perf_event_read_bts (struct btrace_target_info
* tinfo
, const uint8_t *begin
,
165 const uint8_t *end
, const uint8_t *start
, size_t size
)
167 VEC (btrace_block_s
) *btrace
= NULL
;
168 struct perf_event_sample sample
;
170 struct btrace_block block
= { 0, 0 };
171 struct regcache
*regcache
;
173 gdb_assert (begin
<= start
);
174 gdb_assert (start
<= end
);
176 /* The first block ends at the current pc. */
177 regcache
= get_thread_regcache_for_ptid (tinfo
->ptid
);
178 block
.end
= regcache_read_pc (regcache
);
180 /* The buffer may contain a partial record as its last entry (i.e. when the
181 buffer size is not a multiple of the sample size). */
182 read
= sizeof (sample
) - 1;
184 for (; read
< size
; read
+= sizeof (sample
))
186 const struct perf_event_sample
*psample
;
188 /* Find the next perf_event sample in a backwards traversal. */
189 start
-= sizeof (sample
);
191 /* If we're still inside the buffer, we're done. */
193 psample
= (const struct perf_event_sample
*) start
;
198 /* We're to the left of the ring buffer, we will wrap around and
199 reappear at the very right of the ring buffer. */
201 missing
= (begin
- start
);
202 start
= (end
- missing
);
204 /* If the entire sample is missing, we're done. */
205 if (missing
== sizeof (sample
))
206 psample
= (const struct perf_event_sample
*) start
;
211 /* The sample wrapped around. The lower part is at the end and
212 the upper part is at the beginning of the buffer. */
213 stack
= (uint8_t *) &sample
;
215 /* Copy the two parts so we have a contiguous sample. */
216 memcpy (stack
, start
, missing
);
217 memcpy (stack
+ missing
, begin
, sizeof (sample
) - missing
);
223 if (!perf_event_sample_ok (psample
))
225 warning (_("Branch trace may be incomplete."));
229 if (perf_event_skip_record (tinfo
, &psample
->bts
))
232 /* We found a valid sample, so we can complete the current block. */
233 block
.begin
= psample
->bts
.to
;
235 VEC_safe_push (btrace_block_s
, btrace
, &block
);
237 /* Start the next block. */
238 block
.end
= psample
->bts
.from
;
241 /* Push the last block (i.e. the first one of inferior execution), as well.
242 We don't know where it ends, but we know where it starts. If we're
243 reading delta trace, we can fill in the start address later on.
244 Otherwise we will prune it. */
246 VEC_safe_push (btrace_block_s
, btrace
, &block
);
251 /* Check whether the kernel supports branch tracing. */
254 kernel_supports_btrace (void)
256 struct perf_event_attr attr
;
265 warning (_("test branch tracing: cannot fork: %s."), strerror (errno
));
269 status
= ptrace (PTRACE_TRACEME
, 0, NULL
, NULL
);
272 warning (_("test branch tracing: cannot PTRACE_TRACEME: %s."),
277 status
= raise (SIGTRAP
);
280 warning (_("test branch tracing: cannot raise SIGTRAP: %s."),
288 pid
= waitpid (child
, &status
, 0);
291 warning (_("test branch tracing: bad pid %ld, error: %s."),
292 (long) pid
, strerror (errno
));
296 if (!WIFSTOPPED (status
))
298 warning (_("test branch tracing: expected stop. status: %d."),
303 memset (&attr
, 0, sizeof (attr
));
305 attr
.type
= PERF_TYPE_HARDWARE
;
306 attr
.config
= PERF_COUNT_HW_BRANCH_INSTRUCTIONS
;
307 attr
.sample_period
= 1;
308 attr
.sample_type
= PERF_SAMPLE_IP
| PERF_SAMPLE_ADDR
;
309 attr
.exclude_kernel
= 1;
311 attr
.exclude_idle
= 1;
313 file
= syscall (SYS_perf_event_open
, &attr
, child
, -1, -1, 0);
317 kill (child
, SIGKILL
);
318 ptrace (PTRACE_KILL
, child
, NULL
, NULL
);
320 pid
= waitpid (child
, &status
, 0);
323 warning (_("test branch tracing: bad pid %ld, error: %s."),
324 (long) pid
, strerror (errno
));
325 if (!WIFSIGNALED (status
))
326 warning (_("test branch tracing: expected killed. status: %d."),
334 /* Check whether an Intel cpu supports branch tracing. */
337 intel_supports_btrace (void)
339 unsigned int cpuid
, model
, family
;
341 if (!x86_cpuid (1, &cpuid
, NULL
, NULL
, NULL
))
344 family
= (cpuid
>> 8) & 0xf;
345 model
= (cpuid
>> 4) & 0xf;
350 model
+= (cpuid
>> 12) & 0xf0;
354 case 0x1a: /* Nehalem */
358 case 0x25: /* Westmere */
361 case 0x2a: /* Sandy Bridge */
363 case 0x3a: /* Ivy Bridge */
365 /* AAJ122: LBR, BTM, or BTS records may have incorrect branch
366 "from" information afer an EIST transition, T-states, C1E, or
367 Adaptive Thermal Throttling. */
375 /* Check whether the cpu supports branch tracing. */
378 cpu_supports_btrace (void)
380 unsigned int ebx
, ecx
, edx
;
382 if (!x86_cpuid (0, NULL
, &ebx
, &ecx
, &edx
))
385 if (ebx
== signature_INTEL_ebx
&& ecx
== signature_INTEL_ecx
386 && edx
== signature_INTEL_edx
)
387 return intel_supports_btrace ();
389 /* Don't know about others. Let's assume they do. */
393 /* See linux-btrace.h. */
396 linux_supports_btrace (struct target_ops
*ops
)
402 if (!kernel_supports_btrace ())
404 else if (!cpu_supports_btrace ())
413 /* See linux-btrace.h. */
415 struct btrace_target_info
*
416 linux_enable_btrace (ptid_t ptid
)
418 struct btrace_target_info
*tinfo
;
421 tinfo
= xzalloc (sizeof (*tinfo
));
424 tinfo
->attr
.size
= sizeof (tinfo
->attr
);
425 tinfo
->attr
.type
= PERF_TYPE_HARDWARE
;
426 tinfo
->attr
.config
= PERF_COUNT_HW_BRANCH_INSTRUCTIONS
;
427 tinfo
->attr
.sample_period
= 1;
429 /* We sample from and to address. */
430 tinfo
->attr
.sample_type
= PERF_SAMPLE_IP
| PERF_SAMPLE_ADDR
;
432 tinfo
->attr
.exclude_kernel
= 1;
433 tinfo
->attr
.exclude_hv
= 1;
434 tinfo
->attr
.exclude_idle
= 1;
438 pid
= ptid_get_lwp (ptid
);
440 pid
= ptid_get_pid (ptid
);
443 tinfo
->file
= syscall (SYS_perf_event_open
, &tinfo
->attr
, pid
, -1, -1, 0);
447 /* We try to allocate as much buffer as we can get.
448 We could allow the user to specify the size of the buffer, but then
449 we'd leave this search for the maximum buffer size to him. */
450 for (pg
= 4; pg
>= 0; --pg
)
452 /* The number of pages we request needs to be a power of two. */
453 tinfo
->size
= 1 << pg
;
454 tinfo
->buffer
= mmap (NULL
, perf_event_mmap_size (tinfo
),
455 PROT_READ
, MAP_SHARED
, tinfo
->file
, 0);
456 if (tinfo
->buffer
== MAP_FAILED
)
462 /* We were not able to allocate any buffer. */
470 /* See linux-btrace.h. */
473 linux_disable_btrace (struct btrace_target_info
*tinfo
)
478 errcode
= munmap (tinfo
->buffer
, perf_event_mmap_size (tinfo
));
480 return BTRACE_ERR_UNKNOWN
;
485 return BTRACE_ERR_NONE
;
488 /* Check whether the branch trace has changed. */
491 linux_btrace_has_changed (struct btrace_target_info
*tinfo
)
493 volatile struct perf_event_mmap_page
*header
= perf_event_header (tinfo
);
495 return header
->data_head
!= tinfo
->data_head
;
498 /* See linux-btrace.h. */
501 linux_read_btrace (VEC (btrace_block_s
) **btrace
,
502 struct btrace_target_info
*tinfo
,
503 enum btrace_read_type type
)
505 volatile struct perf_event_mmap_page
*header
;
506 const uint8_t *begin
, *end
, *start
;
507 unsigned long data_head
, data_tail
, retries
= 5;
508 size_t buffer_size
, size
;
510 /* For delta reads, we return at least the partial last block containing
512 if (type
== BTRACE_READ_NEW
&& !linux_btrace_has_changed (tinfo
))
513 return BTRACE_ERR_NONE
;
515 header
= perf_event_header (tinfo
);
516 buffer_size
= perf_event_buffer_size (tinfo
);
517 data_tail
= tinfo
->data_head
;
519 /* We may need to retry reading the trace. See below. */
522 data_head
= header
->data_head
;
524 /* Delete any leftover trace from the previous iteration. */
525 VEC_free (btrace_block_s
, *btrace
);
527 if (type
== BTRACE_READ_DELTA
)
529 /* Determine the number of bytes to read and check for buffer
532 /* Check for data head overflows. We might be able to recover from
533 those but they are very unlikely and it's not really worth the
535 if (data_head
< data_tail
)
536 return BTRACE_ERR_OVERFLOW
;
538 /* If the buffer is smaller than the trace delta, we overflowed. */
539 size
= data_head
- data_tail
;
540 if (buffer_size
< size
)
541 return BTRACE_ERR_OVERFLOW
;
545 /* Read the entire buffer. */
548 /* Adjust the size if the buffer has not overflowed, yet. */
549 if (data_head
< size
)
553 /* Data_head keeps growing; the buffer itself is circular. */
554 begin
= perf_event_buffer_begin (tinfo
);
555 start
= begin
+ data_head
% buffer_size
;
557 if (data_head
<= buffer_size
)
560 end
= perf_event_buffer_end (tinfo
);
562 *btrace
= perf_event_read_bts (tinfo
, begin
, end
, start
, size
);
564 /* The stopping thread notifies its ptracer before it is scheduled out.
565 On multi-core systems, the debugger might therefore run while the
566 kernel might be writing the last branch trace records.
568 Let's check whether the data head moved while we read the trace. */
569 if (data_head
== header
->data_head
)
573 tinfo
->data_head
= data_head
;
575 /* Prune the incomplete last block (i.e. the first one of inferior execution)
576 if we're not doing a delta read. There is no way of filling in its zeroed
578 if (!VEC_empty (btrace_block_s
, *btrace
) && type
!= BTRACE_READ_DELTA
)
579 VEC_pop (btrace_block_s
, *btrace
);
581 return BTRACE_ERR_NONE
;
584 #else /* !HAVE_LINUX_PERF_EVENT_H */
586 /* See linux-btrace.h. */
589 linux_supports_btrace (struct target_ops
*ops
)
594 /* See linux-btrace.h. */
596 struct btrace_target_info
*
597 linux_enable_btrace (ptid_t ptid
)
602 /* See linux-btrace.h. */
605 linux_disable_btrace (struct btrace_target_info
*tinfo
)
607 return BTRACE_ERR_NOT_SUPPORTED
;
610 /* See linux-btrace.h. */
613 linux_read_btrace (VEC (btrace_block_s
) **btrace
,
614 struct btrace_target_info
*tinfo
,
615 enum btrace_read_type type
)
617 return BTRACE_ERR_NOT_SUPPORTED
;
620 #endif /* !HAVE_LINUX_PERF_EVENT_H */