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_DESTROY, 46 VM_SUSPEND_LAST 47 }; 48 49 /* 50 * Identifiers for architecturally defined registers. 51 */ 52 enum vm_reg_name { 53 VM_REG_GUEST_X0 = 0, 54 VM_REG_GUEST_X1, 55 VM_REG_GUEST_X2, 56 VM_REG_GUEST_X3, 57 VM_REG_GUEST_X4, 58 VM_REG_GUEST_X5, 59 VM_REG_GUEST_X6, 60 VM_REG_GUEST_X7, 61 VM_REG_GUEST_X8, 62 VM_REG_GUEST_X9, 63 VM_REG_GUEST_X10, 64 VM_REG_GUEST_X11, 65 VM_REG_GUEST_X12, 66 VM_REG_GUEST_X13, 67 VM_REG_GUEST_X14, 68 VM_REG_GUEST_X15, 69 VM_REG_GUEST_X16, 70 VM_REG_GUEST_X17, 71 VM_REG_GUEST_X18, 72 VM_REG_GUEST_X19, 73 VM_REG_GUEST_X20, 74 VM_REG_GUEST_X21, 75 VM_REG_GUEST_X22, 76 VM_REG_GUEST_X23, 77 VM_REG_GUEST_X24, 78 VM_REG_GUEST_X25, 79 VM_REG_GUEST_X26, 80 VM_REG_GUEST_X27, 81 VM_REG_GUEST_X28, 82 VM_REG_GUEST_X29, 83 VM_REG_GUEST_LR, 84 VM_REG_GUEST_SP, 85 VM_REG_GUEST_PC, 86 VM_REG_GUEST_CPSR, 87 88 VM_REG_GUEST_SCTLR_EL1, 89 VM_REG_GUEST_TTBR0_EL1, 90 VM_REG_GUEST_TTBR1_EL1, 91 VM_REG_GUEST_TCR_EL1, 92 VM_REG_GUEST_TCR2_EL1, 93 VM_REG_GUEST_MPIDR_EL1, 94 VM_REG_LAST 95 }; 96 97 #define VM_INTINFO_VECTOR(info) ((info) & 0xff) 98 #define VM_INTINFO_DEL_ERRCODE 0x800 99 #define VM_INTINFO_RSVD 0x7ffff000 100 #define VM_INTINFO_VALID 0x80000000 101 #define VM_INTINFO_TYPE 0x700 102 #define VM_INTINFO_HWINTR (0 << 8) 103 #define VM_INTINFO_NMI (2 << 8) 104 #define VM_INTINFO_HWEXCEPTION (3 << 8) 105 #define VM_INTINFO_SWINTR (4 << 8) 106 107 #define VM_GUEST_BASE_IPA 0x80000000UL /* Guest kernel start ipa */ 108 109 /* 110 * The VM name has to fit into the pathname length constraints of devfs, 111 * governed primarily by SPECNAMELEN. The length is the total number of 112 * characters in the full path, relative to the mount point and not 113 * including any leading '/' characters. 114 * A prefix and a suffix are added to the name specified by the user. 115 * The prefix is usually "vmm/" or "vmm.io/", but can be a few characters 116 * longer for future use. 117 * The suffix is a string that identifies a bootrom image or some similar 118 * image that is attached to the VM. A separator character gets added to 119 * the suffix automatically when generating the full path, so it must be 120 * accounted for, reducing the effective length by 1. 121 * The effective length of a VM name is 229 bytes for FreeBSD 13 and 37 122 * bytes for FreeBSD 12. A minimum length is set for safety and supports 123 * a SPECNAMELEN as small as 32 on old systems. 124 */ 125 #define VM_MAX_PREFIXLEN 10 126 #define VM_MAX_SUFFIXLEN 15 127 #define VM_MAX_NAMELEN \ 128 (SPECNAMELEN - VM_MAX_PREFIXLEN - VM_MAX_SUFFIXLEN - 1) 129 130 #ifdef _KERNEL 131 struct vm; 132 struct vm_exception; 133 struct vm_exit; 134 struct vm_run; 135 struct vm_object; 136 struct vm_guest_paging; 137 struct vm_vgic_descr; 138 struct pmap; 139 140 struct vm_eventinfo { 141 void *rptr; /* rendezvous cookie */ 142 int *sptr; /* suspend cookie */ 143 int *iptr; /* reqidle cookie */ 144 }; 145 146 int vm_create(const char *name, struct vm **retvm); 147 struct vcpu *vm_alloc_vcpu(struct vm *vm, int vcpuid); 148 void vm_disable_vcpu_creation(struct vm *vm); 149 void vm_slock_vcpus(struct vm *vm); 150 void vm_unlock_vcpus(struct vm *vm); 151 void vm_destroy(struct vm *vm); 152 int vm_reinit(struct vm *vm); 153 const char *vm_name(struct vm *vm); 154 155 uint16_t vm_get_maxcpus(struct vm *vm); 156 void vm_get_topology(struct vm *vm, uint16_t *sockets, uint16_t *cores, 157 uint16_t *threads, uint16_t *maxcpus); 158 int vm_set_topology(struct vm *vm, uint16_t sockets, uint16_t cores, 159 uint16_t threads, uint16_t maxcpus); 160 int vm_get_register(struct vcpu *vcpu, int reg, uint64_t *retval); 161 int vm_set_register(struct vcpu *vcpu, int reg, uint64_t val); 162 int vm_run(struct vcpu *vcpu); 163 int vm_suspend(struct vm *vm, enum vm_suspend_how how); 164 void* vm_get_cookie(struct vm *vm); 165 int vcpu_vcpuid(struct vcpu *vcpu); 166 void *vcpu_get_cookie(struct vcpu *vcpu); 167 struct vm *vcpu_vm(struct vcpu *vcpu); 168 struct vcpu *vm_vcpu(struct vm *vm, int cpu); 169 int vm_get_capability(struct vcpu *vcpu, int type, int *val); 170 int vm_set_capability(struct vcpu *vcpu, int type, int val); 171 int vm_activate_cpu(struct vcpu *vcpu); 172 int vm_suspend_cpu(struct vm *vm, struct vcpu *vcpu); 173 int vm_resume_cpu(struct vm *vm, struct vcpu *vcpu); 174 int vm_inject_exception(struct vcpu *vcpu, uint64_t esr, uint64_t far); 175 int vm_attach_vgic(struct vm *vm, struct vm_vgic_descr *descr); 176 int vm_assert_irq(struct vm *vm, uint32_t irq); 177 int vm_deassert_irq(struct vm *vm, uint32_t irq); 178 int vm_raise_msi(struct vm *vm, uint64_t msg, uint64_t addr, int bus, int slot, 179 int func); 180 struct vm_exit *vm_exitinfo(struct vcpu *vcpu); 181 void vm_exit_suspended(struct vcpu *vcpu, uint64_t pc); 182 void vm_exit_debug(struct vcpu *vcpu, uint64_t pc); 183 void vm_exit_rendezvous(struct vcpu *vcpu, uint64_t pc); 184 void vm_exit_astpending(struct vcpu *vcpu, uint64_t pc); 185 186 cpuset_t vm_active_cpus(struct vm *vm); 187 cpuset_t vm_debug_cpus(struct vm *vm); 188 cpuset_t vm_suspended_cpus(struct vm *vm); 189 190 static __inline int 191 vcpu_rendezvous_pending(struct vm_eventinfo *info) 192 { 193 194 return (*((uintptr_t *)(info->rptr)) != 0); 195 } 196 197 static __inline int 198 vcpu_suspended(struct vm_eventinfo *info) 199 { 200 201 return (*info->sptr); 202 } 203 204 int vcpu_debugged(struct vcpu *vcpu); 205 206 enum vcpu_state { 207 VCPU_IDLE, 208 VCPU_FROZEN, 209 VCPU_RUNNING, 210 VCPU_SLEEPING, 211 }; 212 213 int vcpu_set_state(struct vcpu *vcpu, enum vcpu_state state, bool from_idle); 214 enum vcpu_state vcpu_get_state(struct vcpu *vcpu, int *hostcpu); 215 216 static int __inline 217 vcpu_is_running(struct vcpu *vcpu, int *hostcpu) 218 { 219 return (vcpu_get_state(vcpu, hostcpu) == VCPU_RUNNING); 220 } 221 222 #ifdef _SYS_PROC_H_ 223 static int __inline 224 vcpu_should_yield(struct vcpu *vcpu) 225 { 226 struct thread *td; 227 228 td = curthread; 229 return (td->td_ast != 0 || td->td_owepreempt != 0); 230 } 231 #endif 232 233 void *vcpu_stats(struct vcpu *vcpu); 234 void vcpu_notify_event(struct vcpu *vcpu); 235 struct vmspace *vm_vmspace(struct vm *vm); 236 struct vm_mem *vm_mem(struct vm *vm); 237 238 enum vm_reg_name vm_segment_name(int seg_encoding); 239 240 struct vm_copyinfo { 241 uint64_t gpa; 242 size_t len; 243 void *hva; 244 void *cookie; 245 }; 246 247 #endif /* _KERNEL */ 248 249 #define VM_DIR_READ 0 250 #define VM_DIR_WRITE 1 251 252 #define VM_GP_M_MASK 0x1f 253 #define VM_GP_MMU_ENABLED (1 << 5) 254 255 struct vm_guest_paging { 256 uint64_t ttbr0_addr; 257 uint64_t ttbr1_addr; 258 uint64_t tcr_el1; 259 uint64_t tcr2_el1; 260 int flags; 261 int padding; 262 }; 263 264 struct vie { 265 uint8_t access_size:4, sign_extend:1, dir:1, unused:2; 266 enum vm_reg_name reg; 267 }; 268 269 struct vre { 270 uint32_t inst_syndrome; 271 uint8_t dir:1, unused:7; 272 enum vm_reg_name reg; 273 }; 274 275 /* 276 * Identifiers for optional vmm capabilities 277 */ 278 enum vm_cap_type { 279 VM_CAP_HALT_EXIT, 280 VM_CAP_PAUSE_EXIT, 281 VM_CAP_UNRESTRICTED_GUEST, 282 VM_CAP_BRK_EXIT, 283 VM_CAP_SS_EXIT, 284 VM_CAP_MASK_HWINTR, 285 VM_CAP_MAX 286 }; 287 288 enum vm_exitcode { 289 VM_EXITCODE_BOGUS, 290 VM_EXITCODE_INST_EMUL, 291 VM_EXITCODE_REG_EMUL, 292 VM_EXITCODE_HVC, 293 VM_EXITCODE_SUSPENDED, 294 VM_EXITCODE_HYP, 295 VM_EXITCODE_WFI, 296 VM_EXITCODE_PAGING, 297 VM_EXITCODE_SMCCC, 298 VM_EXITCODE_DEBUG, 299 VM_EXITCODE_BRK, 300 VM_EXITCODE_SS, 301 VM_EXITCODE_MAX 302 }; 303 304 struct vm_exit { 305 enum vm_exitcode exitcode; 306 int inst_length; 307 uint64_t pc; 308 union { 309 /* 310 * ARM specific payload. 311 */ 312 struct { 313 uint32_t exception_nr; 314 uint32_t pad; 315 uint64_t esr_el2; /* Exception Syndrome Register */ 316 uint64_t far_el2; /* Fault Address Register */ 317 uint64_t hpfar_el2; /* Hypervisor IPA Fault Address Register */ 318 } hyp; 319 struct { 320 struct vre vre; 321 } reg_emul; 322 struct { 323 uint64_t gpa; 324 uint64_t esr; 325 } paging; 326 struct { 327 uint64_t gpa; 328 struct vm_guest_paging paging; 329 struct vie vie; 330 } inst_emul; 331 332 /* 333 * A SMCCC call, e.g. starting a core via PSCI. 334 * Further arguments can be read by asking the kernel for 335 * all register values. 336 */ 337 struct { 338 uint64_t func_id; 339 uint64_t args[7]; 340 } smccc_call; 341 342 struct { 343 enum vm_suspend_how how; 344 } suspended; 345 } u; 346 }; 347 348 #endif /* _VMM_H_ */ 349