arm/arm64: KVM: support for un-queuing active IRQs (47a98b15) · Commits · 戴 / test

include/kvm/arm_vgic.h

+14 −1

Original line number	Diff line number	Diff line
		@@ -195,6 +195,9 @@ struct vgic_dist {
		/* Level-triggered interrupt queued on VCPU interface */
		struct vgic_bitmap irq_queued;

		/* Interrupt was active when unqueue from VCPU interface */
		struct vgic_bitmap irq_active;

		/* Interrupt priority. Not used yet. */
		struct vgic_bytemap irq_priority;

		@@ -235,6 +238,9 @@ struct vgic_dist {
		/* Bitmap indicating which CPU has something pending */
		unsigned long *irq_pending_on_cpu;

		/* Bitmap indicating which CPU has active IRQs */
		unsigned long *irq_active_on_cpu;

		struct vgic_vm_ops vm_ops;
		};

		@@ -266,9 +272,15 @@ struct vgic_cpu {
		/* per IRQ to LR mapping */
		u8 *vgic_irq_lr_map;

		/* Pending interrupts on this VCPU */
		/* Pending/active/both interrupts on this VCPU */
		DECLARE_BITMAP( pending_percpu, VGIC_NR_PRIVATE_IRQS);
		DECLARE_BITMAP( active_percpu, VGIC_NR_PRIVATE_IRQS);
		DECLARE_BITMAP( pend_act_percpu, VGIC_NR_PRIVATE_IRQS);

		/* Pending/active/both shared interrupts, dynamically sized */
		unsigned long *pending_shared;
		unsigned long *active_shared;
		unsigned long *pend_act_shared;

		/* Bitmap of used/free list registers */
		DECLARE_BITMAP( lr_used, VGIC_V2_MAX_LRS);
		@@ -306,6 +318,7 @@ int kvm_vgic_inject_irq(struct kvm *kvm, int cpuid, unsigned int irq_num,
		bool level);
		void vgic_v3_dispatch_sgi(struct kvm_vcpu *vcpu, u64 reg);
		int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu);
		int kvm_vgic_vcpu_active_irq(struct kvm_vcpu *vcpu);
		bool vgic_handle_mmio(struct kvm_vcpu vcpu, struct kvm_run run,
		struct kvm_exit_mmio *mmio);

virt/kvm/arm/vgic-v2-emul.c

+18 −2

Original line number	Diff line number	Diff line
		@@ -107,6 +107,22 @@ static bool handle_mmio_clear_pending_reg(struct kvm_vcpu *vcpu,
		vcpu->vcpu_id);
		}

		static bool handle_mmio_set_active_reg(struct kvm_vcpu *vcpu,
		struct kvm_exit_mmio *mmio,
		phys_addr_t offset)
		{
		return vgic_handle_set_active_reg(vcpu->kvm, mmio, offset,
		vcpu->vcpu_id);
		}

		static bool handle_mmio_clear_active_reg(struct kvm_vcpu *vcpu,
		struct kvm_exit_mmio *mmio,
		phys_addr_t offset)
		{
		return vgic_handle_clear_active_reg(vcpu->kvm, mmio, offset,
		vcpu->vcpu_id);
		}

		static bool handle_mmio_priority_reg(struct kvm_vcpu *vcpu,
		struct kvm_exit_mmio *mmio,
		phys_addr_t offset)
		@@ -344,13 +360,13 @@ static const struct kvm_mmio_range vgic_dist_ranges[] = {
		.base = GIC_DIST_ACTIVE_SET,
		.len = VGIC_MAX_IRQS / 8,
		.bits_per_irq = 1,
		.handle_mmio = handle_mmio_raz_wi,
		.handle_mmio = handle_mmio_set_active_reg,
		},
		{
		.base = GIC_DIST_ACTIVE_CLEAR,
		.len = VGIC_MAX_IRQS / 8,
		.bits_per_irq = 1,
		.handle_mmio = handle_mmio_raz_wi,
		.handle_mmio = handle_mmio_clear_active_reg,
		},
		{
		.base = GIC_DIST_PRI,

virt/kvm/arm/vgic.c

+172 −35

Original line number	Diff line number	Diff line
		@@ -264,6 +264,13 @@ static int vgic_irq_is_queued(struct kvm_vcpu *vcpu, int irq)
		return vgic_bitmap_get_irq_val(&dist->irq_queued, vcpu->vcpu_id, irq);
		}

		static int vgic_irq_is_active(struct kvm_vcpu *vcpu, int irq)
		{
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;

		return vgic_bitmap_get_irq_val(&dist->irq_active, vcpu->vcpu_id, irq);
		}

		static void vgic_irq_set_queued(struct kvm_vcpu *vcpu, int irq)
		{
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
		@@ -278,6 +285,20 @@ static void vgic_irq_clear_queued(struct kvm_vcpu *vcpu, int irq)
		vgic_bitmap_set_irq_val(&dist->irq_queued, vcpu->vcpu_id, irq, 0);
		}

		static void vgic_irq_set_active(struct kvm_vcpu *vcpu, int irq)
		{
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;

		vgic_bitmap_set_irq_val(&dist->irq_active, vcpu->vcpu_id, irq, 1);
		}

		static void vgic_irq_clear_active(struct kvm_vcpu *vcpu, int irq)
		{
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;

		vgic_bitmap_set_irq_val(&dist->irq_active, vcpu->vcpu_id, irq, 0);
		}

		static int vgic_dist_irq_get_level(struct kvm_vcpu *vcpu, int irq)
		{
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
		@@ -521,6 +542,44 @@ bool vgic_handle_clear_pending_reg(struct kvm *kvm,
		return false;
		}

		bool vgic_handle_set_active_reg(struct kvm *kvm,
		struct kvm_exit_mmio *mmio,
		phys_addr_t offset, int vcpu_id)
		{
		u32 *reg;
		struct vgic_dist *dist = &kvm->arch.vgic;

		reg = vgic_bitmap_get_reg(&dist->irq_active, vcpu_id, offset);
		vgic_reg_access(mmio, reg, offset,
		ACCESS_READ_VALUE \| ACCESS_WRITE_SETBIT);

		if (mmio->is_write) {
		vgic_update_state(kvm);
		return true;
		}

		return false;
		}

		bool vgic_handle_clear_active_reg(struct kvm *kvm,
		struct kvm_exit_mmio *mmio,
		phys_addr_t offset, int vcpu_id)
		{
		u32 *reg;
		struct vgic_dist *dist = &kvm->arch.vgic;

		reg = vgic_bitmap_get_reg(&dist->irq_active, vcpu_id, offset);
		vgic_reg_access(mmio, reg, offset,
		ACCESS_READ_VALUE \| ACCESS_WRITE_CLEARBIT);

		if (mmio->is_write) {
		vgic_update_state(kvm);
		return true;
		}

		return false;
		}

		static u32 vgic_cfg_expand(u16 val)
		{
		u32 res = 0;
		@@ -589,16 +648,12 @@ bool vgic_handle_cfg_reg(u32 reg, struct kvm_exit_mmio mmio,
		}

		/**
		* vgic_unqueue_irqs - move pending IRQs from LRs to the distributor
		* vgic_unqueue_irqs - move pending/active IRQs from LRs to the distributor
		* @vgic_cpu: Pointer to the vgic_cpu struct holding the LRs
		*
		* Move any pending IRQs that have already been assigned to LRs back to the
		* Move any IRQs that have already been assigned to LRs back to the
		* emulated distributor state so that the complete emulated state can be read
		* from the main emulation structures without investigating the LRs.
		*
		* Note that IRQs in the active state in the LRs get their pending state moved
		* to the distributor but the active state stays in the LRs, because we don't
		* track the active state on the distributor side.
		*/
		void vgic_unqueue_irqs(struct kvm_vcpu *vcpu)
		{
		@@ -614,12 +669,22 @@ void vgic_unqueue_irqs(struct kvm_vcpu *vcpu)
		* 01: pending
		* 10: active
		* 11: pending and active
		*
		* If the LR holds only an active interrupt (not pending) then
		* just leave it alone.
		*/
		if ((lr.state & LR_STATE_MASK) == LR_STATE_ACTIVE)
		continue;
		BUG_ON(!(lr.state & LR_STATE_MASK));

		/* Reestablish SGI source for pending and active IRQs */
		if (lr.irq < VGIC_NR_SGIS)
		add_sgi_source(vcpu, lr.irq, lr.source);

		/*
		* If the LR holds an active (10) or a pending and active (11)
		* interrupt then move the active state to the
		* distributor tracking bit.
		*/
		if (lr.state & LR_STATE_ACTIVE) {
		vgic_irq_set_active(vcpu, lr.irq);
		lr.state &= ~LR_STATE_ACTIVE;
		}

		/*
		* Reestablish the pending state on the distributor and the
		@@ -627,21 +692,19 @@ void vgic_unqueue_irqs(struct kvm_vcpu *vcpu)
		* is fine, then we are only setting a few bits that were
		* already set.
		*/
		if (lr.state & LR_STATE_PENDING) {
		vgic_dist_irq_set_pending(vcpu, lr.irq);
		if (lr.irq < VGIC_NR_SGIS)
		add_sgi_source(vcpu, lr.irq, lr.source);
		lr.state &= ~LR_STATE_PENDING;
		}

		vgic_set_lr(vcpu, i, lr);

		/*
		* If there's no state left on the LR (it could still be
		* active), then the LR does not hold any useful info and can
		* be marked as free for other use.
		* Mark the LR as free for other use.
		*/
		if (!(lr.state & LR_STATE_MASK)) {
		BUG_ON(lr.state & LR_STATE_MASK);
		vgic_retire_lr(i, lr.irq, vcpu);
		vgic_irq_clear_queued(vcpu, lr.irq);
		}

		/* Finally update the VGIC state. */
		vgic_update_state(vcpu->kvm);
		@@ -805,6 +868,36 @@ static int vgic_nr_shared_irqs(struct vgic_dist *dist)
		return dist->nr_irqs - VGIC_NR_PRIVATE_IRQS;
		}

		static int compute_active_for_cpu(struct kvm_vcpu *vcpu)
		{
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
		unsigned long active, enabled, act_percpu, act_shared;
		unsigned long active_private, active_shared;
		int nr_shared = vgic_nr_shared_irqs(dist);
		int vcpu_id;

		vcpu_id = vcpu->vcpu_id;
		act_percpu = vcpu->arch.vgic_cpu.active_percpu;
		act_shared = vcpu->arch.vgic_cpu.active_shared;

		active = vgic_bitmap_get_cpu_map(&dist->irq_active, vcpu_id);
		enabled = vgic_bitmap_get_cpu_map(&dist->irq_enabled, vcpu_id);
		bitmap_and(act_percpu, active, enabled, VGIC_NR_PRIVATE_IRQS);

		active = vgic_bitmap_get_shared_map(&dist->irq_active);
		enabled = vgic_bitmap_get_shared_map(&dist->irq_enabled);
		bitmap_and(act_shared, active, enabled, nr_shared);
		bitmap_and(act_shared, act_shared,
		vgic_bitmap_get_shared_map(&dist->irq_spi_target[vcpu_id]),
		nr_shared);

		active_private = find_first_bit(act_percpu, VGIC_NR_PRIVATE_IRQS);
		active_shared = find_first_bit(act_shared, nr_shared);

		return (active_private < VGIC_NR_PRIVATE_IRQS \|\|
		active_shared < nr_shared);
		}

		static int compute_pending_for_cpu(struct kvm_vcpu *vcpu)
		{
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
		@@ -836,7 +929,7 @@ static int compute_pending_for_cpu(struct kvm_vcpu *vcpu)

		/*
		* Update the interrupt state and determine which CPUs have pending
		* interrupts. Must be called with distributor lock held.
		* or active interrupts. Must be called with distributor lock held.
		*/
		void vgic_update_state(struct kvm *kvm)
		{
		@@ -850,10 +943,13 @@ void vgic_update_state(struct kvm *kvm)
		}

		kvm_for_each_vcpu(c, vcpu, kvm) {
		if (compute_pending_for_cpu(vcpu)) {
		pr_debug("CPU%d has pending interrupts\n", c);
		if (compute_pending_for_cpu(vcpu))
		set_bit(c, dist->irq_pending_on_cpu);
		}

		if (compute_active_for_cpu(vcpu))
		set_bit(c, dist->irq_active_on_cpu);
		else
		clear_bit(c, dist->irq_active_on_cpu);
		}
		}

		@@ -953,7 +1049,12 @@ static void vgic_retire_disabled_irqs(struct kvm_vcpu *vcpu)
		static void vgic_queue_irq_to_lr(struct kvm_vcpu *vcpu, int irq,
		int lr_nr, struct vgic_lr vlr)
		{
		if (vgic_dist_irq_is_pending(vcpu, irq)) {
		if (vgic_irq_is_active(vcpu, irq)) {
		vlr.state \|= LR_STATE_ACTIVE;
		kvm_debug("Set active, clear distributor: 0x%x\n", vlr.state);
		vgic_irq_clear_active(vcpu, irq);
		vgic_update_state(vcpu->kvm);
		} else if (vgic_dist_irq_is_pending(vcpu, irq)) {
		vlr.state \|= LR_STATE_PENDING;
		kvm_debug("Set pending: 0x%x\n", vlr.state);
		}
		@@ -1041,39 +1142,49 @@ static void __kvm_vgic_flush_hwstate(struct kvm_vcpu *vcpu)
		{
		struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu;
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
		unsigned long pa_percpu, pa_shared;
		int i, vcpu_id;
		int overflow = 0;
		int nr_shared = vgic_nr_shared_irqs(dist);

		vcpu_id = vcpu->vcpu_id;

		pa_percpu = vcpu->arch.vgic_cpu.pend_act_percpu;
		pa_shared = vcpu->arch.vgic_cpu.pend_act_shared;

		bitmap_or(pa_percpu, vgic_cpu->pending_percpu, vgic_cpu->active_percpu,
		VGIC_NR_PRIVATE_IRQS);
		bitmap_or(pa_shared, vgic_cpu->pending_shared, vgic_cpu->active_shared,
		nr_shared);
		/*
		* We may not have any pending interrupt, or the interrupts
		* may have been serviced from another vcpu. In all cases,
		* move along.
		*/
		if (!kvm_vgic_vcpu_pending_irq(vcpu)) {
		pr_debug("CPU%d has no pending interrupt\n", vcpu_id);
		if (!kvm_vgic_vcpu_pending_irq(vcpu) && !kvm_vgic_vcpu_active_irq(vcpu))
		goto epilog;
		}

		/* SGIs */
		for_each_set_bit(i, vgic_cpu->pending_percpu, VGIC_NR_SGIS) {
		for_each_set_bit(i, pa_percpu, VGIC_NR_SGIS) {
		if (!queue_sgi(vcpu, i))
		overflow = 1;
		}

		/* PPIs */
		for_each_set_bit_from(i, vgic_cpu->pending_percpu, VGIC_NR_PRIVATE_IRQS) {
		for_each_set_bit_from(i, pa_percpu, VGIC_NR_PRIVATE_IRQS) {
		if (!vgic_queue_hwirq(vcpu, i))
		overflow = 1;
		}

		/* SPIs */
		for_each_set_bit(i, vgic_cpu->pending_shared, vgic_nr_shared_irqs(dist)) {
		for_each_set_bit(i, pa_shared, nr_shared) {
		if (!vgic_queue_hwirq(vcpu, i + VGIC_NR_PRIVATE_IRQS))
		overflow = 1;
		}




		epilog:
		if (overflow) {
		vgic_enable_underflow(vcpu);
		@@ -1229,6 +1340,17 @@ int kvm_vgic_vcpu_pending_irq(struct kvm_vcpu *vcpu)
		return test_bit(vcpu->vcpu_id, dist->irq_pending_on_cpu);
		}

		int kvm_vgic_vcpu_active_irq(struct kvm_vcpu *vcpu)
		{
		struct vgic_dist *dist = &vcpu->kvm->arch.vgic;

		if (!irqchip_in_kernel(vcpu->kvm))
		return 0;

		return test_bit(vcpu->vcpu_id, dist->irq_active_on_cpu);
		}


		void vgic_kick_vcpus(struct kvm *kvm)
		{
		struct kvm_vcpu *vcpu;
		@@ -1401,8 +1523,12 @@ void kvm_vgic_vcpu_destroy(struct kvm_vcpu *vcpu)
		struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu;

		kfree(vgic_cpu->pending_shared);
		kfree(vgic_cpu->active_shared);
		kfree(vgic_cpu->pend_act_shared);
		kfree(vgic_cpu->vgic_irq_lr_map);
		vgic_cpu->pending_shared = NULL;
		vgic_cpu->active_shared = NULL;
		vgic_cpu->pend_act_shared = NULL;
		vgic_cpu->vgic_irq_lr_map = NULL;
		}

		@@ -1412,9 +1538,14 @@ static int vgic_vcpu_init_maps(struct kvm_vcpu *vcpu, int nr_irqs)

		int sz = (nr_irqs - VGIC_NR_PRIVATE_IRQS) / 8;
		vgic_cpu->pending_shared = kzalloc(sz, GFP_KERNEL);
		vgic_cpu->active_shared = kzalloc(sz, GFP_KERNEL);
		vgic_cpu->pend_act_shared = kzalloc(sz, GFP_KERNEL);
		vgic_cpu->vgic_irq_lr_map = kmalloc(nr_irqs, GFP_KERNEL);

		if (!vgic_cpu->pending_shared \|\| !vgic_cpu->vgic_irq_lr_map) {
		if (!vgic_cpu->pending_shared
		\|\| !vgic_cpu->active_shared
		\|\| !vgic_cpu->pend_act_shared
		\|\| !vgic_cpu->vgic_irq_lr_map) {
		kvm_vgic_vcpu_destroy(vcpu);
		return -ENOMEM;
		}
		@@ -1467,10 +1598,12 @@ void kvm_vgic_destroy(struct kvm *kvm)
		kfree(dist->irq_spi_mpidr);
		kfree(dist->irq_spi_target);
		kfree(dist->irq_pending_on_cpu);
		kfree(dist->irq_active_on_cpu);
		dist->irq_sgi_sources = NULL;
		dist->irq_spi_cpu = NULL;
		dist->irq_spi_target = NULL;
		dist->irq_pending_on_cpu = NULL;
		dist->irq_active_on_cpu = NULL;
		dist->nr_cpus = 0;
		}

		@@ -1506,6 +1639,7 @@ int vgic_init(struct kvm *kvm)
		ret \|= vgic_init_bitmap(&dist->irq_pending, nr_cpus, nr_irqs);
		ret \|= vgic_init_bitmap(&dist->irq_soft_pend, nr_cpus, nr_irqs);
		ret \|= vgic_init_bitmap(&dist->irq_queued, nr_cpus, nr_irqs);
		ret \|= vgic_init_bitmap(&dist->irq_active, nr_cpus, nr_irqs);
		ret \|= vgic_init_bitmap(&dist->irq_cfg, nr_cpus, nr_irqs);
		ret \|= vgic_init_bytemap(&dist->irq_priority, nr_cpus, nr_irqs);

		@@ -1518,10 +1652,13 @@ int vgic_init(struct kvm *kvm)
		GFP_KERNEL);
		dist->irq_pending_on_cpu = kzalloc(BITS_TO_LONGS(nr_cpus) * sizeof(long),
		GFP_KERNEL);
		dist->irq_active_on_cpu = kzalloc(BITS_TO_LONGS(nr_cpus) * sizeof(long),
		GFP_KERNEL);
		if (!dist->irq_sgi_sources \|\|
		!dist->irq_spi_cpu \|\|
		!dist->irq_spi_target \|\|
		!dist->irq_pending_on_cpu) {
		!dist->irq_pending_on_cpu \|\|
		!dist->irq_active_on_cpu) {
		ret = -ENOMEM;
		goto out;
		}

virt/kvm/arm/vgic.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -107,6 +107,14 @@ bool vgic_handle_set_pending_reg(struct kvm kvm, struct kvm_exit_mmio mmio,
		bool vgic_handle_clear_pending_reg(struct kvm kvm, struct kvm_exit_mmio mmio,
		phys_addr_t offset, int vcpu_id);

		bool vgic_handle_set_active_reg(struct kvm *kvm,
		struct kvm_exit_mmio *mmio,
		phys_addr_t offset, int vcpu_id);

		bool vgic_handle_clear_active_reg(struct kvm *kvm,
		struct kvm_exit_mmio *mmio,
		phys_addr_t offset, int vcpu_id);

		bool vgic_handle_cfg_reg(u32 reg, struct kvm_exit_mmio mmio,
		phys_addr_t offset);

Admin message