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