linux/arch/x86/kernel/ds.c
Markus Metzger e6ae5d9540 x86, ptrace: support 32bit-cross-64bit BTS recording
Support BTS recording of 32bit and 64bit tasks from 32bit or 64bit tasks.

Signed-off-by: Markus Metzger <markus.t.metzger@intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-01-30 13:32:03 +01:00

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 = 0;
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;
}
}