lkml.org 
[lkml]   [2017]   [Feb]   [22]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [RFC 27/55] KVM: arm/arm64: Emulate GICH interface on GICv2
On Mon, Jan 09, 2017 at 01:24:23AM -0500, Jintack Lim wrote:
> Emulate GICH interface accesses from the guest hypervisor.
>
> Signed-off-by: Jintack Lim <jintack@cs.columbia.edu>
> Signed-off-by: Shih-Wei Li <shihwei@cs.columbia.edu>
> Signed-off-by: Christoffer Dall <christoffer.dall@linaro.org>
> ---
> arch/arm64/kvm/Makefile | 1 +
> virt/kvm/arm/vgic/vgic-v2-nested.c | 207 +++++++++++++++++++++++++++++++++++++
> 2 files changed, 208 insertions(+)
> create mode 100644 virt/kvm/arm/vgic/vgic-v2-nested.c
>
> diff --git a/arch/arm64/kvm/Makefile b/arch/arm64/kvm/Makefile
> index 9c35e9a..8573faf 100644
> --- a/arch/arm64/kvm/Makefile
> +++ b/arch/arm64/kvm/Makefile
> @@ -37,3 +37,4 @@ kvm-$(CONFIG_KVM_ARM_PMU) += $(KVM)/arm/pmu.o
>
> kvm-$(CONFIG_KVM_ARM_NESTED_HYP) += handle_exit_nested.o
> kvm-$(CONFIG_KVM_ARM_NESTED_HYP) += emulate-nested.o
> +kvm-$(CONFIG_KVM_ARM_NESTED_HYP) += $(KVM)/arm/vgic/vgic-v2-nested.o
> diff --git a/virt/kvm/arm/vgic/vgic-v2-nested.c b/virt/kvm/arm/vgic/vgic-v2-nested.c
> new file mode 100644
> index 0000000..b13128e
> --- /dev/null
> +++ b/virt/kvm/arm/vgic/vgic-v2-nested.c
> @@ -0,0 +1,207 @@
> +#include <linux/cpu.h>
> +#include <linux/kvm.h>
> +#include <linux/kvm_host.h>
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/uaccess.h>
> +
> +#include <linux/irqchip/arm-gic.h>
> +
> +#include <asm/kvm_emulate.h>
> +#include <asm/kvm_arm.h>
> +#include <asm/kvm_mmu.h>
> +#include <kvm/arm_vgic.h>
> +
> +#include "vgic.h"
> +#include "vgic-mmio.h"
> +
> +static inline struct vgic_v2_cpu_if *vcpu_nested_if(struct kvm_vcpu *vcpu)
> +{
> + return &vcpu->arch.vgic_cpu.nested_vgic_v2;
> +}
> +
> +static inline struct vgic_v2_cpu_if *vcpu_shadow_if(struct kvm_vcpu *vcpu)
> +{
> + return &vcpu->arch.vgic_cpu.shadow_vgic_v2;
> +}
> +
> +static unsigned long vgic_mmio_read_v2_vtr(struct kvm_vcpu *vcpu,
> + gpa_t addr, unsigned int len)
> +{
> + u32 reg;
> +
> + reg = kvm_vgic_global_state.nr_lr - 1;
> + reg |= 0b100 << 26;
> + reg |= 0b100 << 29;

Pure magic? Can we have some defines? Have you checked the existing
header file if we have some defines for this?

> +
> + return reg;
> +}
> +
> +static inline bool lr_triggers_eoi(u32 lr)
> +{
> + return !(lr & (GICH_LR_STATE | GICH_LR_HW)) && (lr & GICH_LR_EOI);
> +}
> +
> +static unsigned long get_eisr(struct kvm_vcpu *vcpu, bool upper_reg)
> +{
> + struct vgic_v2_cpu_if *cpu_if = vcpu_nested_if(vcpu);
> + int max_lr = upper_reg ? 64 : 32;
> + int min_lr = upper_reg ? 32 : 0;
> + int nr_lr = min(kvm_vgic_global_state.nr_lr, max_lr);
> + int i;
> + u32 reg = 0;

So the assumption here is that we can only emualte a virtual GICH
interface with the same number of LRs that the hardware has, yes ? Can
you document this assumption in the commit message and explain how we
deal with nr_lr for all this logic based on that.

Seems like this could go in the commit message.

> +
> + for (i = min_lr; i < nr_lr; i++) {
> + if (lr_triggers_eoi(cpu_if->vgic_lr[i]))
> + reg |= BIT(i - min_lr);
> + }
> +
> + return reg;
> +}
> +
> +static unsigned long vgic_mmio_read_v2_eisr0(struct kvm_vcpu *vcpu,
> + gpa_t addr, unsigned int len)
> +{
> + return get_eisr(vcpu, false);
> +}
> +
> +static unsigned long vgic_mmio_read_v2_eisr1(struct kvm_vcpu *vcpu,
> + gpa_t addr, unsigned int len)
> +{
> + return get_eisr(vcpu, true);
> +}
> +
> +static u32 get_elrsr(struct kvm_vcpu *vcpu, bool upper_reg)
> +{
> + struct vgic_v2_cpu_if *cpu_if = vcpu_nested_if(vcpu);
> + int max_lr = upper_reg ? 64 : 32;
> + int min_lr = upper_reg ? 32 : 0;
> + int nr_lr = min(kvm_vgic_global_state.nr_lr, max_lr);
> + u32 reg = 0;
> + int i;
> +
> + for (i = min_lr; i < nr_lr; i++) {
> + if (!(cpu_if->vgic_lr[i] & GICH_LR_STATE))
> + reg |= BIT(i - min_lr);
> + }
> +
> + return reg;
> +}
> +
> +static unsigned long vgic_mmio_read_v2_elrsr0(struct kvm_vcpu *vcpu,
> + gpa_t addr, unsigned int len)
> +{
> + return get_elrsr(vcpu, false);
> +}
> +
> +static unsigned long vgic_mmio_read_v2_elrsr1(struct kvm_vcpu *vcpu,
> + gpa_t addr, unsigned int len)
> +{
> + return get_elrsr(vcpu, true);
> +}
> +
> +static unsigned long vgic_mmio_read_v2_misr(struct kvm_vcpu *vcpu,
> + gpa_t addr, unsigned int len)
> +{
> + struct vgic_v2_cpu_if *cpu_if = vcpu_nested_if(vcpu);
> + int nr_lr = kvm_vgic_global_state.nr_lr;
> + u32 reg = 0;
> +
> + if (vgic_mmio_read_v2_eisr0(vcpu, addr, len) ||
> + vgic_mmio_read_v2_eisr1(vcpu, addr, len))
> + reg |= GICH_MISR_EOI;
> +
> + if (cpu_if->vgic_hcr & GICH_HCR_UIE) {
> + u32 elrsr0 = vgic_mmio_read_v2_elrsr0(vcpu, addr, len);
> + u32 elrsr1 = vgic_mmio_read_v2_elrsr1(vcpu, addr, len);
> + int used_lrs;
> +
> + used_lrs = nr_lr - (hweight32(elrsr0) + hweight32(elrsr1));
> + if (used_lrs <= 1)
> + reg |= GICH_MISR_U;
> + }
> +
> + /* TODO: Support remaining bits in this register */

Is this going to happen in this series? Why don't we just do it here?

> + return reg;
> +}
> +
> +static unsigned long vgic_mmio_read_v2_gich(struct kvm_vcpu *vcpu,
> + gpa_t addr, unsigned int len)
> +{
> + struct vgic_v2_cpu_if *cpu_if = vcpu_nested_if(vcpu);
> + u32 value;
> +
> + switch (addr & 0xfff) {
> + case GICH_HCR:
> + value = cpu_if->vgic_hcr;
> + break;
> + case GICH_VMCR:
> + value = cpu_if->vgic_vmcr;
> + break;
> + case GICH_APR:
> + value = cpu_if->vgic_apr;
> + break;
> + case GICH_LR0 ... (GICH_LR0 + 4 * (VGIC_V2_MAX_LRS - 1)):
> + value = cpu_if->vgic_lr[(addr & 0xff) >> 2];
> + break;
> + default:
> + return 0;
> + }
> +
> + return value;
> +}
> +
> +static void vgic_mmio_write_v2_gich(struct kvm_vcpu *vcpu,
> + gpa_t addr, unsigned int len,
> + unsigned long val)
> +{
> + struct vgic_v2_cpu_if *cpu_if = vcpu_nested_if(vcpu);
> +
> + switch (addr & 0xfff) {
> + case GICH_HCR:
> + cpu_if->vgic_hcr = val;
> + break;
> + case GICH_VMCR:
> + cpu_if->vgic_vmcr = val;
> + break;
> + case GICH_APR:
> + cpu_if->vgic_apr = val;
> + break;
> + case GICH_LR0 ... (GICH_LR0 + 4 * (VGIC_V2_MAX_LRS - 1)):
> + cpu_if->vgic_lr[(addr & 0xff) >> 2] = val;

Don't you need to check if we actually support this particular LR ?

> + break;
> + }
> +}
> +
> +static const struct vgic_register_region vgic_v2_gich_registers[] = {
> + REGISTER_DESC_WITH_LENGTH(GICH_HCR,
> + vgic_mmio_read_v2_gich, vgic_mmio_write_v2_gich, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_VTR,
> + vgic_mmio_read_v2_vtr, vgic_mmio_write_wi, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_VMCR,
> + vgic_mmio_read_v2_gich, vgic_mmio_write_v2_gich, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_MISR,
> + vgic_mmio_read_v2_misr, vgic_mmio_write_wi, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_EISR0,
> + vgic_mmio_read_v2_eisr0, vgic_mmio_write_wi, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_EISR1,
> + vgic_mmio_read_v2_eisr1, vgic_mmio_write_wi, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_ELRSR0,
> + vgic_mmio_read_v2_elrsr0, vgic_mmio_write_wi, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_ELRSR1,
> + vgic_mmio_read_v2_elrsr1, vgic_mmio_write_wi, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_APR,
> + vgic_mmio_read_v2_gich, vgic_mmio_write_v2_gich, 4,
> + VGIC_ACCESS_32bit),
> + REGISTER_DESC_WITH_LENGTH(GICH_LR0,
> + vgic_mmio_read_v2_gich, vgic_mmio_write_v2_gich,
> + 4 * VGIC_V2_MAX_LRS, VGIC_ACCESS_32bit),
> +};
> --
> 1.9.1
>
>

\
 
 \ /
  Last update: 2017-02-22 14:07    [W:0.483 / U:47.864 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site