x86: Move msr accesses out of line
Subsystems (3)
PATCH 1/4 x86: Move msr accesses out of line
From: Andi Kleen <[email protected]>
To add trace points to msr accesses we need to include linux/tracepoint.h. Unfortunately this causes hellish include loops when done in asm/msr.h, which is included all over. I tried to fix several of them, but eventually gave up.
This patch moves the MSR functions out of line. A MSR access is typically 40-100 cycles or even slower, a call is a few cycles at best, so the additional function call is not really significant.
Kernel text size is neutral:
11852945 1671656 1822720 15347321 ea2e79 vmlinux-no-msr
11852969 1671656 1822720 15347345 ea2e91 vmlinux-msr
Another advantage is that we can now use the function_graph tracer to see how expensive MSR accesses are.
--- arch/x86/include/asm/msr.h | 51 ++++----------------------------------------- arch/x86/lib/msr.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+), 47 deletions(-)
arch/x86/include/asm/msr.h +4 -47
@@ -57,53 +57,10 @@ static inline unsigned long long native_read_tscp(unsigned int *aux)#define EAX_EDX_RET (val, low, high) "=A" (val)#endif -static inline unsigned long long native_read_msr (unsigned int msr) -{ -DECLARE_ARGS (val, low, high); - - asm volatile("rdmsr" : EAX_EDX_RET(val, low, high) : "c" (msr)); -return EAX_EDX_VAL (val, low, high); -} - -static inline unsigned long long native_read_msr_safe (unsigned int msr, -int *err) -{ -DECLARE_ARGS (val, low, high); - - asmvolatile ("2: rdmsr ; xor %[err],%[err]\n" -"1:\n\t" -".section .fixup,\"ax\"\n\t" -"3: mov %[fault],%[err] ; jmp 1b\n\t" -".previous\n\t" - _ASM_EXTABLE(2b, 3b) - : [err] "=r" (*err), EAX_EDX_RET(val, low, high) - : "c" (msr), [fault] "i" (-EIO)); - returnEAX_EDX_VAL (val, low, high); -} - -static inline void native_write_msr (unsigned int msr, -unsigned low,unsigned high) -{ - asmvolatile ("wrmsr" : :"c" (msr),"a" (low),"d" (high) :"memory" ); -} - -/* Can be uninlined because referenced by paravirt */ -notrace static inline int native_write_msr_safe(unsigned int msr, -unsigned low,unsigned high) -{ -int err; - asmvolatile ("2: wrmsr ; xor %[err],%[err]\n" -"1:\n\t" -".section .fixup,\"ax\"\n\t" -"3: mov %[fault],%[err] ; jmp 1b\n\t" -".previous\n\t" - _ASM_EXTABLE(2b, 3b) - : [err] "=a" (err) - : "c" (msr), "0" (low), "d" (high), - [fault] "i" (-EIO) - : "memory"); -return err; -} +extern unsigned long long native_read_msr (unsigned int msr); +extern unsigned long long native_read_msr_safe (unsigned int msr,int *err); +extern int native_write_msr_safe (unsigned int msr,unsigned low,unsigned high); +extern void native_write_msr (unsigned int msr,unsigned low,unsigned high);extern unsigned long long native_read_tsc (void );
arch/x86/lib/msr.c +52 -0
55 lines not on this page · raw message
Signature · 1 line
1.9.3
PATCH 2/4 x86: Add trace point for MSR accesses
From: Andi Kleen <[email protected]>
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 messages when enabled)
Instead define real trace points for all MSR accesses.
This adds two new trace point: read_msr and write_msr. 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.
I only added it to native MSR accesses in C, not paravirtualized or in entry*.S (which is not too interesting)
--- arch/x86/lib/msr.c | 14 ++++++++++++-- include/trace/events/msr.h | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 58 insertions(+), 2 deletions(-) create mode 100644 include/trace/events/msr.h
arch/x86/lib/msr.c +12 -2
@@ -1,6 +1,8 @@#include <linux/module.h> #include <linux/preempt.h> #include <asm/msr.h> +#define CREATE_TRACE_POINTS +#include <trace/events/msr.h> struct msr *msrs_alloc (void ) {
@@ -111,16 +113,20 @@ int msr_clear_bit(u32 msr, u8 bit)inline unsigned long long native_read_msr (unsigned int msr) { +unsigned long long lval;DECLARE_ARGS (val, low, high); asm volatile("rdmsr" : EAX_EDX_RET(val, low, high) : "c" (msr)); -return EAX_EDX_VAL (val, low, high); + lval =EAX_EDX_VAL (val, low, high); +trace_read_msr (msr, lval,0 ); +return lval; }EXPORT_SYMBOL (native_read_msr);inline unsigned long long native_read_msr_safe (unsigned int msr,int *err) { +unsigned long long lval;DECLARE_ARGS (val, low, high); asm volatile("2: rdmsr ; xor %[err],%[err]\n"
@@ -131,7 +137,9 @@ inline unsigned long long native_read_msr_safe(unsigned int msr,_ASM_EXTABLE (2b ,3b ) : [err] "=r" (*err), EAX_EDX_RET(val, low, high) : "c" (msr), [fault] "i" (-EIO)); - returnEAX_EDX_VAL (val, low, high); + lval = EAX_EDX_VAL(val, low, high); +trace_read_msr (msr, lval, *err); +return lval; }EXPORT_SYMBOL (native_read_msr_safe);
@@ -139,6 +147,7 @@ inline void native_write_msr(unsigned int msr, unsigned low, unsigned high) { asmvolatile ("wrmsr" : :"c" (msr),"a" (low),"d" (high) :"memory" ); +trace_write_msr (msr, ((u64 )high <<32 | low),0 ); }EXPORT_SYMBOL (native_write_msr);
@@ -157,6 +166,7 @@ notrace inline int native_write_msr_safe(unsigned int msr, : "c" (msr), "0" (low), "d" (high), [fault] "i" (-EIO) : "memory"); +trace_write_msr (msr, ((u64 )high <<32 | low), err);return err; }EXPORT_SYMBOL (native_write_msr_safe);
include/trace/events/msr.h new file +46 -0
46 lines not on this page · raw message
Signature · 1 line
1.9.3
PATCH 3/4 perf, x86: Remove old MSR tracing code
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Now that we have generic MSR trace points we can remove the old perf MSR trace code.
--- arch/x86/kernel/cpu/perf_event.h | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-)
arch/x86/kernel/cpu/perf_event.h +1 -11
@@ -14,17 +14,7 @@#include <linux/perf_event.h> -#if 0 -#undef wrmsrl -#define wrmsrl (msr, val) \ -do { \ - unsigned int _msr = (msr); \ - u64 _val = (val); \ - trace_printk("wrmsrl(%x, %Lx)\n", (unsigned int)(_msr), \ - (unsigned long long)(_val)); \ - native_write_msr((_msr), (u32)(_val), (u32)(_val >> 32)); \ -} while (0) -#endif +/* To enable MSR tracing please use the generic trace points. */ /* * | NHM/WSM | SNB |
Signature · 1 line
1.9.3
PATCH 4/4 Add trace decoding script to add MSR names to MSR trace
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Add the MSR names from msr-index.h to a trace including read/write_msr events. This makes the output much easier to read.
--- Documentation/trace/postprocess/decode_msr.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100755 Documentation/trace/postprocess/decode_msr.py
Documentation/trace/postprocess/decode_msr.py new file +22 -0
@@ -0,0 +1,22 @@ +#!/usr/bin/python +# add symbolic names to read_msr / write_msr events in trace +# decode_msr $kernel/arch/x86/include/uapi/asm/msr-index.h < trace + +import sys +import re + +msrs = dict() + +with open(sys.argv[1], "r") as f: + for j in f: + m = re.match(r'#define (MSR_\w+)\s+(0x[0-9a-fA-F]+)', j) + if m: + msrs[int(m.group(2), 16)] = m.group(1) + +for j in sys.stdin: + m = re.search(r'(read|write)_msr: ([0-9a-f]+)', j) + if m and int(m.group(2), 16) in msrs: + j = j.replace(" " + m.group(2), " " + msrs[int(m.group(2), 16)]) + print j, + +
Signature · 1 line
1.9.3