sys/amd64/include/vmm.h

   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 #ifndef _VMM_H_
  30 #define _VMM_H_
  31
  32 #ifdef _KERNEL
  33
  34 #define VM_MAX_NAMELEN  32
  35
  36 struct vm;
  37 struct vm_memory_segment;
  38 struct seg_desc;
  39 struct vm_exit;
  40 struct vm_run;
  41 struct vhpet;
  42 struct vioapic;
  43 struct vlapic;
  44 struct vmspace;
  45 struct vm_object;
  46 struct pmap;
  47
  48 enum x2apic_state;
  49
  50 typedef int     (*vmm_init_func_t)(void);
  51 typedef int     (*vmm_cleanup_func_t)(void);
  52 typedef void    (*vmm_resume_func_t)(void);
  53 typedef void *  (*vmi_init_func_t)(struct vm *vm, struct pmap *pmap);
  54 typedef int     (*vmi_run_func_t)(void *vmi, int vcpu, register_t rip,
  55                                   struct pmap *pmap);
  56 typedef void    (*vmi_cleanup_func_t)(void *vmi);
  57 typedef int     (*vmi_get_register_t)(void *vmi, int vcpu, int num,
  58                                       uint64_t *retval);
  59 typedef int     (*vmi_set_register_t)(void *vmi, int vcpu, int num,
  60                                       uint64_t val);
  61 typedef int     (*vmi_get_desc_t)(void *vmi, int vcpu, int num,
  62                                   struct seg_desc *desc);
  63 typedef int     (*vmi_set_desc_t)(void *vmi, int vcpu, int num,
  64                                   struct seg_desc *desc);
  65 typedef int     (*vmi_inject_event_t)(void *vmi, int vcpu,
  66                                       int type, int vector,
  67                                       uint32_t code, int code_valid);
  68 typedef int     (*vmi_get_cap_t)(void *vmi, int vcpu, int num, int *retval);
  69 typedef int     (*vmi_set_cap_t)(void *vmi, int vcpu, int num, int val);
  70 typedef struct vmspace * (*vmi_vmspace_alloc)(vm_offset_t min, vm_offset_t max);
  71 typedef void    (*vmi_vmspace_free)(struct vmspace *vmspace);
  72 typedef struct vlapic * (*vmi_vlapic_init)(void *vmi, int vcpu);
  73 typedef void    (*vmi_vlapic_cleanup)(void *vmi, struct vlapic *vlapic);
  74
  75 struct vmm_ops {
  76         vmm_init_func_t         init;           /* module wide initialization */
  77         vmm_cleanup_func_t      cleanup;
  78         vmm_resume_func_t       resume;
  79
  80         vmi_init_func_t         vminit;         /* vm-specific initialization */
  81         vmi_run_func_t          vmrun;
  82         vmi_cleanup_func_t      vmcleanup;
  83         vmi_get_register_t      vmgetreg;
  84         vmi_set_register_t      vmsetreg;
  85         vmi_get_desc_t          vmgetdesc;
  86         vmi_set_desc_t          vmsetdesc;
  87         vmi_inject_event_t      vminject;
  88         vmi_get_cap_t           vmgetcap;
  89         vmi_set_cap_t           vmsetcap;
  90         vmi_vmspace_alloc       vmspace_alloc;
  91         vmi_vmspace_free        vmspace_free;
  92         vmi_vlapic_init         vlapic_init;
  93         vmi_vlapic_cleanup      vlapic_cleanup;
  94 };
  95
  96 extern struct vmm_ops vmm_ops_intel;
  97 extern struct vmm_ops vmm_ops_amd;
  98
  99 int vm_create(const char *name, struct vm **retvm);
 100 void vm_destroy(struct vm *vm);
 101 const char *vm_name(struct vm *vm);
 102 int vm_malloc(struct vm *vm, vm_paddr_t gpa, size_t len);
 103 int vm_map_mmio(struct vm *vm, vm_paddr_t gpa, size_t len, vm_paddr_t hpa);
 104 int vm_unmap_mmio(struct vm *vm, vm_paddr_t gpa, size_t len);
 105 void *vm_gpa_hold(struct vm *, vm_paddr_t gpa, size_t len, int prot,
 106                   void **cookie);
 107 void vm_gpa_release(void *cookie);
 108 int vm_gpabase2memseg(struct vm *vm, vm_paddr_t gpabase,
 109               struct vm_memory_segment *seg);
 110 int vm_get_memobj(struct vm *vm, vm_paddr_t gpa, size_t len,
 111                   vm_offset_t *offset, struct vm_object **object);
 112 boolean_t vm_mem_allocated(struct vm *vm, vm_paddr_t gpa);
 113 int vm_get_register(struct vm *vm, int vcpu, int reg, uint64_t *retval);
 114 int vm_set_register(struct vm *vm, int vcpu, int reg, uint64_t val);
 115 int vm_get_seg_desc(struct vm *vm, int vcpu, int reg,
 116                     struct seg_desc *ret_desc);
 117 int vm_set_seg_desc(struct vm *vm, int vcpu, int reg,
 118                     struct seg_desc *desc);
 119 int vm_run(struct vm *vm, struct vm_run *vmrun);
 120 int vm_inject_event(struct vm *vm, int vcpu, int type,
 121                     int vector, uint32_t error_code, int error_code_valid);
 122 int vm_inject_nmi(struct vm *vm, int vcpu);
 123 int vm_nmi_pending(struct vm *vm, int vcpuid);
 124 void vm_nmi_clear(struct vm *vm, int vcpuid);
 125 uint64_t *vm_guest_msrs(struct vm *vm, int cpu);
 126 struct vlapic *vm_lapic(struct vm *vm, int cpu);
 127 struct vioapic *vm_ioapic(struct vm *vm);
 128 struct vhpet *vm_hpet(struct vm *vm);
 129 int vm_get_capability(struct vm *vm, int vcpu, int type, int *val);
 130 int vm_set_capability(struct vm *vm, int vcpu, int type, int val);
 131 int vm_get_x2apic_state(struct vm *vm, int vcpu, enum x2apic_state *state);
 132 int vm_set_x2apic_state(struct vm *vm, int vcpu, enum x2apic_state state);
 133 int vm_apicid2vcpuid(struct vm *vm, int apicid);
 134 void vm_activate_cpu(struct vm *vm, int vcpu);
 135 cpuset_t vm_active_cpus(struct vm *vm);
 136 struct vm_exit *vm_exitinfo(struct vm *vm, int vcpuid);
 137
 138 /*
 139  * Return 1 if device indicated by bus/slot/func is supposed to be a
 140  * pci passthrough device.
 141  *
 142  * Return 0 otherwise.
 143  */
 144 int vmm_is_pptdev(int bus, int slot, int func);
 145
 146 void *vm_iommu_domain(struct vm *vm);
 147
 148 enum vcpu_state {
 149         VCPU_IDLE,
 150         VCPU_FROZEN,
 151         VCPU_RUNNING,
 152         VCPU_SLEEPING,
 153 };
 154
 155 int vcpu_set_state(struct vm *vm, int vcpu, enum vcpu_state state,
 156     bool from_idle);
 157 enum vcpu_state vcpu_get_state(struct vm *vm, int vcpu, int *hostcpu);
 158
 159 static int __inline
 160 vcpu_is_running(struct vm *vm, int vcpu, int *hostcpu)
 161 {
 162         return (vcpu_get_state(vm, vcpu, hostcpu) == VCPU_RUNNING);
 163 }
 164
 165 void *vcpu_stats(struct vm *vm, int vcpu);
 166 void vcpu_notify_event(struct vm *vm, int vcpuid, bool lapic_intr);
 167 struct vmspace *vm_get_vmspace(struct vm *vm);
 168 int vm_assign_pptdev(struct vm *vm, int bus, int slot, int func);
 169 int vm_unassign_pptdev(struct vm *vm, int bus, int slot, int func);
 170 #endif  /* KERNEL */
 171
 172 #include <machine/vmm_instruction_emul.h>
 173
 174 #define VM_MAXCPU       16                      /* maximum virtual cpus */
 175
 176 /*
 177  * Identifiers for events that can be injected into the VM
 178  */
 179 enum vm_event_type {
 180         VM_EVENT_NONE,
 181         VM_HW_INTR,
 182         VM_NMI,
 183         VM_HW_EXCEPTION,
 184         VM_SW_INTR,
 185         VM_PRIV_SW_EXCEPTION,
 186         VM_SW_EXCEPTION,
 187         VM_EVENT_MAX
 188 };
 189
 190 /*
 191  * Identifiers for architecturally defined registers.
 192  */
 193 enum vm_reg_name {
 194         VM_REG_GUEST_RAX,
 195         VM_REG_GUEST_RBX,
 196         VM_REG_GUEST_RCX,
 197         VM_REG_GUEST_RDX,
 198         VM_REG_GUEST_RSI,
 199         VM_REG_GUEST_RDI,
 200         VM_REG_GUEST_RBP,
 201         VM_REG_GUEST_R8,
 202         VM_REG_GUEST_R9,
 203         VM_REG_GUEST_R10,
 204         VM_REG_GUEST_R11,
 205         VM_REG_GUEST_R12,
 206         VM_REG_GUEST_R13,
 207         VM_REG_GUEST_R14,
 208         VM_REG_GUEST_R15,
 209         VM_REG_GUEST_CR0,
 210         VM_REG_GUEST_CR3,
 211         VM_REG_GUEST_CR4,
 212         VM_REG_GUEST_DR7,
 213         VM_REG_GUEST_RSP,
 214         VM_REG_GUEST_RIP,
 215         VM_REG_GUEST_RFLAGS,
 216         VM_REG_GUEST_ES,
 217         VM_REG_GUEST_CS,
 218         VM_REG_GUEST_SS,
 219         VM_REG_GUEST_DS,
 220         VM_REG_GUEST_FS,
 221         VM_REG_GUEST_GS,
 222         VM_REG_GUEST_LDTR,
 223         VM_REG_GUEST_TR,
 224         VM_REG_GUEST_IDTR,
 225         VM_REG_GUEST_GDTR,
 226         VM_REG_GUEST_EFER,
 227         VM_REG_LAST
 228 };
 229
 230 /*
 231  * Identifiers for optional vmm capabilities
 232  */
 233 enum vm_cap_type {
 234         VM_CAP_HALT_EXIT,
 235         VM_CAP_MTRAP_EXIT,
 236         VM_CAP_PAUSE_EXIT,
 237         VM_CAP_UNRESTRICTED_GUEST,
 238         VM_CAP_ENABLE_INVPCID,
 239         VM_CAP_MAX
 240 };
 241
 242 enum x2apic_state {
 243         X2APIC_ENABLED,
 244         X2APIC_AVAILABLE,
 245         X2APIC_DISABLED,
 246         X2APIC_STATE_LAST
 247 };
 248
 249 /*
 250  * The 'access' field has the format specified in Table 21-2 of the Intel
 251  * Architecture Manual vol 3b.
 252  *
 253  * XXX The contents of the 'access' field are architecturally defined except
 254  * bit 16 - Segment Unusable.
 255  */
 256 struct seg_desc {
 257         uint64_t        base;
 258         uint32_t        limit;
 259         uint32_t        access;
 260 };
 261
 262 enum vm_exitcode {
 263         VM_EXITCODE_INOUT,
 264         VM_EXITCODE_VMX,
 265         VM_EXITCODE_BOGUS,
 266         VM_EXITCODE_RDMSR,
 267         VM_EXITCODE_WRMSR,
 268         VM_EXITCODE_HLT,
 269         VM_EXITCODE_MTRAP,
 270         VM_EXITCODE_PAUSE,
 271         VM_EXITCODE_PAGING,
 272         VM_EXITCODE_INST_EMUL,
 273         VM_EXITCODE_SPINUP_AP,
 274         VM_EXITCODE_SPINDOWN_CPU,
 275         VM_EXITCODE_MAX
 276 };
 277
 278 struct vm_exit {
 279         enum vm_exitcode        exitcode;
 280         int                     inst_length;    /* 0 means unknown */
 281         uint64_t                rip;
 282         union {
 283                 struct {
 284                         uint16_t        bytes:3;        /* 1 or 2 or 4 */
 285                         uint16_t        in:1;           /* out is 0, in is 1 */
 286                         uint16_t        string:1;
 287                         uint16_t        rep:1;
 288                         uint16_t        port;
 289                         uint32_t        eax;            /* valid for out */
 290                 } inout;
 291                 struct {
 292                         uint64_t        gpa;
 293                         int             fault_type;
 294                 } paging;
 295                 struct {
 296                         uint64_t        gpa;
 297                         uint64_t        gla;
 298                         uint64_t        cr3;
 299                         struct vie      vie;
 300                 } inst_emul;
 301                 /*
 302                  * VMX specific payload. Used when there is no "better"
 303                  * exitcode to represent the VM-exit.
 304                  */
 305                 struct {
 306                         int             status;         /* vmx inst status */
 307                         /*
 308                          * 'exit_reason' and 'exit_qualification' are valid
 309                          * only if 'status' is zero.
 310                          */
 311                         uint32_t        exit_reason;
 312                         uint64_t        exit_qualification;
 313                         /*
 314                          * 'inst_error' and 'inst_type' are valid
 315                          * only if 'status' is non-zero.
 316                          */
 317                         int             inst_type;
 318                         int             inst_error;
 319                 } vmx;
 320                 struct {
 321                         uint32_t        code;           /* ecx value */
 322                         uint64_t        wval;
 323                 } msr;
 324                 struct {
 325                         int             vcpu;
 326                         uint64_t        rip;
 327                 } spinup_ap;
 328                 struct {
 329                         uint64_t        rflags;
 330                 } hlt;
 331         } u;
 332 };
 333
 334 #endif  /* _VMM_H_ */