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_exception;
  38 struct vm_memory_segment;
  39 struct seg_desc;
  40 struct vm_exit;
  41 struct vm_run;
  42 struct vhpet;
  43 struct vioapic;
  44 struct vlapic;
  45 struct vmspace;
  46 struct vm_object;
  47 struct pmap;
  48
  49 enum x2apic_state;
  50
  51 typedef int     (*vmm_init_func_t)(int ipinum);
  52 typedef int     (*vmm_cleanup_func_t)(void);
  53 typedef void    (*vmm_resume_func_t)(void);
  54 typedef void *  (*vmi_init_func_t)(struct vm *vm, struct pmap *pmap);
  55 typedef int     (*vmi_run_func_t)(void *vmi, int vcpu, register_t rip,
  56                                   struct pmap *pmap, void *rendezvous_cookie);
  57 typedef void    (*vmi_cleanup_func_t)(void *vmi);
  58 typedef int     (*vmi_get_register_t)(void *vmi, int vcpu, int num,
  59                                       uint64_t *retval);
  60 typedef int     (*vmi_set_register_t)(void *vmi, int vcpu, int num,
  61                                       uint64_t val);
  62 typedef int     (*vmi_get_desc_t)(void *vmi, int vcpu, int num,
  63                                   struct seg_desc *desc);
  64 typedef int     (*vmi_set_desc_t)(void *vmi, int vcpu, int num,
  65                                   struct seg_desc *desc);
  66 typedef int     (*vmi_get_cap_t)(void *vmi, int vcpu, int num, int *retval);
  67 typedef int     (*vmi_set_cap_t)(void *vmi, int vcpu, int num, int val);
  68 typedef struct vmspace * (*vmi_vmspace_alloc)(vm_offset_t min, vm_offset_t max);
  69 typedef void    (*vmi_vmspace_free)(struct vmspace *vmspace);
  70 typedef struct vlapic * (*vmi_vlapic_init)(void *vmi, int vcpu);
  71 typedef void    (*vmi_vlapic_cleanup)(void *vmi, struct vlapic *vlapic);
  72
  73 struct vmm_ops {
  74         vmm_init_func_t         init;           /* module wide initialization */
  75         vmm_cleanup_func_t      cleanup;
  76         vmm_resume_func_t       resume;
  77
  78         vmi_init_func_t         vminit;         /* vm-specific initialization */
  79         vmi_run_func_t          vmrun;
  80         vmi_cleanup_func_t      vmcleanup;
  81         vmi_get_register_t      vmgetreg;
  82         vmi_set_register_t      vmsetreg;
  83         vmi_get_desc_t          vmgetdesc;
  84         vmi_set_desc_t          vmsetdesc;
  85         vmi_get_cap_t           vmgetcap;
  86         vmi_set_cap_t           vmsetcap;
  87         vmi_vmspace_alloc       vmspace_alloc;
  88         vmi_vmspace_free        vmspace_free;
  89         vmi_vlapic_init         vlapic_init;
  90         vmi_vlapic_cleanup      vlapic_cleanup;
  91 };
  92
  93 extern struct vmm_ops vmm_ops_intel;
  94 extern struct vmm_ops vmm_ops_amd;
  95
  96 int vm_create(const char *name, struct vm **retvm);
  97 void vm_destroy(struct vm *vm);
  98 const char *vm_name(struct vm *vm);
  99 int vm_malloc(struct vm *vm, vm_paddr_t gpa, size_t len);
 100 int vm_map_mmio(struct vm *vm, vm_paddr_t gpa, size_t len, vm_paddr_t hpa);
 101 int vm_unmap_mmio(struct vm *vm, vm_paddr_t gpa, size_t len);
 102 void *vm_gpa_hold(struct vm *, vm_paddr_t gpa, size_t len, int prot,
 103                   void **cookie);
 104 void vm_gpa_release(void *cookie);
 105 int vm_gpabase2memseg(struct vm *vm, vm_paddr_t gpabase,
 106               struct vm_memory_segment *seg);
 107 int vm_get_memobj(struct vm *vm, vm_paddr_t gpa, size_t len,
 108                   vm_offset_t *offset, struct vm_object **object);
 109 boolean_t vm_mem_allocated(struct vm *vm, vm_paddr_t gpa);
 110 int vm_get_register(struct vm *vm, int vcpu, int reg, uint64_t *retval);
 111 int vm_set_register(struct vm *vm, int vcpu, int reg, uint64_t val);
 112 int vm_get_seg_desc(struct vm *vm, int vcpu, int reg,
 113                     struct seg_desc *ret_desc);
 114 int vm_set_seg_desc(struct vm *vm, int vcpu, int reg,
 115                     struct seg_desc *desc);
 116 int vm_run(struct vm *vm, struct vm_run *vmrun);
 117 int vm_inject_nmi(struct vm *vm, int vcpu);
 118 int vm_nmi_pending(struct vm *vm, int vcpuid);
 119 void vm_nmi_clear(struct vm *vm, int vcpuid);
 120 uint64_t *vm_guest_msrs(struct vm *vm, int cpu);
 121 struct vlapic *vm_lapic(struct vm *vm, int cpu);
 122 struct vioapic *vm_ioapic(struct vm *vm);
 123 struct vhpet *vm_hpet(struct vm *vm);
 124 int vm_get_capability(struct vm *vm, int vcpu, int type, int *val);
 125 int vm_set_capability(struct vm *vm, int vcpu, int type, int val);
 126 int vm_get_x2apic_state(struct vm *vm, int vcpu, enum x2apic_state *state);
 127 int vm_set_x2apic_state(struct vm *vm, int vcpu, enum x2apic_state state);
 128 int vm_apicid2vcpuid(struct vm *vm, int apicid);
 129 void vm_activate_cpu(struct vm *vm, int vcpu);
 130 cpuset_t vm_active_cpus(struct vm *vm);
 131 struct vm_exit *vm_exitinfo(struct vm *vm, int vcpuid);
 132
 133 /*
 134  * Rendezvous all vcpus specified in 'dest' and execute 'func(arg)'.
 135  * The rendezvous 'func(arg)' is not allowed to do anything that will
 136  * cause the thread to be put to sleep.
 137  *
 138  * If the rendezvous is being initiated from a vcpu context then the
 139  * 'vcpuid' must refer to that vcpu, otherwise it should be set to -1.
 140  *
 141  * The caller cannot hold any locks when initiating the rendezvous.
 142  *
 143  * The implementation of this API may cause vcpus other than those specified
 144  * by 'dest' to be stalled. The caller should not rely on any vcpus making
 145  * forward progress when the rendezvous is in progress.
 146  */
 147 typedef void (*vm_rendezvous_func_t)(struct vm *vm, int vcpuid, void *arg);
 148 void vm_smp_rendezvous(struct vm *vm, int vcpuid, cpuset_t dest,
 149     vm_rendezvous_func_t func, void *arg);
 150
 151 static __inline int
 152 vcpu_rendezvous_pending(void *rendezvous_cookie)
 153 {
 154
 155         return (*(uintptr_t *)rendezvous_cookie != 0);
 156 }
 157
 158 /*
 159  * Return 1 if device indicated by bus/slot/func is supposed to be a
 160  * pci passthrough device.
 161  *
 162  * Return 0 otherwise.
 163  */
 164 int vmm_is_pptdev(int bus, int slot, int func);
 165
 166 void *vm_iommu_domain(struct vm *vm);
 167
 168 enum vcpu_state {
 169         VCPU_IDLE,
 170         VCPU_FROZEN,
 171         VCPU_RUNNING,
 172         VCPU_SLEEPING,
 173 };
 174
 175 int vcpu_set_state(struct vm *vm, int vcpu, enum vcpu_state state,
 176     bool from_idle);
 177 enum vcpu_state vcpu_get_state(struct vm *vm, int vcpu, int *hostcpu);
 178
 179 static int __inline
 180 vcpu_is_running(struct vm *vm, int vcpu, int *hostcpu)
 181 {
 182         return (vcpu_get_state(vm, vcpu, hostcpu) == VCPU_RUNNING);
 183 }
 184
 185 void *vcpu_stats(struct vm *vm, int vcpu);
 186 void vcpu_notify_event(struct vm *vm, int vcpuid, bool lapic_intr);
 187 struct vmspace *vm_get_vmspace(struct vm *vm);
 188 int vm_assign_pptdev(struct vm *vm, int bus, int slot, int func);
 189 int vm_unassign_pptdev(struct vm *vm, int bus, int slot, int func);
 190
 191 /*
 192  * Inject exception 'vme' into the guest vcpu. This function returns 0 on
 193  * success and non-zero on failure.
 194  *
 195  * Wrapper functions like 'vm_inject_gp()' should be preferred to calling
 196  * this function directly because they enforce the trap-like or fault-like
 197  * behavior of an exception.
 198  *
 199  * This function should only be called in the context of the thread that is
 200  * executing this vcpu.
 201  */
 202 int vm_inject_exception(struct vm *vm, int vcpuid, struct vm_exception *vme);
 203
 204 /*
 205  * Returns 0 if there is no exception pending for this vcpu. Returns 1 if an
 206  * exception is pending and also updates 'vme'. The pending exception is
 207  * cleared when this function returns.
 208  *
 209  * This function should only be called in the context of the thread that is
 210  * executing this vcpu.
 211  */
 212 int vm_exception_pending(struct vm *vm, int vcpuid, struct vm_exception *vme);
 213
 214 void vm_inject_gp(struct vm *vm, int vcpuid); /* general protection fault */
 215 void vm_inject_ud(struct vm *vm, int vcpuid); /* undefined instruction fault */
 216
 217 #endif  /* KERNEL */
 218
 219 #include <machine/vmm_instruction_emul.h>
 220
 221 #define VM_MAXCPU       16                      /* maximum virtual cpus */
 222
 223 /*
 224  * Identifiers for architecturally defined registers.
 225  */
 226 enum vm_reg_name {
 227         VM_REG_GUEST_RAX,
 228         VM_REG_GUEST_RBX,
 229         VM_REG_GUEST_RCX,
 230         VM_REG_GUEST_RDX,
 231         VM_REG_GUEST_RSI,
 232         VM_REG_GUEST_RDI,
 233         VM_REG_GUEST_RBP,
 234         VM_REG_GUEST_R8,
 235         VM_REG_GUEST_R9,
 236         VM_REG_GUEST_R10,
 237         VM_REG_GUEST_R11,
 238         VM_REG_GUEST_R12,
 239         VM_REG_GUEST_R13,
 240         VM_REG_GUEST_R14,
 241         VM_REG_GUEST_R15,
 242         VM_REG_GUEST_CR0,
 243         VM_REG_GUEST_CR3,
 244         VM_REG_GUEST_CR4,
 245         VM_REG_GUEST_DR7,
 246         VM_REG_GUEST_RSP,
 247         VM_REG_GUEST_RIP,
 248         VM_REG_GUEST_RFLAGS,
 249         VM_REG_GUEST_ES,
 250         VM_REG_GUEST_CS,
 251         VM_REG_GUEST_SS,
 252         VM_REG_GUEST_DS,
 253         VM_REG_GUEST_FS,
 254         VM_REG_GUEST_GS,
 255         VM_REG_GUEST_LDTR,
 256         VM_REG_GUEST_TR,
 257         VM_REG_GUEST_IDTR,
 258         VM_REG_GUEST_GDTR,
 259         VM_REG_GUEST_EFER,
 260         VM_REG_LAST
 261 };
 262
 263 /*
 264  * Identifiers for optional vmm capabilities
 265  */
 266 enum vm_cap_type {
 267         VM_CAP_HALT_EXIT,
 268         VM_CAP_MTRAP_EXIT,
 269         VM_CAP_PAUSE_EXIT,
 270         VM_CAP_UNRESTRICTED_GUEST,
 271         VM_CAP_ENABLE_INVPCID,
 272         VM_CAP_MAX
 273 };
 274
 275 enum x2apic_state {
 276         X2APIC_DISABLED,
 277         X2APIC_ENABLED,
 278         X2APIC_STATE_LAST
 279 };
 280
 281 /*
 282  * The 'access' field has the format specified in Table 21-2 of the Intel
 283  * Architecture Manual vol 3b.
 284  *
 285  * XXX The contents of the 'access' field are architecturally defined except
 286  * bit 16 - Segment Unusable.
 287  */
 288 struct seg_desc {
 289         uint64_t        base;
 290         uint32_t        limit;
 291         uint32_t        access;
 292 };
 293
 294 enum vm_exitcode {
 295         VM_EXITCODE_INOUT,
 296         VM_EXITCODE_VMX,
 297         VM_EXITCODE_BOGUS,
 298         VM_EXITCODE_RDMSR,
 299         VM_EXITCODE_WRMSR,
 300         VM_EXITCODE_HLT,
 301         VM_EXITCODE_MTRAP,
 302         VM_EXITCODE_PAUSE,
 303         VM_EXITCODE_PAGING,
 304         VM_EXITCODE_INST_EMUL,
 305         VM_EXITCODE_SPINUP_AP,
 306         VM_EXITCODE_SPINDOWN_CPU,
 307         VM_EXITCODE_RENDEZVOUS,
 308         VM_EXITCODE_IOAPIC_EOI,
 309         VM_EXITCODE_MAX
 310 };
 311
 312 struct vm_exit {
 313         enum vm_exitcode        exitcode;
 314         int                     inst_length;    /* 0 means unknown */
 315         uint64_t                rip;
 316         union {
 317                 struct {
 318                         uint16_t        bytes:3;        /* 1 or 2 or 4 */
 319                         uint16_t        in:1;           /* out is 0, in is 1 */
 320                         uint16_t        string:1;
 321                         uint16_t        rep:1;
 322                         uint16_t        port;
 323                         uint32_t        eax;            /* valid for out */
 324                 } inout;
 325                 struct {
 326                         uint64_t        gpa;
 327                         int             fault_type;
 328                 } paging;
 329                 struct {
 330                         uint64_t        gpa;
 331                         uint64_t        gla;
 332                         uint64_t        cr3;
 333                         enum vie_cpu_mode cpu_mode;
 334                         enum vie_paging_mode paging_mode;
 335                         struct vie      vie;
 336                 } inst_emul;
 337                 /*
 338                  * VMX specific payload. Used when there is no "better"
 339                  * exitcode to represent the VM-exit.
 340                  */
 341                 struct {
 342                         int             status;         /* vmx inst status */
 343                         /*
 344                          * 'exit_reason' and 'exit_qualification' are valid
 345                          * only if 'status' is zero.
 346                          */
 347                         uint32_t        exit_reason;
 348                         uint64_t        exit_qualification;
 349                         /*
 350                          * 'inst_error' and 'inst_type' are valid
 351                          * only if 'status' is non-zero.
 352                          */
 353                         int             inst_type;
 354                         int             inst_error;
 355                 } vmx;
 356                 struct {
 357                         uint32_t        code;           /* ecx value */
 358                         uint64_t        wval;
 359                 } msr;
 360                 struct {
 361                         int             vcpu;
 362                         uint64_t        rip;
 363                 } spinup_ap;
 364                 struct {
 365                         uint64_t        rflags;
 366                 } hlt;
 367                 struct {
 368                         int             vector;
 369                 } ioapic_eoi;
 370         } u;
 371 };
 372
 373 #endif  /* _VMM_H_ */