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 "system/kvm.h" 15 16 #define KVM_ARM_VGIC_V2 (1 << 0) 17 #define KVM_ARM_VGIC_V3 (1 << 1) 18 19 /** 20 * kvm_arm_register_device: 21 * @mr: memory region for this device 22 * @devid: the KVM device ID 23 * @group: device control API group for setting addresses 24 * @attr: device control API address type 25 * @dev_fd: device control device file descriptor 26 * @addr_ormask: value to be OR'ed with resolved address 27 * 28 * Remember the memory region @mr, and when it is mapped by the machine 29 * model, tell the kernel that base address using the device control API. 30 * @devid should be the ID of the device as defined by the arm-vgic device 31 * in the device control API. The machine model may map and unmap the device 32 * multiple times; the kernel will only be told the final address at the 33 * point where machine init is complete. 34 */ 35 void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid, uint64_t group, 36 uint64_t attr, int dev_fd, uint64_t addr_ormask); 37 38 /** 39 * write_list_to_kvmstate: 40 * @cpu: ARMCPU 41 * @level: the state level to sync 42 * 43 * For each register listed in the ARMCPU cpreg_indexes list, write 44 * its value from the cpreg_values list into the kernel (via ioctl). 45 * This updates KVM's working data structures from TCG data or 46 * from incoming migration state. 47 * 48 * Returns: true if all register values were updated correctly, 49 * false if some register was unknown to the kernel or could not 50 * be written (eg constant register with the wrong value). 51 * Note that we do not stop early on failure -- we will attempt 52 * writing all registers in the list. 53 */ 54 bool write_list_to_kvmstate(ARMCPU *cpu, int level); 55 56 /** 57 * write_kvmstate_to_list: 58 * @cpu: ARMCPU 59 * 60 * For each register listed in the ARMCPU cpreg_indexes list, write 61 * its value from the kernel into the cpreg_values list. This is used to 62 * copy info from KVM's working data structures into TCG or 63 * for outbound migration. 64 * 65 * Returns: true if all register values were read correctly, 66 * false if some register was unknown or could not be read. 67 * Note that we do not stop early on failure -- we will attempt 68 * reading all registers in the list. 69 */ 70 bool write_kvmstate_to_list(ARMCPU *cpu); 71 72 /** 73 * kvm_arm_cpu_pre_save: 74 * @cpu: ARMCPU 75 * 76 * Called after write_kvmstate_to_list() from cpu_pre_save() to update 77 * the cpreg list with KVM CPU state. 78 */ 79 void kvm_arm_cpu_pre_save(ARMCPU *cpu); 80 81 /** 82 * kvm_arm_cpu_post_load: 83 * @cpu: ARMCPU 84 * 85 * Called from cpu_post_load() to update KVM CPU state from the cpreg list. 86 */ 87 void kvm_arm_cpu_post_load(ARMCPU *cpu); 88 89 /** 90 * kvm_arm_reset_vcpu: 91 * @cpu: ARMCPU 92 * 93 * Called at reset time to kernel registers to their initial values. 94 */ 95 void kvm_arm_reset_vcpu(ARMCPU *cpu); 96 97 #ifdef CONFIG_KVM 98 /** 99 * kvm_arm_create_scratch_host_vcpu: 100 * @fdarray: filled in with kvmfd, vmfd, cpufd file descriptors in that order 101 * @init: filled in with the necessary values for creating a host 102 * vcpu. If NULL is provided, will not init the vCPU (though the cpufd 103 * will still be set up). 104 * 105 * Create a scratch vcpu in its own VM of the type preferred by the host 106 * kernel (as would be used for '-cpu host'), for purposes of probing it 107 * for capabilities. 108 * 109 * Returns: true on success (and fdarray and init are filled in), 110 * false on failure (and fdarray and init are not valid). 111 */ 112 bool kvm_arm_create_scratch_host_vcpu(int *fdarray, 113 struct kvm_vcpu_init *init); 114 115 /** 116 * kvm_arm_destroy_scratch_host_vcpu: 117 * @fdarray: array of fds as set up by kvm_arm_create_scratch_host_vcpu 118 * 119 * Tear down the scratch vcpu created by kvm_arm_create_scratch_host_vcpu. 120 */ 121 void kvm_arm_destroy_scratch_host_vcpu(int *fdarray); 122 123 /** 124 * kvm_arm_sve_get_vls: 125 * @cpu: ARMCPU 126 * 127 * Get all the SVE vector lengths supported by the KVM host, setting 128 * the bits corresponding to their length in quadwords minus one 129 * (vq - 1) up to ARM_MAX_VQ. Return the resulting map. 130 */ 131 uint32_t kvm_arm_sve_get_vls(ARMCPU *cpu); 132 133 /** 134 * kvm_arm_set_cpu_features_from_host: 135 * @cpu: ARMCPU to set the features for 136 * 137 * Set up the ARMCPU struct fields up to match the information probed 138 * from the host CPU. 139 */ 140 void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu); 141 142 /** 143 * kvm_arm_add_vcpu_properties: 144 * @cpu: The CPU object to add the properties to 145 * 146 * Add all KVM specific CPU properties to the CPU object. These 147 * are the CPU properties with "kvm-" prefixed names. 148 */ 149 void kvm_arm_add_vcpu_properties(ARMCPU *cpu); 150 151 /** 152 * kvm_arm_steal_time_finalize: 153 * @cpu: ARMCPU for which to finalize kvm-steal-time 154 * @errp: Pointer to Error* for error propagation 155 * 156 * Validate the kvm-steal-time property selection and set its default 157 * based on KVM support and guest configuration. 158 */ 159 void kvm_arm_steal_time_finalize(ARMCPU *cpu, Error **errp); 160 161 /** 162 * kvm_arm_aarch32_supported: 163 * 164 * Returns: true if KVM can enable AArch32 mode 165 * and false otherwise. 166 */ 167 bool kvm_arm_aarch32_supported(void); 168 169 /** 170 * kvm_arm_pmu_supported: 171 * 172 * Returns: true if KVM can enable the PMU 173 * and false otherwise. 174 */ 175 bool kvm_arm_pmu_supported(void); 176 177 /** 178 * kvm_arm_sve_supported: 179 * 180 * Returns true if KVM can enable SVE and false otherwise. 181 */ 182 bool kvm_arm_sve_supported(void); 183 184 /** 185 * kvm_arm_mte_supported: 186 * 187 * Returns: true if KVM can enable MTE, and false otherwise. 188 */ 189 bool kvm_arm_mte_supported(void); 190 191 /** 192 * kvm_arm_get_max_vm_ipa_size: 193 * @ms: Machine state handle 194 * @fixed_ipa: True when the IPA limit is fixed at 40. This is the case 195 * for legacy KVM. 196 * 197 * Returns the number of bits in the IPA address space supported by KVM 198 */ 199 int kvm_arm_get_max_vm_ipa_size(MachineState *ms, bool *fixed_ipa); 200 201 int kvm_arm_vgic_probe(void); 202 203 void kvm_arm_pmu_init(ARMCPU *cpu); 204 void kvm_arm_pmu_set_irq(ARMCPU *cpu, int irq); 205 206 /** 207 * kvm_arm_pvtime_init: 208 * @cpu: ARMCPU 209 * @ipa: Per-vcpu guest physical base address of the pvtime structures 210 * 211 * Initializes PVTIME for the VCPU, setting the PVTIME IPA to @ipa. 212 */ 213 void kvm_arm_pvtime_init(ARMCPU *cpu, uint64_t ipa); 214 215 int kvm_arm_set_irq(int cpu, int irqtype, int irq, int level); 216 217 void kvm_arm_enable_mte(Object *cpuobj, Error **errp); 218 219 #else 220 221 /* 222 * It's safe to call these functions without KVM support. 223 * They should either do nothing or return "not supported". 224 */ 225 static inline bool kvm_arm_aarch32_supported(void) 226 { 227 return false; 228 } 229 230 static inline bool kvm_arm_pmu_supported(void) 231 { 232 return false; 233 } 234 235 static inline bool kvm_arm_sve_supported(void) 236 { 237 return false; 238 } 239 240 static inline bool kvm_arm_mte_supported(void) 241 { 242 return false; 243 } 244 245 /* 246 * These functions should never actually be called without KVM support. 247 */ 248 static inline void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu) 249 { 250 g_assert_not_reached(); 251 } 252 253 static inline void kvm_arm_add_vcpu_properties(ARMCPU *cpu) 254 { 255 g_assert_not_reached(); 256 } 257 258 static inline int kvm_arm_get_max_vm_ipa_size(MachineState *ms, bool *fixed_ipa) 259 { 260 g_assert_not_reached(); 261 } 262 263 static inline int kvm_arm_vgic_probe(void) 264 { 265 g_assert_not_reached(); 266 } 267 268 static inline void kvm_arm_pmu_set_irq(ARMCPU *cpu, int irq) 269 { 270 g_assert_not_reached(); 271 } 272 273 static inline void kvm_arm_pmu_init(ARMCPU *cpu) 274 { 275 g_assert_not_reached(); 276 } 277 278 static inline void kvm_arm_pvtime_init(ARMCPU *cpu, uint64_t ipa) 279 { 280 g_assert_not_reached(); 281 } 282 283 static inline void kvm_arm_steal_time_finalize(ARMCPU *cpu, Error **errp) 284 { 285 g_assert_not_reached(); 286 } 287 288 static inline uint32_t kvm_arm_sve_get_vls(ARMCPU *cpu) 289 { 290 g_assert_not_reached(); 291 } 292 293 static inline void kvm_arm_enable_mte(Object *cpuobj, Error **errp) 294 { 295 g_assert_not_reached(); 296 } 297 298 #endif 299 300 #endif 301