sched: make early bootup sched_clock() use safer

[wrt350n-kernel.git] / arch / x86 / kernel / ds.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;
        }
}