Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
cc1dc6d
Documentation
arch
alpha
arm
avr32
blackfin
cris
frv
h8300
ia64
m32r
m68k
m68knommu
mips
mn10300
parisc
powerpc
s390
sh
sparc
sparc64
um
x86
boot
configs
crypto
ia32
include
kernel
acpi
cpu
.gitignore
Makefile
alternative.c
amd_iommu.c
amd_iommu_init.c
aperture_64.c
apic.c
apm_32.c
asm-offsets.c
asm-offsets_32.c
asm-offsets_64.c
audit_64.c
bios_uv.c
bootflag.c
cpuid.c
crash.c
crash_dump_32.c
crash_dump_64.c
doublefault_32.c
ds.c
dumpstack.c
dumpstack.h
dumpstack_32.c
dumpstack_64.c
e820.c
early-quirks.c
early_printk.c
efi.c
efi_32.c
efi_64.c
efi_stub_32.S
efi_stub_64.S
entry_32.S
entry_64.S
es7000_32.c
ftrace.c
genapic_64.c
genapic_flat_64.c
genx2apic_cluster.c
genx2apic_phys.c
genx2apic_uv_x.c
geode_32.c
head.c
head32.c
head64.c
head_32.S
head_64.S
hpet.c
i386_ksyms_32.c
i387.c
i8237.c
i8253.c
i8259.c
init_task.c
io_apic.c
io_delay.c
ioport.c
ipi.c
irq.c
irq_32.c
irq_64.c
irqinit_32.c
irqinit_64.c
k8.c
kdebugfs.c
kgdb.c
kprobes.c
kvm.c
kvmclock.c
ldt.c
machine_kexec_32.c
machine_kexec_64.c
mca_32.c
mfgpt_32.c
microcode_amd.c
microcode_core.c
microcode_intel.c
mmconf-fam10h_64.c
module_32.c
module_64.c
mpparse.c
msr.c
nmi.c
numaq_32.c
olpc.c
paravirt-spinlocks.c
paravirt.c
paravirt_patch_32.c
paravirt_patch_64.c
pci-calgary_64.c
pci-dma.c
pci-gart_64.c
pci-nommu.c
pci-swiotlb_64.c
pcspeaker.c
pmtimer_64.c
probe_roms_32.c
process.c
process_32.c
process_64.c
ptrace.c
pvclock.c
quirks.c
reboot.c
reboot_fixups_32.c
relocate_kernel_32.S
relocate_kernel_64.S
rtc.c
scx200_32.c
setup.c
setup_percpu.c
sigframe.h
signal_32.c
signal_64.c
smp.c
smpboot.c
smpcommon.c
stacktrace.c
step.c
summit_32.c
sys_i386_32.c
sys_x86_64.c
syscall_64.c
syscall_table_32.S
tce_64.c
test_nx.c
test_rodata.c
time_32.c
time_64.c
tlb_32.c
tlb_64.c
tlb_uv.c
tls.c
tls.h
topology.c
trampoline.c
trampoline_32.S
trampoline_64.S
traps.c
tsc.c
tsc_sync.c
uv_irq.c
uv_sysfs.c
verify_cpu_64.S
visws_quirks.c
vm86_32.c
vmi_32.c
vmiclock_32.c
vmlinux.lds.S
vmlinux_32.lds.S
vmlinux_64.lds.S
vsmp_64.c
vsyscall_64.c
x8664_ksyms_64.c
xsave.c
kvm
lguest
lib
mach-default
mach-generic
mach-rdc321x
mach-voyager
math-emu
mm
oprofile
pci
power
vdso
video
xen
Kconfig
Kconfig.cpu
Kconfig.debug
Makefile
Makefile_32.cpu
xtensa
.gitignore
Kconfig
block
crypto
drivers
firmware
fs
include
init
ipc
kernel
lib
mm
net
samples
scripts
security
sound
usr
virt
.gitignore
.mailmap
COPYING
CREDITS
Kbuild
MAINTAINERS
Makefile
README
REPORTING-BUGS
Breadcrumbs
linux
/
arch
/
x86
/
kernel
/
ds.c
Blame
Blame
Latest commit
History
History
1016 lines (826 loc) · 24.1 KB
Breadcrumbs
linux
/
arch
/
x86
/
kernel
/
ds.c
Top
File metadata and controls
Code
Blame
1016 lines (826 loc) · 24.1 KB
Raw
/* * 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-2008 Intel Corporation. * Markus Metzger <markus.t.metzger@intel.com>, 2007-2008 */ #include <asm/ds.h> #include <linux/errno.h> #include <linux/string.h> #include <linux/slab.h> #include <linux/sched.h> #include <linux/mm.h> #include <linux/kernel.h> /* * The configuration for a particular DS hardware implementation. */ struct ds_configuration { /* the name of the configuration */ const char *name; /* the size of one pointer-typed field in the DS structure and in the BTS and PEBS buffers in bytes; this covers the first 8 DS fields related to buffer management. */ unsigned char sizeof_field; /* the size of a BTS/PEBS record in bytes */ unsigned char sizeof_rec[2]; /* a series of bit-masks to control various features indexed * by enum ds_feature */ unsigned long ctl[dsf_ctl_max]; }; static DEFINE_PER_CPU(struct ds_configuration, ds_cfg_array); #define ds_cfg per_cpu(ds_cfg_array, smp_processor_id()) #define MAX_SIZEOF_DS (12 * 8) /* maximal size of a DS configuration */ #define MAX_SIZEOF_BTS (3 * 8) /* maximal size of a BTS record */ #define DS_ALIGNMENT (1 << 3) /* BTS and PEBS buffer alignment */ #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; }; 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_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_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 void get_tracer(struct task_struct *task) { if (task) atomic_inc(&tracers); else atomic_dec(&tracers); } static inline void put_tracer(struct task_struct *task) { if (task) atomic_dec(&tracers); else atomic_inc(&tracers); } static inline int check_tracer(struct task_struct *task) { return task ? (atomic_read(&tracers) >= 0) : (atomic_read(&tracers) <= 0); } /* * 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 { /* pointer to 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; /* a pointer to the context location inside the thread_struct * or the per_cpu context array */ struct ds_context **this; /* a pointer to the task owning this context, or NULL, if the * context is owned by a cpu */ struct task_struct *task; }; static DEFINE_PER_CPU(struct ds_context *, system_context_array); #define system_context per_cpu(system_context_array, smp_processor_id()) static inline struct ds_context *ds_get_context(struct task_struct *task) { struct ds_context **p_context = (task ? &task->thread.ds_ctx : &system_context); struct ds_context *context = NULL; struct ds_context *new_context = NULL; unsigned long irq; /* Chances are small that we already have a context. */ new_context = kzalloc(sizeof(*new_context), GFP_KERNEL); if (!new_context) return NULL; spin_lock_irqsave(&ds_lock, irq); context = *p_context; if (!context) { context = new_context; context->this = p_context; context->task = task; context->count = 0; if (task) set_tsk_thread_flag(task, TIF_DS_AREA_MSR); if (!task || (task == current)) wrmsrl(MSR_IA32_DS_AREA, (unsigned long)context->ds); *p_context = context; } context->count++; spin_unlock_irqrestore(&ds_lock, irq); if (context != new_context) kfree(new_context); return context; } static inline void ds_put_context(struct ds_context *context) { 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; if (context->task) clear_tsk_thread_flag(context->task, TIF_DS_AREA_MSR); if (!context->task || (context->task == current)) wrmsrl(MSR_IA32_DS_AREA, 0); spin_unlock_irqrestore(&ds_lock, irq); kfree(context); } /* * 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 first 8 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_jiffies = 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, enum bts_field field) { base += (ds_cfg.sizeof_field * field); return *(unsigned long *)base; } static inline void bts_set(char *base, enum bts_field field, unsigned long val) { base += (ds_cfg.sizeof_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.timestamp.jiffies = bts_get(at, bts_jiffies); out->variant.timestamp.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); } 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_jiffies, in->variant.timestamp.jiffies); bts_set(raw, bts_pid, in->variant.timestamp.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. */ 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, void *base, size_t size, size_t th, unsigned int flags) { struct ds_context *context; int error; error = -EINVAL; if (!base) goto out; /* we require some space to do alignment adjustments below */ error = -EINVAL; if (size < (DS_ALIGNMENT + ds_cfg.sizeof_rec[qual])) 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); if (!context) goto out; tracer->context = context; ds_init_ds_trace(trace, qual, base, size, th, flags); error = 0; out: return error; } struct bts_tracer *ds_request_bts(struct task_struct *task, void *base, size_t size, bts_ovfl_callback_t ovfl, size_t th, unsigned int flags) { struct bts_tracer *tracer; unsigned long irq; int error; error = -EOPNOTSUPP; if (!ds_cfg.ctl[dsf_bts]) goto out; /* buffer overflow notification is not yet implemented */ error = -EOPNOTSUPP; if (ovfl) goto out; error = -ENOMEM; tracer = kzalloc(sizeof(*tracer), GFP_KERNEL); if (!tracer) goto out; tracer->ovfl = ovfl; error = ds_request(&tracer->ds, &tracer->trace.ds, ds_bts, task, base, size, th, flags); if (error < 0) goto out_tracer; spin_lock_irqsave(&ds_lock, irq); error = -EPERM; if (!check_tracer(task)) goto out_unlock; get_tracer(task); error = -EPERM; if (tracer->ds.context->bts_master) goto out_put_tracer; tracer->ds.context->bts_master = tracer; spin_unlock_irqrestore(&ds_lock, irq); tracer->trace.read = bts_read; tracer->trace.write = bts_write; ds_write_config(tracer->ds.context, &tracer->trace.ds, ds_bts); ds_resume_bts(tracer); return tracer; out_put_tracer: put_tracer(task); out_unlock: spin_unlock_irqrestore(&ds_lock, irq); ds_put_context(tracer->ds.context); out_tracer: kfree(tracer); out: return ERR_PTR(error); } struct pebs_tracer *ds_request_pebs(struct task_struct *task, void *base, size_t size, pebs_ovfl_callback_t ovfl, size_t th, unsigned int flags) { struct pebs_tracer *tracer; unsigned long irq; int error; /* buffer overflow notification is not yet implemented */ error = -EOPNOTSUPP; if (ovfl) goto out; error = -ENOMEM; tracer = kzalloc(sizeof(*tracer), GFP_KERNEL); if (!tracer) goto out; tracer->ovfl = ovfl; error = ds_request(&tracer->ds, &tracer->trace.ds, ds_pebs, task, base, size, th, flags); if (error < 0) goto out_tracer; spin_lock_irqsave(&ds_lock, irq); error = -EPERM; if (!check_tracer(task)) goto out_unlock; get_tracer(task); error = -EPERM; if (tracer->ds.context->pebs_master) goto out_put_tracer; tracer->ds.context->pebs_master = tracer; spin_unlock_irqrestore(&ds_lock, irq); ds_write_config(tracer->ds.context, &tracer->trace.ds, ds_bts); ds_resume_pebs(tracer); return tracer; out_put_tracer: put_tracer(task); out_unlock: spin_unlock_irqrestore(&ds_lock, irq); ds_put_context(tracer->ds.context); out_tracer: kfree(tracer); out: return ERR_PTR(error); } void ds_release_bts(struct bts_tracer *tracer) { if (!tracer) return; ds_suspend_bts(tracer); WARN_ON_ONCE(tracer->ds.context->bts_master != tracer); tracer->ds.context->bts_master = NULL; put_tracer(tracer->ds.context->task); ds_put_context(tracer->ds.context); kfree(tracer); } void ds_suspend_bts(struct bts_tracer *tracer) { struct task_struct *task; if (!tracer) return; task = tracer->ds.context->task; if (!task || (task == current)) update_debugctlmsr(get_debugctlmsr() & ~BTS_CONTROL); if (task) { task->thread.debugctlmsr &= ~BTS_CONTROL; if (!task->thread.debugctlmsr) clear_tsk_thread_flag(task, TIF_DEBUGCTLMSR); } } void ds_resume_bts(struct bts_tracer *tracer) { struct task_struct *task; unsigned long control; if (!tracer) return; task = tracer->ds.context->task; 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]; if (task) { task->thread.debugctlmsr |= control; set_tsk_thread_flag(task, TIF_DEBUGCTLMSR); } if (!task || (task == current)) update_debugctlmsr(get_debugctlmsr() | control); } void ds_release_pebs(struct pebs_tracer *tracer) { if (!tracer) return; ds_suspend_pebs(tracer); WARN_ON_ONCE(tracer->ds.context->pebs_master != tracer); tracer->ds.context->pebs_master = NULL; put_tracer(tracer->ds.context->task); ds_put_context(tracer->ds.context); kfree(tracer); } void ds_suspend_pebs(struct pebs_tracer *tracer) { } void ds_resume_pebs(struct pebs_tracer *tracer) { } 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.reset_value = *(u64 *)(tracer->ds.context->ds + (ds_cfg.sizeof_field * 8)); 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_bts, ds_index, (unsigned long)tracer->trace.ds.top); return 0; } int ds_set_pebs_reset(struct pebs_tracer *tracer, u64 value) { if (!tracer) return -EINVAL; *(u64 *)(tracer->ds.context->ds + (ds_cfg.sizeof_field * 8)) = 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), .sizeof_field = sizeof(long), .sizeof_rec[ds_bts] = sizeof(long) * 3, #ifdef __i386__ .sizeof_rec[ds_pebs] = sizeof(long) * 10, #else .sizeof_rec[ds_pebs] = sizeof(long) * 18, #endif }; static const struct ds_configuration ds_cfg_pentium_m = { .name = "pentium m", .ctl[dsf_bts] = (1 << 6) | (1 << 7), .sizeof_field = sizeof(long), .sizeof_rec[ds_bts] = sizeof(long) * 3, #ifdef __i386__ .sizeof_rec[ds_pebs] = sizeof(long) * 10, #else .sizeof_rec[ds_pebs] = sizeof(long) * 18, #endif }; static const struct ds_configuration ds_cfg_core2 = { .name = "core 2", .ctl[dsf_bts] = (1 << 6) | (1 << 7), .ctl[dsf_bts_kernel] = (1 << 9), .ctl[dsf_bts_user] = (1 << 10), .sizeof_field = 8, .sizeof_rec[ds_bts] = 8 * 3, .sizeof_rec[ds_pebs] = 8 * 18, }; static void ds_configure(const struct ds_configuration *cfg) { memset(&ds_cfg, 0, sizeof(ds_cfg)); ds_cfg = *cfg; printk(KERN_INFO "[ds] using %s configuration\n", ds_cfg.name); if (!cpu_has_bts) { ds_cfg.ctl[dsf_bts] = 0; printk(KERN_INFO "[ds] bts not available\n"); } if (!cpu_has_pebs) printk(KERN_INFO "[ds] pebs not available\n"); WARN_ON_ONCE(MAX_SIZEOF_DS < (12 * ds_cfg.sizeof_field)); } void __cpuinit ds_init_intel(struct cpuinfo_x86 *c) { switch (c->x86) { case 0x6: switch (c->x86_model) { case 0 ... 0xC: /* sorry, don't know about them */ break; case 0xD: case 0xE: /* Pentium M */ ds_configure(&ds_cfg_pentium_m); break; default: /* Core2, Atom, ... */ ds_configure(&ds_cfg_core2); break; } break; case 0xF: switch (c->x86_model) { case 0x0: case 0x1: case 0x2: /* Netburst */ ds_configure(&ds_cfg_netburst); break; default: /* sorry, don't know about them */ break; } break; default: /* sorry, don't know about them */ break; } } /* * 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; if (prev_ctx) { update_debugctlmsr(0); if (prev_ctx->bts_master && (prev_ctx->bts_master->trace.ds.flags & BTS_TIMESTAMPS)) { struct bts_struct ts = { .qualifier = bts_task_departs, .variant.timestamp.jiffies = jiffies_64, .variant.timestamp.pid = prev->pid }; bts_write(prev_ctx->bts_master, &ts); } } if (next_ctx) { if (next_ctx->bts_master && (next_ctx->bts_master->trace.ds.flags & BTS_TIMESTAMPS)) { struct bts_struct ts = { .qualifier = bts_task_arrives, .variant.timestamp.jiffies = jiffies_64, .variant.timestamp.pid = next->pid }; bts_write(next_ctx->bts_master, &ts); } wrmsrl(MSR_IA32_DS_AREA, (unsigned long)next_ctx->ds); } update_debugctlmsr(next->thread.debugctlmsr); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
You can’t perform that action at this time.