1b58b977eSPatrick Mooney /*-
232640292SAndy Fiddaman * SPDX-License-Identifier: BSD-2-Clause
3b58b977eSPatrick Mooney *
4b58b977eSPatrick Mooney * Copyright (c) 2011 NetApp, Inc.
5b58b977eSPatrick Mooney * All rights reserved.
6b58b977eSPatrick Mooney *
7b58b977eSPatrick Mooney * Redistribution and use in source and binary forms, with or without
8b58b977eSPatrick Mooney * modification, are permitted provided that the following conditions
9b58b977eSPatrick Mooney * are met:
10b58b977eSPatrick Mooney * 1. Redistributions of source code must retain the above copyright
11b58b977eSPatrick Mooney * notice, this list of conditions and the following disclaimer.
12b58b977eSPatrick Mooney * 2. Redistributions in binary form must reproduce the above copyright
13b58b977eSPatrick Mooney * notice, this list of conditions and the following disclaimer in the
14b58b977eSPatrick Mooney * documentation and/or other materials provided with the distribution.
15b58b977eSPatrick Mooney *
16b58b977eSPatrick Mooney * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
17b58b977eSPatrick Mooney * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18b58b977eSPatrick Mooney * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19b58b977eSPatrick Mooney * ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
20b58b977eSPatrick Mooney * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21b58b977eSPatrick Mooney * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22b58b977eSPatrick Mooney * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23b58b977eSPatrick Mooney * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24b58b977eSPatrick Mooney * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25b58b977eSPatrick Mooney * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26b58b977eSPatrick Mooney * SUCH DAMAGE.
27b58b977eSPatrick Mooney */
28b58b977eSPatrick Mooney /*
29b58b977eSPatrick Mooney * This file and its contents are supplied under the terms of the
30b58b977eSPatrick Mooney * Common Development and Distribution License ("CDDL"), version 1.0.
31b58b977eSPatrick Mooney * You may only use this file in accordance with the terms of version
32b58b977eSPatrick Mooney * 1.0 of the CDDL.
33b58b977eSPatrick Mooney *
34b58b977eSPatrick Mooney * A full copy of the text of the CDDL should have accompanied this
35b58b977eSPatrick Mooney * source. A copy of the CDDL is also available via the Internet at
36b58b977eSPatrick Mooney * http://www.illumos.org/license/CDDL.
37b58b977eSPatrick Mooney *
38b58b977eSPatrick Mooney * Copyright 2015 Pluribus Networks Inc.
39b58b977eSPatrick Mooney * Copyright 2019 Joyent, Inc.
40*4bd36be4SPatrick Mooney * Copyright 2024 Oxide Computer Company
412b948146SAndy Fiddaman * Copyright 2021 OmniOS Community Edition (OmniOSce) Association.
42b58b977eSPatrick Mooney */
43b58b977eSPatrick Mooney
44b58b977eSPatrick Mooney #ifndef _VMM_KERNEL_H_
45b58b977eSPatrick Mooney #define _VMM_KERNEL_H_
46b58b977eSPatrick Mooney
47b58b977eSPatrick Mooney #include <sys/sdt.h>
48b58b977eSPatrick Mooney #include <x86/segments.h>
490153d828SPatrick Mooney #include <sys/vmm.h>
50d515dd77SPatrick Mooney #include <sys/vmm_data.h>
51d515dd77SPatrick Mooney #include <sys/linker_set.h>
52b58b977eSPatrick Mooney
53b58b977eSPatrick Mooney SDT_PROVIDER_DECLARE(vmm);
54b58b977eSPatrick Mooney
55b58b977eSPatrick Mooney struct vm;
56b58b977eSPatrick Mooney struct vm_exception;
57b58b977eSPatrick Mooney struct seg_desc;
58b58b977eSPatrick Mooney struct vm_exit;
59e0c0d44eSPatrick Mooney struct vie;
60b58b977eSPatrick Mooney struct vm_run;
61b58b977eSPatrick Mooney struct vhpet;
62b58b977eSPatrick Mooney struct vioapic;
63b58b977eSPatrick Mooney struct vlapic;
64b58b977eSPatrick Mooney struct vmspace;
650153d828SPatrick Mooney struct vm_client;
66b58b977eSPatrick Mooney struct vm_object;
67b58b977eSPatrick Mooney struct vm_guest_paging;
68d515dd77SPatrick Mooney struct vmm_data_req;
69b58b977eSPatrick Mooney
70717646f7SJordan Paige Hendricks /* Return values for architecture-specific calculation of the TSC multiplier */
71717646f7SJordan Paige Hendricks typedef enum {
72717646f7SJordan Paige Hendricks FR_VALID, /* valid multiplier, scaling needed */
73717646f7SJordan Paige Hendricks FR_SCALING_NOT_NEEDED, /* scaling not required */
74717646f7SJordan Paige Hendricks FR_SCALING_NOT_SUPPORTED, /* scaling not supported by platform */
75717646f7SJordan Paige Hendricks FR_OUT_OF_RANGE, /* freq ratio out of supported range */
76717646f7SJordan Paige Hendricks } freqratio_res_t;
77717646f7SJordan Paige Hendricks
780153d828SPatrick Mooney typedef int (*vmm_init_func_t)(void);
79b58b977eSPatrick Mooney typedef int (*vmm_cleanup_func_t)(void);
80b58b977eSPatrick Mooney typedef void (*vmm_resume_func_t)(void);
810153d828SPatrick Mooney typedef void * (*vmi_init_func_t)(struct vm *vm);
820153d828SPatrick Mooney typedef int (*vmi_run_func_t)(void *vmi, int vcpu, uint64_t rip);
83b58b977eSPatrick Mooney typedef void (*vmi_cleanup_func_t)(void *vmi);
84b58b977eSPatrick Mooney typedef int (*vmi_get_register_t)(void *vmi, int vcpu, int num,
852699b94cSPatrick Mooney uint64_t *retval);
86b58b977eSPatrick Mooney typedef int (*vmi_set_register_t)(void *vmi, int vcpu, int num,
872699b94cSPatrick Mooney uint64_t val);
88b58b977eSPatrick Mooney typedef int (*vmi_get_desc_t)(void *vmi, int vcpu, int num,
892699b94cSPatrick Mooney struct seg_desc *desc);
90b58b977eSPatrick Mooney typedef int (*vmi_set_desc_t)(void *vmi, int vcpu, int num,
912606939dSPatrick Mooney const struct seg_desc *desc);
92b58b977eSPatrick Mooney typedef int (*vmi_get_cap_t)(void *vmi, int vcpu, int num, int *retval);
93b58b977eSPatrick Mooney typedef int (*vmi_set_cap_t)(void *vmi, int vcpu, int num, int val);
942699b94cSPatrick Mooney typedef struct vlapic *(*vmi_vlapic_init)(void *vmi, int vcpu);
95b58b977eSPatrick Mooney typedef void (*vmi_vlapic_cleanup)(void *vmi, struct vlapic *vlapic);
96b58b977eSPatrick Mooney typedef void (*vmi_savectx)(void *vmi, int vcpu);
97b58b977eSPatrick Mooney typedef void (*vmi_restorectx)(void *vmi, int vcpu);
98ad4335f7SPatrick Mooney typedef void (*vmi_pause_t)(void *vmi, int vcpu);
99b58b977eSPatrick Mooney
10054cf5b63SPatrick Mooney typedef int (*vmi_get_msr_t)(void *vmi, int vcpu, uint32_t msr,
10154cf5b63SPatrick Mooney uint64_t *valp);
10254cf5b63SPatrick Mooney typedef int (*vmi_set_msr_t)(void *vmi, int vcpu, uint32_t msr,
10354cf5b63SPatrick Mooney uint64_t val);
104717646f7SJordan Paige Hendricks typedef freqratio_res_t (*vmi_freqratio_t)(uint64_t guest_hz,
105717646f7SJordan Paige Hendricks uint64_t host_hz, uint64_t *mult);
10654cf5b63SPatrick Mooney
107b58b977eSPatrick Mooney struct vmm_ops {
108b58b977eSPatrick Mooney vmm_init_func_t init; /* module wide initialization */
109b58b977eSPatrick Mooney vmm_cleanup_func_t cleanup;
110b58b977eSPatrick Mooney vmm_resume_func_t resume;
111b58b977eSPatrick Mooney
112b58b977eSPatrick Mooney vmi_init_func_t vminit; /* vm-specific initialization */
113b58b977eSPatrick Mooney vmi_run_func_t vmrun;
114b58b977eSPatrick Mooney vmi_cleanup_func_t vmcleanup;
115b58b977eSPatrick Mooney vmi_get_register_t vmgetreg;
116b58b977eSPatrick Mooney vmi_set_register_t vmsetreg;
117b58b977eSPatrick Mooney vmi_get_desc_t vmgetdesc;
118b58b977eSPatrick Mooney vmi_set_desc_t vmsetdesc;
119b58b977eSPatrick Mooney vmi_get_cap_t vmgetcap;
120b58b977eSPatrick Mooney vmi_set_cap_t vmsetcap;
121b58b977eSPatrick Mooney vmi_vlapic_init vlapic_init;
122b58b977eSPatrick Mooney vmi_vlapic_cleanup vlapic_cleanup;
123ad4335f7SPatrick Mooney vmi_pause_t vmpause;
124b58b977eSPatrick Mooney
125b58b977eSPatrick Mooney vmi_savectx vmsavectx;
126b58b977eSPatrick Mooney vmi_restorectx vmrestorectx;
12754cf5b63SPatrick Mooney
12854cf5b63SPatrick Mooney vmi_get_msr_t vmgetmsr;
12954cf5b63SPatrick Mooney vmi_set_msr_t vmsetmsr;
130717646f7SJordan Paige Hendricks
131717646f7SJordan Paige Hendricks vmi_freqratio_t vmfreqratio;
132717646f7SJordan Paige Hendricks uint32_t fr_intsize;
133717646f7SJordan Paige Hendricks uint32_t fr_fracsize;
134b58b977eSPatrick Mooney };
135b58b977eSPatrick Mooney
136b58b977eSPatrick Mooney extern struct vmm_ops vmm_ops_intel;
137b58b977eSPatrick Mooney extern struct vmm_ops vmm_ops_amd;
138b58b977eSPatrick Mooney
139d4f59ae5SPatrick Mooney int vm_create(uint64_t flags, struct vm **retvm);
140b58b977eSPatrick Mooney void vm_destroy(struct vm *vm);
14152fac30eSPatrick Mooney int vm_reinit(struct vm *vm, uint64_t);
142b58b977eSPatrick Mooney uint16_t vm_get_maxcpus(struct vm *vm);
143b58b977eSPatrick Mooney void vm_get_topology(struct vm *vm, uint16_t *sockets, uint16_t *cores,
144b58b977eSPatrick Mooney uint16_t *threads, uint16_t *maxcpus);
145b58b977eSPatrick Mooney int vm_set_topology(struct vm *vm, uint16_t sockets, uint16_t cores,
146b58b977eSPatrick Mooney uint16_t threads, uint16_t maxcpus);
147b58b977eSPatrick Mooney
1482cac0506SPatrick Mooney int vm_pause_instance(struct vm *);
1492cac0506SPatrick Mooney int vm_resume_instance(struct vm *);
1502cac0506SPatrick Mooney bool vm_is_paused(struct vm *);
1512cac0506SPatrick Mooney
1528779b448SDan Cross /*
1538779b448SDan Cross * APIs that race against hardware.
1548779b448SDan Cross */
1554ac713daSLuqman Aden int vm_track_dirty_pages(struct vm *, uint64_t, size_t, uint8_t *);
156b9b43e84SPatrick Mooney int vm_npt_do_operation(struct vm *, uint64_t, size_t, uint32_t, uint8_t *,
157b9b43e84SPatrick Mooney int *);
1588779b448SDan Cross
159b58b977eSPatrick Mooney /*
160b58b977eSPatrick Mooney * APIs that modify the guest memory map require all vcpus to be frozen.
161b58b977eSPatrick Mooney */
162b58b977eSPatrick Mooney int vm_mmap_memseg(struct vm *vm, vm_paddr_t gpa, int segid, vm_ooffset_t off,
163b58b977eSPatrick Mooney size_t len, int prot, int flags);
1642b948146SAndy Fiddaman int vm_munmap_memseg(struct vm *vm, vm_paddr_t gpa, size_t len);
165b58b977eSPatrick Mooney int vm_alloc_memseg(struct vm *vm, int ident, size_t len, bool sysmem);
166b58b977eSPatrick Mooney void vm_free_memseg(struct vm *vm, int ident);
167b58b977eSPatrick Mooney int vm_map_mmio(struct vm *vm, vm_paddr_t gpa, size_t len, vm_paddr_t hpa);
168b58b977eSPatrick Mooney int vm_unmap_mmio(struct vm *vm, vm_paddr_t gpa, size_t len);
169b58b977eSPatrick Mooney int vm_assign_pptdev(struct vm *vm, int pptfd);
170b58b977eSPatrick Mooney int vm_unassign_pptdev(struct vm *vm, int pptfd);
171b58b977eSPatrick Mooney
172b58b977eSPatrick Mooney /*
173b58b977eSPatrick Mooney * APIs that inspect the guest memory map require only a *single* vcpu to
174b58b977eSPatrick Mooney * be frozen. This acts like a read lock on the guest memory map since any
175b58b977eSPatrick Mooney * modification requires *all* vcpus to be frozen.
176b58b977eSPatrick Mooney */
177b58b977eSPatrick Mooney int vm_mmap_getnext(struct vm *vm, vm_paddr_t *gpa, int *segid,
178b58b977eSPatrick Mooney vm_ooffset_t *segoff, size_t *len, int *prot, int *flags);
179b58b977eSPatrick Mooney int vm_get_memseg(struct vm *vm, int ident, size_t *len, bool *sysmem,
180b58b977eSPatrick Mooney struct vm_object **objptr);
181b58b977eSPatrick Mooney vm_paddr_t vmm_sysmem_maxaddr(struct vm *vm);
182b58b977eSPatrick Mooney bool vm_mem_allocated(struct vm *vm, int vcpuid, vm_paddr_t gpa);
183b58b977eSPatrick Mooney
184b58b977eSPatrick Mooney int vm_get_register(struct vm *vm, int vcpu, int reg, uint64_t *retval);
185b58b977eSPatrick Mooney int vm_set_register(struct vm *vm, int vcpu, int reg, uint64_t val);
186b58b977eSPatrick Mooney int vm_get_seg_desc(struct vm *vm, int vcpu, int reg,
1872606939dSPatrick Mooney struct seg_desc *ret_desc);
188b58b977eSPatrick Mooney int vm_set_seg_desc(struct vm *vm, int vcpu, int reg,
1892606939dSPatrick Mooney const struct seg_desc *desc);
1902606939dSPatrick Mooney int vm_get_run_state(struct vm *vm, int vcpuid, uint32_t *state,
1912606939dSPatrick Mooney uint8_t *sipi_vec);
1922606939dSPatrick Mooney int vm_set_run_state(struct vm *vm, int vcpuid, uint32_t state,
1932606939dSPatrick Mooney uint8_t sipi_vec);
194957246c9SPatrick Mooney int vm_get_fpu(struct vm *vm, int vcpuid, void *buf, size_t len);
195957246c9SPatrick Mooney int vm_set_fpu(struct vm *vm, int vcpuid, void *buf, size_t len);
196e0c0d44eSPatrick Mooney int vm_run(struct vm *vm, int vcpuid, const struct vm_entry *);
19772473353SPatrick Mooney int vm_suspend(struct vm *, enum vm_suspend_how, int);
198b58b977eSPatrick Mooney int vm_inject_nmi(struct vm *vm, int vcpu);
1993d097f7dSPatrick Mooney bool vm_nmi_pending(struct vm *vm, int vcpuid);
200b58b977eSPatrick Mooney void vm_nmi_clear(struct vm *vm, int vcpuid);
201b58b977eSPatrick Mooney int vm_inject_extint(struct vm *vm, int vcpu);
2023d097f7dSPatrick Mooney bool vm_extint_pending(struct vm *vm, int vcpuid);
203b58b977eSPatrick Mooney void vm_extint_clear(struct vm *vm, int vcpuid);
2042606939dSPatrick Mooney int vm_inject_init(struct vm *vm, int vcpuid);
2052606939dSPatrick Mooney int vm_inject_sipi(struct vm *vm, int vcpuid, uint8_t vec);
206b58b977eSPatrick Mooney struct vlapic *vm_lapic(struct vm *vm, int cpu);
207b58b977eSPatrick Mooney struct vioapic *vm_ioapic(struct vm *vm);
208b58b977eSPatrick Mooney struct vhpet *vm_hpet(struct vm *vm);
209b58b977eSPatrick Mooney int vm_get_capability(struct vm *vm, int vcpu, int type, int *val);
210b58b977eSPatrick Mooney int vm_set_capability(struct vm *vm, int vcpu, int type, int val);
211b58b977eSPatrick Mooney int vm_get_x2apic_state(struct vm *vm, int vcpu, enum x2apic_state *state);
212b58b977eSPatrick Mooney int vm_set_x2apic_state(struct vm *vm, int vcpu, enum x2apic_state state);
213b58b977eSPatrick Mooney int vm_apicid2vcpuid(struct vm *vm, int apicid);
214b58b977eSPatrick Mooney int vm_activate_cpu(struct vm *vm, int vcpu);
215b58b977eSPatrick Mooney int vm_suspend_cpu(struct vm *vm, int vcpu);
216b58b977eSPatrick Mooney int vm_resume_cpu(struct vm *vm, int vcpu);
217b58b977eSPatrick Mooney struct vm_exit *vm_exitinfo(struct vm *vm, int vcpuid);
218e0c0d44eSPatrick Mooney struct vie *vm_vie_ctx(struct vm *vm, int vcpuid);
219b58b977eSPatrick Mooney void vm_exit_suspended(struct vm *vm, int vcpuid, uint64_t rip);
220b58b977eSPatrick Mooney void vm_exit_debug(struct vm *vm, int vcpuid, uint64_t rip);
221b58b977eSPatrick Mooney void vm_exit_astpending(struct vm *vm, int vcpuid, uint64_t rip);
222b58b977eSPatrick Mooney void vm_exit_reqidle(struct vm *vm, int vcpuid, uint64_t rip);
2232606939dSPatrick Mooney void vm_exit_run_state(struct vm *vm, int vcpuid, uint64_t rip);
224e0c0d44eSPatrick Mooney int vm_service_mmio_read(struct vm *vm, int cpuid, uint64_t gpa, uint64_t *rval,
225e0c0d44eSPatrick Mooney int rsize);
226e0c0d44eSPatrick Mooney int vm_service_mmio_write(struct vm *vm, int cpuid, uint64_t gpa, uint64_t wval,
227e0c0d44eSPatrick Mooney int wsize);
228b58b977eSPatrick Mooney
229b58b977eSPatrick Mooney #ifdef _SYS__CPUSET_H_
230b58b977eSPatrick Mooney cpuset_t vm_active_cpus(struct vm *vm);
231b58b977eSPatrick Mooney cpuset_t vm_debug_cpus(struct vm *vm);
232b58b977eSPatrick Mooney #endif /* _SYS__CPUSET_H_ */
233b58b977eSPatrick Mooney
2342606939dSPatrick Mooney bool vcpu_entry_bailout_checks(struct vm *vm, int vcpuid, uint64_t rip);
2352606939dSPatrick Mooney bool vcpu_run_state_pending(struct vm *vm, int vcpuid);
2362606939dSPatrick Mooney int vcpu_arch_reset(struct vm *vm, int vcpuid, bool init_only);
23772473353SPatrick Mooney int vm_vcpu_barrier(struct vm *, int);
238b58b977eSPatrick Mooney
239b58b977eSPatrick Mooney /*
240b58b977eSPatrick Mooney * Return true if device indicated by bus/slot/func is supposed to be a
241b58b977eSPatrick Mooney * pci passthrough device.
242b58b977eSPatrick Mooney *
243b58b977eSPatrick Mooney * Return false otherwise.
244b58b977eSPatrick Mooney */
245b58b977eSPatrick Mooney bool vmm_is_pptdev(int bus, int slot, int func);
246b58b977eSPatrick Mooney
247b58b977eSPatrick Mooney void *vm_iommu_domain(struct vm *vm);
248b58b977eSPatrick Mooney
249b58b977eSPatrick Mooney enum vcpu_state {
250b58b977eSPatrick Mooney VCPU_IDLE,
251b58b977eSPatrick Mooney VCPU_FROZEN,
252b58b977eSPatrick Mooney VCPU_RUNNING,
253b58b977eSPatrick Mooney VCPU_SLEEPING,
254b58b977eSPatrick Mooney };
255b58b977eSPatrick Mooney
256b58b977eSPatrick Mooney int vcpu_set_state(struct vm *vm, int vcpu, enum vcpu_state state,
257b58b977eSPatrick Mooney bool from_idle);
258b58b977eSPatrick Mooney enum vcpu_state vcpu_get_state(struct vm *vm, int vcpu, int *hostcpu);
259b58b977eSPatrick Mooney void vcpu_block_run(struct vm *, int);
260b58b977eSPatrick Mooney void vcpu_unblock_run(struct vm *, int);
261b58b977eSPatrick Mooney
2629250eb13SPatrick Mooney uint64_t vcpu_tsc_offset(struct vm *vm, int vcpuid, bool phys_adj);
263d515dd77SPatrick Mooney hrtime_t vm_normalize_hrtime(struct vm *, hrtime_t);
264d515dd77SPatrick Mooney hrtime_t vm_denormalize_hrtime(struct vm *, hrtime_t);
265717646f7SJordan Paige Hendricks uint64_t vm_get_freq_multiplier(struct vm *);
266b58b977eSPatrick Mooney
267d515dd77SPatrick Mooney static __inline bool
vcpu_is_running(struct vm * vm,int vcpu,int * hostcpu)268b58b977eSPatrick Mooney vcpu_is_running(struct vm *vm, int vcpu, int *hostcpu)
269b58b977eSPatrick Mooney {
270b58b977eSPatrick Mooney return (vcpu_get_state(vm, vcpu, hostcpu) == VCPU_RUNNING);
271b58b977eSPatrick Mooney }
272b58b977eSPatrick Mooney
273b58b977eSPatrick Mooney #ifdef _SYS_THREAD_H
274b58b977eSPatrick Mooney static __inline int
vcpu_should_yield(struct vm * vm,int vcpu)275b58b977eSPatrick Mooney vcpu_should_yield(struct vm *vm, int vcpu)
276b58b977eSPatrick Mooney {
277b58b977eSPatrick Mooney
278b58b977eSPatrick Mooney if (curthread->t_astflag)
279b58b977eSPatrick Mooney return (1);
280b58b977eSPatrick Mooney else if (CPU->cpu_runrun)
281b58b977eSPatrick Mooney return (1);
282b58b977eSPatrick Mooney else
283b58b977eSPatrick Mooney return (0);
284b58b977eSPatrick Mooney }
285b58b977eSPatrick Mooney #endif /* _SYS_THREAD_H */
286b58b977eSPatrick Mooney
287c74a40a5SPatrick Mooney typedef enum vcpu_notify {
288c74a40a5SPatrick Mooney VCPU_NOTIFY_NONE,
289c74a40a5SPatrick Mooney VCPU_NOTIFY_APIC, /* Posted intr notification (if possible) */
290c74a40a5SPatrick Mooney VCPU_NOTIFY_EXIT, /* IPI to cause VM exit */
291c74a40a5SPatrick Mooney } vcpu_notify_t;
292c74a40a5SPatrick Mooney
293b58b977eSPatrick Mooney void *vcpu_stats(struct vm *vm, int vcpu);
294c74a40a5SPatrick Mooney void vcpu_notify_event(struct vm *vm, int vcpuid);
295c74a40a5SPatrick Mooney void vcpu_notify_event_type(struct vm *vm, int vcpuid, vcpu_notify_t);
296b58b977eSPatrick Mooney struct vmspace *vm_get_vmspace(struct vm *vm);
2970153d828SPatrick Mooney struct vm_client *vm_get_vmclient(struct vm *vm, int vcpuid);
298b58b977eSPatrick Mooney struct vatpic *vm_atpic(struct vm *vm);
299b58b977eSPatrick Mooney struct vatpit *vm_atpit(struct vm *vm);
300b58b977eSPatrick Mooney struct vpmtmr *vm_pmtmr(struct vm *vm);
301b58b977eSPatrick Mooney struct vrtc *vm_rtc(struct vm *vm);
302b58b977eSPatrick Mooney
303b58b977eSPatrick Mooney /*
304b58b977eSPatrick Mooney * Inject exception 'vector' into the guest vcpu. This function returns 0 on
305b58b977eSPatrick Mooney * success and non-zero on failure.
306b58b977eSPatrick Mooney *
307b58b977eSPatrick Mooney * Wrapper functions like 'vm_inject_gp()' should be preferred to calling
308b58b977eSPatrick Mooney * this function directly because they enforce the trap-like or fault-like
309b58b977eSPatrick Mooney * behavior of an exception.
310b58b977eSPatrick Mooney *
311b58b977eSPatrick Mooney * This function should only be called in the context of the thread that is
312b58b977eSPatrick Mooney * executing this vcpu.
313b58b977eSPatrick Mooney */
3143d097f7dSPatrick Mooney int vm_inject_exception(struct vm *vm, int vcpuid, uint8_t vector,
3153d097f7dSPatrick Mooney bool err_valid, uint32_t errcode, bool restart_instruction);
316b58b977eSPatrick Mooney
317b58b977eSPatrick Mooney /*
318b58b977eSPatrick Mooney * This function is called after a VM-exit that occurred during exception or
319b58b977eSPatrick Mooney * interrupt delivery through the IDT. The format of 'intinfo' is described
320b58b977eSPatrick Mooney * in Figure 15-1, "EXITINTINFO for All Intercepts", APM, Vol 2.
321b58b977eSPatrick Mooney *
322b58b977eSPatrick Mooney * If a VM-exit handler completes the event delivery successfully then it
323b58b977eSPatrick Mooney * should call vm_exit_intinfo() to extinguish the pending event. For e.g.,
324b58b977eSPatrick Mooney * if the task switch emulation is triggered via a task gate then it should
325b58b977eSPatrick Mooney * call this function with 'intinfo=0' to indicate that the external event
326b58b977eSPatrick Mooney * is not pending anymore.
327b58b977eSPatrick Mooney *
328b58b977eSPatrick Mooney * Return value is 0 on success and non-zero on failure.
329b58b977eSPatrick Mooney */
330b58b977eSPatrick Mooney int vm_exit_intinfo(struct vm *vm, int vcpuid, uint64_t intinfo);
331b58b977eSPatrick Mooney
332b58b977eSPatrick Mooney /*
333b58b977eSPatrick Mooney * This function is called before every VM-entry to retrieve a pending
334b58b977eSPatrick Mooney * event that should be injected into the guest. This function combines
335b58b977eSPatrick Mooney * nested events into a double or triple fault.
336b58b977eSPatrick Mooney *
3373d097f7dSPatrick Mooney * Returns false if there are no events that need to be injected into the guest.
338b58b977eSPatrick Mooney */
3393d097f7dSPatrick Mooney bool vm_entry_intinfo(struct vm *vm, int vcpuid, uint64_t *info);
340b58b977eSPatrick Mooney
341b58b977eSPatrick Mooney int vm_get_intinfo(struct vm *vm, int vcpuid, uint64_t *info1, uint64_t *info2);
342b58b977eSPatrick Mooney
343b58b977eSPatrick Mooney enum vm_reg_name vm_segment_name(int seg_encoding);
344b58b977eSPatrick Mooney
345b58b977eSPatrick Mooney struct vm_copyinfo {
346b58b977eSPatrick Mooney uint64_t gpa;
347b58b977eSPatrick Mooney size_t len;
3480153d828SPatrick Mooney int prot;
349b58b977eSPatrick Mooney void *hva;
350b58b977eSPatrick Mooney void *cookie;
351b58b977eSPatrick Mooney };
352b58b977eSPatrick Mooney
353b58b977eSPatrick Mooney /*
354b58b977eSPatrick Mooney * Set up 'copyinfo[]' to copy to/from guest linear address space starting
355b58b977eSPatrick Mooney * at 'gla' and 'len' bytes long. The 'prot' should be set to PROT_READ for
356b58b977eSPatrick Mooney * a copyin or PROT_WRITE for a copyout.
357b58b977eSPatrick Mooney *
358b58b977eSPatrick Mooney * retval is_fault Interpretation
359b58b977eSPatrick Mooney * 0 0 Success
360b58b977eSPatrick Mooney * 0 1 An exception was injected into the guest
361b58b977eSPatrick Mooney * EFAULT N/A Unrecoverable error
362b58b977eSPatrick Mooney *
363b58b977eSPatrick Mooney * The 'copyinfo[]' can be passed to 'vm_copyin()' or 'vm_copyout()' only if
364b58b977eSPatrick Mooney * the return value is 0. The 'copyinfo[]' resources should be freed by calling
365b58b977eSPatrick Mooney * 'vm_copy_teardown()' after the copy is done.
366b58b977eSPatrick Mooney */
367b58b977eSPatrick Mooney int vm_copy_setup(struct vm *vm, int vcpuid, struct vm_guest_paging *paging,
368b58b977eSPatrick Mooney uint64_t gla, size_t len, int prot, struct vm_copyinfo *copyinfo,
3690153d828SPatrick Mooney uint_t num_copyinfo, int *is_fault);
370b58b977eSPatrick Mooney void vm_copy_teardown(struct vm *vm, int vcpuid, struct vm_copyinfo *copyinfo,
3710153d828SPatrick Mooney uint_t num_copyinfo);
372b58b977eSPatrick Mooney void vm_copyin(struct vm *vm, int vcpuid, struct vm_copyinfo *copyinfo,
373b58b977eSPatrick Mooney void *kaddr, size_t len);
374b58b977eSPatrick Mooney void vm_copyout(struct vm *vm, int vcpuid, const void *kaddr,
375b58b977eSPatrick Mooney struct vm_copyinfo *copyinfo, size_t len);
376b58b977eSPatrick Mooney
377b58b977eSPatrick Mooney int vcpu_trace_exceptions(struct vm *vm, int vcpuid);
3784f3f3e9aSAndy Fiddaman int vcpu_trap_wbinvd(struct vm *vm, int vcpuid);
379b58b977eSPatrick Mooney
380b58b977eSPatrick Mooney void vm_inject_ud(struct vm *vm, int vcpuid);
381b58b977eSPatrick Mooney void vm_inject_gp(struct vm *vm, int vcpuid);
3823d097f7dSPatrick Mooney void vm_inject_ac(struct vm *vm, int vcpuid, uint32_t errcode);
3833d097f7dSPatrick Mooney void vm_inject_ss(struct vm *vm, int vcpuid, uint32_t errcode);
3843d097f7dSPatrick Mooney void vm_inject_pf(struct vm *vm, int vcpuid, uint32_t errcode, uint64_t cr2);
385b58b977eSPatrick Mooney
386c74a40a5SPatrick Mooney /*
387c74a40a5SPatrick Mooney * Both SVM and VMX have complex logic for injecting events such as exceptions
388c74a40a5SPatrick Mooney * or interrupts into the guest. Within those two backends, the progress of
389c74a40a5SPatrick Mooney * event injection is tracked by event_inject_state, hopefully making it easier
390c74a40a5SPatrick Mooney * to reason about.
391c74a40a5SPatrick Mooney */
392c74a40a5SPatrick Mooney enum event_inject_state {
393c74a40a5SPatrick Mooney EIS_CAN_INJECT = 0, /* exception/interrupt can be injected */
394c74a40a5SPatrick Mooney EIS_EV_EXISTING = 1, /* blocked by existing event */
395c74a40a5SPatrick Mooney EIS_EV_INJECTED = 2, /* blocked by injected event */
396c74a40a5SPatrick Mooney EIS_GI_BLOCK = 3, /* blocked by guest interruptability */
397c74a40a5SPatrick Mooney
398c74a40a5SPatrick Mooney /*
399c74a40a5SPatrick Mooney * Flag to request an immediate exit from VM context after event
400c74a40a5SPatrick Mooney * injection in order to perform more processing
401c74a40a5SPatrick Mooney */
402c74a40a5SPatrick Mooney EIS_REQ_EXIT = (1 << 15),
403c74a40a5SPatrick Mooney };
404c74a40a5SPatrick Mooney
405d2f938fdSPatrick Mooney /* Possible result codes for MSR access emulation */
406d2f938fdSPatrick Mooney typedef enum vm_msr_result {
407d2f938fdSPatrick Mooney VMR_OK = 0, /* succesfully emulated */
408d2f938fdSPatrick Mooney VMR_GP = 1, /* #GP should be injected */
409d2f938fdSPatrick Mooney VMR_UNHANLDED = 2, /* handle in userspace, kernel cannot emulate */
410d2f938fdSPatrick Mooney } vm_msr_result_t;
411d2f938fdSPatrick Mooney
41254cf5b63SPatrick Mooney enum vm_cpuid_capability {
41354cf5b63SPatrick Mooney VCC_NONE,
41454cf5b63SPatrick Mooney VCC_NO_EXECUTE,
41554cf5b63SPatrick Mooney VCC_FFXSR,
41654cf5b63SPatrick Mooney VCC_TCE,
41754cf5b63SPatrick Mooney VCC_LAST
41854cf5b63SPatrick Mooney };
41954cf5b63SPatrick Mooney
420578d9a56SPatrick Mooney /* Possible flags and entry count limit definited in sys/vmm.h */
421578d9a56SPatrick Mooney typedef struct vcpu_cpuid_config {
422578d9a56SPatrick Mooney uint32_t vcc_flags;
423578d9a56SPatrick Mooney uint32_t vcc_nent;
424578d9a56SPatrick Mooney struct vcpu_cpuid_entry *vcc_entries;
425578d9a56SPatrick Mooney } vcpu_cpuid_config_t;
426578d9a56SPatrick Mooney
427578d9a56SPatrick Mooney vcpu_cpuid_config_t *vm_cpuid_config(struct vm *, int);
428578d9a56SPatrick Mooney int vm_get_cpuid(struct vm *, int, vcpu_cpuid_config_t *);
429578d9a56SPatrick Mooney int vm_set_cpuid(struct vm *, int, const vcpu_cpuid_config_t *);
430578d9a56SPatrick Mooney void vcpu_emulate_cpuid(struct vm *, int, uint64_t *, uint64_t *, uint64_t *,
43154cf5b63SPatrick Mooney uint64_t *);
432578d9a56SPatrick Mooney void legacy_emulate_cpuid(struct vm *, int, uint32_t *, uint32_t *, uint32_t *,
433578d9a56SPatrick Mooney uint32_t *);
434578d9a56SPatrick Mooney void vcpu_cpuid_init(vcpu_cpuid_config_t *);
435578d9a56SPatrick Mooney void vcpu_cpuid_cleanup(vcpu_cpuid_config_t *);
436578d9a56SPatrick Mooney
43754cf5b63SPatrick Mooney bool vm_cpuid_capability(struct vm *, int, enum vm_cpuid_capability);
43854cf5b63SPatrick Mooney bool validate_guest_xcr0(uint64_t, uint64_t);
43954cf5b63SPatrick Mooney
440b58b977eSPatrick Mooney void vmm_sol_glue_init(void);
441b58b977eSPatrick Mooney void vmm_sol_glue_cleanup(void);
442b58b977eSPatrick Mooney
4438130f8e1SPatrick Mooney void *vmm_contig_alloc(size_t);
4448130f8e1SPatrick Mooney void vmm_contig_free(void *, size_t);
4458130f8e1SPatrick Mooney
446b58b977eSPatrick Mooney int vmm_mod_load(void);
447b58b977eSPatrick Mooney int vmm_mod_unload(void);
448b58b977eSPatrick Mooney
449e760f150SPatrick Mooney bool vmm_check_iommu(void);
450e760f150SPatrick Mooney
451b58b977eSPatrick Mooney void vmm_call_trap(uint64_t);
452b58b977eSPatrick Mooney
45317b3b9a6SPatrick Mooney uint64_t vmm_host_tsc_delta(void);
45417b3b9a6SPatrick Mooney
455b58b977eSPatrick Mooney /*
4560e1453c3SPatrick Mooney * Because of tangled headers, this is not exposed directly via the vmm_drv
4570e1453c3SPatrick Mooney * interface, but rather mirrored as vmm_drv_iop_cb_t in vmm_drv.h.
458b58b977eSPatrick Mooney */
4590e1453c3SPatrick Mooney typedef int (*ioport_handler_t)(void *, bool, uint16_t, uint8_t, uint32_t *);
460b58b977eSPatrick Mooney
4610e1453c3SPatrick Mooney int vm_ioport_access(struct vm *vm, int vcpuid, bool in, uint16_t port,
4620e1453c3SPatrick Mooney uint8_t bytes, uint32_t *val);
4630e1453c3SPatrick Mooney
4640e1453c3SPatrick Mooney int vm_ioport_attach(struct vm *vm, uint16_t port, ioport_handler_t func,
4650e1453c3SPatrick Mooney void *arg, void **cookie);
4660e1453c3SPatrick Mooney int vm_ioport_detach(struct vm *vm, void **cookie, ioport_handler_t *old_func,
4670e1453c3SPatrick Mooney void **old_arg);
4680e1453c3SPatrick Mooney
4690e1453c3SPatrick Mooney int vm_ioport_hook(struct vm *, uint16_t, ioport_handler_t, void *, void **);
470b58b977eSPatrick Mooney void vm_ioport_unhook(struct vm *, void **);
471b58b977eSPatrick Mooney
47259460b49SPatrick Mooney enum vcpu_ustate {
47359460b49SPatrick Mooney VU_INIT = 0, /* initialized but has not yet attempted to run */
47459460b49SPatrick Mooney VU_RUN, /* running in guest context */
47559460b49SPatrick Mooney VU_IDLE, /* idle (HLTed, wait-for-SIPI, etc) */
47659460b49SPatrick Mooney VU_EMU_KERN, /* emulation performed in-kernel */
47759460b49SPatrick Mooney VU_EMU_USER, /* emulation performed in userspace */
47859460b49SPatrick Mooney VU_SCHED, /* off-cpu for interrupt, preempt, lock contention */
47959460b49SPatrick Mooney VU_MAX
48059460b49SPatrick Mooney };
48159460b49SPatrick Mooney
48259460b49SPatrick Mooney void vcpu_ustate_change(struct vm *, int, enum vcpu_ustate);
48359460b49SPatrick Mooney
48459460b49SPatrick Mooney typedef struct vmm_kstats {
48559460b49SPatrick Mooney kstat_named_t vk_name;
48659460b49SPatrick Mooney } vmm_kstats_t;
48759460b49SPatrick Mooney
48859460b49SPatrick Mooney typedef struct vmm_vcpu_kstats {
48959460b49SPatrick Mooney kstat_named_t vvk_vcpu;
49059460b49SPatrick Mooney kstat_named_t vvk_time_init;
49159460b49SPatrick Mooney kstat_named_t vvk_time_run;
49259460b49SPatrick Mooney kstat_named_t vvk_time_idle;
49359460b49SPatrick Mooney kstat_named_t vvk_time_emu_kern;
49459460b49SPatrick Mooney kstat_named_t vvk_time_emu_user;
49559460b49SPatrick Mooney kstat_named_t vvk_time_sched;
49659460b49SPatrick Mooney } vmm_vcpu_kstats_t;
49759460b49SPatrick Mooney
49859460b49SPatrick Mooney #define VMM_KSTAT_CLASS "misc"
49959460b49SPatrick Mooney
50059460b49SPatrick Mooney int vmm_kstat_update_vcpu(struct kstat *, int);
50159460b49SPatrick Mooney
502d515dd77SPatrick Mooney typedef struct vmm_data_req {
503d515dd77SPatrick Mooney uint16_t vdr_class;
504d515dd77SPatrick Mooney uint16_t vdr_version;
505d515dd77SPatrick Mooney uint32_t vdr_flags;
506d515dd77SPatrick Mooney uint32_t vdr_len;
507d515dd77SPatrick Mooney void *vdr_data;
50854cf5b63SPatrick Mooney uint32_t *vdr_result_len;
509*4bd36be4SPatrick Mooney int vdr_vcpuid;
510d515dd77SPatrick Mooney } vmm_data_req_t;
511d515dd77SPatrick Mooney
512d515dd77SPatrick Mooney typedef int (*vmm_data_writef_t)(void *, const vmm_data_req_t *);
513d515dd77SPatrick Mooney typedef int (*vmm_data_readf_t)(void *, const vmm_data_req_t *);
514ad4335f7SPatrick Mooney typedef int (*vmm_data_vcpu_writef_t)(struct vm *, int, const vmm_data_req_t *);
515ad4335f7SPatrick Mooney typedef int (*vmm_data_vcpu_readf_t)(struct vm *, int, const vmm_data_req_t *);
516d515dd77SPatrick Mooney
517d515dd77SPatrick Mooney typedef struct vmm_data_version_entry {
518d515dd77SPatrick Mooney uint16_t vdve_class;
519d515dd77SPatrick Mooney uint16_t vdve_version;
5202c83e262SPatrick Mooney
5212c83e262SPatrick Mooney /*
5222c83e262SPatrick Mooney * If these handlers accept/emit a single item of a fixed length, it
5232c83e262SPatrick Mooney * should be specified in vdve_len_expect. The vmm-data logic will then
5242c83e262SPatrick Mooney * ensure that requests possess at least that specified length before
5252c83e262SPatrick Mooney * calling into the defined handlers.
5262c83e262SPatrick Mooney */
527d515dd77SPatrick Mooney uint16_t vdve_len_expect;
5282c83e262SPatrick Mooney
5292c83e262SPatrick Mooney /*
5302c83e262SPatrick Mooney * For handlers which deal with (potentially) multiple items of a fixed
5312c83e262SPatrick Mooney * length, vdve_len_per_item is used to hint (via the VDC_VERSION class)
5322c83e262SPatrick Mooney * to userspace what that item size is. Although not strictly mutually
5332c83e262SPatrick Mooney * exclusive with vdve_len_expect, it is nonsensical to set them both.
5342c83e262SPatrick Mooney */
53554cf5b63SPatrick Mooney uint16_t vdve_len_per_item;
5362c83e262SPatrick Mooney
5372c83e262SPatrick Mooney /*
5382c83e262SPatrick Mooney * A vmm-data handler is expected to provide read/write functions which
5392c83e262SPatrick Mooney * are either VM-wide (via vdve_readf and vdve_writef) or per-vCPU
5402c83e262SPatrick Mooney * (via vdve_vcpu_readf and vdve_vcpu_writef). Providing both is not
5412c83e262SPatrick Mooney * allowed (but is not currently checked at compile time).
5422c83e262SPatrick Mooney */
5432c83e262SPatrick Mooney
5442c83e262SPatrick Mooney /* VM-wide handlers */
545d515dd77SPatrick Mooney vmm_data_readf_t vdve_readf;
546d515dd77SPatrick Mooney vmm_data_writef_t vdve_writef;
5472c83e262SPatrick Mooney
5482c83e262SPatrick Mooney /* Per-vCPU handlers */
549ad4335f7SPatrick Mooney vmm_data_vcpu_readf_t vdve_vcpu_readf;
550ad4335f7SPatrick Mooney vmm_data_vcpu_writef_t vdve_vcpu_writef;
5512c83e262SPatrick Mooney
5522c83e262SPatrick Mooney /*
5532c83e262SPatrick Mooney * The vdve_vcpu_readf/writef handlers can rely on vcpuid to be within
5542c83e262SPatrick Mooney * the [0, VM_MAXCPU) bounds. If they also can handle vcpuid == -1 (for
5552c83e262SPatrick Mooney * VM-wide data), then they can opt into such cases by setting
5562c83e262SPatrick Mooney * vdve_vcpu_wildcard to true.
5572c83e262SPatrick Mooney *
5582c83e262SPatrick Mooney * At a later time, it would make sense to improve the logic so a
5592c83e262SPatrick Mooney * vmm-data class could define both the VM-wide and per-vCPU handlers,
5602c83e262SPatrick Mooney * letting the incoming vcpuid determine which would be called. Until
5612c83e262SPatrick Mooney * then, vdve_vcpu_wildcard is the stopgap.
5622c83e262SPatrick Mooney */
5632c83e262SPatrick Mooney bool vdve_vcpu_wildcard;
564d515dd77SPatrick Mooney } vmm_data_version_entry_t;
565d515dd77SPatrick Mooney
566d515dd77SPatrick Mooney #define VMM_DATA_VERSION(sym) SET_ENTRY(vmm_data_version_entries, sym)
567d515dd77SPatrick Mooney
568*4bd36be4SPatrick Mooney int vmm_data_read(struct vm *, const vmm_data_req_t *);
569*4bd36be4SPatrick Mooney int vmm_data_write(struct vm *, const vmm_data_req_t *);
570d515dd77SPatrick Mooney
571717646f7SJordan Paige Hendricks /*
572717646f7SJordan Paige Hendricks * TSC Scaling
573717646f7SJordan Paige Hendricks */
574717646f7SJordan Paige Hendricks uint64_t vmm_calc_freq_multiplier(uint64_t guest_hz, uint64_t host_hz,
575717646f7SJordan Paige Hendricks uint32_t frac);
576717646f7SJordan Paige Hendricks
577717646f7SJordan Paige Hendricks /* represents a multiplier for a guest in which no scaling is required */
578717646f7SJordan Paige Hendricks #define VM_TSCM_NOSCALE 0
579717646f7SJordan Paige Hendricks
580b58b977eSPatrick Mooney #endif /* _VMM_KERNEL_H_ */
581