1 #include <linux/module.h> 2 #include <linux/preempt.h> 3 #include <linux/smp.h> 4 #include <asm/msr.h> 5 6 struct msr_info { 7 u32 msr_no; 8 struct msr reg; 9 struct msr *msrs; 10 int off; 11 int err; 12 }; 13 14 static void __rdmsr_on_cpu(void *info) 15 { 16 struct msr_info *rv = info; 17 struct msr *reg; 18 int this_cpu = raw_smp_processor_id(); 19 20 if (rv->msrs) 21 reg = &rv->msrs[this_cpu - rv->off]; 22 else 23 reg = &rv->reg; 24 25 rdmsr(rv->msr_no, reg->l, reg->h); 26 } 27 28 static void __wrmsr_on_cpu(void *info) 29 { 30 struct msr_info *rv = info; 31 struct msr *reg; 32 int this_cpu = raw_smp_processor_id(); 33 34 if (rv->msrs) 35 reg = &rv->msrs[this_cpu - rv->off]; 36 else 37 reg = &rv->reg; 38 39 wrmsr(rv->msr_no, reg->l, reg->h); 40 } 41 42 int rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h) 43 { 44 int err; 45 struct msr_info rv; 46 47 memset(&rv, 0, sizeof(rv)); 48 49 rv.msr_no = msr_no; 50 err = smp_call_function_single(cpu, __rdmsr_on_cpu, &rv, 1); 51 *l = rv.reg.l; 52 *h = rv.reg.h; 53 54 return err; 55 } 56 EXPORT_SYMBOL(rdmsr_on_cpu); 57 58 int wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h) 59 { 60 int err; 61 struct msr_info rv; 62 63 memset(&rv, 0, sizeof(rv)); 64 65 rv.msr_no = msr_no; 66 rv.reg.l = l; 67 rv.reg.h = h; 68 err = smp_call_function_single(cpu, __wrmsr_on_cpu, &rv, 1); 69 70 return err; 71 } 72 EXPORT_SYMBOL(wrmsr_on_cpu); 73 74 /* rdmsr on a bunch of CPUs 75 * 76 * @mask: which CPUs 77 * @msr_no: which MSR 78 * @msrs: array of MSR values 79 * 80 */ 81 void rdmsr_on_cpus(const cpumask_t *mask, u32 msr_no, struct msr *msrs) 82 { 83 struct msr_info rv; 84 int this_cpu; 85 86 memset(&rv, 0, sizeof(rv)); 87 88 rv.off = cpumask_first(mask); 89 rv.msrs = msrs; 90 rv.msr_no = msr_no; 91 92 preempt_disable(); 93 /* 94 * FIXME: handle the CPU we're executing on separately for now until 95 * smp_call_function_many has been fixed to not skip it. 96 */ 97 this_cpu = raw_smp_processor_id(); 98 smp_call_function_single(this_cpu, __rdmsr_on_cpu, &rv, 1); 99 100 smp_call_function_many(mask, __rdmsr_on_cpu, &rv, 1); 101 preempt_enable(); 102 } 103 EXPORT_SYMBOL(rdmsr_on_cpus); 104 105 /* 106 * wrmsr on a bunch of CPUs 107 * 108 * @mask: which CPUs 109 * @msr_no: which MSR 110 * @msrs: array of MSR values 111 * 112 */ 113 void wrmsr_on_cpus(const cpumask_t *mask, u32 msr_no, struct msr *msrs) 114 { 115 struct msr_info rv; 116 int this_cpu; 117 118 memset(&rv, 0, sizeof(rv)); 119 120 rv.off = cpumask_first(mask); 121 rv.msrs = msrs; 122 rv.msr_no = msr_no; 123 124 preempt_disable(); 125 /* 126 * FIXME: handle the CPU we're executing on separately for now until 127 * smp_call_function_many has been fixed to not skip it. 128 */ 129 this_cpu = raw_smp_processor_id(); 130 smp_call_function_single(this_cpu, __wrmsr_on_cpu, &rv, 1); 131 132 smp_call_function_many(mask, __wrmsr_on_cpu, &rv, 1); 133 preempt_enable(); 134 } 135 EXPORT_SYMBOL(wrmsr_on_cpus); 136 137 /* These "safe" variants are slower and should be used when the target MSR 138 may not actually exist. */ 139 static void __rdmsr_safe_on_cpu(void *info) 140 { 141 struct msr_info *rv = info; 142 143 rv->err = rdmsr_safe(rv->msr_no, &rv->reg.l, &rv->reg.h); 144 } 145 146 static void __wrmsr_safe_on_cpu(void *info) 147 { 148 struct msr_info *rv = info; 149 150 rv->err = wrmsr_safe(rv->msr_no, rv->reg.l, rv->reg.h); 151 } 152 153 int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h) 154 { 155 int err; 156 struct msr_info rv; 157 158 memset(&rv, 0, sizeof(rv)); 159 160 rv.msr_no = msr_no; 161 err = smp_call_function_single(cpu, __rdmsr_safe_on_cpu, &rv, 1); 162 *l = rv.reg.l; 163 *h = rv.reg.h; 164 165 return err ? err : rv.err; 166 } 167 EXPORT_SYMBOL(rdmsr_safe_on_cpu); 168 169 int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h) 170 { 171 int err; 172 struct msr_info rv; 173 174 memset(&rv, 0, sizeof(rv)); 175 176 rv.msr_no = msr_no; 177 rv.reg.l = l; 178 rv.reg.h = h; 179 err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); 180 181 return err ? err : rv.err; 182 } 183 EXPORT_SYMBOL(wrmsr_safe_on_cpu); 184