forked from luck/tmp_suning_uos_patched
7f47d8cc03
For debugging low level code interacting with the CPU it is often useful to trace the MSR read/writes. This gives a concise summary of PMU and other operations. perf has an ad-hoc way to do this using trace_printk, but it's somewhat limited (and also now spews ugly boot messages when enabled) Instead define real trace points for all MSR accesses. This adds three new trace points: read_msr and write_msr and rdpmc. They also report if the access faulted (if *_safe is used) This allows filtering and triggering on specific MSR values, which allows various more advanced debugging techniques. All the values are well defined in the CPU documentation. The trace can be post processed with Documentation/trace/postprocess/decode_msr.py to add symbolic MSR names to the trace. I only added it to native MSR accesses in C, not paravirtualized or in entry*.S (which is not too interesting) Originally the patch kit moved the MSRs out of line. This uses an alternative approach recommended by Steven Rostedt of only moving the trace calls out of line, but open coding the access to the jump label. Signed-off-by: Andi Kleen <ak@linux.intel.com> Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org> Acked-by: Steven Rostedt <rostedt@goodmis.org> Cc: Arnaldo Carvalho de Melo <acme@redhat.com> Cc: Jiri Olsa <jolsa@redhat.com> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Mike Galbraith <efault@gmx.de> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Stephane Eranian <eranian@google.com> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: Vince Weaver <vincent.weaver@maine.edu> Link: http://lkml.kernel.org/r/1449018060-1742-3-git-send-email-andi@firstfloor.org Signed-off-by: Ingo Molnar <mingo@kernel.org>
137 lines
2.2 KiB
C
137 lines
2.2 KiB
C
#include <linux/module.h>
|
|
#include <linux/preempt.h>
|
|
#include <asm/msr.h>
|
|
#define CREATE_TRACE_POINTS
|
|
#include <asm/msr-trace.h>
|
|
|
|
struct msr *msrs_alloc(void)
|
|
{
|
|
struct msr *msrs = NULL;
|
|
|
|
msrs = alloc_percpu(struct msr);
|
|
if (!msrs) {
|
|
pr_warn("%s: error allocating msrs\n", __func__);
|
|
return NULL;
|
|
}
|
|
|
|
return msrs;
|
|
}
|
|
EXPORT_SYMBOL(msrs_alloc);
|
|
|
|
void msrs_free(struct msr *msrs)
|
|
{
|
|
free_percpu(msrs);
|
|
}
|
|
EXPORT_SYMBOL(msrs_free);
|
|
|
|
/**
|
|
* Read an MSR with error handling
|
|
*
|
|
* @msr: MSR to read
|
|
* @m: value to read into
|
|
*
|
|
* It returns read data only on success, otherwise it doesn't change the output
|
|
* argument @m.
|
|
*
|
|
*/
|
|
int msr_read(u32 msr, struct msr *m)
|
|
{
|
|
int err;
|
|
u64 val;
|
|
|
|
err = rdmsrl_safe(msr, &val);
|
|
if (!err)
|
|
m->q = val;
|
|
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* Write an MSR with error handling
|
|
*
|
|
* @msr: MSR to write
|
|
* @m: value to write
|
|
*/
|
|
int msr_write(u32 msr, struct msr *m)
|
|
{
|
|
return wrmsrl_safe(msr, m->q);
|
|
}
|
|
|
|
static inline int __flip_bit(u32 msr, u8 bit, bool set)
|
|
{
|
|
struct msr m, m1;
|
|
int err = -EINVAL;
|
|
|
|
if (bit > 63)
|
|
return err;
|
|
|
|
err = msr_read(msr, &m);
|
|
if (err)
|
|
return err;
|
|
|
|
m1 = m;
|
|
if (set)
|
|
m1.q |= BIT_64(bit);
|
|
else
|
|
m1.q &= ~BIT_64(bit);
|
|
|
|
if (m1.q == m.q)
|
|
return 0;
|
|
|
|
err = msr_write(msr, &m1);
|
|
if (err)
|
|
return err;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Set @bit in a MSR @msr.
|
|
*
|
|
* Retval:
|
|
* < 0: An error was encountered.
|
|
* = 0: Bit was already set.
|
|
* > 0: Hardware accepted the MSR write.
|
|
*/
|
|
int msr_set_bit(u32 msr, u8 bit)
|
|
{
|
|
return __flip_bit(msr, bit, true);
|
|
}
|
|
|
|
/**
|
|
* Clear @bit in a MSR @msr.
|
|
*
|
|
* Retval:
|
|
* < 0: An error was encountered.
|
|
* = 0: Bit was already cleared.
|
|
* > 0: Hardware accepted the MSR write.
|
|
*/
|
|
int msr_clear_bit(u32 msr, u8 bit)
|
|
{
|
|
return __flip_bit(msr, bit, false);
|
|
}
|
|
|
|
#ifdef CONFIG_TRACEPOINTS
|
|
void do_trace_write_msr(unsigned msr, u64 val, int failed)
|
|
{
|
|
trace_write_msr(msr, val, failed);
|
|
}
|
|
EXPORT_SYMBOL(do_trace_write_msr);
|
|
EXPORT_TRACEPOINT_SYMBOL(write_msr);
|
|
|
|
void do_trace_read_msr(unsigned msr, u64 val, int failed)
|
|
{
|
|
trace_read_msr(msr, val, failed);
|
|
}
|
|
EXPORT_SYMBOL(do_trace_read_msr);
|
|
EXPORT_TRACEPOINT_SYMBOL(read_msr);
|
|
|
|
void do_trace_rdpmc(unsigned counter, u64 val, int failed)
|
|
{
|
|
trace_rdpmc(counter, val, failed);
|
|
}
|
|
EXPORT_SYMBOL(do_trace_rdpmc);
|
|
EXPORT_TRACEPOINT_SYMBOL(rdpmc);
|
|
|
|
#endif
|