sys/amd64/include/vmm.h

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2011 NetApp, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD$
  29  */
  30
  31 #ifndef _VMM_H_
  32 #define _VMM_H_
  33
  34 #include <x86/segments.h>
  35
  36 enum vm_suspend_how {
  37         VM_SUSPEND_NONE,
  38         VM_SUSPEND_RESET,
  39         VM_SUSPEND_POWEROFF,
  40         VM_SUSPEND_HALT,
  41         VM_SUSPEND_TRIPLEFAULT,
  42         VM_SUSPEND_LAST
  43 };
  44
  45 /*
  46  * Identifiers for architecturally defined registers.
  47  */
  48 enum vm_reg_name {
  49         VM_REG_GUEST_RAX,
  50         VM_REG_GUEST_RBX,
  51         VM_REG_GUEST_RCX,
  52         VM_REG_GUEST_RDX,
  53         VM_REG_GUEST_RSI,
  54         VM_REG_GUEST_RDI,
  55         VM_REG_GUEST_RBP,
  56         VM_REG_GUEST_R8,
  57         VM_REG_GUEST_R9,
  58         VM_REG_GUEST_R10,
  59         VM_REG_GUEST_R11,
  60         VM_REG_GUEST_R12,
  61         VM_REG_GUEST_R13,
  62         VM_REG_GUEST_R14,
  63         VM_REG_GUEST_R15,
  64         VM_REG_GUEST_CR0,
  65         VM_REG_GUEST_CR3,
  66         VM_REG_GUEST_CR4,
  67         VM_REG_GUEST_DR7,
  68         VM_REG_GUEST_RSP,
  69         VM_REG_GUEST_RIP,
  70         VM_REG_GUEST_RFLAGS,
  71         VM_REG_GUEST_ES,
  72         VM_REG_GUEST_CS,
  73         VM_REG_GUEST_SS,
  74         VM_REG_GUEST_DS,
  75         VM_REG_GUEST_FS,
  76         VM_REG_GUEST_GS,
  77         VM_REG_GUEST_LDTR,
  78         VM_REG_GUEST_TR,
  79         VM_REG_GUEST_IDTR,
  80         VM_REG_GUEST_GDTR,
  81         VM_REG_GUEST_EFER,
  82         VM_REG_GUEST_CR2,
  83         VM_REG_GUEST_PDPTE0,
  84         VM_REG_GUEST_PDPTE1,
  85         VM_REG_GUEST_PDPTE2,
  86         VM_REG_GUEST_PDPTE3,
  87         VM_REG_GUEST_INTR_SHADOW,
  88         VM_REG_GUEST_DR0,
  89         VM_REG_GUEST_DR1,
  90         VM_REG_GUEST_DR2,
  91         VM_REG_GUEST_DR3,
  92         VM_REG_GUEST_DR6,
  93         VM_REG_LAST
  94 };
  95
  96 enum x2apic_state {
  97         X2APIC_DISABLED,
  98         X2APIC_ENABLED,
  99         X2APIC_STATE_LAST
 100 };
 101
 102 #define VM_INTINFO_VECTOR(info) ((info) & 0xff)
 103 #define VM_INTINFO_DEL_ERRCODE  0x800
 104 #define VM_INTINFO_RSVD         0x7ffff000
 105 #define VM_INTINFO_VALID        0x80000000
 106 #define VM_INTINFO_TYPE         0x700
 107 #define VM_INTINFO_HWINTR       (0 << 8)
 108 #define VM_INTINFO_NMI          (2 << 8)
 109 #define VM_INTINFO_HWEXCEPTION  (3 << 8)
 110 #define VM_INTINFO_SWINTR       (4 << 8)
 111
 112 #ifdef _KERNEL
 113
 114 #define VM_MAX_NAMELEN  32
 115
 116 struct vm;
 117 struct vm_exception;
 118 struct seg_desc;
 119 struct vm_exit;
 120 struct vm_run;
 121 struct vhpet;
 122 struct vioapic;
 123 struct vlapic;
 124 struct vmspace;
 125 struct vm_object;
 126 struct vm_guest_paging;
 127 struct pmap;
 128
 129 struct vm_eventinfo {
 130         void    *rptr;          /* rendezvous cookie */
 131         int     *sptr;          /* suspend cookie */
 132         int     *iptr;          /* reqidle cookie */
 133 };
 134
 135 typedef int     (*vmm_init_func_t)(int ipinum);
 136 typedef int     (*vmm_cleanup_func_t)(void);
 137 typedef void    (*vmm_resume_func_t)(void);
 138 typedef void *  (*vmi_init_func_t)(struct vm *vm, struct pmap *pmap);
 139 typedef int     (*vmi_run_func_t)(void *vmi, int vcpu, register_t rip,
 140                     struct pmap *pmap, struct vm_eventinfo *info);
 141 typedef void    (*vmi_cleanup_func_t)(void *vmi);
 142 typedef int     (*vmi_get_register_t)(void *vmi, int vcpu, int num,
 143                                       uint64_t *retval);
 144 typedef int     (*vmi_set_register_t)(void *vmi, int vcpu, int num,
 145                                       uint64_t val);
 146 typedef int     (*vmi_get_desc_t)(void *vmi, int vcpu, int num,
 147                                   struct seg_desc *desc);
 148 typedef int     (*vmi_set_desc_t)(void *vmi, int vcpu, int num,
 149                                   struct seg_desc *desc);
 150 typedef int     (*vmi_get_cap_t)(void *vmi, int vcpu, int num, int *retval);
 151 typedef int     (*vmi_set_cap_t)(void *vmi, int vcpu, int num, int val);
 152 typedef struct vmspace * (*vmi_vmspace_alloc)(vm_offset_t min, vm_offset_t max);
 153 typedef void    (*vmi_vmspace_free)(struct vmspace *vmspace);
 154 typedef struct vlapic * (*vmi_vlapic_init)(void *vmi, int vcpu);
 155 typedef void    (*vmi_vlapic_cleanup)(void *vmi, struct vlapic *vlapic);
 156
 157 struct vmm_ops {
 158         vmm_init_func_t         init;           /* module wide initialization */
 159         vmm_cleanup_func_t      cleanup;
 160         vmm_resume_func_t       resume;
 161
 162         vmi_init_func_t         vminit;         /* vm-specific initialization */
 163         vmi_run_func_t          vmrun;
 164         vmi_cleanup_func_t      vmcleanup;
 165         vmi_get_register_t      vmgetreg;
 166         vmi_set_register_t      vmsetreg;
 167         vmi_get_desc_t          vmgetdesc;
 168         vmi_set_desc_t          vmsetdesc;
 169         vmi_get_cap_t           vmgetcap;
 170         vmi_set_cap_t           vmsetcap;
 171         vmi_vmspace_alloc       vmspace_alloc;
 172         vmi_vmspace_free        vmspace_free;
 173         vmi_vlapic_init         vlapic_init;
 174         vmi_vlapic_cleanup      vlapic_cleanup;
 175 };
 176
 177 extern struct vmm_ops vmm_ops_intel;
 178 extern struct vmm_ops vmm_ops_amd;
 179
 180 int vm_create(const char *name, struct vm **retvm);
 181 void vm_destroy(struct vm *vm);
 182 int vm_reinit(struct vm *vm);
 183 const char *vm_name(struct vm *vm);
 184
 185 /*
 186  * APIs that modify the guest memory map require all vcpus to be frozen.
 187  */
 188 int vm_mmap_memseg(struct vm *vm, vm_paddr_t gpa, int segid, vm_ooffset_t off,
 189     size_t len, int prot, int flags);
 190 int vm_alloc_memseg(struct vm *vm, int ident, size_t len, bool sysmem);
 191 void vm_free_memseg(struct vm *vm, int ident);
 192 int vm_map_mmio(struct vm *vm, vm_paddr_t gpa, size_t len, vm_paddr_t hpa);
 193 int vm_unmap_mmio(struct vm *vm, vm_paddr_t gpa, size_t len);
 194 int vm_assign_pptdev(struct vm *vm, int bus, int slot, int func);
 195 int vm_unassign_pptdev(struct vm *vm, int bus, int slot, int func);
 196
 197 /*
 198  * APIs that inspect the guest memory map require only a *single* vcpu to
 199  * be frozen. This acts like a read lock on the guest memory map since any
 200  * modification requires *all* vcpus to be frozen.
 201  */
 202 int vm_mmap_getnext(struct vm *vm, vm_paddr_t *gpa, int *segid,
 203     vm_ooffset_t *segoff, size_t *len, int *prot, int *flags);
 204 int vm_get_memseg(struct vm *vm, int ident, size_t *len, bool *sysmem,
 205     struct vm_object **objptr);
 206 void *vm_gpa_hold(struct vm *, int vcpuid, vm_paddr_t gpa, size_t len,
 207     int prot, void **cookie);
 208 void vm_gpa_release(void *cookie);
 209 bool vm_mem_allocated(struct vm *vm, int vcpuid, vm_paddr_t gpa);
 210
 211 int vm_get_register(struct vm *vm, int vcpu, int reg, uint64_t *retval);
 212 int vm_set_register(struct vm *vm, int vcpu, int reg, uint64_t val);
 213 int vm_get_seg_desc(struct vm *vm, int vcpu, int reg,
 214                     struct seg_desc *ret_desc);
 215 int vm_set_seg_desc(struct vm *vm, int vcpu, int reg,
 216                     struct seg_desc *desc);
 217 int vm_run(struct vm *vm, struct vm_run *vmrun);
 218 int vm_suspend(struct vm *vm, enum vm_suspend_how how);
 219 int vm_inject_nmi(struct vm *vm, int vcpu);
 220 int vm_nmi_pending(struct vm *vm, int vcpuid);
 221 void vm_nmi_clear(struct vm *vm, int vcpuid);
 222 int vm_inject_extint(struct vm *vm, int vcpu);
 223 int vm_extint_pending(struct vm *vm, int vcpuid);
 224 void vm_extint_clear(struct vm *vm, int vcpuid);
 225 struct vlapic *vm_lapic(struct vm *vm, int cpu);
 226 struct vioapic *vm_ioapic(struct vm *vm);
 227 struct vhpet *vm_hpet(struct vm *vm);
 228 int vm_get_capability(struct vm *vm, int vcpu, int type, int *val);
 229 int vm_set_capability(struct vm *vm, int vcpu, int type, int val);
 230 int vm_get_x2apic_state(struct vm *vm, int vcpu, enum x2apic_state *state);
 231 int vm_set_x2apic_state(struct vm *vm, int vcpu, enum x2apic_state state);
 232 int vm_apicid2vcpuid(struct vm *vm, int apicid);
 233 int vm_activate_cpu(struct vm *vm, int vcpu);
 234 struct vm_exit *vm_exitinfo(struct vm *vm, int vcpuid);
 235 void vm_exit_suspended(struct vm *vm, int vcpuid, uint64_t rip);
 236 void vm_exit_rendezvous(struct vm *vm, int vcpuid, uint64_t rip);
 237 void vm_exit_astpending(struct vm *vm, int vcpuid, uint64_t rip);
 238 void vm_exit_reqidle(struct vm *vm, int vcpuid, uint64_t rip);
 239
 240 #ifdef _SYS__CPUSET_H_
 241 /*
 242  * Rendezvous all vcpus specified in 'dest' and execute 'func(arg)'.
 243  * The rendezvous 'func(arg)' is not allowed to do anything that will
 244  * cause the thread to be put to sleep.
 245  *
 246  * If the rendezvous is being initiated from a vcpu context then the
 247  * 'vcpuid' must refer to that vcpu, otherwise it should be set to -1.
 248  *
 249  * The caller cannot hold any locks when initiating the rendezvous.
 250  *
 251  * The implementation of this API may cause vcpus other than those specified
 252  * by 'dest' to be stalled. The caller should not rely on any vcpus making
 253  * forward progress when the rendezvous is in progress.
 254  */
 255 typedef void (*vm_rendezvous_func_t)(struct vm *vm, int vcpuid, void *arg);
 256 void vm_smp_rendezvous(struct vm *vm, int vcpuid, cpuset_t dest,
 257     vm_rendezvous_func_t func, void *arg);
 258 cpuset_t vm_active_cpus(struct vm *vm);
 259 cpuset_t vm_suspended_cpus(struct vm *vm);
 260 #endif  /* _SYS__CPUSET_H_ */
 261
 262 static __inline int
 263 vcpu_rendezvous_pending(struct vm_eventinfo *info)
 264 {
 265
 266         return (*((uintptr_t *)(info->rptr)) != 0);
 267 }
 268
 269 static __inline int
 270 vcpu_suspended(struct vm_eventinfo *info)
 271 {
 272
 273         return (*info->sptr);
 274 }
 275
 276 static __inline int
 277 vcpu_reqidle(struct vm_eventinfo *info)
 278 {
 279
 280         return (*info->iptr);
 281 }
 282
 283 /*
 284  * Return 1 if device indicated by bus/slot/func is supposed to be a
 285  * pci passthrough device.
 286  *
 287  * Return 0 otherwise.
 288  */
 289 int vmm_is_pptdev(int bus, int slot, int func);
 290
 291 void *vm_iommu_domain(struct vm *vm);
 292
 293 enum vcpu_state {
 294         VCPU_IDLE,
 295         VCPU_FROZEN,
 296         VCPU_RUNNING,
 297         VCPU_SLEEPING,
 298 };
 299
 300 int vcpu_set_state(struct vm *vm, int vcpu, enum vcpu_state state,
 301     bool from_idle);
 302 enum vcpu_state vcpu_get_state(struct vm *vm, int vcpu, int *hostcpu);
 303
 304 static int __inline
 305 vcpu_is_running(struct vm *vm, int vcpu, int *hostcpu)
 306 {
 307         return (vcpu_get_state(vm, vcpu, hostcpu) == VCPU_RUNNING);
 308 }
 309
 310 #ifdef _SYS_PROC_H_
 311 static int __inline
 312 vcpu_should_yield(struct vm *vm, int vcpu)
 313 {
 314
 315         if (curthread->td_flags & (TDF_ASTPENDING | TDF_NEEDRESCHED))
 316                 return (1);
 317         else if (curthread->td_owepreempt)
 318                 return (1);
 319         else
 320                 return (0);
 321 }
 322 #endif
 323
 324 void *vcpu_stats(struct vm *vm, int vcpu);
 325 void vcpu_notify_event(struct vm *vm, int vcpuid, bool lapic_intr);
 326 struct vmspace *vm_get_vmspace(struct vm *vm);
 327 struct vatpic *vm_atpic(struct vm *vm);
 328 struct vatpit *vm_atpit(struct vm *vm);
 329 struct vpmtmr *vm_pmtmr(struct vm *vm);
 330 struct vrtc *vm_rtc(struct vm *vm);
 331
 332 /*
 333  * Inject exception 'vector' into the guest vcpu. This function returns 0 on
 334  * success and non-zero on failure.
 335  *
 336  * Wrapper functions like 'vm_inject_gp()' should be preferred to calling
 337  * this function directly because they enforce the trap-like or fault-like
 338  * behavior of an exception.
 339  *
 340  * This function should only be called in the context of the thread that is
 341  * executing this vcpu.
 342  */
 343 int vm_inject_exception(struct vm *vm, int vcpuid, int vector, int err_valid,
 344     uint32_t errcode, int restart_instruction);
 345
 346 /*
 347  * This function is called after a VM-exit that occurred during exception or
 348  * interrupt delivery through the IDT. The format of 'intinfo' is described
 349  * in Figure 15-1, "EXITINTINFO for All Intercepts", APM, Vol 2.
 350  *
 351  * If a VM-exit handler completes the event delivery successfully then it
 352  * should call vm_exit_intinfo() to extinguish the pending event. For e.g.,
 353  * if the task switch emulation is triggered via a task gate then it should
 354  * call this function with 'intinfo=0' to indicate that the external event
 355  * is not pending anymore.
 356  *
 357  * Return value is 0 on success and non-zero on failure.
 358  */
 359 int vm_exit_intinfo(struct vm *vm, int vcpuid, uint64_t intinfo);
 360
 361 /*
 362  * This function is called before every VM-entry to retrieve a pending
 363  * event that should be injected into the guest. This function combines
 364  * nested events into a double or triple fault.
 365  *
 366  * Returns 0 if there are no events that need to be injected into the guest
 367  * and non-zero otherwise.
 368  */
 369 int vm_entry_intinfo(struct vm *vm, int vcpuid, uint64_t *info);
 370
 371 int vm_get_intinfo(struct vm *vm, int vcpuid, uint64_t *info1, uint64_t *info2);
 372
 373 enum vm_reg_name vm_segment_name(int seg_encoding);
 374
 375 struct vm_copyinfo {
 376         uint64_t        gpa;
 377         size_t          len;
 378         void            *hva;
 379         void            *cookie;
 380 };
 381
 382 /*
 383  * Set up 'copyinfo[]' to copy to/from guest linear address space starting
 384  * at 'gla' and 'len' bytes long. The 'prot' should be set to PROT_READ for
 385  * a copyin or PROT_WRITE for a copyout.
 386  *
 387  * retval       is_fault        Interpretation
 388  *   0             0            Success
 389  *   0             1            An exception was injected into the guest
 390  * EFAULT         N/A           Unrecoverable error
 391  *
 392  * The 'copyinfo[]' can be passed to 'vm_copyin()' or 'vm_copyout()' only if
 393  * the return value is 0. The 'copyinfo[]' resources should be freed by calling
 394  * 'vm_copy_teardown()' after the copy is done.
 395  */
 396 int vm_copy_setup(struct vm *vm, int vcpuid, struct vm_guest_paging *paging,
 397     uint64_t gla, size_t len, int prot, struct vm_copyinfo *copyinfo,
 398     int num_copyinfo, int *is_fault);
 399 void vm_copy_teardown(struct vm *vm, int vcpuid, struct vm_copyinfo *copyinfo,
 400     int num_copyinfo);
 401 void vm_copyin(struct vm *vm, int vcpuid, struct vm_copyinfo *copyinfo,
 402     void *kaddr, size_t len);
 403 void vm_copyout(struct vm *vm, int vcpuid, const void *kaddr,
 404     struct vm_copyinfo *copyinfo, size_t len);
 405
 406 int vcpu_trace_exceptions(struct vm *vm, int vcpuid);
 407 #endif  /* KERNEL */
 408
 409 #define VM_MAXCPU       16                      /* maximum virtual cpus */
 410
 411 /*
 412  * Identifiers for optional vmm capabilities
 413  */
 414 enum vm_cap_type {
 415         VM_CAP_HALT_EXIT,
 416         VM_CAP_MTRAP_EXIT,
 417         VM_CAP_PAUSE_EXIT,
 418         VM_CAP_UNRESTRICTED_GUEST,
 419         VM_CAP_ENABLE_INVPCID,
 420         VM_CAP_MAX
 421 };
 422
 423 enum vm_intr_trigger {
 424         EDGE_TRIGGER,
 425         LEVEL_TRIGGER
 426 };
 427
 428 /*
 429  * The 'access' field has the format specified in Table 21-2 of the Intel
 430  * Architecture Manual vol 3b.
 431  *
 432  * XXX The contents of the 'access' field are architecturally defined except
 433  * bit 16 - Segment Unusable.
 434  */
 435 struct seg_desc {
 436         uint64_t        base;
 437         uint32_t        limit;
 438         uint32_t        access;
 439 };
 440 #define SEG_DESC_TYPE(access)           ((access) & 0x001f)
 441 #define SEG_DESC_DPL(access)            (((access) >> 5) & 0x3)
 442 #define SEG_DESC_PRESENT(access)        (((access) & 0x0080) ? 1 : 0)
 443 #define SEG_DESC_DEF32(access)          (((access) & 0x4000) ? 1 : 0)
 444 #define SEG_DESC_GRANULARITY(access)    (((access) & 0x8000) ? 1 : 0)
 445 #define SEG_DESC_UNUSABLE(access)       (((access) & 0x10000) ? 1 : 0)
 446
 447 enum vm_cpu_mode {
 448         CPU_MODE_REAL,
 449         CPU_MODE_PROTECTED,
 450         CPU_MODE_COMPATIBILITY,         /* IA-32E mode (CS.L = 0) */
 451         CPU_MODE_64BIT,                 /* IA-32E mode (CS.L = 1) */
 452 };
 453
 454 enum vm_paging_mode {
 455         PAGING_MODE_FLAT,
 456         PAGING_MODE_32,
 457         PAGING_MODE_PAE,
 458         PAGING_MODE_64,
 459 };
 460
 461 struct vm_guest_paging {
 462         uint64_t        cr3;
 463         int             cpl;
 464         enum vm_cpu_mode cpu_mode;
 465         enum vm_paging_mode paging_mode;
 466 };
 467
 468 /*
 469  * The data structures 'vie' and 'vie_op' are meant to be opaque to the
 470  * consumers of instruction decoding. The only reason why their contents
 471  * need to be exposed is because they are part of the 'vm_exit' structure.
 472  */
 473 struct vie_op {
 474         uint8_t         op_byte;        /* actual opcode byte */
 475         uint8_t         op_type;        /* type of operation (e.g. MOV) */
 476         uint16_t        op_flags;
 477 };
 478
 479 #define VIE_INST_SIZE   15
 480 struct vie {
 481         uint8_t         inst[VIE_INST_SIZE];    /* instruction bytes */
 482         uint8_t         num_valid;              /* size of the instruction */
 483         uint8_t         num_processed;
 484
 485         uint8_t         addrsize:4, opsize:4;   /* address and operand sizes */
 486         uint8_t         rex_w:1,                /* REX prefix */
 487                         rex_r:1,
 488                         rex_x:1,
 489                         rex_b:1,
 490                         rex_present:1,
 491                         repz_present:1,         /* REP/REPE/REPZ prefix */
 492                         repnz_present:1,        /* REPNE/REPNZ prefix */
 493                         opsize_override:1,      /* Operand size override */
 494                         addrsize_override:1,    /* Address size override */
 495                         segment_override:1;     /* Segment override */
 496
 497         uint8_t         mod:2,                  /* ModRM byte */
 498                         reg:4,
 499                         rm:4;
 500
 501         uint8_t         ss:2,                   /* SIB byte */
 502                         index:4,
 503                         base:4;
 504
 505         uint8_t         disp_bytes;
 506         uint8_t         imm_bytes;
 507
 508         uint8_t         scale;
 509         int             base_register;          /* VM_REG_GUEST_xyz */
 510         int             index_register;         /* VM_REG_GUEST_xyz */
 511         int             segment_register;       /* VM_REG_GUEST_xyz */
 512
 513         int64_t         displacement;           /* optional addr displacement */
 514         int64_t         immediate;              /* optional immediate operand */
 515
 516         uint8_t         decoded;        /* set to 1 if successfully decoded */
 517
 518         struct vie_op   op;                     /* opcode description */
 519 };
 520
 521 enum vm_exitcode {
 522         VM_EXITCODE_INOUT,
 523         VM_EXITCODE_VMX,
 524         VM_EXITCODE_BOGUS,
 525         VM_EXITCODE_RDMSR,
 526         VM_EXITCODE_WRMSR,
 527         VM_EXITCODE_HLT,
 528         VM_EXITCODE_MTRAP,
 529         VM_EXITCODE_PAUSE,
 530         VM_EXITCODE_PAGING,
 531         VM_EXITCODE_INST_EMUL,
 532         VM_EXITCODE_SPINUP_AP,
 533         VM_EXITCODE_DEPRECATED1,        /* used to be SPINDOWN_CPU */
 534         VM_EXITCODE_RENDEZVOUS,
 535         VM_EXITCODE_IOAPIC_EOI,
 536         VM_EXITCODE_SUSPENDED,
 537         VM_EXITCODE_INOUT_STR,
 538         VM_EXITCODE_TASK_SWITCH,
 539         VM_EXITCODE_MONITOR,
 540         VM_EXITCODE_MWAIT,
 541         VM_EXITCODE_SVM,
 542         VM_EXITCODE_REQIDLE,
 543         VM_EXITCODE_MAX
 544 };
 545
 546 struct vm_inout {
 547         uint16_t        bytes:3;        /* 1 or 2 or 4 */
 548         uint16_t        in:1;
 549         uint16_t        string:1;
 550         uint16_t        rep:1;
 551         uint16_t        port;
 552         uint32_t        eax;            /* valid for out */
 553 };
 554
 555 struct vm_inout_str {
 556         struct vm_inout inout;          /* must be the first element */
 557         struct vm_guest_paging paging;
 558         uint64_t        rflags;
 559         uint64_t        cr0;
 560         uint64_t        index;
 561         uint64_t        count;          /* rep=1 (%rcx), rep=0 (1) */
 562         int             addrsize;
 563         enum vm_reg_name seg_name;
 564         struct seg_desc seg_desc;
 565 };
 566
 567 enum task_switch_reason {
 568         TSR_CALL,
 569         TSR_IRET,
 570         TSR_JMP,
 571         TSR_IDT_GATE,   /* task gate in IDT */
 572 };
 573
 574 struct vm_task_switch {
 575         uint16_t        tsssel;         /* new TSS selector */
 576         int             ext;            /* task switch due to external event */
 577         uint32_t        errcode;
 578         int             errcode_valid;  /* push 'errcode' on the new stack */
 579         enum task_switch_reason reason;
 580         struct vm_guest_paging paging;
 581 };
 582
 583 struct vm_exit {
 584         enum vm_exitcode        exitcode;
 585         int                     inst_length;    /* 0 means unknown */
 586         uint64_t                rip;
 587         union {
 588                 struct vm_inout inout;
 589                 struct vm_inout_str inout_str;
 590                 struct {
 591                         uint64_t        gpa;
 592                         int             fault_type;
 593                 } paging;
 594                 struct {
 595                         uint64_t        gpa;
 596                         uint64_t        gla;
 597                         uint64_t        cs_base;
 598                         int             cs_d;           /* CS.D */
 599                         struct vm_guest_paging paging;
 600                         struct vie      vie;
 601                 } inst_emul;
 602                 /*
 603                  * VMX specific payload. Used when there is no "better"
 604                  * exitcode to represent the VM-exit.
 605                  */
 606                 struct {
 607                         int             status;         /* vmx inst status */
 608                         /*
 609                          * 'exit_reason' and 'exit_qualification' are valid
 610                          * only if 'status' is zero.
 611                          */
 612                         uint32_t        exit_reason;
 613                         uint64_t        exit_qualification;
 614                         /*
 615                          * 'inst_error' and 'inst_type' are valid
 616                          * only if 'status' is non-zero.
 617                          */
 618                         int             inst_type;
 619                         int             inst_error;
 620                 } vmx;
 621                 /*
 622                  * SVM specific payload.
 623                  */
 624                 struct {
 625                         uint64_t        exitcode;
 626                         uint64_t        exitinfo1;
 627                         uint64_t        exitinfo2;
 628                 } svm;
 629                 struct {
 630                         uint32_t        code;           /* ecx value */
 631                         uint64_t        wval;
 632                 } msr;
 633                 struct {
 634                         int             vcpu;
 635                         uint64_t        rip;
 636                 } spinup_ap;
 637                 struct {
 638                         uint64_t        rflags;
 639                 } hlt;
 640                 struct {
 641                         int             vector;
 642                 } ioapic_eoi;
 643                 struct {
 644                         enum vm_suspend_how how;
 645                 } suspended;
 646                 struct vm_task_switch task_switch;
 647         } u;
 648 };
 649
 650 /* APIs to inject faults into the guest */
 651 void vm_inject_fault(void *vm, int vcpuid, int vector, int errcode_valid,
 652     int errcode);
 653
 654 static __inline void
 655 vm_inject_ud(void *vm, int vcpuid)
 656 {
 657         vm_inject_fault(vm, vcpuid, IDT_UD, 0, 0);
 658 }
 659
 660 static __inline void
 661 vm_inject_gp(void *vm, int vcpuid)
 662 {
 663         vm_inject_fault(vm, vcpuid, IDT_GP, 1, 0);
 664 }
 665
 666 static __inline void
 667 vm_inject_ac(void *vm, int vcpuid, int errcode)
 668 {
 669         vm_inject_fault(vm, vcpuid, IDT_AC, 1, errcode);
 670 }
 671
 672 static __inline void
 673 vm_inject_ss(void *vm, int vcpuid, int errcode)
 674 {
 675         vm_inject_fault(vm, vcpuid, IDT_SS, 1, errcode);
 676 }
 677
 678 void vm_inject_pf(void *vm, int vcpuid, int error_code, uint64_t cr2);
 679
 680 int vm_restart_instruction(void *vm, int vcpuid);
 681
 682 #endif  /* _VMM_H_ */