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
  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  */
  27 int 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  */
  46 void 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  */
  59 int 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  */
  69 bool 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  */
  78 int 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  */
  96 bool 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  */
 112 bool 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  */
 120 void 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  */
 141 bool 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  */
 151 void 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
 159 typedef 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  */
 176 bool 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  */
 185 int 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  */
 193 int kvm_arm_sync_mpstate_to_qemu(ARMCPU *cpu);
 194
 195 int kvm_arm_vgic_probe(void);
 196
 197 int kvm_arm_pmu_create(CPUState *cs, int irq);
 198
 199 #else
 200
 201 static inline int kvm_arm_vgic_probe(void)
 202 {
 203     return 0;
 204 }
 205
 206 static inline int kvm_arm_pmu_create(CPUState *cs, int irq)
 207 {
 208     return 0;
 209 }
 210
 211 #endif
 212
 213 static inline const char *gic_class_name(void)
 214 {
 215     return kvm_irqchip_in_kernel() ? "kvm-arm-gic" : "arm_gic";
 216 }
 217
 218 /**
 219  * gicv3_class_name
 220  *
 221  * Return name of GICv3 class to use depending on whether KVM acceleration is
 222  * in use. May throw an error if the chosen implementation is not available.
 223  *
 224  * Returns: class name to use
 225  */
 226 const char *gicv3_class_name(void);
 227
 228 /**
 229  * kvm_arm_handle_debug:
 230  * @cs: CPUState
 231  * @debug_exit: debug part of the KVM exit structure
 232  *
 233  * Returns: TRUE if the debug exception was handled.
 234  */
 235 bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit);
 236
 237 /**
 238  * kvm_arm_hw_debug_active:
 239  * @cs: CPU State
 240  *
 241  * Return: TRUE if any hardware breakpoints in use.
 242  */
 243
 244 bool kvm_arm_hw_debug_active(CPUState *cs);
 245
 246 /**
 247  * kvm_arm_copy_hw_debug_data:
 248  *
 249  * @ptr: kvm_guest_debug_arch structure
 250  *
 251  * Copy the architecture specific debug registers into the
 252  * kvm_guest_debug ioctl structure.
 253  */
 254 struct kvm_guest_debug_arch;
 255
 256 void kvm_arm_copy_hw_debug_data(struct kvm_guest_debug_arch *ptr);
 257
 258 #endif