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 204 virt_enabled(void) 205 { 206 207 return (has_hyp()); 208 } 209 210 static __inline int 211 vcpu_rendezvous_pending(struct vm_eventinfo *info) 212 { 213 214 return (*((uintptr_t *)(info->rptr)) != 0); 215 } 216 217 static __inline int 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 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 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