Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5863c2ce authored by Marc Zyngier's avatar Marc Zyngier
Browse files

ARM: KVM: VGIC interrupt injection 



Plug the interrupt injection code. Interrupts can now be generated
from user space.

Reviewed-by: default avatarWill Deacon <will.deacon@arm.com>
Signed-off-by: default avatarChristoffer Dall <c.dall@virtualopensystems.com>
Signed-off-by: default avatarMarc Zyngier <marc.zyngier@arm.com>
parent a1fcb44e

arch/arm/include/asm/kvm_vgic.h

+8 −0
Original line number Diff line number Diff line
@@ -147,6 +147,8 @@ struct kvm_exit_mmio; 
int kvm_vgic_set_addr(struct kvm *kvm, unsigned long type, u64 addr);

void kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu);

void kvm_vgic_sync_hwstate(struct kvm_vcpu *vcpu);

int kvm_vgic_inject_irq(struct kvm *kvm, int cpuid, unsigned int irq_num,

			bool level);

int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu);

bool vgic_handle_mmio(struct kvm_vcpu *vcpu, struct kvm_run *run,

		      struct kvm_exit_mmio *mmio);
@@ -182,6 +184,12 @@ static inline int kvm_vgic_vcpu_init(struct kvm_vcpu *vcpu) 
static inline void kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu) {}

static inline void kvm_vgic_sync_hwstate(struct kvm_vcpu *vcpu) {}



static inline int kvm_vgic_inject_irq(struct kvm *kvm, int cpuid,

				      unsigned int irq_num, bool level)

{

	return 0;

}



static inline int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu)

{

	return 0;

arch/arm/kvm/arm.c

+45 −10
Original line number Diff line number Diff line
@@ -810,8 +810,10 @@ int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_level) 


	trace_kvm_irq_line(irq_type, vcpu_idx, irq_num, irq_level->level);



	if (irq_type != KVM_ARM_IRQ_TYPE_CPU)

		return -EINVAL;

	switch (irq_type) {

	case KVM_ARM_IRQ_TYPE_CPU:

		if (irqchip_in_kernel(kvm))

			return -ENXIO;



		if (vcpu_idx >= nrcpus)

			return -EINVAL;
@@ -824,6 +826,33 @@ int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_level) 
			return -EINVAL;



		return vcpu_interrupt_line(vcpu, irq_num, level);

	case KVM_ARM_IRQ_TYPE_PPI:

		if (!irqchip_in_kernel(kvm))

			return -ENXIO;



		if (vcpu_idx >= nrcpus)

			return -EINVAL;



		vcpu = kvm_get_vcpu(kvm, vcpu_idx);

		if (!vcpu)

			return -EINVAL;



		if (irq_num < VGIC_NR_SGIS || irq_num >= VGIC_NR_PRIVATE_IRQS)

			return -EINVAL;



		return kvm_vgic_inject_irq(kvm, vcpu->vcpu_id, irq_num, level);

	case KVM_ARM_IRQ_TYPE_SPI:

		if (!irqchip_in_kernel(kvm))

			return -ENXIO;



		if (irq_num < VGIC_NR_PRIVATE_IRQS ||

		    irq_num > KVM_ARM_IRQ_GIC_MAX)

			return -EINVAL;



		return kvm_vgic_inject_irq(kvm, 0, irq_num, level);

	}



	return -EINVAL;

}



long kvm_arch_vcpu_ioctl(struct file *filp,
@@ -904,6 +933,12 @@ long kvm_arch_vm_ioctl(struct file *filp, 
	void __user *argp = (void __user *)arg;



	switch (ioctl) {

	case KVM_CREATE_IRQCHIP: {

		if (vgic_present)

			return kvm_vgic_create(kvm);

		else

			return -ENXIO;

	}

	case KVM_ARM_SET_DEVICE_ADDR: {

		struct kvm_arm_device_addr dev_addr;

arch/arm/kvm/vgic.c

+117 −0
Original line number Diff line number Diff line
@@ -73,6 +73,7 @@ 


static void vgic_retire_disabled_irqs(struct kvm_vcpu *vcpu);

static void vgic_update_state(struct kvm *kvm);

static void vgic_kick_vcpus(struct kvm *kvm);

static void vgic_dispatch_sgi(struct kvm_vcpu *vcpu, u32 reg);



static u32 *vgic_bitmap_get_reg(struct vgic_bitmap *x,
@@ -708,6 +709,9 @@ bool vgic_handle_mmio(struct kvm_vcpu *vcpu, struct kvm_run *run, 
	kvm_prepare_mmio(run, mmio);

	kvm_handle_mmio_return(vcpu, run);



	if (updated_state)

		vgic_kick_vcpus(vcpu->kvm);



	return true;

}
@@ -1104,6 +1108,119 @@ int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu) 
	return test_bit(vcpu->vcpu_id, &dist->irq_pending_on_cpu);

}



static void vgic_kick_vcpus(struct kvm *kvm)

{

	struct kvm_vcpu *vcpu;

	int c;



	/*

	 * We've injected an interrupt, time to find out who deserves

	 * a good kick...

	 */

	kvm_for_each_vcpu(c, vcpu, kvm) {

		if (kvm_vgic_vcpu_pending_irq(vcpu))

			kvm_vcpu_kick(vcpu);

	}

}



static int vgic_validate_injection(struct kvm_vcpu *vcpu, int irq, int level)

{

	int is_edge = vgic_irq_is_edge(vcpu, irq);

	int state = vgic_dist_irq_is_pending(vcpu, irq);



	/*

	 * Only inject an interrupt if:

	 * - edge triggered and we have a rising edge

	 * - level triggered and we change level

	 */

	if (is_edge)

		return level > state;

	else

		return level != state;

}



static bool vgic_update_irq_state(struct kvm *kvm, int cpuid,

				  unsigned int irq_num, bool level)

{

	struct vgic_dist *dist = &kvm->arch.vgic;

	struct kvm_vcpu *vcpu;

	int is_edge, is_level;

	int enabled;

	bool ret = true;



	spin_lock(&dist->lock);



	vcpu = kvm_get_vcpu(kvm, cpuid);

	is_edge = vgic_irq_is_edge(vcpu, irq_num);

	is_level = !is_edge;



	if (!vgic_validate_injection(vcpu, irq_num, level)) {

		ret = false;

		goto out;

	}



	if (irq_num >= VGIC_NR_PRIVATE_IRQS) {

		cpuid = dist->irq_spi_cpu[irq_num - VGIC_NR_PRIVATE_IRQS];

		vcpu = kvm_get_vcpu(kvm, cpuid);

	}



	kvm_debug("Inject IRQ%d level %d CPU%d\n", irq_num, level, cpuid);



	if (level)

		vgic_dist_irq_set(vcpu, irq_num);

	else

		vgic_dist_irq_clear(vcpu, irq_num);



	enabled = vgic_irq_is_enabled(vcpu, irq_num);



	if (!enabled) {

		ret = false;

		goto out;

	}



	if (is_level && vgic_irq_is_active(vcpu, irq_num)) {

		/*

		 * Level interrupt in progress, will be picked up

		 * when EOId.

		 */

		ret = false;

		goto out;

	}



	if (level) {

		vgic_cpu_irq_set(vcpu, irq_num);

		set_bit(cpuid, &dist->irq_pending_on_cpu);

	}



out:

	spin_unlock(&dist->lock);



	return ret;

}



/**

 * kvm_vgic_inject_irq - Inject an IRQ from a device to the vgic

 * @kvm:     The VM structure pointer

 * @cpuid:   The CPU for PPIs

 * @irq_num: The IRQ number that is assigned to the device

 * @level:   Edge-triggered:  true:  to trigger the interrupt

 *			      false: to ignore the call

 *	     Level-sensitive  true:  activates an interrupt

 *			      false: deactivates an interrupt

 *

 * The GIC is not concerned with devices being active-LOW or active-HIGH for

 * level-sensitive interrupts.  You can think of the level parameter as 1

 * being HIGH and 0 being LOW and all devices being active-HIGH.

 */

int kvm_vgic_inject_irq(struct kvm *kvm, int cpuid, unsigned int irq_num,

			bool level)

{

	if (vgic_update_irq_state(kvm, cpuid, irq_num, level))

		vgic_kick_vcpus(kvm);



	return 0;

}



static bool vgic_ioaddr_overlap(struct kvm *kvm)

{

	phys_addr_t dist = kvm->arch.vgic.vgic_dist_base;