| /* | |
| * Debug Store support | |
| * | |
| * This provides a low-level interface to the hardware's Debug Store | |
| * feature that is used for branch trace store (BTS) and | |
| * precise-event based sampling (PEBS). | |
| * | |
| * It manages: | |
| * - DS and BTS hardware configuration | |
| * - buffer overflow handling (to be done) | |
| * - buffer access | |
| * | |
| * It does not do: | |
| * - security checking (is the caller allowed to trace the task) | |
| * - buffer allocation (memory accounting) | |
| * | |
| * | |
| * Copyright (C) 2007-2009 Intel Corporation. | |
| * Markus Metzger <markus.t.metzger@intel.com>, 2007-2009 | |
| */ | |
| #include <linux/kernel.h> | |
| #include <linux/string.h> | |
| #include <linux/errno.h> | |
| #include <linux/sched.h> | |
| #include <linux/slab.h> | |
| #include <linux/mm.h> | |
| #include <linux/trace_clock.h> | |
| #include <asm/ds.h> | |
| #include "ds_selftest.h" | |
| /* | |
| * The configuration for a particular DS hardware implementation: | |
| */ | |
| struct ds_configuration { | |
| /* The name of the configuration: */ | |
| const char *name; | |
| /* The size of pointer-typed fields in DS, BTS, and PEBS: */ | |
| unsigned char sizeof_ptr_field; | |
| /* The size of a BTS/PEBS record in bytes: */ | |
| unsigned char sizeof_rec[2]; | |
| /* The number of pebs counter reset values in the DS structure. */ | |
| unsigned char nr_counter_reset; | |
| /* Control bit-masks indexed by enum ds_feature: */ | |
| unsigned long ctl[dsf_ctl_max]; | |
| }; | |
| static struct ds_configuration ds_cfg __read_mostly; | |
| /* Maximal size of a DS configuration: */ | |
| #define MAX_SIZEOF_DS 0x80 | |
| /* Maximal size of a BTS record: */ | |
| #define MAX_SIZEOF_BTS (3 * 8) | |
| /* BTS and PEBS buffer alignment: */ | |
| #define DS_ALIGNMENT (1 << 3) | |
| /* Number of buffer pointers in DS: */ | |
| #define NUM_DS_PTR_FIELDS 8 | |
| /* Size of a pebs reset value in DS: */ | |
| #define PEBS_RESET_FIELD_SIZE 8 | |
| /* Mask of control bits in the DS MSR register: */ | |
| #define BTS_CONTROL \ | |
| ( ds_cfg.ctl[dsf_bts] | \ | |
| ds_cfg.ctl[dsf_bts_kernel] | \ | |
| ds_cfg.ctl[dsf_bts_user] | \ | |
| ds_cfg.ctl[dsf_bts_overflow] ) | |
| /* | |
| * A BTS or PEBS tracer. | |
| * | |
| * This holds the configuration of the tracer and serves as a handle | |
| * to identify tracers. | |
| */ | |
| struct ds_tracer { | |
| /* The DS context (partially) owned by this tracer. */ | |
| struct ds_context *context; | |
| /* The buffer provided on ds_request() and its size in bytes. */ | |
| void *buffer; | |
| size_t size; | |
| }; | |
| struct bts_tracer { | |
| /* The common DS part: */ | |
| struct ds_tracer ds; | |
| /* The trace including the DS configuration: */ | |
| struct bts_trace trace; | |
| /* Buffer overflow notification function: */ | |
| bts_ovfl_callback_t ovfl; | |
| /* Active flags affecting trace collection. */ | |
| unsigned int flags; | |
| }; | |
| struct pebs_tracer { | |
| /* The common DS part: */ | |
| struct ds_tracer ds; | |
| /* The trace including the DS configuration: */ | |
| struct pebs_trace trace; | |
| /* Buffer overflow notification function: */ | |
| pebs_ovfl_callback_t ovfl; | |
| }; | |
| /* | |
| * 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 | |
| * | |
| * Later architectures use 64bit pointers throughout, whereas earlier | |
| * architectures use 32bit pointers in 32bit mode. | |
| * | |
| * | |
| * We compute the base address for the first 8 fields based on: | |
| * - the field size stored in the DS configuration | |
| * - the relative field position | |
| * - an offset giving the start of the respective region | |
| * | |
| * This offset is further used to index various arrays holding | |
| * information for BTS and PEBS at the respective index. | |
| * | |
| * On later 32bit processors, we only access the lower 32bit of the | |
| * 64bit pointer fields. The upper halves will be zeroed out. | |
| */ | |
| enum ds_field { | |
| ds_buffer_base = 0, | |
| ds_index, | |
| ds_absolute_maximum, | |
| ds_interrupt_threshold, | |
| }; | |
| enum ds_qualifier { | |
| ds_bts = 0, | |
| ds_pebs | |
| }; | |
| static inline unsigned long | |
| ds_get(const unsigned char *base, enum ds_qualifier qual, enum ds_field field) | |
| { | |
| base += (ds_cfg.sizeof_ptr_field * (field + (4 * qual))); | |
| return *(unsigned long *)base; | |
| } | |
| static inline void | |
| ds_set(unsigned char *base, enum ds_qualifier qual, enum ds_field field, | |
| unsigned long value) | |
| { | |
| base += (ds_cfg.sizeof_ptr_field * (field + (4 * qual))); | |
| (*(unsigned long *)base) = value; | |
| } | |
| /* | |
| * Locking is done only for allocating BTS or PEBS resources. | |
| */ | |
| static DEFINE_SPINLOCK(ds_lock); | |
| /* | |
| * We either support (system-wide) per-cpu or per-thread allocation. | |
| * We distinguish the two based on the task_struct pointer, where a | |
| * NULL pointer indicates per-cpu allocation for the current cpu. | |
| * | |
| * Allocations are use-counted. As soon as resources are allocated, | |
| * further allocations must be of the same type (per-cpu or | |
| * per-thread). We model this by counting allocations (i.e. the number | |
| * of tracers of a certain type) for one type negatively: | |
| * =0 no tracers | |
| * >0 number of per-thread tracers | |
| * <0 number of per-cpu tracers | |
| * | |
| * Tracers essentially gives the number of ds contexts for a certain | |
| * type of allocation. | |
| */ | |
| static atomic_t tracers = ATOMIC_INIT(0); | |
| static inline int get_tracer(struct task_struct *task) | |
| { | |
| int error; | |
| spin_lock_irq(&ds_lock); | |
| if (task) { | |
| error = -EPERM; | |
| if (atomic_read(&tracers) < 0) | |
| goto out; | |
| atomic_inc(&tracers); | |
| } else { | |
| error = -EPERM; | |
| if (atomic_read(&tracers) > 0) | |
| goto out; | |
| atomic_dec(&tracers); | |
| } | |
| error = 0; | |
| out: | |
| spin_unlock_irq(&ds_lock); | |
| return error; | |
| } | |
| static inline void put_tracer(struct task_struct *task) | |
| { | |
| if (task) | |
| atomic_dec(&tracers); | |
| else | |
| atomic_inc(&tracers); | |
| } | |
| /* | |
| * The DS context is either attached to a thread or to a cpu: | |
| * - in the former case, the thread_struct contains a pointer to the | |
| * attached context. | |
| * - in the latter case, we use a static array of per-cpu context | |
| * pointers. | |
| * | |
| * Contexts are use-counted. They are allocated on first access and | |
| * deallocated when the last user puts the context. | |
| */ | |
| struct ds_context { | |
| /* The DS configuration; goes into MSR_IA32_DS_AREA: */ | |
| unsigned char ds[MAX_SIZEOF_DS]; | |
| /* The owner of the BTS and PEBS configuration, respectively: */ | |
| struct bts_tracer *bts_master; | |
| struct pebs_tracer *pebs_master; | |
| /* Use count: */ | |
| unsigned long count; | |
| /* Pointer to the context pointer field: */ | |
| struct ds_context **this; | |
| /* The traced task; NULL for cpu tracing: */ | |
| struct task_struct *task; | |
| /* The traced cpu; only valid if task is NULL: */ | |
| int cpu; | |
| }; | |
| static DEFINE_PER_CPU(struct ds_context *, cpu_context); | |
| static struct ds_context *ds_get_context(struct task_struct *task, int cpu) | |
| { | |
| struct ds_context **p_context = | |
| (task ? &task->thread.ds_ctx : &per_cpu(cpu_context, cpu)); | |
| struct ds_context *context = NULL; | |
| struct ds_context *new_context = NULL; | |
| /* Chances are small that we already have a context. */ | |
| new_context = kzalloc(sizeof(*new_context), GFP_KERNEL); | |
| if (!new_context) | |
| return NULL; | |
| spin_lock_irq(&ds_lock); | |
| context = *p_context; | |
| if (likely(!context)) { | |
| context = new_context; | |
| context->this = p_context; | |
| context->task = task; | |
| context->cpu = cpu; | |
| context->count = 0; | |
| *p_context = context; | |
| } | |
| context->count++; | |
| spin_unlock_irq(&ds_lock); | |
| if (context != new_context) | |
| kfree(new_context); | |
| return context; | |
| } | |
| static void ds_put_context(struct ds_context *context) | |
| { | |
| struct task_struct *task; | |
| unsigned long irq; | |
| if (!context) | |
| return; | |
| spin_lock_irqsave(&ds_lock, irq); | |
| if (--context->count) { | |
| spin_unlock_irqrestore(&ds_lock, irq); | |
| return; | |
| } | |
| *(context->this) = NULL; | |
| task = context->task; | |
| if (task) | |
| clear_tsk_thread_flag(task, TIF_DS_AREA_MSR); | |
| /* | |
| * We leave the (now dangling) pointer to the DS configuration in | |
| * the DS_AREA msr. This is as good or as bad as replacing it with | |
| * NULL - the hardware would crash if we enabled tracing. | |
| * | |
| * This saves us some problems with having to write an msr on a | |
| * different cpu while preventing others from doing the same for the | |
| * next context for that same cpu. | |
| */ | |
| spin_unlock_irqrestore(&ds_lock, irq); | |
| /* The context might still be in use for context switching. */ | |
| if (task && (task != current)) | |
| wait_task_context_switch(task); | |
| kfree(context); | |
| } | |
| static void ds_install_ds_area(struct ds_context *context) | |
| { | |
| unsigned long ds; | |
| ds = (unsigned long)context->ds; | |
| /* | |
| * There is a race between the bts master and the pebs master. | |
| * | |
| * The thread/cpu access is synchronized via get/put_cpu() for | |
| * task tracing and via wrmsr_on_cpu for cpu tracing. | |
| * | |
| * If bts and pebs are collected for the same task or same cpu, | |
| * the same confiuration is written twice. | |
| */ | |
| if (context->task) { | |
| get_cpu(); | |
| if (context->task == current) | |
| wrmsrl(MSR_IA32_DS_AREA, ds); | |
| set_tsk_thread_flag(context->task, TIF_DS_AREA_MSR); | |
| put_cpu(); | |
| } else | |
| wrmsr_on_cpu(context->cpu, MSR_IA32_DS_AREA, | |
| (u32)((u64)ds), (u32)((u64)ds >> 32)); | |
| } | |
| /* | |
| * Call the tracer's callback on a buffer overflow. | |
| * | |
| * context: the ds context | |
| * qual: the buffer type | |
| */ | |
| static void ds_overflow(struct ds_context *context, enum ds_qualifier qual) | |
| { | |
| switch (qual) { | |
| case ds_bts: | |
| if (context->bts_master && | |
| context->bts_master->ovfl) | |
| context->bts_master->ovfl(context->bts_master); | |
| break; | |
| case ds_pebs: | |
| if (context->pebs_master && | |
| context->pebs_master->ovfl) | |
| context->pebs_master->ovfl(context->pebs_master); | |
| break; | |
| } | |
| } | |
| /* | |
| * Write raw data into the BTS or PEBS buffer. | |
| * | |
| * The remainder of any partially written record is zeroed out. | |
| * | |
| * context: the DS context | |
| * qual: the buffer type | |
| * record: the data to write | |
| * size: the size of the data | |
| */ | |
| static int ds_write(struct ds_context *context, enum ds_qualifier qual, | |
| const void *record, size_t size) | |
| { | |
| int bytes_written = 0; | |
| if (!record) | |
| return -EINVAL; | |
| while (size) { | |
| unsigned long base, index, end, write_end, int_th; | |
| unsigned long write_size, adj_write_size; | |
| /* | |
| * Write as much as possible without producing an | |
| * overflow interrupt. | |
| * | |
| * Interrupt_threshold must either be | |
| * - bigger than absolute_maximum or | |
| * - point to a record between buffer_base and absolute_maximum | |
| * | |
| * Index points to a valid record. | |
| */ | |
| base = ds_get(context->ds, qual, ds_buffer_base); | |
| index = ds_get(context->ds, qual, ds_index); | |
| end = ds_get(context->ds, qual, ds_absolute_maximum); | |
| int_th = ds_get(context->ds, qual, ds_interrupt_threshold); | |
| write_end = min(end, int_th); | |
| /* | |
| * If we are already beyond the interrupt threshold, | |
| * we fill the entire buffer. | |
| */ | |
| if (write_end <= index) | |
| write_end = end; | |
| if (write_end <= index) | |
| break; | |
| write_size = min((unsigned long) size, write_end - index); | |
| memcpy((void *)index, record, write_size); | |
| record = (const char *)record + write_size; | |
| size -= write_size; | |
| bytes_written += write_size; | |
| adj_write_size = write_size / ds_cfg.sizeof_rec[qual]; | |
| adj_write_size *= ds_cfg.sizeof_rec[qual]; | |
| /* Zero out trailing bytes. */ | |
| memset((char *)index + write_size, 0, | |
| adj_write_size - write_size); | |
| index += adj_write_size; | |
| if (index >= end) | |
| index = base; | |
| ds_set(context->ds, qual, ds_index, index); | |
| if (index >= int_th) | |
| ds_overflow(context, qual); | |
| } | |
| return bytes_written; | |
| } | |
| /* | |
| * Branch Trace Store (BTS) uses the following format. Different | |
| * architectures vary in the size of those fields. | |
| * - source linear address | |
| * - destination linear address | |
| * - flags | |
| * | |
| * Later architectures use 64bit pointers throughout, whereas earlier | |
| * architectures use 32bit pointers in 32bit mode. | |
| * | |
| * We compute the base address for the fields based on: | |
| * - the field size stored in the DS configuration | |
| * - the relative field position | |
| * | |
| * In order to store additional information in the BTS buffer, we use | |
| * a special source address to indicate that the record requires | |
| * special interpretation. | |
| * | |
| * Netburst indicated via a bit in the flags field whether the branch | |
| * was predicted; this is ignored. | |
| * | |
| * We use two levels of abstraction: | |
| * - the raw data level defined here | |
| * - an arch-independent level defined in ds.h | |
| */ | |
| enum bts_field { | |
| bts_from, | |
| bts_to, | |
| bts_flags, | |
| bts_qual = bts_from, | |
| bts_clock = bts_to, | |
| bts_pid = bts_flags, | |
| bts_qual_mask = (bts_qual_max - 1), | |
| bts_escape = ((unsigned long)-1 & ~bts_qual_mask) | |
| }; | |
| static inline unsigned long bts_get(const char *base, unsigned long field) | |
| { | |
| base += (ds_cfg.sizeof_ptr_field * field); | |
| return *(unsigned long *)base; | |
| } | |
| static inline void bts_set(char *base, unsigned long field, unsigned long val) | |
| { | |
| base += (ds_cfg.sizeof_ptr_field * field); | |
| (*(unsigned long *)base) = val; | |
| } | |
| /* | |
| * The raw BTS data is architecture dependent. | |
| * | |
| * For higher-level users, we give an arch-independent view. | |
| * - ds.h defines struct bts_struct | |
| * - bts_read translates one raw bts record into a bts_struct | |
| * - bts_write translates one bts_struct into the raw format and | |
| * writes it into the top of the parameter tracer's buffer. | |
| * | |
| * return: bytes read/written on success; -Eerrno, otherwise | |
| */ | |
| static int | |
| bts_read(struct bts_tracer *tracer, const void *at, struct bts_struct *out) | |
| { | |
| if (!tracer) | |
| return -EINVAL; | |
| if (at < tracer->trace.ds.begin) | |
| return -EINVAL; | |
| if (tracer->trace.ds.end < (at + tracer->trace.ds.size)) | |
| return -EINVAL; | |
| memset(out, 0, sizeof(*out)); | |
| if ((bts_get(at, bts_qual) & ~bts_qual_mask) == bts_escape) { | |
| out->qualifier = (bts_get(at, bts_qual) & bts_qual_mask); | |
| out->variant.event.clock = bts_get(at, bts_clock); | |
| out->variant.event.pid = bts_get(at, bts_pid); | |
| } else { | |
| out->qualifier = bts_branch; | |
| out->variant.lbr.from = bts_get(at, bts_from); | |
| out->variant.lbr.to = bts_get(at, bts_to); | |
| if (!out->variant.lbr.from && !out->variant.lbr.to) | |
| out->qualifier = bts_invalid; | |
| } | |
| return ds_cfg.sizeof_rec[ds_bts]; | |
| } | |
| static int bts_write(struct bts_tracer *tracer, const struct bts_struct *in) | |
| { | |
| unsigned char raw[MAX_SIZEOF_BTS]; | |
| if (!tracer) | |
| return -EINVAL; | |
| if (MAX_SIZEOF_BTS < ds_cfg.sizeof_rec[ds_bts]) | |
| return -EOVERFLOW; | |
| switch (in->qualifier) { | |
| case bts_invalid: | |
| bts_set(raw, bts_from, 0); | |
| bts_set(raw, bts_to, 0); | |
| bts_set(raw, bts_flags, 0); | |
| break; | |
| case bts_branch: | |
| bts_set(raw, bts_from, in->variant.lbr.from); | |
| bts_set(raw, bts_to, in->variant.lbr.to); | |
| bts_set(raw, bts_flags, 0); | |
| break; | |
| case bts_task_arrives: | |
| case bts_task_departs: | |
| bts_set(raw, bts_qual, (bts_escape | in->qualifier)); | |
| bts_set(raw, bts_clock, in->variant.event.clock); | |
| bts_set(raw, bts_pid, in->variant.event.pid); | |
| break; | |
| default: | |
| return -EINVAL; | |
| } | |
| return ds_write(tracer->ds.context, ds_bts, raw, | |
| ds_cfg.sizeof_rec[ds_bts]); | |
| } | |
| static void ds_write_config(struct ds_context *context, | |
| struct ds_trace *cfg, enum ds_qualifier qual) | |
| { | |
| unsigned char *ds = context->ds; | |
| ds_set(ds, qual, ds_buffer_base, (unsigned long)cfg->begin); | |
| ds_set(ds, qual, ds_index, (unsigned long)cfg->top); | |
| ds_set(ds, qual, ds_absolute_maximum, (unsigned long)cfg->end); | |
| ds_set(ds, qual, ds_interrupt_threshold, (unsigned long)cfg->ith); | |
| } | |
| static void ds_read_config(struct ds_context *context, | |
| struct ds_trace *cfg, enum ds_qualifier qual) | |
| { | |
| unsigned char *ds = context->ds; | |
| cfg->begin = (void *)ds_get(ds, qual, ds_buffer_base); | |
| cfg->top = (void *)ds_get(ds, qual, ds_index); | |
| cfg->end = (void *)ds_get(ds, qual, ds_absolute_maximum); | |
| cfg->ith = (void *)ds_get(ds, qual, ds_interrupt_threshold); | |
| } | |
| static void ds_init_ds_trace(struct ds_trace *trace, enum ds_qualifier qual, | |
| void *base, size_t size, size_t ith, | |
| unsigned int flags) { | |
| unsigned long buffer, adj; | |
| /* | |
| * Adjust the buffer address and size to meet alignment | |
| * constraints: | |
| * - buffer is double-word aligned | |
| * - size is multiple of record size | |
| * | |
| * We checked the size at the very beginning; we have enough | |
| * space to do the adjustment. | |
| */ | |
| buffer = (unsigned long)base; | |
| adj = ALIGN(buffer, DS_ALIGNMENT) - buffer; | |
| buffer += adj; | |
| size -= adj; | |
| trace->n = size / ds_cfg.sizeof_rec[qual]; | |
| trace->size = ds_cfg.sizeof_rec[qual]; | |
| size = (trace->n * trace->size); | |
| trace->begin = (void *)buffer; | |
| trace->top = trace->begin; | |
| trace->end = (void *)(buffer + size); | |
| /* | |
| * The value for 'no threshold' is -1, which will set the | |
| * threshold outside of the buffer, just like we want it. | |
| */ | |
| ith *= ds_cfg.sizeof_rec[qual]; | |
| trace->ith = (void *)(buffer + size - ith); | |
| trace->flags = flags; | |
| } | |
| static int ds_request(struct ds_tracer *tracer, struct ds_trace *trace, | |
| enum ds_qualifier qual, struct task_struct *task, | |
| int cpu, void *base, size_t size, size_t th) | |
| { | |
| struct ds_context *context; | |
| int error; | |
| size_t req_size; | |
| error = -EOPNOTSUPP; | |
| if (!ds_cfg.sizeof_rec[qual]) | |
| goto out; | |
| error = -EINVAL; | |
| if (!base) | |
| goto out; | |
| req_size = ds_cfg.sizeof_rec[qual]; | |
| /* We might need space for alignment adjustments. */ | |
| if (!IS_ALIGNED((unsigned long)base, DS_ALIGNMENT)) | |
| req_size += DS_ALIGNMENT; | |
| error = -EINVAL; | |
| if (size < req_size) | |
| goto out; | |
| if (th != (size_t)-1) { | |
| th *= ds_cfg.sizeof_rec[qual]; | |
| error = -EINVAL; | |
| if (size <= th) | |
| goto out; | |
| } | |
| tracer->buffer = base; | |
| tracer->size = size; | |
| error = -ENOMEM; | |
| context = ds_get_context(task, cpu); | |
| if (!context) | |
| goto out; | |
| tracer->context = context; | |
| /* | |
| * Defer any tracer-specific initialization work for the context until | |
| * context ownership has been clarified. | |
| */ | |
| error = 0; | |
| out: | |
| return error; | |
| } | |
| static struct bts_tracer *ds_request_bts(struct task_struct *task, int cpu, | |
| void *base, size_t size, | |
| bts_ovfl_callback_t ovfl, size_t th, | |
| unsigned int flags) | |
| { | |
| struct bts_tracer *tracer; | |
| int error; | |
| /* Buffer overflow notification is not yet implemented. */ | |
| error = -EOPNOTSUPP; | |
| if (ovfl) | |
| goto out; | |
| error = get_tracer(task); | |
| if (error < 0) | |
| goto out; | |
| error = -ENOMEM; | |
| tracer = kzalloc(sizeof(*tracer), GFP_KERNEL); | |
| if (!tracer) | |
| goto out_put_tracer; | |
| tracer->ovfl = ovfl; | |
| /* Do some more error checking and acquire a tracing context. */ | |
| error = ds_request(&tracer->ds, &tracer->trace.ds, | |
| ds_bts, task, cpu, base, size, th); | |
| if (error < 0) | |
| goto out_tracer; | |
| /* Claim the bts part of the tracing context we acquired above. */ | |
| spin_lock_irq(&ds_lock); | |
| error = -EPERM; | |
| if (tracer->ds.context->bts_master) | |
| goto out_unlock; | |
| tracer->ds.context->bts_master = tracer; | |
| spin_unlock_irq(&ds_lock); | |
| /* | |
| * Now that we own the bts part of the context, let's complete the | |
| * initialization for that part. | |
| */ | |
| ds_init_ds_trace(&tracer->trace.ds, ds_bts, base, size, th, flags); | |
| ds_write_config(tracer->ds.context, &tracer->trace.ds, ds_bts); | |
| ds_install_ds_area(tracer->ds.context); | |
| tracer->trace.read = bts_read; | |
| tracer->trace.write = bts_write; | |
| /* Start tracing. */ | |
| ds_resume_bts(tracer); | |
| return tracer; | |
| out_unlock: | |
| spin_unlock_irq(&ds_lock); | |
| ds_put_context(tracer->ds.context); | |
| out_tracer: | |
| kfree(tracer); | |
| out_put_tracer: | |
| put_tracer(task); | |
| out: | |
| return ERR_PTR(error); | |
| } | |
| struct bts_tracer *ds_request_bts_task(struct task_struct *task, | |
| void *base, size_t size, | |
| bts_ovfl_callback_t ovfl, | |
| size_t th, unsigned int flags) | |
| { | |
| return ds_request_bts(task, 0, base, size, ovfl, th, flags); | |
| } | |
| struct bts_tracer *ds_request_bts_cpu(int cpu, void *base, size_t size, | |
| bts_ovfl_callback_t ovfl, | |
| size_t th, unsigned int flags) | |
| { | |
| return ds_request_bts(NULL, cpu, base, size, ovfl, th, flags); | |
| } | |
| static struct pebs_tracer *ds_request_pebs(struct task_struct *task, int cpu, | |
| void *base, size_t size, | |
| pebs_ovfl_callback_t ovfl, size_t th, | |
| unsigned int flags) | |
| { | |
| struct pebs_tracer *tracer; | |
| int error; | |
| /* Buffer overflow notification is not yet implemented. */ | |
| error = -EOPNOTSUPP; | |
| if (ovfl) | |
| goto out; | |
| error = get_tracer(task); | |
| if (error < 0) | |
| goto out; | |
| error = -ENOMEM; | |
| tracer = kzalloc(sizeof(*tracer), GFP_KERNEL); | |
| if (!tracer) | |
| goto out_put_tracer; | |
| tracer->ovfl = ovfl; | |
| /* Do some more error checking and acquire a tracing context. */ | |
| error = ds_request(&tracer->ds, &tracer->trace.ds, | |
| ds_pebs, task, cpu, base, size, th); | |
| if (error < 0) | |
| goto out_tracer; | |
| /* Claim the pebs part of the tracing context we acquired above. */ | |
| spin_lock_irq(&ds_lock); | |
| error = -EPERM; | |
| if (tracer->ds.context->pebs_master) | |
| goto out_unlock; | |
| tracer->ds.context->pebs_master = tracer; | |
| spin_unlock_irq(&ds_lock); | |
| /* | |
| * Now that we own the pebs part of the context, let's complete the | |
| * initialization for that part. | |
| */ | |
| ds_init_ds_trace(&tracer->trace.ds, ds_pebs, base, size, th, flags); | |
| ds_write_config(tracer->ds.context, &tracer->trace.ds, ds_pebs); | |
| ds_install_ds_area(tracer->ds.context); | |
| /* Start tracing. */ | |
| ds_resume_pebs(tracer); | |
| return tracer; | |
| out_unlock: | |
| spin_unlock_irq(&ds_lock); | |
| ds_put_context(tracer->ds.context); | |
| out_tracer: | |
| kfree(tracer); | |
| out_put_tracer: | |
| put_tracer(task); | |
| out: | |
| return ERR_PTR(error); | |
| } | |
| struct pebs_tracer *ds_request_pebs_task(struct task_struct *task, | |
| void *base, size_t size, | |
| pebs_ovfl_callback_t ovfl, | |
| size_t th, unsigned int flags) | |
| { | |
| return ds_request_pebs(task, 0, base, size, ovfl, th, flags); | |
| } | |
| struct pebs_tracer *ds_request_pebs_cpu(int cpu, void *base, size_t size, | |
| pebs_ovfl_callback_t ovfl, | |
| size_t th, unsigned int flags) | |
| { | |
| return ds_request_pebs(NULL, cpu, base, size, ovfl, th, flags); | |
| } | |
| static void ds_free_bts(struct bts_tracer *tracer) | |
| { | |
| struct task_struct *task; | |
| task = tracer->ds.context->task; | |
| WARN_ON_ONCE(tracer->ds.context->bts_master != tracer); | |
| tracer->ds.context->bts_master = NULL; | |
| /* Make sure tracing stopped and the tracer is not in use. */ | |
| if (task && (task != current)) | |
| wait_task_context_switch(task); | |
| ds_put_context(tracer->ds.context); | |
| put_tracer(task); | |
| kfree(tracer); | |
| } | |
| void ds_release_bts(struct bts_tracer *tracer) | |
| { | |
| might_sleep(); | |
| if (!tracer) | |
| return; | |
| ds_suspend_bts(tracer); | |
| ds_free_bts(tracer); | |
| } | |
| int ds_release_bts_noirq(struct bts_tracer *tracer) | |
| { | |
| struct task_struct *task; | |
| unsigned long irq; | |
| int error; | |
| if (!tracer) | |
| return 0; | |
| task = tracer->ds.context->task; | |
| local_irq_save(irq); | |
| error = -EPERM; | |
| if (!task && | |
| (tracer->ds.context->cpu != smp_processor_id())) | |
| goto out; | |
| error = -EPERM; | |
| if (task && (task != current)) | |
| goto out; | |
| ds_suspend_bts_noirq(tracer); | |
| ds_free_bts(tracer); | |
| error = 0; | |
| out: | |
| local_irq_restore(irq); | |
| return error; | |
| } | |
| static void update_task_debugctlmsr(struct task_struct *task, | |
| unsigned long debugctlmsr) | |
| { | |
| task->thread.debugctlmsr = debugctlmsr; | |
| get_cpu(); | |
| if (task == current) | |
| update_debugctlmsr(debugctlmsr); | |
| put_cpu(); | |
| } | |
| void ds_suspend_bts(struct bts_tracer *tracer) | |
| { | |
| struct task_struct *task; | |
| unsigned long debugctlmsr; | |
| int cpu; | |
| if (!tracer) | |
| return; | |
| tracer->flags = 0; | |
| task = tracer->ds.context->task; | |
| cpu = tracer->ds.context->cpu; | |
| WARN_ON(!task && irqs_disabled()); | |
| debugctlmsr = (task ? | |
| task->thread.debugctlmsr : | |
| get_debugctlmsr_on_cpu(cpu)); | |
| debugctlmsr &= ~BTS_CONTROL; | |
| if (task) | |
| update_task_debugctlmsr(task, debugctlmsr); | |
| else | |
| update_debugctlmsr_on_cpu(cpu, debugctlmsr); | |
| } | |
| int ds_suspend_bts_noirq(struct bts_tracer *tracer) | |
| { | |
| struct task_struct *task; | |
| unsigned long debugctlmsr, irq; | |
| int cpu, error = 0; | |
| if (!tracer) | |
| return 0; | |
| tracer->flags = 0; | |
| task = tracer->ds.context->task; | |
| cpu = tracer->ds.context->cpu; | |
| local_irq_save(irq); | |
| error = -EPERM; | |
| if (!task && (cpu != smp_processor_id())) | |
| goto out; | |
| debugctlmsr = (task ? | |
| task->thread.debugctlmsr : | |
| get_debugctlmsr()); | |
| debugctlmsr &= ~BTS_CONTROL; | |
| if (task) | |
| update_task_debugctlmsr(task, debugctlmsr); | |
| else | |
| update_debugctlmsr(debugctlmsr); | |
| error = 0; | |
| out: | |
| local_irq_restore(irq); | |
| return error; | |
| } | |
| static unsigned long ds_bts_control(struct bts_tracer *tracer) | |
| { | |
| unsigned long control; | |
| control = ds_cfg.ctl[dsf_bts]; | |
| if (!(tracer->trace.ds.flags & BTS_KERNEL)) | |
| control |= ds_cfg.ctl[dsf_bts_kernel]; | |
| if (!(tracer->trace.ds.flags & BTS_USER)) | |
| control |= ds_cfg.ctl[dsf_bts_user]; | |
| return control; | |
| } | |
| void ds_resume_bts(struct bts_tracer *tracer) | |
| { | |
| struct task_struct *task; | |
| unsigned long debugctlmsr; | |
| int cpu; | |
| if (!tracer) | |
| return; | |
| tracer->flags = tracer->trace.ds.flags; | |
| task = tracer->ds.context->task; | |
| cpu = tracer->ds.context->cpu; | |
| WARN_ON(!task && irqs_disabled()); | |
| debugctlmsr = (task ? | |
| task->thread.debugctlmsr : | |
| get_debugctlmsr_on_cpu(cpu)); | |
| debugctlmsr |= ds_bts_control(tracer); | |
| if (task) | |
| update_task_debugctlmsr(task, debugctlmsr); | |
| else | |
| update_debugctlmsr_on_cpu(cpu, debugctlmsr); | |
| } | |
| int ds_resume_bts_noirq(struct bts_tracer *tracer) | |
| { | |
| struct task_struct *task; | |
| unsigned long debugctlmsr, irq; | |
| int cpu, error = 0; | |
| if (!tracer) | |
| return 0; | |
| tracer->flags = tracer->trace.ds.flags; | |
| task = tracer->ds.context->task; | |
| cpu = tracer->ds.context->cpu; | |
| local_irq_save(irq); | |
| error = -EPERM; | |
| if (!task && (cpu != smp_processor_id())) | |
| goto out; | |
| debugctlmsr = (task ? | |
| task->thread.debugctlmsr : | |
| get_debugctlmsr()); | |
| debugctlmsr |= ds_bts_control(tracer); | |
| if (task) | |
| update_task_debugctlmsr(task, debugctlmsr); | |
| else | |
| update_debugctlmsr(debugctlmsr); | |
| error = 0; | |
| out: | |
| local_irq_restore(irq); | |
| return error; | |
| } | |
| static void ds_free_pebs(struct pebs_tracer *tracer) | |
| { | |
| struct task_struct *task; | |
| task = tracer->ds.context->task; | |
| WARN_ON_ONCE(tracer->ds.context->pebs_master != tracer); | |
| tracer->ds.context->pebs_master = NULL; | |
| ds_put_context(tracer->ds.context); | |
| put_tracer(task); | |
| kfree(tracer); | |
| } | |
| void ds_release_pebs(struct pebs_tracer *tracer) | |
| { | |
| might_sleep(); | |
| if (!tracer) | |
| return; | |
| ds_suspend_pebs(tracer); | |
| ds_free_pebs(tracer); | |
| } | |
| int ds_release_pebs_noirq(struct pebs_tracer *tracer) | |
| { | |
| struct task_struct *task; | |
| unsigned long irq; | |
| int error; | |
| if (!tracer) | |
| return 0; | |
| task = tracer->ds.context->task; | |
| local_irq_save(irq); | |
| error = -EPERM; | |
| if (!task && | |
| (tracer->ds.context->cpu != smp_processor_id())) | |
| goto out; | |
| error = -EPERM; | |
| if (task && (task != current)) | |
| goto out; | |
| ds_suspend_pebs_noirq(tracer); | |
| ds_free_pebs(tracer); | |
| error = 0; | |
| out: | |
| local_irq_restore(irq); | |
| return error; | |
| } | |
| void ds_suspend_pebs(struct pebs_tracer *tracer) | |
| { | |
| } | |
| int ds_suspend_pebs_noirq(struct pebs_tracer *tracer) | |
| { | |
| return 0; | |
| } | |
| void ds_resume_pebs(struct pebs_tracer *tracer) | |
| { | |
| } | |
| int ds_resume_pebs_noirq(struct pebs_tracer *tracer) | |
| { | |
| return 0; | |
| } | |
| const struct bts_trace *ds_read_bts(struct bts_tracer *tracer) | |
| { | |
| if (!tracer) | |
| return NULL; | |
| ds_read_config(tracer->ds.context, &tracer->trace.ds, ds_bts); | |
| return &tracer->trace; | |
| } | |
| const struct pebs_trace *ds_read_pebs(struct pebs_tracer *tracer) | |
| { | |
| if (!tracer) | |
| return NULL; | |
| ds_read_config(tracer->ds.context, &tracer->trace.ds, ds_pebs); | |
| tracer->trace.counters = ds_cfg.nr_counter_reset; | |
| memcpy(tracer->trace.counter_reset, | |
| tracer->ds.context->ds + | |
| (NUM_DS_PTR_FIELDS * ds_cfg.sizeof_ptr_field), | |
| ds_cfg.nr_counter_reset * PEBS_RESET_FIELD_SIZE); | |
| return &tracer->trace; | |
| } | |
| int ds_reset_bts(struct bts_tracer *tracer) | |
| { | |
| if (!tracer) | |
| return -EINVAL; | |
| tracer->trace.ds.top = tracer->trace.ds.begin; | |
| ds_set(tracer->ds.context->ds, ds_bts, ds_index, | |
| (unsigned long)tracer->trace.ds.top); | |
| return 0; | |
| } | |
| int ds_reset_pebs(struct pebs_tracer *tracer) | |
| { | |
| if (!tracer) | |
| return -EINVAL; | |
| tracer->trace.ds.top = tracer->trace.ds.begin; | |
| ds_set(tracer->ds.context->ds, ds_pebs, ds_index, | |
| (unsigned long)tracer->trace.ds.top); | |
| return 0; | |
| } | |
| int ds_set_pebs_reset(struct pebs_tracer *tracer, | |
| unsigned int counter, u64 value) | |
| { | |
| if (!tracer) | |
| return -EINVAL; | |
| if (ds_cfg.nr_counter_reset < counter) | |
| return -EINVAL; | |
| *(u64 *)(tracer->ds.context->ds + | |
| (NUM_DS_PTR_FIELDS * ds_cfg.sizeof_ptr_field) + | |
| (counter * PEBS_RESET_FIELD_SIZE)) = value; | |
| return 0; | |
| } | |
| static const struct ds_configuration ds_cfg_netburst = { | |
| .name = "Netburst", | |
| .ctl[dsf_bts] = (1 << 2) | (1 << 3), | |
| .ctl[dsf_bts_kernel] = (1 << 5), | |
| .ctl[dsf_bts_user] = (1 << 6), | |
| .nr_counter_reset = 1, | |
| }; | |
| static const struct ds_configuration ds_cfg_pentium_m = { | |
| .name = "Pentium M", | |
| .ctl[dsf_bts] = (1 << 6) | (1 << 7), | |
| .nr_counter_reset = 1, | |
| }; | |
| static const struct ds_configuration ds_cfg_core2_atom = { | |
| .name = "Core 2/Atom", | |
| .ctl[dsf_bts] = (1 << 6) | (1 << 7), | |
| .ctl[dsf_bts_kernel] = (1 << 9), | |
| .ctl[dsf_bts_user] = (1 << 10), | |
| .nr_counter_reset = 1, | |
| }; | |
| static const struct ds_configuration ds_cfg_core_i7 = { | |
| .name = "Core i7", | |
| .ctl[dsf_bts] = (1 << 6) | (1 << 7), | |
| .ctl[dsf_bts_kernel] = (1 << 9), | |
| .ctl[dsf_bts_user] = (1 << 10), | |
| .nr_counter_reset = 4, | |
| }; | |
| static void | |
| ds_configure(const struct ds_configuration *cfg, | |
| struct cpuinfo_x86 *cpu) | |
| { | |
| unsigned long nr_pebs_fields = 0; | |
| printk(KERN_INFO "[ds] using %s configuration\n", cfg->name); | |
| #ifdef __i386__ | |
| nr_pebs_fields = 10; | |
| #else | |
| nr_pebs_fields = 18; | |
| #endif | |
| /* | |
| * Starting with version 2, architectural performance | |
| * monitoring supports a format specifier. | |
| */ | |
| if ((cpuid_eax(0xa) & 0xff) > 1) { | |
| unsigned long perf_capabilities, format; | |
| rdmsrl(MSR_IA32_PERF_CAPABILITIES, perf_capabilities); | |
| format = (perf_capabilities >> 8) & 0xf; | |
| switch (format) { | |
| case 0: | |
| nr_pebs_fields = 18; | |
| break; | |
| case 1: | |
| nr_pebs_fields = 22; | |
| break; | |
| default: | |
| printk(KERN_INFO | |
| "[ds] unknown PEBS format: %lu\n", format); | |
| nr_pebs_fields = 0; | |
| break; | |
| } | |
| } | |
| memset(&ds_cfg, 0, sizeof(ds_cfg)); | |
| ds_cfg = *cfg; | |
| ds_cfg.sizeof_ptr_field = | |
| (cpu_has(cpu, X86_FEATURE_DTES64) ? 8 : 4); | |
| ds_cfg.sizeof_rec[ds_bts] = ds_cfg.sizeof_ptr_field * 3; | |
| ds_cfg.sizeof_rec[ds_pebs] = ds_cfg.sizeof_ptr_field * nr_pebs_fields; | |
| if (!cpu_has(cpu, X86_FEATURE_BTS)) { | |
| ds_cfg.sizeof_rec[ds_bts] = 0; | |
| printk(KERN_INFO "[ds] bts not available\n"); | |
| } | |
| if (!cpu_has(cpu, X86_FEATURE_PEBS)) { | |
| ds_cfg.sizeof_rec[ds_pebs] = 0; | |
| printk(KERN_INFO "[ds] pebs not available\n"); | |
| } | |
| printk(KERN_INFO "[ds] sizes: address: %u bit, ", | |
| 8 * ds_cfg.sizeof_ptr_field); | |
| printk("bts/pebs record: %u/%u bytes\n", | |
| ds_cfg.sizeof_rec[ds_bts], ds_cfg.sizeof_rec[ds_pebs]); | |
| WARN_ON_ONCE(MAX_PEBS_COUNTERS < ds_cfg.nr_counter_reset); | |
| } | |
| void __cpuinit ds_init_intel(struct cpuinfo_x86 *c) | |
| { | |
| /* Only configure the first cpu. Others are identical. */ | |
| if (ds_cfg.name) | |
| return; | |
| switch (c->x86) { | |
| case 0x6: | |
| switch (c->x86_model) { | |
| case 0x9: | |
| case 0xd: /* Pentium M */ | |
| ds_configure(&ds_cfg_pentium_m, c); | |
| break; | |
| case 0xf: | |
| case 0x17: /* Core2 */ | |
| case 0x1c: /* Atom */ | |
| ds_configure(&ds_cfg_core2_atom, c); | |
| break; | |
| case 0x1a: /* Core i7 */ | |
| ds_configure(&ds_cfg_core_i7, c); | |
| break; | |
| default: | |
| /* Sorry, don't know about them. */ | |
| break; | |
| } | |
| break; | |
| case 0xf: | |
| switch (c->x86_model) { | |
| case 0x0: | |
| case 0x1: | |
| case 0x2: /* Netburst */ | |
| ds_configure(&ds_cfg_netburst, c); | |
| break; | |
| default: | |
| /* Sorry, don't know about them. */ | |
| break; | |
| } | |
| break; | |
| default: | |
| /* Sorry, don't know about them. */ | |
| break; | |
| } | |
| } | |
| static inline void ds_take_timestamp(struct ds_context *context, | |
| enum bts_qualifier qualifier, | |
| struct task_struct *task) | |
| { | |
| struct bts_tracer *tracer = context->bts_master; | |
| struct bts_struct ts; | |
| /* Prevent compilers from reading the tracer pointer twice. */ | |
| barrier(); | |
| if (!tracer || !(tracer->flags & BTS_TIMESTAMPS)) | |
| return; | |
| memset(&ts, 0, sizeof(ts)); | |
| ts.qualifier = qualifier; | |
| ts.variant.event.clock = trace_clock_global(); | |
| ts.variant.event.pid = task->pid; | |
| bts_write(tracer, &ts); | |
| } | |
| /* | |
| * Change the DS configuration from tracing prev to tracing next. | |
| */ | |
| void ds_switch_to(struct task_struct *prev, struct task_struct *next) | |
| { | |
| struct ds_context *prev_ctx = prev->thread.ds_ctx; | |
| struct ds_context *next_ctx = next->thread.ds_ctx; | |
| unsigned long debugctlmsr = next->thread.debugctlmsr; | |
| /* Make sure all data is read before we start. */ | |
| barrier(); | |
| if (prev_ctx) { | |
| update_debugctlmsr(0); | |
| ds_take_timestamp(prev_ctx, bts_task_departs, prev); | |
| } | |
| if (next_ctx) { | |
| ds_take_timestamp(next_ctx, bts_task_arrives, next); | |
| wrmsrl(MSR_IA32_DS_AREA, (unsigned long)next_ctx->ds); | |
| } | |
| update_debugctlmsr(debugctlmsr); | |
| } | |
| static __init int ds_selftest(void) | |
| { | |
| if (ds_cfg.sizeof_rec[ds_bts]) { | |
| int error; | |
| error = ds_selftest_bts(); | |
| if (error) { | |
| WARN(1, "[ds] selftest failed. disabling bts.\n"); | |
| ds_cfg.sizeof_rec[ds_bts] = 0; | |
| } | |
| } | |
| if (ds_cfg.sizeof_rec[ds_pebs]) { | |
| int error; | |
| error = ds_selftest_pebs(); | |
| if (error) { | |
| WARN(1, "[ds] selftest failed. disabling pebs.\n"); | |
| ds_cfg.sizeof_rec[ds_pebs] = 0; | |
| } | |
| } | |
| return 0; | |
| } | |
| device_initcall(ds_selftest); |