465 lines
11 KiB
C
465 lines
11 KiB
C
/*
|
|
* Debug Store support
|
|
*
|
|
* This provides a low-level interface to the hardware's Debug Store
|
|
* feature that is used for last branch recording (LBR) and
|
|
* precise-event based sampling (PEBS).
|
|
*
|
|
* Different architectures use a different DS layout/pointer size.
|
|
* The below functions therefore work on a void*.
|
|
*
|
|
*
|
|
* Since there is no user for PEBS, yet, only LBR (or branch
|
|
* trace store, BTS) is supported.
|
|
*
|
|
*
|
|
* Copyright (C) 2007 Intel Corporation.
|
|
* Markus Metzger <markus.t.metzger@intel.com>, Dec 2007
|
|
*/
|
|
|
|
#include <asm/ds.h>
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/string.h>
|
|
#include <linux/slab.h>
|
|
|
|
|
|
/*
|
|
* Debug Store (DS) save area configuration (see Intel64 and IA32
|
|
* Architectures Software Developer's Manual, section 18.5)
|
|
*
|
|
* The DS configuration consists of the following fields; different
|
|
* architetures vary in the size of those fields.
|
|
* - double-word aligned base linear address of the BTS buffer
|
|
* - write pointer into the BTS buffer
|
|
* - end linear address of the BTS buffer (one byte beyond the end of
|
|
* the buffer)
|
|
* - interrupt pointer into BTS buffer
|
|
* (interrupt occurs when write pointer passes interrupt pointer)
|
|
* - double-word aligned base linear address of the PEBS buffer
|
|
* - write pointer into the PEBS buffer
|
|
* - end linear address of the PEBS buffer (one byte beyond the end of
|
|
* the buffer)
|
|
* - interrupt pointer into PEBS buffer
|
|
* (interrupt occurs when write pointer passes interrupt pointer)
|
|
* - value to which counter is reset following counter overflow
|
|
*
|
|
* On later architectures, the last branch recording hardware uses
|
|
* 64bit pointers even in 32bit mode.
|
|
*
|
|
*
|
|
* Branch Trace Store (BTS) records store information about control
|
|
* flow changes. They at least provide the following information:
|
|
* - source linear address
|
|
* - destination linear address
|
|
*
|
|
* Netburst supported a predicated bit that had been dropped in later
|
|
* architectures. We do not suppor it.
|
|
*
|
|
*
|
|
* In order to abstract from the actual DS and BTS layout, we describe
|
|
* the access to the relevant fields.
|
|
* Thanks to Andi Kleen for proposing this design.
|
|
*
|
|
* The implementation, however, is not as general as it might seem. In
|
|
* order to stay somewhat simple and efficient, we assume an
|
|
* underlying unsigned type (mostly a pointer type) and we expect the
|
|
* field to be at least as big as that type.
|
|
*/
|
|
|
|
/*
|
|
* A special from_ip address to indicate that the BTS record is an
|
|
* info record that needs to be interpreted or skipped.
|
|
*/
|
|
#define BTS_ESCAPE_ADDRESS (-1)
|
|
|
|
/*
|
|
* A field access descriptor
|
|
*/
|
|
struct access_desc {
|
|
unsigned char offset;
|
|
unsigned char size;
|
|
};
|
|
|
|
/*
|
|
* The configuration for a particular DS/BTS hardware implementation.
|
|
*/
|
|
struct ds_configuration {
|
|
/* the DS configuration */
|
|
unsigned char sizeof_ds;
|
|
struct access_desc bts_buffer_base;
|
|
struct access_desc bts_index;
|
|
struct access_desc bts_absolute_maximum;
|
|
struct access_desc bts_interrupt_threshold;
|
|
/* the BTS configuration */
|
|
unsigned char sizeof_bts;
|
|
struct access_desc from_ip;
|
|
struct access_desc to_ip;
|
|
/* BTS variants used to store additional information like
|
|
timestamps */
|
|
struct access_desc info_type;
|
|
struct access_desc info_data;
|
|
unsigned long debugctl_mask;
|
|
};
|
|
|
|
/*
|
|
* The global configuration used by the below accessor functions
|
|
*/
|
|
static struct ds_configuration ds_cfg;
|
|
|
|
/*
|
|
* Accessor functions for some DS and BTS fields using the above
|
|
* global ptrace_bts_cfg.
|
|
*/
|
|
static inline unsigned long get_bts_buffer_base(char *base)
|
|
{
|
|
return *(unsigned long *)(base + ds_cfg.bts_buffer_base.offset);
|
|
}
|
|
static inline void set_bts_buffer_base(char *base, unsigned long value)
|
|
{
|
|
(*(unsigned long *)(base + ds_cfg.bts_buffer_base.offset)) = value;
|
|
}
|
|
static inline unsigned long get_bts_index(char *base)
|
|
{
|
|
return *(unsigned long *)(base + ds_cfg.bts_index.offset);
|
|
}
|
|
static inline void set_bts_index(char *base, unsigned long value)
|
|
{
|
|
(*(unsigned long *)(base + ds_cfg.bts_index.offset)) = value;
|
|
}
|
|
static inline unsigned long get_bts_absolute_maximum(char *base)
|
|
{
|
|
return *(unsigned long *)(base + ds_cfg.bts_absolute_maximum.offset);
|
|
}
|
|
static inline void set_bts_absolute_maximum(char *base, unsigned long value)
|
|
{
|
|
(*(unsigned long *)(base + ds_cfg.bts_absolute_maximum.offset)) = value;
|
|
}
|
|
static inline unsigned long get_bts_interrupt_threshold(char *base)
|
|
{
|
|
return *(unsigned long *)(base + ds_cfg.bts_interrupt_threshold.offset);
|
|
}
|
|
static inline void set_bts_interrupt_threshold(char *base, unsigned long value)
|
|
{
|
|
(*(unsigned long *)(base + ds_cfg.bts_interrupt_threshold.offset)) = value;
|
|
}
|
|
static inline unsigned long get_from_ip(char *base)
|
|
{
|
|
return *(unsigned long *)(base + ds_cfg.from_ip.offset);
|
|
}
|
|
static inline void set_from_ip(char *base, unsigned long value)
|
|
{
|
|
(*(unsigned long *)(base + ds_cfg.from_ip.offset)) = value;
|
|
}
|
|
static inline unsigned long get_to_ip(char *base)
|
|
{
|
|
return *(unsigned long *)(base + ds_cfg.to_ip.offset);
|
|
}
|
|
static inline void set_to_ip(char *base, unsigned long value)
|
|
{
|
|
(*(unsigned long *)(base + ds_cfg.to_ip.offset)) = value;
|
|
}
|
|
static inline unsigned char get_info_type(char *base)
|
|
{
|
|
return *(unsigned char *)(base + ds_cfg.info_type.offset);
|
|
}
|
|
static inline void set_info_type(char *base, unsigned char value)
|
|
{
|
|
(*(unsigned char *)(base + ds_cfg.info_type.offset)) = value;
|
|
}
|
|
static inline unsigned long get_info_data(char *base)
|
|
{
|
|
return *(unsigned long *)(base + ds_cfg.info_data.offset);
|
|
}
|
|
static inline void set_info_data(char *base, unsigned long value)
|
|
{
|
|
(*(unsigned long *)(base + ds_cfg.info_data.offset)) = value;
|
|
}
|
|
|
|
|
|
int ds_allocate(void **dsp, size_t bts_size_in_bytes)
|
|
{
|
|
size_t bts_size_in_records;
|
|
unsigned long bts;
|
|
void *ds;
|
|
|
|
if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (bts_size_in_bytes < 0)
|
|
return -EINVAL;
|
|
|
|
bts_size_in_records =
|
|
bts_size_in_bytes / ds_cfg.sizeof_bts;
|
|
bts_size_in_bytes =
|
|
bts_size_in_records * ds_cfg.sizeof_bts;
|
|
|
|
if (bts_size_in_bytes <= 0)
|
|
return -EINVAL;
|
|
|
|
bts = (unsigned long)kzalloc(bts_size_in_bytes, GFP_KERNEL);
|
|
|
|
if (!bts)
|
|
return -ENOMEM;
|
|
|
|
ds = kzalloc(ds_cfg.sizeof_ds, GFP_KERNEL);
|
|
|
|
if (!ds) {
|
|
kfree((void *)bts);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
set_bts_buffer_base(ds, bts);
|
|
set_bts_index(ds, bts);
|
|
set_bts_absolute_maximum(ds, bts + bts_size_in_bytes);
|
|
set_bts_interrupt_threshold(ds, bts + bts_size_in_bytes + 1);
|
|
|
|
*dsp = ds;
|
|
return 0;
|
|
}
|
|
|
|
int ds_free(void **dsp)
|
|
{
|
|
if (*dsp) {
|
|
kfree((void *)get_bts_buffer_base(*dsp));
|
|
kfree(*dsp);
|
|
*dsp = NULL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ds_get_bts_size(void *ds)
|
|
{
|
|
int size_in_bytes;
|
|
|
|
if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (!ds)
|
|
return 0;
|
|
|
|
size_in_bytes =
|
|
get_bts_absolute_maximum(ds) -
|
|
get_bts_buffer_base(ds);
|
|
return size_in_bytes;
|
|
}
|
|
|
|
int ds_get_bts_end(void *ds)
|
|
{
|
|
int size_in_bytes = ds_get_bts_size(ds);
|
|
|
|
if (size_in_bytes <= 0)
|
|
return size_in_bytes;
|
|
|
|
return size_in_bytes / ds_cfg.sizeof_bts;
|
|
}
|
|
|
|
int ds_get_bts_index(void *ds)
|
|
{
|
|
int index_offset_in_bytes;
|
|
|
|
if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
|
|
return -EOPNOTSUPP;
|
|
|
|
index_offset_in_bytes =
|
|
get_bts_index(ds) -
|
|
get_bts_buffer_base(ds);
|
|
|
|
return index_offset_in_bytes / ds_cfg.sizeof_bts;
|
|
}
|
|
|
|
int ds_set_overflow(void *ds, int method)
|
|
{
|
|
switch (method) {
|
|
case DS_O_SIGNAL:
|
|
return -EOPNOTSUPP;
|
|
case DS_O_WRAP:
|
|
return 0;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
int ds_get_overflow(void *ds)
|
|
{
|
|
return DS_O_WRAP;
|
|
}
|
|
|
|
int ds_clear(void *ds)
|
|
{
|
|
int bts_size = ds_get_bts_size(ds);
|
|
unsigned long bts_base;
|
|
|
|
if (bts_size <= 0)
|
|
return bts_size;
|
|
|
|
bts_base = get_bts_buffer_base(ds);
|
|
memset((void *)bts_base, 0, bts_size);
|
|
|
|
set_bts_index(ds, bts_base);
|
|
return 0;
|
|
}
|
|
|
|
int ds_read_bts(void *ds, int index, struct bts_struct *out)
|
|
{
|
|
void *bts;
|
|
|
|
if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (index < 0)
|
|
return -EINVAL;
|
|
|
|
if (index >= ds_get_bts_size(ds))
|
|
return -EINVAL;
|
|
|
|
bts = (void *)(get_bts_buffer_base(ds) + (index * ds_cfg.sizeof_bts));
|
|
|
|
memset(out, 0, sizeof(*out));
|
|
if (get_from_ip(bts) == BTS_ESCAPE_ADDRESS) {
|
|
out->qualifier = get_info_type(bts);
|
|
out->variant.jiffies = get_info_data(bts);
|
|
} else {
|
|
out->qualifier = BTS_BRANCH;
|
|
out->variant.lbr.from_ip = get_from_ip(bts);
|
|
out->variant.lbr.to_ip = get_to_ip(bts);
|
|
}
|
|
|
|
return sizeof(*out);;
|
|
}
|
|
|
|
int ds_write_bts(void *ds, const struct bts_struct *in)
|
|
{
|
|
unsigned long bts;
|
|
|
|
if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (ds_get_bts_size(ds) <= 0)
|
|
return -ENXIO;
|
|
|
|
bts = get_bts_index(ds);
|
|
|
|
memset((void *)bts, 0, ds_cfg.sizeof_bts);
|
|
switch (in->qualifier) {
|
|
case BTS_INVALID:
|
|
break;
|
|
|
|
case BTS_BRANCH:
|
|
set_from_ip((void *)bts, in->variant.lbr.from_ip);
|
|
set_to_ip((void *)bts, in->variant.lbr.to_ip);
|
|
break;
|
|
|
|
case BTS_TASK_ARRIVES:
|
|
case BTS_TASK_DEPARTS:
|
|
set_from_ip((void *)bts, BTS_ESCAPE_ADDRESS);
|
|
set_info_type((void *)bts, in->qualifier);
|
|
set_info_data((void *)bts, in->variant.jiffies);
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
bts = bts + ds_cfg.sizeof_bts;
|
|
if (bts >= get_bts_absolute_maximum(ds))
|
|
bts = get_bts_buffer_base(ds);
|
|
set_bts_index(ds, bts);
|
|
|
|
return ds_cfg.sizeof_bts;
|
|
}
|
|
|
|
unsigned long ds_debugctl_mask(void)
|
|
{
|
|
return ds_cfg.debugctl_mask;
|
|
}
|
|
|
|
#ifdef __i386__
|
|
static const struct ds_configuration ds_cfg_netburst = {
|
|
.sizeof_ds = 9 * 4,
|
|
.bts_buffer_base = { 0, 4 },
|
|
.bts_index = { 4, 4 },
|
|
.bts_absolute_maximum = { 8, 4 },
|
|
.bts_interrupt_threshold = { 12, 4 },
|
|
.sizeof_bts = 3 * 4,
|
|
.from_ip = { 0, 4 },
|
|
.to_ip = { 4, 4 },
|
|
.info_type = { 4, 1 },
|
|
.info_data = { 8, 4 },
|
|
.debugctl_mask = (1<<2)|(1<<3)
|
|
};
|
|
|
|
static const struct ds_configuration ds_cfg_pentium_m = {
|
|
.sizeof_ds = 9 * 4,
|
|
.bts_buffer_base = { 0, 4 },
|
|
.bts_index = { 4, 4 },
|
|
.bts_absolute_maximum = { 8, 4 },
|
|
.bts_interrupt_threshold = { 12, 4 },
|
|
.sizeof_bts = 3 * 4,
|
|
.from_ip = { 0, 4 },
|
|
.to_ip = { 4, 4 },
|
|
.info_type = { 4, 1 },
|
|
.info_data = { 8, 4 },
|
|
.debugctl_mask = (1<<6)|(1<<7)
|
|
};
|
|
#endif /* _i386_ */
|
|
|
|
static const struct ds_configuration ds_cfg_core2 = {
|
|
.sizeof_ds = 9 * 8,
|
|
.bts_buffer_base = { 0, 8 },
|
|
.bts_index = { 8, 8 },
|
|
.bts_absolute_maximum = { 16, 8 },
|
|
.bts_interrupt_threshold = { 24, 8 },
|
|
.sizeof_bts = 3 * 8,
|
|
.from_ip = { 0, 8 },
|
|
.to_ip = { 8, 8 },
|
|
.info_type = { 8, 1 },
|
|
.info_data = { 16, 8 },
|
|
.debugctl_mask = (1<<6)|(1<<7)|(1<<9)
|
|
};
|
|
|
|
static inline void
|
|
ds_configure(const struct ds_configuration *cfg)
|
|
{
|
|
ds_cfg = *cfg;
|
|
}
|
|
|
|
void __cpuinit ds_init_intel(struct cpuinfo_x86 *c)
|
|
{
|
|
switch (c->x86) {
|
|
case 0x6:
|
|
switch (c->x86_model) {
|
|
#ifdef __i386__
|
|
case 0xD:
|
|
case 0xE: /* Pentium M */
|
|
ds_configure(&ds_cfg_pentium_m);
|
|
break;
|
|
#endif /* _i386_ */
|
|
case 0xF: /* Core2 */
|
|
ds_configure(&ds_cfg_core2);
|
|
break;
|
|
default:
|
|
/* sorry, don't know about them */
|
|
break;
|
|
}
|
|
break;
|
|
case 0xF:
|
|
switch (c->x86_model) {
|
|
#ifdef __i386__
|
|
case 0x0:
|
|
case 0x1:
|
|
case 0x2: /* Netburst */
|
|
ds_configure(&ds_cfg_netburst);
|
|
break;
|
|
#endif /* _i386_ */
|
|
default:
|
|
/* sorry, don't know about them */
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
/* sorry, don't know about them */
|
|
break;
|
|
}
|
|
}
|