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 * Returns: true on success, or false if write_list_to_kvmstate failed. 88 */ 89 bool kvm_arm_cpu_post_load(ARMCPU *cpu); 90 91 /** 92 * kvm_arm_reset_vcpu: 93 * @cpu: ARMCPU 94 * 95 * Called at reset time to kernel registers to their initial values. 96 */ 97 void kvm_arm_reset_vcpu(ARMCPU *cpu); 98 99 struct kvm_vcpu_init; 100 /** 101 * kvm_arm_create_scratch_host_vcpu: 102 * @fdarray: filled in with kvmfd, vmfd, cpufd file descriptors in that order 103 * @init: filled in with the necessary values for creating a host 104 * vcpu. If NULL is provided, will not init the vCPU (though the cpufd 105 * will still be set up). 106 * 107 * Create a scratch vcpu in its own VM of the type preferred by the host 108 * kernel (as would be used for '-cpu host'), for purposes of probing it 109 * for capabilities. 110 * 111 * Returns: true on success (and fdarray and init are filled in), 112 * false on failure (and fdarray and init are not valid). 113 */ 114 bool kvm_arm_create_scratch_host_vcpu(int *fdarray, 115 struct kvm_vcpu_init *init); 116 117 /** 118 * kvm_arm_destroy_scratch_host_vcpu: 119 * @fdarray: array of fds as set up by kvm_arm_create_scratch_host_vcpu 120 * 121 * Tear down the scratch vcpu created by kvm_arm_create_scratch_host_vcpu. 122 */ 123 void kvm_arm_destroy_scratch_host_vcpu(int *fdarray); 124 125 /** 126 * kvm_arm_sve_get_vls: 127 * @cpu: ARMCPU 128 * 129 * Get all the SVE vector lengths supported by the KVM host, setting 130 * the bits corresponding to their length in quadwords minus one 131 * (vq - 1) up to ARM_MAX_VQ. Return the resulting map. 132 */ 133 uint32_t kvm_arm_sve_get_vls(ARMCPU *cpu); 134 135 /** 136 * kvm_arm_set_cpu_features_from_host: 137 * @cpu: ARMCPU to set the features for 138 * 139 * Set up the ARMCPU struct fields up to match the information probed 140 * from the host CPU. 141 */ 142 void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu); 143 144 /** 145 * kvm_arm_add_vcpu_properties: 146 * @cpu: The CPU object to add the properties to 147 * 148 * Add all KVM specific CPU properties to the CPU object. These 149 * are the CPU properties with "kvm-" prefixed names. 150 */ 151 void kvm_arm_add_vcpu_properties(ARMCPU *cpu); 152 153 /** 154 * kvm_arm_steal_time_finalize: 155 * @cpu: ARMCPU for which to finalize kvm-steal-time 156 * @errp: Pointer to Error* for error propagation 157 * 158 * Validate the kvm-steal-time property selection and set its default 159 * based on KVM support and guest configuration. 160 */ 161 void kvm_arm_steal_time_finalize(ARMCPU *cpu, Error **errp); 162 163 /** 164 * kvm_arm_aarch32_supported: 165 * 166 * Returns: true if KVM can enable AArch32 mode 167 * and false otherwise. 168 */ 169 bool kvm_arm_aarch32_supported(void); 170 171 /** 172 * kvm_arm_pmu_supported: 173 * 174 * Returns: true if KVM can enable the PMU 175 * and false otherwise. 176 */ 177 bool kvm_arm_pmu_supported(void); 178 179 /** 180 * kvm_arm_sve_supported: 181 * 182 * Returns true if KVM can enable SVE and false otherwise. 183 */ 184 bool kvm_arm_sve_supported(void); 185 186 /** 187 * kvm_arm_mte_supported: 188 * 189 * Returns: true if KVM can enable MTE, and false otherwise. 190 */ 191 bool kvm_arm_mte_supported(void); 192 193 /** 194 * kvm_arm_get_max_vm_ipa_size: 195 * @ms: Machine state handle 196 * @fixed_ipa: True when the IPA limit is fixed at 40. This is the case 197 * for legacy KVM. 198 * 199 * Returns the number of bits in the IPA address space supported by KVM 200 */ 201 int kvm_arm_get_max_vm_ipa_size(MachineState *ms, bool *fixed_ipa); 202 203 int kvm_arm_vgic_probe(void); 204 205 void kvm_arm_pmu_init(ARMCPU *cpu); 206 void kvm_arm_pmu_set_irq(ARMCPU *cpu, int irq); 207 208 /** 209 * kvm_arm_pvtime_init: 210 * @cpu: ARMCPU 211 * @ipa: Per-vcpu guest physical base address of the pvtime structures 212 * 213 * Initializes PVTIME for the VCPU, setting the PVTIME IPA to @ipa. 214 */ 215 void kvm_arm_pvtime_init(ARMCPU *cpu, uint64_t ipa); 216 217 int kvm_arm_set_irq(int cpu, int irqtype, int irq, int level); 218 219 void kvm_arm_enable_mte(Object *cpuobj, Error **errp); 220 221 void arm_cpu_kvm_set_irq(void *arm_cpu, int irq, int level); 222 223 #endif 224