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#define KVM_ARM_VGIC_V2 (1 << 0) 19#define KVM_ARM_VGIC_V3 (1 << 1) 20 21/** 22 * kvm_arm_vcpu_init: 23 * @cs: CPUState 24 * 25 * Initialize (or reinitialize) the VCPU by invoking the 26 * KVM_ARM_VCPU_INIT ioctl with the CPU type and feature 27 * bitmask specified in the CPUState. 28 * 29 * Returns: 0 if success else < 0 error code 30 */ 31int kvm_arm_vcpu_init(CPUState *cs); 32 33/** 34 * kvm_arm_vcpu_finalize: 35 * @cs: CPUState 36 * @feature: feature to finalize 37 * 38 * Finalizes the configuration of the specified VCPU feature by 39 * invoking the KVM_ARM_VCPU_FINALIZE ioctl. Features requiring 40 * this are documented in the "KVM_ARM_VCPU_FINALIZE" section of 41 * KVM's API documentation. 42 * 43 * Returns: 0 if success else < 0 error code 44 */ 45int kvm_arm_vcpu_finalize(CPUState *cs, int feature); 46 47/** 48 * kvm_arm_register_device: 49 * @mr: memory region for this device 50 * @devid: the KVM device ID 51 * @group: device control API group for setting addresses 52 * @attr: device control API address type 53 * @dev_fd: device control device file descriptor (or -1 if not supported) 54 * @addr_ormask: value to be OR'ed with resolved address 55 * 56 * Remember the memory region @mr, and when it is mapped by the 57 * machine model, tell the kernel that base address using the 58 * KVM_ARM_SET_DEVICE_ADDRESS ioctl or the newer device control API. @devid 59 * should be the ID of the device as defined by KVM_ARM_SET_DEVICE_ADDRESS or 60 * the arm-vgic device in the device control API. 61 * The machine model may map 62 * and unmap the device multiple times; the kernel will only be told the final 63 * address at the point where machine init is complete. 64 */ 65void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid, uint64_t group, 66 uint64_t attr, int dev_fd, uint64_t addr_ormask); 67 68/** 69 * kvm_arm_init_cpreg_list: 70 * @cpu: ARMCPU 71 * 72 * Initialize the ARMCPU cpreg list according to the kernel's 73 * definition of what CPU registers it knows about (and throw away 74 * the previous TCG-created cpreg list). 75 * 76 * Returns: 0 if success, else < 0 error code 77 */ 78int kvm_arm_init_cpreg_list(ARMCPU *cpu); 79 80/** 81 * kvm_arm_reg_syncs_via_cpreg_list: 82 * @regidx: KVM register index 83 * 84 * Return true if this KVM register should be synchronized via the 85 * cpreg list of arbitrary system registers, false if it is synchronized 86 * by hand using code in kvm_arch_get/put_registers(). 87 */ 88bool kvm_arm_reg_syncs_via_cpreg_list(uint64_t regidx); 89 90/** 91 * kvm_arm_cpreg_level: 92 * @regidx: KVM register index 93 * 94 * Return the level of this coprocessor/system register. Return value is 95 * either KVM_PUT_RUNTIME_STATE, KVM_PUT_RESET_STATE, or KVM_PUT_FULL_STATE. 96 */ 97int kvm_arm_cpreg_level(uint64_t regidx); 98 99/** 100 * write_list_to_kvmstate: 101 * @cpu: ARMCPU 102 * @level: the state level to sync 103 * 104 * For each register listed in the ARMCPU cpreg_indexes list, write 105 * its value from the cpreg_values list into the kernel (via ioctl). 106 * This updates KVM's working data structures from TCG data or 107 * from incoming migration state. 108 * 109 * Returns: true if all register values were updated correctly, 110 * false if some register was unknown to the kernel or could not 111 * be written (eg constant register with the wrong value). 112 * Note that we do not stop early on failure -- we will attempt 113 * writing all registers in the list. 114 */ 115bool write_list_to_kvmstate(ARMCPU *cpu, int level); 116 117/** 118 * write_kvmstate_to_list: 119 * @cpu: ARMCPU 120 * 121 * For each register listed in the ARMCPU cpreg_indexes list, write 122 * its value from the kernel into the cpreg_values list. This is used to 123 * copy info from KVM's working data structures into TCG or 124 * for outbound migration. 125 * 126 * Returns: true if all register values were read correctly, 127 * false if some register was unknown or could not be read. 128 * Note that we do not stop early on failure -- we will attempt 129 * reading all registers in the list. 130 */ 131bool write_kvmstate_to_list(ARMCPU *cpu); 132 133/** 134 * kvm_arm_cpu_pre_save: 135 * @cpu: ARMCPU 136 * 137 * Called after write_kvmstate_to_list() from cpu_pre_save() to update 138 * the cpreg list with KVM CPU state. 139 */ 140void kvm_arm_cpu_pre_save(ARMCPU *cpu); 141 142/** 143 * kvm_arm_cpu_post_load: 144 * @cpu: ARMCPU 145 * 146 * Called from cpu_post_load() to update KVM CPU state from the cpreg list. 147 */ 148void kvm_arm_cpu_post_load(ARMCPU *cpu); 149 150/** 151 * kvm_arm_reset_vcpu: 152 * @cpu: ARMCPU 153 * 154 * Called at reset time to kernel registers to their initial values. 155 */ 156void kvm_arm_reset_vcpu(ARMCPU *cpu); 157 158/** 159 * kvm_arm_init_serror_injection: 160 * @cs: CPUState 161 * 162 * Check whether KVM can set guest SError syndrome. 163 */ 164void kvm_arm_init_serror_injection(CPUState *cs); 165 166/** 167 * kvm_get_vcpu_events: 168 * @cpu: ARMCPU 169 * 170 * Get VCPU related state from kvm. 171 * 172 * Returns: 0 if success else < 0 error code 173 */ 174int kvm_get_vcpu_events(ARMCPU *cpu); 175 176/** 177 * kvm_put_vcpu_events: 178 * @cpu: ARMCPU 179 * 180 * Put VCPU related state to kvm. 181 * 182 * Returns: 0 if success else < 0 error code 183 */ 184int kvm_put_vcpu_events(ARMCPU *cpu); 185 186#ifdef CONFIG_KVM 187/** 188 * kvm_arm_create_scratch_host_vcpu: 189 * @cpus_to_try: array of QEMU_KVM_ARM_TARGET_* values (terminated with 190 * QEMU_KVM_ARM_TARGET_NONE) to try as fallback if the kernel does not 191 * know the PREFERRED_TARGET ioctl. Passing NULL is the same as passing 192 * an empty array. 193 * @fdarray: filled in with kvmfd, vmfd, cpufd file descriptors in that order 194 * @init: filled in with the necessary values for creating a host 195 * vcpu. If NULL is provided, will not init the vCPU (though the cpufd 196 * will still be set up). 197 * 198 * Create a scratch vcpu in its own VM of the type preferred by the host 199 * kernel (as would be used for '-cpu host'), for purposes of probing it 200 * for capabilities. 201 * 202 * Returns: true on success (and fdarray and init are filled in), 203 * false on failure (and fdarray and init are not valid). 204 */ 205bool kvm_arm_create_scratch_host_vcpu(const uint32_t *cpus_to_try, 206 int *fdarray, 207 struct kvm_vcpu_init *init); 208 209/** 210 * kvm_arm_destroy_scratch_host_vcpu: 211 * @fdarray: array of fds as set up by kvm_arm_create_scratch_host_vcpu 212 * 213 * Tear down the scratch vcpu created by kvm_arm_create_scratch_host_vcpu. 214 */ 215void kvm_arm_destroy_scratch_host_vcpu(int *fdarray); 216 217#define TYPE_ARM_HOST_CPU "host-" TYPE_ARM_CPU 218 219/** 220 * ARMHostCPUFeatures: information about the host CPU (identified 221 * by asking the host kernel) 222 */ 223typedef struct ARMHostCPUFeatures { 224 ARMISARegisters isar; 225 uint64_t features; 226 uint32_t target; 227 const char *dtb_compatible; 228} ARMHostCPUFeatures; 229 230/** 231 * kvm_arm_get_host_cpu_features: 232 * @ahcf: ARMHostCPUClass to fill in 233 * 234 * Probe the capabilities of the host kernel's preferred CPU and fill 235 * in the ARMHostCPUClass struct accordingly. 236 * 237 * Returns true on success and false otherwise. 238 */ 239bool kvm_arm_get_host_cpu_features(ARMHostCPUFeatures *ahcf); 240 241/** 242 * kvm_arm_sve_get_vls: 243 * @cs: CPUState 244 * @map: bitmap to fill in 245 * 246 * Get all the SVE vector lengths supported by the KVM host, setting 247 * the bits corresponding to their length in quadwords minus one 248 * (vq - 1) in @map up to ARM_MAX_VQ. 249 */ 250void kvm_arm_sve_get_vls(CPUState *cs, unsigned long *map); 251 252/** 253 * kvm_arm_set_cpu_features_from_host: 254 * @cpu: ARMCPU to set the features for 255 * 256 * Set up the ARMCPU struct fields up to match the information probed 257 * from the host CPU. 258 */ 259void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu); 260 261/** 262 * kvm_arm_add_vcpu_properties: 263 * @obj: The CPU object to add the properties to 264 * 265 * Add all KVM specific CPU properties to the CPU object. These 266 * are the CPU properties with "kvm-" prefixed names. 267 */ 268void kvm_arm_add_vcpu_properties(Object *obj); 269 270/** 271 * kvm_arm_steal_time_finalize: 272 * @cpu: ARMCPU for which to finalize kvm-steal-time 273 * @errp: Pointer to Error* for error propagation 274 * 275 * Validate the kvm-steal-time property selection and set its default 276 * based on KVM support and guest configuration. 277 */ 278void kvm_arm_steal_time_finalize(ARMCPU *cpu, Error **errp); 279 280/** 281 * kvm_arm_steal_time_supported: 282 * 283 * Returns: true if KVM can enable steal time reporting 284 * and false otherwise. 285 */ 286bool kvm_arm_steal_time_supported(void); 287 288/** 289 * kvm_arm_aarch32_supported: 290 * 291 * Returns: true if KVM can enable AArch32 mode 292 * and false otherwise. 293 */ 294bool kvm_arm_aarch32_supported(void); 295 296/** 297 * kvm_arm_pmu_supported: 298 * 299 * Returns: true if KVM can enable the PMU 300 * and false otherwise. 301 */ 302bool kvm_arm_pmu_supported(void); 303 304/** 305 * kvm_arm_sve_supported: 306 * 307 * Returns true if KVM can enable SVE and false otherwise. 308 */ 309bool kvm_arm_sve_supported(void); 310 311/** 312 * kvm_arm_get_max_vm_ipa_size: 313 * @ms: Machine state handle 314 * @fixed_ipa: True when the IPA limit is fixed at 40. This is the case 315 * for legacy KVM. 316 * 317 * Returns the number of bits in the IPA address space supported by KVM 318 */ 319int kvm_arm_get_max_vm_ipa_size(MachineState *ms, bool *fixed_ipa); 320 321/** 322 * kvm_arm_sync_mpstate_to_kvm: 323 * @cpu: ARMCPU 324 * 325 * If supported set the KVM MP_STATE based on QEMU's model. 326 * 327 * Returns 0 on success and -1 on failure. 328 */ 329int kvm_arm_sync_mpstate_to_kvm(ARMCPU *cpu); 330 331/** 332 * kvm_arm_sync_mpstate_to_qemu: 333 * @cpu: ARMCPU 334 * 335 * If supported get the MP_STATE from KVM and store in QEMU's model. 336 * 337 * Returns 0 on success and aborts on failure. 338 */ 339int kvm_arm_sync_mpstate_to_qemu(ARMCPU *cpu); 340 341/** 342 * kvm_arm_get_virtual_time: 343 * @cs: CPUState 344 * 345 * Gets the VCPU's virtual counter and stores it in the KVM CPU state. 346 */ 347void kvm_arm_get_virtual_time(CPUState *cs); 348 349/** 350 * kvm_arm_put_virtual_time: 351 * @cs: CPUState 352 * 353 * Sets the VCPU's virtual counter to the value stored in the KVM CPU state. 354 */ 355void kvm_arm_put_virtual_time(CPUState *cs); 356 357void kvm_arm_vm_state_change(void *opaque, bool running, RunState state); 358 359int kvm_arm_vgic_probe(void); 360 361void kvm_arm_pmu_set_irq(CPUState *cs, int irq); 362void kvm_arm_pmu_init(CPUState *cs); 363 364/** 365 * kvm_arm_pvtime_init: 366 * @cs: CPUState 367 * @ipa: Per-vcpu guest physical base address of the pvtime structures 368 * 369 * Initializes PVTIME for the VCPU, setting the PVTIME IPA to @ipa. 370 */ 371void kvm_arm_pvtime_init(CPUState *cs, uint64_t ipa); 372 373int kvm_arm_set_irq(int cpu, int irqtype, int irq, int level); 374 375#else 376 377/* 378 * It's safe to call these functions without KVM support. 379 * They should either do nothing or return "not supported". 380 */ 381static inline bool kvm_arm_aarch32_supported(void) 382{ 383 return false; 384} 385 386static inline bool kvm_arm_pmu_supported(void) 387{ 388 return false; 389} 390 391static inline bool kvm_arm_sve_supported(void) 392{ 393 return false; 394} 395 396static inline bool kvm_arm_steal_time_supported(void) 397{ 398 return false; 399} 400 401/* 402 * These functions should never actually be called without KVM support. 403 */ 404static inline void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu) 405{ 406 g_assert_not_reached(); 407} 408 409static inline void kvm_arm_add_vcpu_properties(Object *obj) 410{ 411 g_assert_not_reached(); 412} 413 414static inline int kvm_arm_get_max_vm_ipa_size(MachineState *ms, bool *fixed_ipa) 415{ 416 g_assert_not_reached(); 417} 418 419static inline int kvm_arm_vgic_probe(void) 420{ 421 g_assert_not_reached(); 422} 423 424static inline void kvm_arm_pmu_set_irq(CPUState *cs, int irq) 425{ 426 g_assert_not_reached(); 427} 428 429static inline void kvm_arm_pmu_init(CPUState *cs) 430{ 431 g_assert_not_reached(); 432} 433 434static inline void kvm_arm_pvtime_init(CPUState *cs, uint64_t ipa) 435{ 436 g_assert_not_reached(); 437} 438 439static inline void kvm_arm_steal_time_finalize(ARMCPU *cpu, Error **errp) 440{ 441 g_assert_not_reached(); 442} 443 444static inline void kvm_arm_sve_get_vls(CPUState *cs, unsigned long *map) 445{ 446 g_assert_not_reached(); 447} 448 449#endif 450 451static inline const char *gic_class_name(void) 452{ 453 return kvm_irqchip_in_kernel() ? "kvm-arm-gic" : "arm_gic"; 454} 455 456/** 457 * gicv3_class_name 458 * 459 * Return name of GICv3 class to use depending on whether KVM acceleration is 460 * in use. May throw an error if the chosen implementation is not available. 461 * 462 * Returns: class name to use 463 */ 464static inline const char *gicv3_class_name(void) 465{ 466 if (kvm_irqchip_in_kernel()) { 467 return "kvm-arm-gicv3"; 468 } else { 469 if (kvm_enabled()) { 470 error_report("Userspace GICv3 is not supported with KVM"); 471 exit(1); 472 } 473 return "arm-gicv3"; 474 } 475} 476 477/** 478 * kvm_arm_handle_debug: 479 * @cs: CPUState 480 * @debug_exit: debug part of the KVM exit structure 481 * 482 * Returns: TRUE if the debug exception was handled. 483 */ 484bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit); 485 486/** 487 * kvm_arm_hw_debug_active: 488 * @cs: CPU State 489 * 490 * Return: TRUE if any hardware breakpoints in use. 491 */ 492bool kvm_arm_hw_debug_active(CPUState *cs); 493 494/** 495 * kvm_arm_copy_hw_debug_data: 496 * @ptr: kvm_guest_debug_arch structure 497 * 498 * Copy the architecture specific debug registers into the 499 * kvm_guest_debug ioctl structure. 500 */ 501struct kvm_guest_debug_arch; 502void kvm_arm_copy_hw_debug_data(struct kvm_guest_debug_arch *ptr); 503 504/** 505 * kvm_arm_verify_ext_dabt_pending: 506 * @cs: CPUState 507 * 508 * Verify the fault status code wrt the Ext DABT injection 509 * 510 * Returns: true if the fault status code is as expected, false otherwise 511 */ 512bool kvm_arm_verify_ext_dabt_pending(CPUState *cs); 513 514/** 515 * its_class_name: 516 * 517 * Return the ITS class name to use depending on whether KVM acceleration 518 * and KVM CAP_SIGNAL_MSI are supported 519 * 520 * Returns: class name to use or NULL 521 */ 522static inline const char *its_class_name(void) 523{ 524 if (kvm_irqchip_in_kernel()) { 525 /* KVM implementation requires this capability */ 526 return kvm_direct_msi_enabled() ? "arm-its-kvm" : NULL; 527 } else { 528 /* Software emulation is not implemented yet */ 529 return NULL; 530 } 531} 532 533#endif 534