sys/arm64/include/vmm.h

   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_GUEST_BASE_IPA       0x80000000UL    /* Guest kernel start ipa */
 106
 107 /*
 108  * The VM name has to fit into the pathname length constraints of devfs,
 109  * governed primarily by SPECNAMELEN.  The length is the total number of
 110  * characters in the full path, relative to the mount point and not
 111  * including any leading '/' characters.
 112  * A prefix and a suffix are added to the name specified by the user.
 113  * The prefix is usually "vmm/" or "vmm.io/", but can be a few characters
 114  * longer for future use.
 115  * The suffix is a string that identifies a bootrom image or some similar
 116  * image that is attached to the VM. A separator character gets added to
 117  * the suffix automatically when generating the full path, so it must be
 118  * accounted for, reducing the effective length by 1.
 119  * The effective length of a VM name is 229 bytes for FreeBSD 13 and 37
 120  * bytes for FreeBSD 12.  A minimum length is set for safety and supports
 121  * a SPECNAMELEN as small as 32 on old systems.
 122  */
 123 #define VM_MAX_PREFIXLEN 10
 124 #define VM_MAX_SUFFIXLEN 15
 125 #define VM_MAX_NAMELEN \
 126     (SPECNAMELEN - VM_MAX_PREFIXLEN - VM_MAX_SUFFIXLEN - 1)
 127
 128 #ifdef _KERNEL
 129 struct vm;
 130 struct vm_exception;
 131 struct vm_exit;
 132 struct vm_run;
 133 struct vm_object;
 134 struct vm_guest_paging;
 135 struct vm_vgic_descr;
 136 struct pmap;
 137
 138 struct vm_eventinfo {
 139         void    *rptr;          /* rendezvous cookie */
 140         int     *sptr;          /* suspend cookie */
 141         int     *iptr;          /* reqidle cookie */
 142 };
 143
 144 int vm_create(const char *name, struct vm **retvm);
 145 struct vcpu *vm_alloc_vcpu(struct vm *vm, int vcpuid);
 146 void vm_disable_vcpu_creation(struct vm *vm);
 147 void vm_slock_vcpus(struct vm *vm);
 148 void vm_unlock_vcpus(struct vm *vm);
 149 void vm_destroy(struct vm *vm);
 150 int vm_reinit(struct vm *vm);
 151 const char *vm_name(struct vm *vm);
 152
 153 /*
 154  * APIs that modify the guest memory map require all vcpus to be frozen.
 155  */
 156 void vm_slock_memsegs(struct vm *vm);
 157 void vm_xlock_memsegs(struct vm *vm);
 158 void vm_unlock_memsegs(struct vm *vm);
 159 int vm_mmap_memseg(struct vm *vm, vm_paddr_t gpa, int segid, vm_ooffset_t off,
 160     size_t len, int prot, int flags);
 161 int vm_munmap_memseg(struct vm *vm, vm_paddr_t gpa, size_t len);
 162 int vm_alloc_memseg(struct vm *vm, int ident, size_t len, bool sysmem);
 163 void vm_free_memseg(struct vm *vm, int ident);
 164
 165 /*
 166  * APIs that inspect the guest memory map require only a *single* vcpu to
 167  * be frozen. This acts like a read lock on the guest memory map since any
 168  * modification requires *all* vcpus to be frozen.
 169  */
 170 int vm_mmap_getnext(struct vm *vm, vm_paddr_t *gpa, int *segid,
 171     vm_ooffset_t *segoff, size_t *len, int *prot, int *flags);
 172 int vm_get_memseg(struct vm *vm, int ident, size_t *len, bool *sysmem,
 173     struct vm_object **objptr);
 174 vm_paddr_t vmm_sysmem_maxaddr(struct vm *vm);
 175 void *vm_gpa_hold(struct vcpu *vcpu, vm_paddr_t gpa, size_t len,
 176     int prot, void **cookie);
 177 void *vm_gpa_hold_global(struct vm *vm, vm_paddr_t gpa, size_t len,
 178     int prot, void **cookie);
 179 void vm_gpa_release(void *cookie);
 180 bool vm_mem_allocated(struct vcpu *vcpu, vm_paddr_t gpa);
 181
 182 int vm_gla2gpa_nofault(struct vcpu *vcpu, struct vm_guest_paging *paging,
 183     uint64_t gla, int prot, uint64_t *gpa, int *is_fault);
 184
 185 uint16_t vm_get_maxcpus(struct vm *vm);
 186 void vm_get_topology(struct vm *vm, uint16_t *sockets, uint16_t *cores,
 187     uint16_t *threads, uint16_t *maxcpus);
 188 int vm_set_topology(struct vm *vm, uint16_t sockets, uint16_t cores,
 189     uint16_t threads, uint16_t maxcpus);
 190 int vm_get_register(struct vcpu *vcpu, int reg, uint64_t *retval);
 191 int vm_set_register(struct vcpu *vcpu, int reg, uint64_t val);
 192 int vm_run(struct vcpu *vcpu);
 193 int vm_suspend(struct vm *vm, enum vm_suspend_how how);
 194 void* vm_get_cookie(struct vm *vm);
 195 int vcpu_vcpuid(struct vcpu *vcpu);
 196 void *vcpu_get_cookie(struct vcpu *vcpu);
 197 struct vm *vcpu_vm(struct vcpu *vcpu);
 198 struct vcpu *vm_vcpu(struct vm *vm, int cpu);
 199 int vm_get_capability(struct vcpu *vcpu, int type, int *val);
 200 int vm_set_capability(struct vcpu *vcpu, int type, int val);
 201 int vm_activate_cpu(struct vcpu *vcpu);
 202 int vm_suspend_cpu(struct vm *vm, struct vcpu *vcpu);
 203 int vm_resume_cpu(struct vm *vm, struct vcpu *vcpu);
 204 int vm_inject_exception(struct vcpu *vcpu, uint64_t esr, uint64_t far);
 205 int vm_attach_vgic(struct vm *vm, struct vm_vgic_descr *descr);
 206 int vm_assert_irq(struct vm *vm, uint32_t irq);
 207 int vm_deassert_irq(struct vm *vm, uint32_t irq);
 208 int vm_raise_msi(struct vm *vm, uint64_t msg, uint64_t addr, int bus, int slot,
 209     int func);
 210 struct vm_exit *vm_exitinfo(struct vcpu *vcpu);
 211 void vm_exit_suspended(struct vcpu *vcpu, uint64_t pc);
 212 void vm_exit_debug(struct vcpu *vcpu, uint64_t pc);
 213 void vm_exit_rendezvous(struct vcpu *vcpu, uint64_t pc);
 214 void vm_exit_astpending(struct vcpu *vcpu, uint64_t pc);
 215
 216 cpuset_t vm_active_cpus(struct vm *vm);
 217 cpuset_t vm_debug_cpus(struct vm *vm);
 218 cpuset_t vm_suspended_cpus(struct vm *vm);
 219
 220 static __inline int
 221 vcpu_rendezvous_pending(struct vm_eventinfo *info)
 222 {
 223
 224         return (*((uintptr_t *)(info->rptr)) != 0);
 225 }
 226
 227 static __inline int
 228 vcpu_suspended(struct vm_eventinfo *info)
 229 {
 230
 231         return (*info->sptr);
 232 }
 233
 234 int vcpu_debugged(struct vcpu *vcpu);
 235
 236 enum vcpu_state {
 237         VCPU_IDLE,
 238         VCPU_FROZEN,
 239         VCPU_RUNNING,
 240         VCPU_SLEEPING,
 241 };
 242
 243 int vcpu_set_state(struct vcpu *vcpu, enum vcpu_state state, bool from_idle);
 244 enum vcpu_state vcpu_get_state(struct vcpu *vcpu, int *hostcpu);
 245
 246 static int __inline
 247 vcpu_is_running(struct vcpu *vcpu, int *hostcpu)
 248 {
 249         return (vcpu_get_state(vcpu, hostcpu) == VCPU_RUNNING);
 250 }
 251
 252 #ifdef _SYS_PROC_H_
 253 static int __inline
 254 vcpu_should_yield(struct vcpu *vcpu)
 255 {
 256         struct thread *td;
 257
 258         td = curthread;
 259         return (td->td_ast != 0 || td->td_owepreempt != 0);
 260 }
 261 #endif
 262
 263 void *vcpu_stats(struct vcpu *vcpu);
 264 void vcpu_notify_event(struct vcpu *vcpu);
 265
 266 enum vm_reg_name vm_segment_name(int seg_encoding);
 267
 268 struct vm_copyinfo {
 269         uint64_t        gpa;
 270         size_t          len;
 271         void            *hva;
 272         void            *cookie;
 273 };
 274
 275 #endif  /* _KERNEL */
 276
 277 #define VM_DIR_READ     0
 278 #define VM_DIR_WRITE    1
 279
 280 #define VM_GP_M_MASK            0x1f
 281 #define VM_GP_MMU_ENABLED       (1 << 5)
 282
 283 struct vm_guest_paging {
 284         uint64_t        ttbr0_addr;
 285         uint64_t        ttbr1_addr;
 286         uint64_t        tcr_el1;
 287         uint64_t        tcr2_el1;
 288         int             flags;
 289         int             padding;
 290 };
 291
 292 struct vie {
 293         uint8_t access_size:4, sign_extend:1, dir:1, unused:2;
 294         enum vm_reg_name reg;
 295 };
 296
 297 struct vre {
 298         uint32_t inst_syndrome;
 299         uint8_t dir:1, unused:7;
 300         enum vm_reg_name reg;
 301 };
 302
 303 /*
 304  * Identifiers for optional vmm capabilities
 305  */
 306 enum vm_cap_type {
 307         VM_CAP_HALT_EXIT,
 308         VM_CAP_PAUSE_EXIT,
 309         VM_CAP_UNRESTRICTED_GUEST,
 310         VM_CAP_BRK_EXIT,
 311         VM_CAP_SS_EXIT,
 312         VM_CAP_MASK_HWINTR,
 313         VM_CAP_MAX
 314 };
 315
 316 enum vm_exitcode {
 317         VM_EXITCODE_BOGUS,
 318         VM_EXITCODE_INST_EMUL,
 319         VM_EXITCODE_REG_EMUL,
 320         VM_EXITCODE_HVC,
 321         VM_EXITCODE_SUSPENDED,
 322         VM_EXITCODE_HYP,
 323         VM_EXITCODE_WFI,
 324         VM_EXITCODE_PAGING,
 325         VM_EXITCODE_SMCCC,
 326         VM_EXITCODE_DEBUG,
 327         VM_EXITCODE_BRK,
 328         VM_EXITCODE_SS,
 329         VM_EXITCODE_MAX
 330 };
 331
 332 struct vm_exit {
 333         enum vm_exitcode        exitcode;
 334         int                     inst_length;
 335         uint64_t                pc;
 336         union {
 337                 /*
 338                  * ARM specific payload.
 339                  */
 340                 struct {
 341                         uint32_t        exception_nr;
 342                         uint32_t        pad;
 343                         uint64_t        esr_el2;        /* Exception Syndrome Register */
 344                         uint64_t        far_el2;        /* Fault Address Register */
 345                         uint64_t        hpfar_el2;      /* Hypervisor IPA Fault Address Register */
 346                 } hyp;
 347                 struct {
 348                         struct vre      vre;
 349                 } reg_emul;
 350                 struct {
 351                         uint64_t        gpa;
 352                         uint64_t        esr;
 353                 } paging;
 354                 struct {
 355                         uint64_t        gpa;
 356                         struct vm_guest_paging paging;
 357                         struct vie      vie;
 358                 } inst_emul;
 359
 360                 /*
 361                  * A SMCCC call, e.g. starting a core via PSCI.
 362                  * Further arguments can be read by asking the kernel for
 363                  * all register values.
 364                  */
 365                 struct {
 366                         uint64_t        func_id;
 367                         uint64_t        args[7];
 368                 } smccc_call;
 369
 370                 struct {
 371                         enum vm_suspend_how how;
 372                 } suspended;
 373         } u;
 374 };
 375
 376 #endif  /* _VMM_H_ */