arch/x86/lib/msr.c

   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);