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 17/** 18 * kvm_arm_vcpu_init: 19 * @cs: CPUState 20 * 21 * Initialize (or reinitialize) the VCPU by invoking the 22 * KVM_ARM_VCPU_INIT ioctl with the CPU type and feature 23 * bitmask specified in the CPUState. 24 * 25 * Returns: 0 if success else < 0 error code 26 */ 27int kvm_arm_vcpu_init(CPUState *cs); 28 29/** 30 * kvm_arm_register_device: 31 * @mr: memory region for this device 32 * @devid: the KVM device ID 33 * @group: device control API group for setting addresses 34 * @attr: device control API address type 35 * @dev_fd: device control device file descriptor (or -1 if not supported) 36 * 37 * Remember the memory region @mr, and when it is mapped by the 38 * machine model, tell the kernel that base address using the 39 * KVM_ARM_SET_DEVICE_ADDRESS ioctl or the newer device control API. @devid 40 * should be the ID of the device as defined by KVM_ARM_SET_DEVICE_ADDRESS or 41 * the arm-vgic device in the device control API. 42 * The machine model may map 43 * and unmap the device multiple times; the kernel will only be told the final 44 * address at the point where machine init is complete. 45 */ 46void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid, uint64_t group, 47 uint64_t attr, int dev_fd); 48 49/** 50 * kvm_arm_init_cpreg_list: 51 * @cs: CPUState 52 * 53 * Initialize the CPUState's cpreg list according to the kernel's 54 * definition of what CPU registers it knows about (and throw away 55 * the previous TCG-created cpreg list). 56 * 57 * Returns: 0 if success, else < 0 error code 58 */ 59int kvm_arm_init_cpreg_list(ARMCPU *cpu); 60 61/** 62 * kvm_arm_reg_syncs_via_cpreg_list 63 * regidx: KVM register index 64 * 65 * Return true if this KVM register should be synchronized via the 66 * cpreg list of arbitrary system registers, false if it is synchronized 67 * by hand using code in kvm_arch_get/put_registers(). 68 */ 69bool kvm_arm_reg_syncs_via_cpreg_list(uint64_t regidx); 70 71/** 72 * kvm_arm_cpreg_level 73 * regidx: KVM register index 74 * 75 * Return the level of this coprocessor/system register. Return value is 76 * either KVM_PUT_RUNTIME_STATE, KVM_PUT_RESET_STATE, or KVM_PUT_FULL_STATE. 77 */ 78int kvm_arm_cpreg_level(uint64_t regidx); 79 80/** 81 * write_list_to_kvmstate: 82 * @cpu: ARMCPU 83 * @level: the state level to sync 84 * 85 * For each register listed in the ARMCPU cpreg_indexes list, write 86 * its value from the cpreg_values list into the kernel (via ioctl). 87 * This updates KVM's working data structures from TCG data or 88 * from incoming migration state. 89 * 90 * Returns: true if all register values were updated correctly, 91 * false if some register was unknown to the kernel or could not 92 * be written (eg constant register with the wrong value). 93 * Note that we do not stop early on failure -- we will attempt 94 * writing all registers in the list. 95 */ 96bool write_list_to_kvmstate(ARMCPU *cpu, int level); 97 98/** 99 * write_kvmstate_to_list: 100 * @cpu: ARMCPU 101 * 102 * For each register listed in the ARMCPU cpreg_indexes list, write 103 * its value from the kernel into the cpreg_values list. This is used to 104 * copy info from KVM's working data structures into TCG or 105 * for outbound migration. 106 * 107 * Returns: true if all register values were read correctly, 108 * false if some register was unknown or could not be read. 109 * Note that we do not stop early on failure -- we will attempt 110 * reading all registers in the list. 111 */ 112bool write_kvmstate_to_list(ARMCPU *cpu); 113 114/** 115 * kvm_arm_reset_vcpu: 116 * @cpu: ARMCPU 117 * 118 * Called at reset time to kernel registers to their initial values. 119 */ 120void kvm_arm_reset_vcpu(ARMCPU *cpu); 121 122#ifdef CONFIG_KVM 123/** 124 * kvm_arm_create_scratch_host_vcpu: 125 * @cpus_to_try: array of QEMU_KVM_ARM_TARGET_* values (terminated with 126 * QEMU_KVM_ARM_TARGET_NONE) to try as fallback if the kernel does not 127 * know the PREFERRED_TARGET ioctl. Passing NULL is the same as passing 128 * an empty array. 129 * @fdarray: filled in with kvmfd, vmfd, cpufd file descriptors in that order 130 * @init: filled in with the necessary values for creating a host 131 * vcpu. If NULL is provided, will not init the vCPU (though the cpufd 132 * will still be set up). 133 * 134 * Create a scratch vcpu in its own VM of the type preferred by the host 135 * kernel (as would be used for '-cpu host'), for purposes of probing it 136 * for capabilities. 137 * 138 * Returns: true on success (and fdarray and init are filled in), 139 * false on failure (and fdarray and init are not valid). 140 */ 141bool kvm_arm_create_scratch_host_vcpu(const uint32_t *cpus_to_try, 142 int *fdarray, 143 struct kvm_vcpu_init *init); 144 145/** 146 * kvm_arm_destroy_scratch_host_vcpu: 147 * @fdarray: array of fds as set up by kvm_arm_create_scratch_host_vcpu 148 * 149 * Tear down the scratch vcpu created by kvm_arm_create_scratch_host_vcpu. 150 */ 151void kvm_arm_destroy_scratch_host_vcpu(int *fdarray); 152 153#define TYPE_ARM_HOST_CPU "host-" TYPE_ARM_CPU 154#define ARM_HOST_CPU_CLASS(klass) \ 155 OBJECT_CLASS_CHECK(ARMHostCPUClass, (klass), TYPE_ARM_HOST_CPU) 156#define ARM_HOST_CPU_GET_CLASS(obj) \ 157 OBJECT_GET_CLASS(ARMHostCPUClass, (obj), TYPE_ARM_HOST_CPU) 158 159typedef struct ARMHostCPUClass { 160 /*< private >*/ 161 ARMCPUClass parent_class; 162 /*< public >*/ 163 164 uint64_t features; 165 uint32_t target; 166 const char *dtb_compatible; 167} ARMHostCPUClass; 168 169/** 170 * kvm_arm_get_host_cpu_features: 171 * @ahcc: ARMHostCPUClass to fill in 172 * 173 * Probe the capabilities of the host kernel's preferred CPU and fill 174 * in the ARMHostCPUClass struct accordingly. 175 */ 176bool kvm_arm_get_host_cpu_features(ARMHostCPUClass *ahcc); 177 178 179/** 180 * kvm_arm_sync_mpstate_to_kvm 181 * @cpu: ARMCPU 182 * 183 * If supported set the KVM MP_STATE based on QEMU's model. 184 */ 185int kvm_arm_sync_mpstate_to_kvm(ARMCPU *cpu); 186 187/** 188 * kvm_arm_sync_mpstate_to_qemu 189 * @cpu: ARMCPU 190 * 191 * If supported get the MP_STATE from KVM and store in QEMU's model. 192 */ 193int kvm_arm_sync_mpstate_to_qemu(ARMCPU *cpu); 194 195int kvm_arm_vgic_probe(void); 196 197#else 198 199static inline int kvm_arm_vgic_probe(void) 200{ 201 return 0; 202} 203 204#endif 205 206static inline const char *gic_class_name(void) 207{ 208 return kvm_irqchip_in_kernel() ? "kvm-arm-gic" : "arm_gic"; 209} 210 211/** 212 * gicv3_class_name 213 * 214 * Return name of GICv3 class to use depending on whether KVM acceleration is 215 * in use. May throw an error if the chosen implementation is not available. 216 * 217 * Returns: class name to use 218 */ 219const char *gicv3_class_name(void); 220 221/** 222 * kvm_arm_handle_debug: 223 * @cs: CPUState 224 * @debug_exit: debug part of the KVM exit structure 225 * 226 * Returns: TRUE if the debug exception was handled. 227 */ 228bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit); 229 230/** 231 * kvm_arm_hw_debug_active: 232 * @cs: CPU State 233 * 234 * Return: TRUE if any hardware breakpoints in use. 235 */ 236 237bool kvm_arm_hw_debug_active(CPUState *cs); 238 239/** 240 * kvm_arm_copy_hw_debug_data: 241 * 242 * @ptr: kvm_guest_debug_arch structure 243 * 244 * Copy the architecture specific debug registers into the 245 * kvm_guest_debug ioctl structure. 246 */ 247struct kvm_guest_debug_arch; 248 249void kvm_arm_copy_hw_debug_data(struct kvm_guest_debug_arch *ptr); 250 251#endif 252