1 /*
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2015 Mihai Carabas <mihai.carabas@gmail.com>
5 * Copyright (c) 2024 Ruslan Bukin <br@bsdpad.com>
6 *
7 * This software was developed by the University of Cambridge Computer
8 * Laboratory (Department of Computer Science and Technology) under Innovate
9 * UK project 105694, "Digital Security by Design (DSbD) Technology Platform
10 * Prototype".
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #ifndef _VMM_H_
35 #define _VMM_H_
36
37 #include <sys/param.h>
38 #include <sys/cpuset.h>
39 #include <vm/vm.h>
40 #include <vm/pmap.h>
41
42 #include "pte.h"
43 #include "pmap.h"
44
45 struct vcpu;
46
47 enum vm_suspend_how {
48 VM_SUSPEND_NONE,
49 VM_SUSPEND_RESET,
50 VM_SUSPEND_POWEROFF,
51 VM_SUSPEND_HALT,
52 VM_SUSPEND_DESTROY,
53 VM_SUSPEND_LAST
54 };
55
56 /*
57 * Identifiers for architecturally defined registers.
58 */
59 enum vm_reg_name {
60 VM_REG_GUEST_ZERO = 0,
61 VM_REG_GUEST_RA,
62 VM_REG_GUEST_SP,
63 VM_REG_GUEST_GP,
64 VM_REG_GUEST_TP,
65 VM_REG_GUEST_T0,
66 VM_REG_GUEST_T1,
67 VM_REG_GUEST_T2,
68 VM_REG_GUEST_S0,
69 VM_REG_GUEST_S1,
70 VM_REG_GUEST_A0,
71 VM_REG_GUEST_A1,
72 VM_REG_GUEST_A2,
73 VM_REG_GUEST_A3,
74 VM_REG_GUEST_A4,
75 VM_REG_GUEST_A5,
76 VM_REG_GUEST_A6,
77 VM_REG_GUEST_A7,
78 VM_REG_GUEST_S2,
79 VM_REG_GUEST_S3,
80 VM_REG_GUEST_S4,
81 VM_REG_GUEST_S5,
82 VM_REG_GUEST_S6,
83 VM_REG_GUEST_S7,
84 VM_REG_GUEST_S8,
85 VM_REG_GUEST_S9,
86 VM_REG_GUEST_S10,
87 VM_REG_GUEST_S11,
88 VM_REG_GUEST_T3,
89 VM_REG_GUEST_T4,
90 VM_REG_GUEST_T5,
91 VM_REG_GUEST_T6,
92 VM_REG_GUEST_SEPC,
93 VM_REG_LAST
94 };
95
96 #define VM_INTINFO_VECTOR(info) ((info) & 0xff)
97 #define VM_INTINFO_DEL_ERRCODE 0x800
98 #define VM_INTINFO_RSVD 0x7ffff000
99 #define VM_INTINFO_VALID 0x80000000
100 #define VM_INTINFO_TYPE 0x700
101 #define VM_INTINFO_HWINTR (0 << 8)
102 #define VM_INTINFO_NMI (2 << 8)
103 #define VM_INTINFO_HWEXCEPTION (3 << 8)
104 #define VM_INTINFO_SWINTR (4 << 8)
105
106 #define VM_MAX_NAMELEN 32
107 #define VM_MAX_SUFFIXLEN 15
108
109 #ifdef _KERNEL
110
111 struct vm;
112 struct vm_exception;
113 struct vm_exit;
114 struct vm_run;
115 struct vm_object;
116 struct vm_guest_paging;
117 struct vm_aplic_descr;
118 struct pmap;
119
120 struct vm_eventinfo {
121 void *rptr; /* rendezvous cookie */
122 int *sptr; /* suspend cookie */
123 int *iptr; /* reqidle cookie */
124 };
125
126 #define DECLARE_VMMOPS_FUNC(ret_type, opname, args) \
127 ret_type vmmops_##opname args
128
129 DECLARE_VMMOPS_FUNC(int, modinit, (void));
130 DECLARE_VMMOPS_FUNC(int, modcleanup, (void));
131 DECLARE_VMMOPS_FUNC(void *, init, (struct vm *vm, struct pmap *pmap));
132 DECLARE_VMMOPS_FUNC(int, gla2gpa, (void *vcpui, struct vm_guest_paging *paging,
133 uint64_t gla, int prot, uint64_t *gpa, int *is_fault));
134 DECLARE_VMMOPS_FUNC(int, run, (void *vcpui, register_t pc, struct pmap *pmap,
135 struct vm_eventinfo *info));
136 DECLARE_VMMOPS_FUNC(void, cleanup, (void *vmi));
137 DECLARE_VMMOPS_FUNC(void *, vcpu_init, (void *vmi, struct vcpu *vcpu,
138 int vcpu_id));
139 DECLARE_VMMOPS_FUNC(void, vcpu_cleanup, (void *vcpui));
140 DECLARE_VMMOPS_FUNC(int, exception, (void *vcpui, uint64_t scause));
141 DECLARE_VMMOPS_FUNC(int, getreg, (void *vcpui, int num, uint64_t *retval));
142 DECLARE_VMMOPS_FUNC(int, setreg, (void *vcpui, int num, uint64_t val));
143 DECLARE_VMMOPS_FUNC(int, getcap, (void *vcpui, int num, int *retval));
144 DECLARE_VMMOPS_FUNC(int, setcap, (void *vcpui, int num, int val));
145 DECLARE_VMMOPS_FUNC(struct vmspace *, vmspace_alloc, (vm_offset_t min,
146 vm_offset_t max));
147 DECLARE_VMMOPS_FUNC(void, vmspace_free, (struct vmspace *vmspace));
148
149 int vm_create(const char *name, struct vm **retvm);
150 struct vcpu *vm_alloc_vcpu(struct vm *vm, int vcpuid);
151 void vm_disable_vcpu_creation(struct vm *vm);
152 void vm_lock_vcpus(struct vm *vm);
153 void vm_unlock_vcpus(struct vm *vm);
154 void vm_destroy(struct vm *vm);
155 int vm_reinit(struct vm *vm);
156 const char *vm_name(struct vm *vm);
157
158 uint16_t vm_get_maxcpus(struct vm *vm);
159 void vm_get_topology(struct vm *vm, uint16_t *sockets, uint16_t *cores,
160 uint16_t *threads, uint16_t *maxcpus);
161 int vm_set_topology(struct vm *vm, uint16_t sockets, uint16_t cores,
162 uint16_t threads, uint16_t maxcpus);
163 int vm_get_register(struct vcpu *vcpu, int reg, uint64_t *retval);
164 int vm_set_register(struct vcpu *vcpu, int reg, uint64_t val);
165 int vm_run(struct vcpu *vcpu);
166 int vm_suspend(struct vm *vm, enum vm_suspend_how how);
167 void* vm_get_cookie(struct vm *vm);
168 int vcpu_vcpuid(struct vcpu *vcpu);
169 void *vcpu_get_cookie(struct vcpu *vcpu);
170 struct vm *vcpu_vm(struct vcpu *vcpu);
171 struct vcpu *vm_vcpu(struct vm *vm, int cpu);
172 int vm_get_capability(struct vcpu *vcpu, int type, int *val);
173 int vm_set_capability(struct vcpu *vcpu, int type, int val);
174 int vm_activate_cpu(struct vcpu *vcpu);
175 int vm_suspend_cpu(struct vm *vm, struct vcpu *vcpu);
176 int vm_resume_cpu(struct vm *vm, struct vcpu *vcpu);
177 int vm_inject_exception(struct vcpu *vcpu, uint64_t scause);
178 int vm_attach_aplic(struct vm *vm, struct vm_aplic_descr *descr);
179 int vm_assert_irq(struct vm *vm, uint32_t irq);
180 int vm_deassert_irq(struct vm *vm, uint32_t irq);
181 int vm_raise_msi(struct vm *vm, uint64_t msg, uint64_t addr, int bus, int slot,
182 int func);
183 struct vm_exit *vm_exitinfo(struct vcpu *vcpu);
184 void vm_exit_suspended(struct vcpu *vcpu, uint64_t pc);
185 void vm_exit_debug(struct vcpu *vcpu, uint64_t pc);
186 void vm_exit_rendezvous(struct vcpu *vcpu, uint64_t pc);
187 void vm_exit_astpending(struct vcpu *vcpu, uint64_t pc);
188
189 cpuset_t vm_active_cpus(struct vm *vm);
190 cpuset_t vm_debug_cpus(struct vm *vm);
191 cpuset_t vm_suspended_cpus(struct vm *vm);
192
193 static __inline int
vcpu_rendezvous_pending(struct vm_eventinfo * info)194 vcpu_rendezvous_pending(struct vm_eventinfo *info)
195 {
196
197 return (*((uintptr_t *)(info->rptr)) != 0);
198 }
199
200 static __inline int
vcpu_suspended(struct vm_eventinfo * info)201 vcpu_suspended(struct vm_eventinfo *info)
202 {
203
204 return (*info->sptr);
205 }
206
207 int vcpu_debugged(struct vcpu *vcpu);
208
209 enum vcpu_state {
210 VCPU_IDLE,
211 VCPU_FROZEN,
212 VCPU_RUNNING,
213 VCPU_SLEEPING,
214 };
215
216 int vcpu_set_state(struct vcpu *vcpu, enum vcpu_state state, bool from_idle);
217 enum vcpu_state vcpu_get_state(struct vcpu *vcpu, int *hostcpu);
218
219 static int __inline
vcpu_is_running(struct vcpu * vcpu,int * hostcpu)220 vcpu_is_running(struct vcpu *vcpu, int *hostcpu)
221 {
222 return (vcpu_get_state(vcpu, hostcpu) == VCPU_RUNNING);
223 }
224
225 #ifdef _SYS_PROC_H_
226 static int __inline
vcpu_should_yield(struct vcpu * vcpu)227 vcpu_should_yield(struct vcpu *vcpu)
228 {
229 struct thread *td;
230
231 td = curthread;
232 return (td->td_ast != 0 || td->td_owepreempt != 0);
233 }
234 #endif
235
236 void *vcpu_stats(struct vcpu *vcpu);
237 void vcpu_notify_event(struct vcpu *vcpu);
238 struct vm_mem *vm_mem(struct vm *vm);
239
240 enum vm_reg_name vm_segment_name(int seg_encoding);
241
242 #endif /* _KERNEL */
243
244 #define VM_DIR_READ 0
245 #define VM_DIR_WRITE 1
246
247 #define VM_GP_M_MASK 0x1f
248 #define VM_GP_MMU_ENABLED (1 << 5)
249
250 struct vm_guest_paging {
251 int flags;
252 int padding;
253 };
254
255 struct vie {
256 uint8_t access_size:4, sign_extend:1, dir:1, unused:2;
257 enum vm_reg_name reg;
258 };
259
260 struct vre {
261 uint32_t inst_syndrome;
262 uint8_t dir:1, unused:7;
263 enum vm_reg_name reg;
264 };
265
266 /*
267 * Identifiers for optional vmm capabilities
268 */
269 enum vm_cap_type {
270 VM_CAP_UNRESTRICTED_GUEST,
271 VM_CAP_SSTC,
272 VM_CAP_MAX
273 };
274
275 enum vm_exitcode {
276 VM_EXITCODE_BOGUS,
277 VM_EXITCODE_ECALL,
278 VM_EXITCODE_HYP,
279 VM_EXITCODE_PAGING,
280 VM_EXITCODE_SUSPENDED,
281 VM_EXITCODE_DEBUG,
282 VM_EXITCODE_INST_EMUL,
283 VM_EXITCODE_WFI,
284 VM_EXITCODE_MAX
285 };
286
287 struct vm_exit {
288 uint64_t scause;
289 uint64_t sepc;
290 uint64_t stval;
291 uint64_t htval;
292 uint64_t htinst;
293 enum vm_exitcode exitcode;
294 int inst_length;
295 uint64_t pc;
296 union {
297 struct {
298 uint64_t gpa;
299 } paging;
300
301 struct {
302 uint64_t gpa;
303 struct vm_guest_paging paging;
304 struct vie vie;
305 } inst_emul;
306
307 struct {
308 uint64_t args[8];
309 } ecall;
310
311 struct {
312 enum vm_suspend_how how;
313 } suspended;
314
315 struct {
316 uint64_t scause;
317 } hyp;
318 } u;
319 };
320
321 #endif /* _VMM_H_ */
322