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