Convert kvm_arm_vgic_probe() so that it returns a bitmap of supported in-kernel emulation VGIC versions instead of the max version: at the moment values can be v2 and v3. This allows to expose the case where the host GICv3 also supports GICv2 emulation. This will be useful to choose the default version in KVM accelerated mode. Signed-off-by: Eric Auger <eric.auger@redhat.com> Reviewed-by: Andrew Jones <drjones@redhat.com> Reviewed-by: Richard Henderson <richard.henderson@linaro.org> Message-id: 20200311131618.7187-5-eric.auger@redhat.com Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
475 lines
12 KiB
C
475 lines
12 KiB
C
/*
|
|
* QEMU KVM support -- ARM specific functions.
|
|
*
|
|
* Copyright (c) 2012 Linaro Limited
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*
|
|
*/
|
|
|
|
#ifndef QEMU_KVM_ARM_H
|
|
#define QEMU_KVM_ARM_H
|
|
|
|
#include "sysemu/kvm.h"
|
|
#include "exec/memory.h"
|
|
#include "qemu/error-report.h"
|
|
|
|
#define KVM_ARM_VGIC_V2 (1 << 0)
|
|
#define KVM_ARM_VGIC_V3 (1 << 1)
|
|
|
|
/**
|
|
* kvm_arm_vcpu_init:
|
|
* @cs: CPUState
|
|
*
|
|
* Initialize (or reinitialize) the VCPU by invoking the
|
|
* KVM_ARM_VCPU_INIT ioctl with the CPU type and feature
|
|
* bitmask specified in the CPUState.
|
|
*
|
|
* Returns: 0 if success else < 0 error code
|
|
*/
|
|
int kvm_arm_vcpu_init(CPUState *cs);
|
|
|
|
/**
|
|
* kvm_arm_vcpu_finalize:
|
|
* @cs: CPUState
|
|
* @feature: feature to finalize
|
|
*
|
|
* Finalizes the configuration of the specified VCPU feature by
|
|
* invoking the KVM_ARM_VCPU_FINALIZE ioctl. Features requiring
|
|
* this are documented in the "KVM_ARM_VCPU_FINALIZE" section of
|
|
* KVM's API documentation.
|
|
*
|
|
* Returns: 0 if success else < 0 error code
|
|
*/
|
|
int kvm_arm_vcpu_finalize(CPUState *cs, int feature);
|
|
|
|
/**
|
|
* kvm_arm_register_device:
|
|
* @mr: memory region for this device
|
|
* @devid: the KVM device ID
|
|
* @group: device control API group for setting addresses
|
|
* @attr: device control API address type
|
|
* @dev_fd: device control device file descriptor (or -1 if not supported)
|
|
* @addr_ormask: value to be OR'ed with resolved address
|
|
*
|
|
* Remember the memory region @mr, and when it is mapped by the
|
|
* machine model, tell the kernel that base address using the
|
|
* KVM_ARM_SET_DEVICE_ADDRESS ioctl or the newer device control API. @devid
|
|
* should be the ID of the device as defined by KVM_ARM_SET_DEVICE_ADDRESS or
|
|
* the arm-vgic device in the device control API.
|
|
* The machine model may map
|
|
* and unmap the device multiple times; the kernel will only be told the final
|
|
* address at the point where machine init is complete.
|
|
*/
|
|
void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid, uint64_t group,
|
|
uint64_t attr, int dev_fd, uint64_t addr_ormask);
|
|
|
|
/**
|
|
* kvm_arm_init_cpreg_list:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* Initialize the ARMCPU cpreg list according to the kernel's
|
|
* definition of what CPU registers it knows about (and throw away
|
|
* the previous TCG-created cpreg list).
|
|
*
|
|
* Returns: 0 if success, else < 0 error code
|
|
*/
|
|
int kvm_arm_init_cpreg_list(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_arm_reg_syncs_via_cpreg_list:
|
|
* @regidx: KVM register index
|
|
*
|
|
* Return true if this KVM register should be synchronized via the
|
|
* cpreg list of arbitrary system registers, false if it is synchronized
|
|
* by hand using code in kvm_arch_get/put_registers().
|
|
*/
|
|
bool kvm_arm_reg_syncs_via_cpreg_list(uint64_t regidx);
|
|
|
|
/**
|
|
* kvm_arm_cpreg_level:
|
|
* @regidx: KVM register index
|
|
*
|
|
* Return the level of this coprocessor/system register. Return value is
|
|
* either KVM_PUT_RUNTIME_STATE, KVM_PUT_RESET_STATE, or KVM_PUT_FULL_STATE.
|
|
*/
|
|
int kvm_arm_cpreg_level(uint64_t regidx);
|
|
|
|
/**
|
|
* write_list_to_kvmstate:
|
|
* @cpu: ARMCPU
|
|
* @level: the state level to sync
|
|
*
|
|
* For each register listed in the ARMCPU cpreg_indexes list, write
|
|
* its value from the cpreg_values list into the kernel (via ioctl).
|
|
* This updates KVM's working data structures from TCG data or
|
|
* from incoming migration state.
|
|
*
|
|
* Returns: true if all register values were updated correctly,
|
|
* false if some register was unknown to the kernel or could not
|
|
* be written (eg constant register with the wrong value).
|
|
* Note that we do not stop early on failure -- we will attempt
|
|
* writing all registers in the list.
|
|
*/
|
|
bool write_list_to_kvmstate(ARMCPU *cpu, int level);
|
|
|
|
/**
|
|
* write_kvmstate_to_list:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* For each register listed in the ARMCPU cpreg_indexes list, write
|
|
* its value from the kernel into the cpreg_values list. This is used to
|
|
* copy info from KVM's working data structures into TCG or
|
|
* for outbound migration.
|
|
*
|
|
* Returns: true if all register values were read correctly,
|
|
* false if some register was unknown or could not be read.
|
|
* Note that we do not stop early on failure -- we will attempt
|
|
* reading all registers in the list.
|
|
*/
|
|
bool write_kvmstate_to_list(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_arm_cpu_pre_save:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* Called after write_kvmstate_to_list() from cpu_pre_save() to update
|
|
* the cpreg list with KVM CPU state.
|
|
*/
|
|
void kvm_arm_cpu_pre_save(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_arm_cpu_post_load:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* Called from cpu_post_load() to update KVM CPU state from the cpreg list.
|
|
*/
|
|
void kvm_arm_cpu_post_load(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_arm_reset_vcpu:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* Called at reset time to kernel registers to their initial values.
|
|
*/
|
|
void kvm_arm_reset_vcpu(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_arm_init_serror_injection:
|
|
* @cs: CPUState
|
|
*
|
|
* Check whether KVM can set guest SError syndrome.
|
|
*/
|
|
void kvm_arm_init_serror_injection(CPUState *cs);
|
|
|
|
/**
|
|
* kvm_get_vcpu_events:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* Get VCPU related state from kvm.
|
|
*
|
|
* Returns: 0 if success else < 0 error code
|
|
*/
|
|
int kvm_get_vcpu_events(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_put_vcpu_events:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* Put VCPU related state to kvm.
|
|
*
|
|
* Returns: 0 if success else < 0 error code
|
|
*/
|
|
int kvm_put_vcpu_events(ARMCPU *cpu);
|
|
|
|
#ifdef CONFIG_KVM
|
|
/**
|
|
* kvm_arm_create_scratch_host_vcpu:
|
|
* @cpus_to_try: array of QEMU_KVM_ARM_TARGET_* values (terminated with
|
|
* QEMU_KVM_ARM_TARGET_NONE) to try as fallback if the kernel does not
|
|
* know the PREFERRED_TARGET ioctl. Passing NULL is the same as passing
|
|
* an empty array.
|
|
* @fdarray: filled in with kvmfd, vmfd, cpufd file descriptors in that order
|
|
* @init: filled in with the necessary values for creating a host
|
|
* vcpu. If NULL is provided, will not init the vCPU (though the cpufd
|
|
* will still be set up).
|
|
*
|
|
* Create a scratch vcpu in its own VM of the type preferred by the host
|
|
* kernel (as would be used for '-cpu host'), for purposes of probing it
|
|
* for capabilities.
|
|
*
|
|
* Returns: true on success (and fdarray and init are filled in),
|
|
* false on failure (and fdarray and init are not valid).
|
|
*/
|
|
bool kvm_arm_create_scratch_host_vcpu(const uint32_t *cpus_to_try,
|
|
int *fdarray,
|
|
struct kvm_vcpu_init *init);
|
|
|
|
/**
|
|
* kvm_arm_destroy_scratch_host_vcpu:
|
|
* @fdarray: array of fds as set up by kvm_arm_create_scratch_host_vcpu
|
|
*
|
|
* Tear down the scratch vcpu created by kvm_arm_create_scratch_host_vcpu.
|
|
*/
|
|
void kvm_arm_destroy_scratch_host_vcpu(int *fdarray);
|
|
|
|
#define TYPE_ARM_HOST_CPU "host-" TYPE_ARM_CPU
|
|
|
|
/**
|
|
* ARMHostCPUFeatures: information about the host CPU (identified
|
|
* by asking the host kernel)
|
|
*/
|
|
typedef struct ARMHostCPUFeatures {
|
|
ARMISARegisters isar;
|
|
uint64_t features;
|
|
uint32_t target;
|
|
const char *dtb_compatible;
|
|
} ARMHostCPUFeatures;
|
|
|
|
/**
|
|
* kvm_arm_get_host_cpu_features:
|
|
* @ahcf: ARMHostCPUClass to fill in
|
|
*
|
|
* Probe the capabilities of the host kernel's preferred CPU and fill
|
|
* in the ARMHostCPUClass struct accordingly.
|
|
*
|
|
* Returns true on success and false otherwise.
|
|
*/
|
|
bool kvm_arm_get_host_cpu_features(ARMHostCPUFeatures *ahcf);
|
|
|
|
/**
|
|
* kvm_arm_sve_get_vls:
|
|
* @cs: CPUState
|
|
* @map: bitmap to fill in
|
|
*
|
|
* Get all the SVE vector lengths supported by the KVM host, setting
|
|
* the bits corresponding to their length in quadwords minus one
|
|
* (vq - 1) in @map up to ARM_MAX_VQ.
|
|
*/
|
|
void kvm_arm_sve_get_vls(CPUState *cs, unsigned long *map);
|
|
|
|
/**
|
|
* kvm_arm_set_cpu_features_from_host:
|
|
* @cpu: ARMCPU to set the features for
|
|
*
|
|
* Set up the ARMCPU struct fields up to match the information probed
|
|
* from the host CPU.
|
|
*/
|
|
void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_arm_add_vcpu_properties:
|
|
* @obj: The CPU object to add the properties to
|
|
*
|
|
* Add all KVM specific CPU properties to the CPU object. These
|
|
* are the CPU properties with "kvm-" prefixed names.
|
|
*/
|
|
void kvm_arm_add_vcpu_properties(Object *obj);
|
|
|
|
/**
|
|
* kvm_arm_aarch32_supported:
|
|
* @cs: CPUState
|
|
*
|
|
* Returns: true if the KVM VCPU can enable AArch32 mode
|
|
* and false otherwise.
|
|
*/
|
|
bool kvm_arm_aarch32_supported(CPUState *cs);
|
|
|
|
/**
|
|
* kvm_arm_pmu_supported:
|
|
* @cs: CPUState
|
|
*
|
|
* Returns: true if the KVM VCPU can enable its PMU
|
|
* and false otherwise.
|
|
*/
|
|
bool kvm_arm_pmu_supported(CPUState *cs);
|
|
|
|
/**
|
|
* kvm_arm_sve_supported:
|
|
* @cs: CPUState
|
|
*
|
|
* Returns true if the KVM VCPU can enable SVE and false otherwise.
|
|
*/
|
|
bool kvm_arm_sve_supported(CPUState *cs);
|
|
|
|
/**
|
|
* kvm_arm_get_max_vm_ipa_size:
|
|
* @ms: Machine state handle
|
|
*
|
|
* Returns the number of bits in the IPA address space supported by KVM
|
|
*/
|
|
int kvm_arm_get_max_vm_ipa_size(MachineState *ms);
|
|
|
|
/**
|
|
* kvm_arm_sync_mpstate_to_kvm:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* If supported set the KVM MP_STATE based on QEMU's model.
|
|
*
|
|
* Returns 0 on success and -1 on failure.
|
|
*/
|
|
int kvm_arm_sync_mpstate_to_kvm(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_arm_sync_mpstate_to_qemu:
|
|
* @cpu: ARMCPU
|
|
*
|
|
* If supported get the MP_STATE from KVM and store in QEMU's model.
|
|
*
|
|
* Returns 0 on success and aborts on failure.
|
|
*/
|
|
int kvm_arm_sync_mpstate_to_qemu(ARMCPU *cpu);
|
|
|
|
/**
|
|
* kvm_arm_get_virtual_time:
|
|
* @cs: CPUState
|
|
*
|
|
* Gets the VCPU's virtual counter and stores it in the KVM CPU state.
|
|
*/
|
|
void kvm_arm_get_virtual_time(CPUState *cs);
|
|
|
|
/**
|
|
* kvm_arm_put_virtual_time:
|
|
* @cs: CPUState
|
|
*
|
|
* Sets the VCPU's virtual counter to the value stored in the KVM CPU state.
|
|
*/
|
|
void kvm_arm_put_virtual_time(CPUState *cs);
|
|
|
|
void kvm_arm_vm_state_change(void *opaque, int running, RunState state);
|
|
|
|
int kvm_arm_vgic_probe(void);
|
|
|
|
void kvm_arm_pmu_set_irq(CPUState *cs, int irq);
|
|
void kvm_arm_pmu_init(CPUState *cs);
|
|
int kvm_arm_set_irq(int cpu, int irqtype, int irq, int level);
|
|
|
|
#else
|
|
|
|
static inline void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu)
|
|
{
|
|
/*
|
|
* This should never actually be called in the "not KVM" case,
|
|
* but set up the fields to indicate an error anyway.
|
|
*/
|
|
cpu->kvm_target = QEMU_KVM_ARM_TARGET_NONE;
|
|
cpu->host_cpu_probe_failed = true;
|
|
}
|
|
|
|
static inline void kvm_arm_add_vcpu_properties(Object *obj) {}
|
|
|
|
static inline bool kvm_arm_aarch32_supported(CPUState *cs)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline bool kvm_arm_pmu_supported(CPUState *cs)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline bool kvm_arm_sve_supported(CPUState *cs)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline int kvm_arm_get_max_vm_ipa_size(MachineState *ms)
|
|
{
|
|
return -ENOENT;
|
|
}
|
|
|
|
static inline int kvm_arm_vgic_probe(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline void kvm_arm_pmu_set_irq(CPUState *cs, int irq) {}
|
|
static inline void kvm_arm_pmu_init(CPUState *cs) {}
|
|
|
|
static inline void kvm_arm_sve_get_vls(CPUState *cs, unsigned long *map) {}
|
|
|
|
static inline void kvm_arm_get_virtual_time(CPUState *cs) {}
|
|
static inline void kvm_arm_put_virtual_time(CPUState *cs) {}
|
|
#endif
|
|
|
|
static inline const char *gic_class_name(void)
|
|
{
|
|
return kvm_irqchip_in_kernel() ? "kvm-arm-gic" : "arm_gic";
|
|
}
|
|
|
|
/**
|
|
* gicv3_class_name
|
|
*
|
|
* Return name of GICv3 class to use depending on whether KVM acceleration is
|
|
* in use. May throw an error if the chosen implementation is not available.
|
|
*
|
|
* Returns: class name to use
|
|
*/
|
|
static inline const char *gicv3_class_name(void)
|
|
{
|
|
if (kvm_irqchip_in_kernel()) {
|
|
#ifdef TARGET_AARCH64
|
|
return "kvm-arm-gicv3";
|
|
#else
|
|
error_report("KVM GICv3 acceleration is not supported on this "
|
|
"platform");
|
|
exit(1);
|
|
#endif
|
|
} else {
|
|
if (kvm_enabled()) {
|
|
error_report("Userspace GICv3 is not supported with KVM");
|
|
exit(1);
|
|
}
|
|
return "arm-gicv3";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* kvm_arm_handle_debug:
|
|
* @cs: CPUState
|
|
* @debug_exit: debug part of the KVM exit structure
|
|
*
|
|
* Returns: TRUE if the debug exception was handled.
|
|
*/
|
|
bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit);
|
|
|
|
/**
|
|
* kvm_arm_hw_debug_active:
|
|
* @cs: CPU State
|
|
*
|
|
* Return: TRUE if any hardware breakpoints in use.
|
|
*/
|
|
bool kvm_arm_hw_debug_active(CPUState *cs);
|
|
|
|
/**
|
|
* kvm_arm_copy_hw_debug_data:
|
|
* @ptr: kvm_guest_debug_arch structure
|
|
*
|
|
* Copy the architecture specific debug registers into the
|
|
* kvm_guest_debug ioctl structure.
|
|
*/
|
|
struct kvm_guest_debug_arch;
|
|
void kvm_arm_copy_hw_debug_data(struct kvm_guest_debug_arch *ptr);
|
|
|
|
/**
|
|
* its_class_name:
|
|
*
|
|
* Return the ITS class name to use depending on whether KVM acceleration
|
|
* and KVM CAP_SIGNAL_MSI are supported
|
|
*
|
|
* Returns: class name to use or NULL
|
|
*/
|
|
static inline const char *its_class_name(void)
|
|
{
|
|
if (kvm_irqchip_in_kernel()) {
|
|
/* KVM implementation requires this capability */
|
|
return kvm_direct_msi_enabled() ? "arm-its-kvm" : NULL;
|
|
} else {
|
|
/* Software emulation is not implemented yet */
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
#endif
|