target/arm/kvm_arm.h

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