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"
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. */
184 regcache
= get_thread_regcache (find_thread_ptid (tinfo
->ptid
), 1);
186 regcache
= get_thread_regcache (tinfo
->ptid
);
188 block
.end
= regcache_read_pc (regcache
);
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;
194 for (; read
< size
; read
+= sizeof (sample
))
196 const struct perf_event_sample
*psample
;
198 /* Find the next perf_event sample in a backwards traversal. */
199 start
-= sizeof (sample
);
201 /* If we're still inside the buffer, we're done. */
203 psample
= (const struct perf_event_sample
*) start
;
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. */
211 missing
= (begin
- start
);
212 start
= (end
- missing
);
214 /* If the entire sample is missing, we're done. */
215 if (missing
== sizeof (sample
))
216 psample
= (const struct perf_event_sample
*) start
;
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
;
225 /* Copy the two parts so we have a contiguous sample. */
226 memcpy (stack
, start
, missing
);
227 memcpy (stack
+ missing
, begin
, sizeof (sample
) - missing
);
233 if (!perf_event_sample_ok (psample
))
235 warning (_("Branch trace may be incomplete."));
239 if (perf_event_skip_record (tinfo
, &psample
->bts
))
242 /* We found a valid sample, so we can complete the current block. */
243 block
.begin
= psample
->bts
.to
;
245 VEC_safe_push (btrace_block_s
, btrace
, &block
);
247 /* Start the next block. */
248 block
.end
= psample
->bts
.from
;
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. */
256 VEC_safe_push (btrace_block_s
, btrace
, &block
);
261 /* Check whether the kernel supports branch tracing. */
264 kernel_supports_btrace (void)
266 struct perf_event_attr attr
;
275 warning (_("test branch tracing: cannot fork: %s."), strerror (errno
));
279 status
= ptrace (PTRACE_TRACEME
, 0, NULL
, NULL
);
282 warning (_("test branch tracing: cannot PTRACE_TRACEME: %s."),
287 status
= raise (SIGTRAP
);
290 warning (_("test branch tracing: cannot raise SIGTRAP: %s."),
298 pid
= waitpid (child
, &status
, 0);
301 warning (_("test branch tracing: bad pid %ld, error: %s."),
302 (long) pid
, strerror (errno
));
306 if (!WIFSTOPPED (status
))
308 warning (_("test branch tracing: expected stop. status: %d."),
313 memset (&attr
, 0, sizeof (attr
));
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;
321 attr
.exclude_idle
= 1;
323 file
= syscall (SYS_perf_event_open
, &attr
, child
, -1, -1, 0);
327 kill (child
, SIGKILL
);
328 ptrace (PTRACE_KILL
, child
, NULL
, NULL
);
330 pid
= waitpid (child
, &status
, 0);
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."),
344 /* Check whether an Intel cpu supports branch tracing. */
347 intel_supports_btrace (void)
349 unsigned int cpuid
, model
, family
;
351 if (!x86_cpuid (1, &cpuid
, NULL
, NULL
, NULL
))
354 family
= (cpuid
>> 8) & 0xf;
355 model
= (cpuid
>> 4) & 0xf;
360 model
+= (cpuid
>> 12) & 0xf0;
364 case 0x1a: /* Nehalem */
368 case 0x25: /* Westmere */
371 case 0x2a: /* Sandy Bridge */
373 case 0x3a: /* Ivy Bridge */
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. */
385 /* Check whether the cpu supports branch tracing. */
388 cpu_supports_btrace (void)
390 unsigned int ebx
, ecx
, edx
;
392 if (!x86_cpuid (0, NULL
, &ebx
, &ecx
, &edx
))
395 if (ebx
== signature_INTEL_ebx
&& ecx
== signature_INTEL_ecx
396 && edx
== signature_INTEL_edx
)
397 return intel_supports_btrace ();
399 /* Don't know about others. Let's assume they do. */
403 /* See linux-btrace.h. */
406 linux_supports_btrace (struct target_ops
*ops
)
412 if (!kernel_supports_btrace ())
414 else if (!cpu_supports_btrace ())
423 /* See linux-btrace.h. */
425 struct btrace_target_info
*
426 linux_enable_btrace (ptid_t ptid
)
428 struct btrace_target_info
*tinfo
;
431 tinfo
= xzalloc (sizeof (*tinfo
));
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;
439 /* We sample from and to address. */
440 tinfo
->attr
.sample_type
= PERF_SAMPLE_IP
| PERF_SAMPLE_ADDR
;
442 tinfo
->attr
.exclude_kernel
= 1;
443 tinfo
->attr
.exclude_hv
= 1;
444 tinfo
->attr
.exclude_idle
= 1;
448 pid
= ptid_get_lwp (ptid
);
450 pid
= ptid_get_pid (ptid
);
453 tinfo
->file
= syscall (SYS_perf_event_open
, &tinfo
->attr
, pid
, -1, -1, 0);
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
)
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
)
472 /* We were not able to allocate any buffer. */
480 /* See linux-btrace.h. */
483 linux_disable_btrace (struct btrace_target_info
*tinfo
)
488 errcode
= munmap (tinfo
->buffer
, perf_event_mmap_size (tinfo
));
490 return BTRACE_ERR_UNKNOWN
;
495 return BTRACE_ERR_NONE
;
498 /* Check whether the branch trace has changed. */
501 linux_btrace_has_changed (struct btrace_target_info
*tinfo
)
503 volatile struct perf_event_mmap_page
*header
= perf_event_header (tinfo
);
505 return header
->data_head
!= tinfo
->data_head
;
508 /* See linux-btrace.h. */
511 linux_read_btrace (VEC (btrace_block_s
) **btrace
,
512 struct btrace_target_info
*tinfo
,
513 enum btrace_read_type type
)
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
;
520 /* For delta reads, we return at least the partial last block containing
522 if (type
== BTRACE_READ_NEW
&& !linux_btrace_has_changed (tinfo
))
523 return BTRACE_ERR_NONE
;
525 header
= perf_event_header (tinfo
);
526 buffer_size
= perf_event_buffer_size (tinfo
);
527 data_tail
= tinfo
->data_head
;
529 /* We may need to retry reading the trace. See below. */
532 data_head
= header
->data_head
;
534 /* Delete any leftover trace from the previous iteration. */
535 VEC_free (btrace_block_s
, *btrace
);
537 if (type
== BTRACE_READ_DELTA
)
539 /* Determine the number of bytes to read and check for buffer
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
545 if (data_head
< data_tail
)
546 return BTRACE_ERR_OVERFLOW
;
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
;
555 /* Read the entire buffer. */
558 /* Adjust the size if the buffer has not overflowed, yet. */
559 if (data_head
< size
)
563 /* Data_head keeps growing; the buffer itself is circular. */
564 begin
= perf_event_buffer_begin (tinfo
);
565 start
= begin
+ data_head
% buffer_size
;
567 if (data_head
<= buffer_size
)
570 end
= perf_event_buffer_end (tinfo
);
572 *btrace
= perf_event_read_bts (tinfo
, begin
, end
, start
, size
);
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.
578 Let's check whether the data head moved while we read the trace. */
579 if (data_head
== header
->data_head
)
583 tinfo
->data_head
= data_head
;
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
588 if (!VEC_empty (btrace_block_s
, *btrace
) && type
!= BTRACE_READ_DELTA
)
589 VEC_pop (btrace_block_s
, *btrace
);
591 return BTRACE_ERR_NONE
;
594 #else /* !HAVE_LINUX_PERF_EVENT_H */
596 /* See linux-btrace.h. */
599 linux_supports_btrace (struct target_ops
*ops
)
604 /* See linux-btrace.h. */
606 struct btrace_target_info
*
607 linux_enable_btrace (ptid_t ptid
)
612 /* See linux-btrace.h. */
615 linux_disable_btrace (struct btrace_target_info
*tinfo
)
617 return BTRACE_ERR_NOT_SUPPORTED
;
620 /* See linux-btrace.h. */
623 linux_read_btrace (VEC (btrace_block_s
) **btrace
,
624 struct btrace_target_info
*tinfo
,
625 enum btrace_read_type type
)
627 return BTRACE_ERR_NOT_SUPPORTED
;
630 #endif /* !HAVE_LINUX_PERF_EVENT_H */