1/* 2 * QEMU KVM support -- ARM specific functions. 3 * 4 * Copyright (c) 2012 Linaro Limited 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or later. 7 * See the COPYING file in the top-level directory. 8 * 9 */ 10 11#ifndef QEMU_KVM_ARM_H 12#define QEMU_KVM_ARM_H 13 14#include "sysemu/kvm.h" 15#include "exec/memory.h" 16#include "qemu/error-report.h" 17 18/** 19 * kvm_arm_vcpu_init: 20 * @cs: CPUState 21 * 22 * Initialize (or reinitialize) the VCPU by invoking the 23 * KVM_ARM_VCPU_INIT ioctl with the CPU type and feature 24 * bitmask specified in the CPUState. 25 * 26 * Returns: 0 if success else < 0 error code 27 */ 28int kvm_arm_vcpu_init(CPUState *cs); 29 30/** 31 * kvm_arm_register_device: 32 * @mr: memory region for this device 33 * @devid: the KVM device ID 34 * @group: device control API group for setting addresses 35 * @attr: device control API address type 36 * @dev_fd: device control device file descriptor (or -1 if not supported) 37 * 38 * Remember the memory region @mr, and when it is mapped by the 39 * machine model, tell the kernel that base address using the 40 * KVM_ARM_SET_DEVICE_ADDRESS ioctl or the newer device control API. @devid 41 * should be the ID of the device as defined by KVM_ARM_SET_DEVICE_ADDRESS or 42 * the arm-vgic device in the device control API. 43 * The machine model may map 44 * and unmap the device multiple times; the kernel will only be told the final 45 * address at the point where machine init is complete. 46 */ 47void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid, uint64_t group, 48 uint64_t attr, int dev_fd); 49 50/** 51 * kvm_arm_init_cpreg_list: 52 * @cs: CPUState 53 * 54 * Initialize the CPUState's cpreg list according to the kernel's 55 * definition of what CPU registers it knows about (and throw away 56 * the previous TCG-created cpreg list). 57 * 58 * Returns: 0 if success, else < 0 error code 59 */ 60int kvm_arm_init_cpreg_list(ARMCPU *cpu); 61 62/** 63 * kvm_arm_reg_syncs_via_cpreg_list 64 * regidx: KVM register index 65 * 66 * Return true if this KVM register should be synchronized via the 67 * cpreg list of arbitrary system registers, false if it is synchronized 68 * by hand using code in kvm_arch_get/put_registers(). 69 */ 70bool kvm_arm_reg_syncs_via_cpreg_list(uint64_t regidx); 71 72/** 73 * kvm_arm_cpreg_level 74 * regidx: KVM register index 75 * 76 * Return the level of this coprocessor/system register. Return value is 77 * either KVM_PUT_RUNTIME_STATE, KVM_PUT_RESET_STATE, or KVM_PUT_FULL_STATE. 78 */ 79int kvm_arm_cpreg_level(uint64_t regidx); 80 81/** 82 * write_list_to_kvmstate: 83 * @cpu: ARMCPU 84 * @level: the state level to sync 85 * 86 * For each register listed in the ARMCPU cpreg_indexes list, write 87 * its value from the cpreg_values list into the kernel (via ioctl). 88 * This updates KVM's working data structures from TCG data or 89 * from incoming migration state. 90 * 91 * Returns: true if all register values were updated correctly, 92 * false if some register was unknown to the kernel or could not 93 * be written (eg constant register with the wrong value). 94 * Note that we do not stop early on failure -- we will attempt 95 * writing all registers in the list. 96 */ 97bool write_list_to_kvmstate(ARMCPU *cpu, int level); 98 99/** 100 * write_kvmstate_to_list: 101 * @cpu: ARMCPU 102 * 103 * For each register listed in the ARMCPU cpreg_indexes list, write 104 * its value from the kernel into the cpreg_values list. This is used to 105 * copy info from KVM's working data structures into TCG or 106 * for outbound migration. 107 * 108 * Returns: true if all register values were read correctly, 109 * false if some register was unknown or could not be read. 110 * Note that we do not stop early on failure -- we will attempt 111 * reading all registers in the list. 112 */ 113bool write_kvmstate_to_list(ARMCPU *cpu); 114 115/** 116 * kvm_arm_reset_vcpu: 117 * @cpu: ARMCPU 118 * 119 * Called at reset time to kernel registers to their initial values. 120 */ 121void kvm_arm_reset_vcpu(ARMCPU *cpu); 122 123#ifdef CONFIG_KVM 124/** 125 * kvm_arm_create_scratch_host_vcpu: 126 * @cpus_to_try: array of QEMU_KVM_ARM_TARGET_* values (terminated with 127 * QEMU_KVM_ARM_TARGET_NONE) to try as fallback if the kernel does not 128 * know the PREFERRED_TARGET ioctl. Passing NULL is the same as passing 129 * an empty array. 130 * @fdarray: filled in with kvmfd, vmfd, cpufd file descriptors in that order 131 * @init: filled in with the necessary values for creating a host 132 * vcpu. If NULL is provided, will not init the vCPU (though the cpufd 133 * will still be set up). 134 * 135 * Create a scratch vcpu in its own VM of the type preferred by the host 136 * kernel (as would be used for '-cpu host'), for purposes of probing it 137 * for capabilities. 138 * 139 * Returns: true on success (and fdarray and init are filled in), 140 * false on failure (and fdarray and init are not valid). 141 */ 142bool kvm_arm_create_scratch_host_vcpu(const uint32_t *cpus_to_try, 143 int *fdarray, 144 struct kvm_vcpu_init *init); 145 146/** 147 * kvm_arm_destroy_scratch_host_vcpu: 148 * @fdarray: array of fds as set up by kvm_arm_create_scratch_host_vcpu 149 * 150 * Tear down the scratch vcpu created by kvm_arm_create_scratch_host_vcpu. 151 */ 152void kvm_arm_destroy_scratch_host_vcpu(int *fdarray); 153 154#define TYPE_ARM_HOST_CPU "host-" TYPE_ARM_CPU 155 156/** 157 * ARMHostCPUFeatures: information about the host CPU (identified 158 * by asking the host kernel) 159 */ 160typedef struct ARMHostCPUFeatures { 161 uint64_t features; 162 uint32_t target; 163 const char *dtb_compatible; 164} ARMHostCPUFeatures; 165 166/** 167 * kvm_arm_get_host_cpu_features: 168 * @ahcc: ARMHostCPUClass to fill in 169 * 170 * Probe the capabilities of the host kernel's preferred CPU and fill 171 * in the ARMHostCPUClass struct accordingly. 172 */ 173bool kvm_arm_get_host_cpu_features(ARMHostCPUFeatures *ahcf); 174 175/** 176 * kvm_arm_set_cpu_features_from_host: 177 * @cpu: ARMCPU to set the features for 178 * 179 * Set up the ARMCPU struct fields up to match the information probed 180 * from the host CPU. 181 */ 182void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu); 183 184/** 185 * kvm_arm_sync_mpstate_to_kvm 186 * @cpu: ARMCPU 187 * 188 * If supported set the KVM MP_STATE based on QEMU's model. 189 */ 190int kvm_arm_sync_mpstate_to_kvm(ARMCPU *cpu); 191 192/** 193 * kvm_arm_sync_mpstate_to_qemu 194 * @cpu: ARMCPU 195 * 196 * If supported get the MP_STATE from KVM and store in QEMU's model. 197 */ 198int kvm_arm_sync_mpstate_to_qemu(ARMCPU *cpu); 199 200int kvm_arm_vgic_probe(void); 201 202void kvm_arm_pmu_set_irq(CPUState *cs, int irq); 203void kvm_arm_pmu_init(CPUState *cs); 204 205#else 206 207static inline void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu) 208{ 209 /* This should never actually be called in the "not KVM" case, 210 * but set up the fields to indicate an error anyway. 211 */ 212 cpu->kvm_target = QEMU_KVM_ARM_TARGET_NONE; 213 cpu->host_cpu_probe_failed = true; 214} 215 216static inline int kvm_arm_vgic_probe(void) 217{ 218 return 0; 219} 220 221static inline void kvm_arm_pmu_set_irq(CPUState *cs, int irq) {} 222static inline void kvm_arm_pmu_init(CPUState *cs) {} 223 224#endif 225 226static inline const char *gic_class_name(void) 227{ 228 return kvm_irqchip_in_kernel() ? "kvm-arm-gic" : "arm_gic"; 229} 230 231/** 232 * gicv3_class_name 233 * 234 * Return name of GICv3 class to use depending on whether KVM acceleration is 235 * in use. May throw an error if the chosen implementation is not available. 236 * 237 * Returns: class name to use 238 */ 239static inline const char *gicv3_class_name(void) 240{ 241 if (kvm_irqchip_in_kernel()) { 242#ifdef TARGET_AARCH64 243 return "kvm-arm-gicv3"; 244#else 245 error_report("KVM GICv3 acceleration is not supported on this " 246 "platform"); 247 exit(1); 248#endif 249 } else { 250 if (kvm_enabled()) { 251 error_report("Userspace GICv3 is not supported with KVM"); 252 exit(1); 253 } 254 return "arm-gicv3"; 255 } 256} 257 258/** 259 * kvm_arm_handle_debug: 260 * @cs: CPUState 261 * @debug_exit: debug part of the KVM exit structure 262 * 263 * Returns: TRUE if the debug exception was handled. 264 */ 265bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit); 266 267/** 268 * kvm_arm_hw_debug_active: 269 * @cs: CPU State 270 * 271 * Return: TRUE if any hardware breakpoints in use. 272 */ 273 274bool kvm_arm_hw_debug_active(CPUState *cs); 275 276/** 277 * kvm_arm_copy_hw_debug_data: 278 * 279 * @ptr: kvm_guest_debug_arch structure 280 * 281 * Copy the architecture specific debug registers into the 282 * kvm_guest_debug ioctl structure. 283 */ 284struct kvm_guest_debug_arch; 285 286void kvm_arm_copy_hw_debug_data(struct kvm_guest_debug_arch *ptr); 287 288/** 289 * its_class_name 290 * 291 * Return the ITS class name to use depending on whether KVM acceleration 292 * and KVM CAP_SIGNAL_MSI are supported 293 * 294 * Returns: class name to use or NULL 295 */ 296static inline const char *its_class_name(void) 297{ 298 if (kvm_irqchip_in_kernel()) { 299 /* KVM implementation requires this capability */ 300 return kvm_direct_msi_enabled() ? "arm-its-kvm" : NULL; 301 } else { 302 /* Software emulation is not implemented yet */ 303 return NULL; 304 } 305} 306 307#endif 308