sys/amd64/vmm/vmm_msr.c

   1 /*-
   2  * Copyright (c) 2011 NetApp, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/smp.h>
  35
  36 #include <machine/specialreg.h>
  37
  38 #include <machine/vmm.h>
  39 #include "vmm_lapic.h"
  40 #include "vmm_msr.h"
  41
  42 #define VMM_MSR_F_EMULATE       0x01
  43 #define VMM_MSR_F_READONLY      0x02
  44 #define VMM_MSR_F_INVALID       0x04  /* guest_msr_valid() can override this */
  45
  46 struct vmm_msr {
  47         int             num;
  48         int             flags;
  49         uint64_t        hostval;
  50 };
  51
  52 static struct vmm_msr vmm_msr[] = {
  53         { MSR_LSTAR,    0 },
  54         { MSR_CSTAR,    0 },
  55         { MSR_STAR,     0 },
  56         { MSR_SF_MASK,  0 },
  57         { MSR_PAT,      VMM_MSR_F_EMULATE | VMM_MSR_F_INVALID },
  58         { MSR_BIOS_SIGN,VMM_MSR_F_EMULATE },
  59         { MSR_MCG_CAP,  VMM_MSR_F_EMULATE | VMM_MSR_F_READONLY },
  60 };
  61
  62 #define vmm_msr_num     (sizeof(vmm_msr) / sizeof(vmm_msr[0]))
  63 CTASSERT(VMM_MSR_NUM >= vmm_msr_num);
  64
  65 #define readonly_msr(idx)       \
  66         ((vmm_msr[(idx)].flags & VMM_MSR_F_READONLY) != 0)
  67
  68 #define emulated_msr(idx)       \
  69         ((vmm_msr[(idx)].flags & VMM_MSR_F_EMULATE) != 0)
  70
  71 #define invalid_msr(idx)        \
  72         ((vmm_msr[(idx)].flags & VMM_MSR_F_INVALID) != 0)
  73
  74 void
  75 vmm_msr_init(void)
  76 {
  77         int i;
  78
  79         for (i = 0; i < vmm_msr_num; i++) {
  80                 if (emulated_msr(i))
  81                         continue;
  82                 /*
  83                  * XXX this assumes that the value of the host msr does not
  84                  * change after we have cached it.
  85                  */
  86                 vmm_msr[i].hostval = rdmsr(vmm_msr[i].num);
  87         }
  88 }
  89
  90 void
  91 guest_msrs_init(struct vm *vm, int cpu)
  92 {
  93         int i;
  94         uint64_t *guest_msrs;
  95
  96         guest_msrs = vm_guest_msrs(vm, cpu);
  97
  98         for (i = 0; i < vmm_msr_num; i++) {
  99                 switch (vmm_msr[i].num) {
 100                 case MSR_LSTAR:
 101                 case MSR_CSTAR:
 102                 case MSR_STAR:
 103                 case MSR_SF_MASK:
 104                 case MSR_BIOS_SIGN:
 105                 case MSR_MCG_CAP:
 106                         guest_msrs[i] = 0;
 107                         break;
 108                 case MSR_PAT:
 109                         guest_msrs[i] = PAT_VALUE(0, PAT_WRITE_BACK)      |
 110                                 PAT_VALUE(1, PAT_WRITE_THROUGH)   |
 111                                 PAT_VALUE(2, PAT_UNCACHED)        |
 112                                 PAT_VALUE(3, PAT_UNCACHEABLE)     |
 113                                 PAT_VALUE(4, PAT_WRITE_BACK)      |
 114                                 PAT_VALUE(5, PAT_WRITE_THROUGH)   |
 115                                 PAT_VALUE(6, PAT_UNCACHED)        |
 116                                 PAT_VALUE(7, PAT_UNCACHEABLE);
 117                         break;
 118                 default:
 119                         panic("guest_msrs_init: missing initialization for msr "
 120                               "0x%0x", vmm_msr[i].num);
 121                 }
 122         }
 123 }
 124
 125 static int
 126 msr_num_to_idx(u_int num)
 127 {
 128         int i;
 129
 130         for (i = 0; i < vmm_msr_num; i++)
 131                 if (vmm_msr[i].num == num)
 132                         return (i);
 133
 134         return (-1);
 135 }
 136
 137 int
 138 emulate_wrmsr(struct vm *vm, int cpu, u_int num, uint64_t val)
 139 {
 140         int idx;
 141         uint64_t *guest_msrs;
 142
 143         if (lapic_msr(num))
 144                 return (lapic_wrmsr(vm, cpu, num, val));
 145
 146         idx = msr_num_to_idx(num);
 147         if (idx < 0 || invalid_msr(idx))
 148                 return (EINVAL);
 149
 150         if (!readonly_msr(idx)) {
 151                 guest_msrs = vm_guest_msrs(vm, cpu);
 152
 153                 /* Stash the value */
 154                 guest_msrs[idx] = val;
 155
 156                 /* Update processor state for non-emulated MSRs */
 157                 if (!emulated_msr(idx))
 158                         wrmsr(vmm_msr[idx].num, val);
 159         }
 160
 161         return (0);
 162 }
 163
 164 int
 165 emulate_rdmsr(struct vm *vm, int cpu, u_int num)
 166 {
 167         int error, idx;
 168         uint32_t eax, edx;
 169         uint64_t result, *guest_msrs;
 170
 171         if (lapic_msr(num)) {
 172                 error = lapic_rdmsr(vm, cpu, num, &result);
 173                 goto done;
 174         }
 175
 176         idx = msr_num_to_idx(num);
 177         if (idx < 0 || invalid_msr(idx)) {
 178                 error = EINVAL;
 179                 goto done;
 180         }
 181
 182         guest_msrs = vm_guest_msrs(vm, cpu);
 183         result = guest_msrs[idx];
 184
 185         /*
 186          * If this is not an emulated msr register make sure that the processor
 187          * state matches our cached state.
 188          */
 189         if (!emulated_msr(idx) && (rdmsr(num) != result)) {
 190                 panic("emulate_rdmsr: msr 0x%0x has inconsistent cached "
 191                       "(0x%016lx) and actual (0x%016lx) values", num,
 192                       result, rdmsr(num));
 193         }
 194
 195         error = 0;
 196
 197 done:
 198         if (error == 0) {
 199                 eax = result;
 200                 edx = result >> 32;
 201                 error = vm_set_register(vm, cpu, VM_REG_GUEST_RAX, eax);
 202                 if (error)
 203                         panic("vm_set_register(rax) error %d", error);
 204                 error = vm_set_register(vm, cpu, VM_REG_GUEST_RDX, edx);
 205                 if (error)
 206                         panic("vm_set_register(rdx) error %d", error);
 207         }
 208         return (error);
 209 }
 210
 211 void
 212 restore_guest_msrs(struct vm *vm, int cpu)
 213 {
 214         int i;
 215         uint64_t *guest_msrs;
 216
 217         guest_msrs = vm_guest_msrs(vm, cpu);
 218
 219         for (i = 0; i < vmm_msr_num; i++) {
 220                 if (emulated_msr(i))
 221                         continue;
 222                 else
 223                         wrmsr(vmm_msr[i].num, guest_msrs[i]);
 224         }
 225 }
 226
 227 void
 228 restore_host_msrs(struct vm *vm, int cpu)
 229 {
 230         int i;
 231
 232         for (i = 0; i < vmm_msr_num; i++) {
 233                 if (emulated_msr(i))
 234                         continue;
 235                 else
 236                         wrmsr(vmm_msr[i].num, vmm_msr[i].hostval);
 237         }
 238 }
 239
 240 /*
 241  * Must be called by the CPU-specific code before any guests are
 242  * created
 243  */
 244 void
 245 guest_msr_valid(int msr)
 246 {
 247         int i;
 248
 249         for (i = 0; i < vmm_msr_num; i++) {
 250                 if (vmm_msr[i].num == msr && invalid_msr(i)) {
 251                         vmm_msr[i].flags &= ~VMM_MSR_F_INVALID;
 252                 }
 253         }
 254 }