1 /*
2 * Copyright (C) 2015 Mihai Carabas <mihai.carabas@gmail.com>
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 AUTHOR AND CONTRIBUTORS ``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 AUTHOR 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
27 #ifndef _VMM_H_
28 #define _VMM_H_
29
30 #include <sys/param.h>
31 #include <sys/cpuset.h>
32 #include <vm/vm.h>
33 #include <vm/pmap.h>
34
35 #include "pte.h"
36 #include "pmap.h"
37
38 struct vcpu;
39
40 enum vm_suspend_how {
41 VM_SUSPEND_NONE,
42 VM_SUSPEND_RESET,
43 VM_SUSPEND_POWEROFF,
44 VM_SUSPEND_HALT,
45 VM_SUSPEND_LAST
46 };
47
48 /*
49 * Identifiers for architecturally defined registers.
50 */
51 enum vm_reg_name {
52 VM_REG_GUEST_X0 = 0,
53 VM_REG_GUEST_X1,
54 VM_REG_GUEST_X2,
55 VM_REG_GUEST_X3,
56 VM_REG_GUEST_X4,
57 VM_REG_GUEST_X5,
58 VM_REG_GUEST_X6,
59 VM_REG_GUEST_X7,
60 VM_REG_GUEST_X8,
61 VM_REG_GUEST_X9,
62 VM_REG_GUEST_X10,
63 VM_REG_GUEST_X11,
64 VM_REG_GUEST_X12,
65 VM_REG_GUEST_X13,
66 VM_REG_GUEST_X14,
67 VM_REG_GUEST_X15,
68 VM_REG_GUEST_X16,
69 VM_REG_GUEST_X17,
70 VM_REG_GUEST_X18,
71 VM_REG_GUEST_X19,
72 VM_REG_GUEST_X20,
73 VM_REG_GUEST_X21,
74 VM_REG_GUEST_X22,
75 VM_REG_GUEST_X23,
76 VM_REG_GUEST_X24,
77 VM_REG_GUEST_X25,
78 VM_REG_GUEST_X26,
79 VM_REG_GUEST_X27,
80 VM_REG_GUEST_X28,
81 VM_REG_GUEST_X29,
82 VM_REG_GUEST_LR,
83 VM_REG_GUEST_SP,
84 VM_REG_GUEST_PC,
85 VM_REG_GUEST_CPSR,
86
87 VM_REG_GUEST_SCTLR_EL1,
88 VM_REG_GUEST_TTBR0_EL1,
89 VM_REG_GUEST_TTBR1_EL1,
90 VM_REG_GUEST_TCR_EL1,
91 VM_REG_GUEST_TCR2_EL1,
92 VM_REG_LAST
93 };
94
95 #define VM_INTINFO_VECTOR(info) ((info) & 0xff)
96 #define VM_INTINFO_DEL_ERRCODE 0x800
97 #define VM_INTINFO_RSVD 0x7ffff000
98 #define VM_INTINFO_VALID 0x80000000
99 #define VM_INTINFO_TYPE 0x700
100 #define VM_INTINFO_HWINTR (0 << 8)
101 #define VM_INTINFO_NMI (2 << 8)
102 #define VM_INTINFO_HWEXCEPTION (3 << 8)
103 #define VM_INTINFO_SWINTR (4 << 8)
104
105 #define VM_MAX_SUFFIXLEN 15
106
107 #define VM_GUEST_BASE_IPA 0x80000000UL /* Guest kernel start ipa */
108
109 #ifdef _KERNEL
110
111 #define VM_MAX_NAMELEN 32
112
113 struct vm;
114 struct vm_exception;
115 struct vm_exit;
116 struct vm_run;
117 struct vm_object;
118 struct vm_guest_paging;
119 struct vm_vgic_descr;
120 struct pmap;
121
122 struct vm_eventinfo {
123 void *rptr; /* rendezvous cookie */
124 int *sptr; /* suspend cookie */
125 int *iptr; /* reqidle cookie */
126 };
127
128 int vm_create(const char *name, struct vm **retvm);
129 struct vcpu *vm_alloc_vcpu(struct vm *vm, int vcpuid);
130 void vm_slock_vcpus(struct vm *vm);
131 void vm_unlock_vcpus(struct vm *vm);
132 void vm_destroy(struct vm *vm);
133 int vm_reinit(struct vm *vm);
134 const char *vm_name(struct vm *vm);
135
136 /*
137 * APIs that modify the guest memory map require all vcpus to be frozen.
138 */
139 void vm_slock_memsegs(struct vm *vm);
140 void vm_xlock_memsegs(struct vm *vm);
141 void vm_unlock_memsegs(struct vm *vm);
142 int vm_mmap_memseg(struct vm *vm, vm_paddr_t gpa, int segid, vm_ooffset_t off,
143 size_t len, int prot, int flags);
144 int vm_munmap_memseg(struct vm *vm, vm_paddr_t gpa, size_t len);
145 int vm_alloc_memseg(struct vm *vm, int ident, size_t len, bool sysmem);
146 void vm_free_memseg(struct vm *vm, int ident);
147
148 /*
149 * APIs that inspect the guest memory map require only a *single* vcpu to
150 * be frozen. This acts like a read lock on the guest memory map since any
151 * modification requires *all* vcpus to be frozen.
152 */
153 int vm_mmap_getnext(struct vm *vm, vm_paddr_t *gpa, int *segid,
154 vm_ooffset_t *segoff, size_t *len, int *prot, int *flags);
155 int vm_get_memseg(struct vm *vm, int ident, size_t *len, bool *sysmem,
156 struct vm_object **objptr);
157 vm_paddr_t vmm_sysmem_maxaddr(struct vm *vm);
158 void *vm_gpa_hold(struct vcpu *vcpu, vm_paddr_t gpa, size_t len,
159 int prot, void **cookie);
160 void *vm_gpa_hold_global(struct vm *vm, vm_paddr_t gpa, size_t len,
161 int prot, void **cookie);
162 void vm_gpa_release(void *cookie);
163 bool vm_mem_allocated(struct vcpu *vcpu, vm_paddr_t gpa);
164
165 int vm_gla2gpa_nofault(struct vcpu *vcpu, struct vm_guest_paging *paging,
166 uint64_t gla, int prot, uint64_t *gpa, int *is_fault);
167
168 uint16_t vm_get_maxcpus(struct vm *vm);
169 void vm_get_topology(struct vm *vm, uint16_t *sockets, uint16_t *cores,
170 uint16_t *threads, uint16_t *maxcpus);
171 int vm_set_topology(struct vm *vm, uint16_t sockets, uint16_t cores,
172 uint16_t threads, uint16_t maxcpus);
173 int vm_get_register(struct vcpu *vcpu, int reg, uint64_t *retval);
174 int vm_set_register(struct vcpu *vcpu, int reg, uint64_t val);
175 int vm_run(struct vcpu *vcpu);
176 int vm_suspend(struct vm *vm, enum vm_suspend_how how);
177 void* vm_get_cookie(struct vm *vm);
178 int vcpu_vcpuid(struct vcpu *vcpu);
179 void *vcpu_get_cookie(struct vcpu *vcpu);
180 struct vm *vcpu_vm(struct vcpu *vcpu);
181 struct vcpu *vm_vcpu(struct vm *vm, int cpu);
182 int vm_get_capability(struct vcpu *vcpu, int type, int *val);
183 int vm_set_capability(struct vcpu *vcpu, int type, int val);
184 int vm_activate_cpu(struct vcpu *vcpu);
185 int vm_suspend_cpu(struct vm *vm, struct vcpu *vcpu);
186 int vm_resume_cpu(struct vm *vm, struct vcpu *vcpu);
187 int vm_inject_exception(struct vcpu *vcpu, uint64_t esr, uint64_t far);
188 int vm_attach_vgic(struct vm *vm, struct vm_vgic_descr *descr);
189 int vm_assert_irq(struct vm *vm, uint32_t irq);
190 int vm_deassert_irq(struct vm *vm, uint32_t irq);
191 int vm_raise_msi(struct vm *vm, uint64_t msg, uint64_t addr, int bus, int slot,
192 int func);
193 struct vm_exit *vm_exitinfo(struct vcpu *vcpu);
194 void vm_exit_suspended(struct vcpu *vcpu, uint64_t pc);
195 void vm_exit_debug(struct vcpu *vcpu, uint64_t pc);
196 void vm_exit_rendezvous(struct vcpu *vcpu, uint64_t pc);
197 void vm_exit_astpending(struct vcpu *vcpu, uint64_t pc);
198
199 cpuset_t vm_active_cpus(struct vm *vm);
200 cpuset_t vm_debug_cpus(struct vm *vm);
201 cpuset_t vm_suspended_cpus(struct vm *vm);
202
203 static __inline bool
virt_enabled(void)204 virt_enabled(void)
205 {
206
207 return (has_hyp());
208 }
209
210 static __inline int
vcpu_rendezvous_pending(struct vm_eventinfo * info)211 vcpu_rendezvous_pending(struct vm_eventinfo *info)
212 {
213
214 return (*((uintptr_t *)(info->rptr)) != 0);
215 }
216
217 static __inline int
vcpu_suspended(struct vm_eventinfo * info)218 vcpu_suspended(struct vm_eventinfo *info)
219 {
220
221 return (*info->sptr);
222 }
223
224 int vcpu_debugged(struct vcpu *vcpu);
225
226 enum vcpu_state {
227 VCPU_IDLE,
228 VCPU_FROZEN,
229 VCPU_RUNNING,
230 VCPU_SLEEPING,
231 };
232
233 int vcpu_set_state(struct vcpu *vcpu, enum vcpu_state state, bool from_idle);
234 enum vcpu_state vcpu_get_state(struct vcpu *vcpu, int *hostcpu);
235
236 static int __inline
vcpu_is_running(struct vcpu * vcpu,int * hostcpu)237 vcpu_is_running(struct vcpu *vcpu, int *hostcpu)
238 {
239 return (vcpu_get_state(vcpu, hostcpu) == VCPU_RUNNING);
240 }
241
242 #ifdef _SYS_PROC_H_
243 static int __inline
vcpu_should_yield(struct vcpu * vcpu)244 vcpu_should_yield(struct vcpu *vcpu)
245 {
246 struct thread *td;
247
248 td = curthread;
249 return (td->td_ast != 0 || td->td_owepreempt != 0);
250 }
251 #endif
252
253 void *vcpu_stats(struct vcpu *vcpu);
254 void vcpu_notify_event(struct vcpu *vcpu);
255
256 enum vm_reg_name vm_segment_name(int seg_encoding);
257
258 struct vm_copyinfo {
259 uint64_t gpa;
260 size_t len;
261 void *hva;
262 void *cookie;
263 };
264
265 #endif /* _KERNEL */
266
267 #define VM_DIR_READ 0
268 #define VM_DIR_WRITE 1
269
270 #define VM_GP_M_MASK 0x1f
271 #define VM_GP_MMU_ENABLED (1 << 5)
272
273 struct vm_guest_paging {
274 uint64_t ttbr0_addr;
275 uint64_t ttbr1_addr;
276 uint64_t tcr_el1;
277 uint64_t tcr2_el1;
278 int flags;
279 int padding;
280 };
281
282 struct vie {
283 uint8_t access_size:4, sign_extend:1, dir:1, unused:2;
284 enum vm_reg_name reg;
285 };
286
287 struct vre {
288 uint32_t inst_syndrome;
289 uint8_t dir:1, unused:7;
290 enum vm_reg_name reg;
291 };
292
293 /*
294 * Identifiers for optional vmm capabilities
295 */
296 enum vm_cap_type {
297 VM_CAP_HALT_EXIT,
298 VM_CAP_MTRAP_EXIT,
299 VM_CAP_PAUSE_EXIT,
300 VM_CAP_UNRESTRICTED_GUEST,
301 VM_CAP_MAX
302 };
303
304 enum vm_exitcode {
305 VM_EXITCODE_BOGUS,
306 VM_EXITCODE_INST_EMUL,
307 VM_EXITCODE_REG_EMUL,
308 VM_EXITCODE_HVC,
309 VM_EXITCODE_SUSPENDED,
310 VM_EXITCODE_HYP,
311 VM_EXITCODE_WFI,
312 VM_EXITCODE_PAGING,
313 VM_EXITCODE_SMCCC,
314 VM_EXITCODE_DEBUG,
315 VM_EXITCODE_MAX
316 };
317
318 struct vm_exit {
319 enum vm_exitcode exitcode;
320 int inst_length;
321 uint64_t pc;
322 union {
323 /*
324 * ARM specific payload.
325 */
326 struct {
327 uint32_t exception_nr;
328 uint32_t pad;
329 uint64_t esr_el2; /* Exception Syndrome Register */
330 uint64_t far_el2; /* Fault Address Register */
331 uint64_t hpfar_el2; /* Hypervisor IPA Fault Address Register */
332 } hyp;
333 struct {
334 struct vre vre;
335 } reg_emul;
336 struct {
337 uint64_t gpa;
338 uint64_t esr;
339 } paging;
340 struct {
341 uint64_t gpa;
342 struct vm_guest_paging paging;
343 struct vie vie;
344 } inst_emul;
345
346 /*
347 * A SMCCC call, e.g. starting a core via PSCI.
348 * Further arguments can be read by asking the kernel for
349 * all register values.
350 */
351 struct {
352 uint64_t func_id;
353 uint64_t args[7];
354 } smccc_call;
355
356 struct {
357 enum vm_suspend_how how;
358 } suspended;
359 } u;
360 };
361
362 #endif /* _VMM_H_ */
363