/* * 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 , 2007-2009 */ #include #include #include #include #include #include #include #include #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);