hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

arm/arm64: KVM: Rename irq_active to irq_queued 

We have a special bitmap on the distributor struct to keep track of when
level-triggered interrupts are queued on the list registers.  This was
named irq_active, which is confusing, because the active state of an
interrupt as per the GIC spec is a different thing, not specifically
related to edge-triggered/level-triggered configurations but rather
indicates an interrupt which has been ack'ed but not yet eoi'ed.

Rename the bitmap and the corresponding accessor functions to irq_queued
to clarify what this is actually used for.

Signed-off-by: Christoffer Dall <christoffer.dall@linaro.org>
This commit is contained in:
Christoffer Dall 2014-06-09 12:55:13 +02:00
parent 227844f538
commit dbf20f9d81
2 changed files with 21 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/kvm/arm_vgic.h
View File

@ -143,8 +143,8 @@ struct vgic_dist {
/* Interrupt state is pending on the distributor */ /* Interrupt state is pending on the distributor */
struct vgic_bitmap irq_pending; struct vgic_bitmap irq_pending;
/* Level-triggered interrupt in progress */ /* Level-triggered interrupt queued on VCPU interface */
struct vgic_bitmap irq_active; struct vgic_bitmap irq_queued;
/* Interrupt priority. Not used yet. */ /* Interrupt priority. Not used yet. */
struct vgic_bytemap irq_priority; struct vgic_bytemap irq_priority;

33
virt/kvm/arm/vgic.c
View File

@ -60,12 +60,12 @@
* the 'line' again. This is achieved as such: * the 'line' again. This is achieved as such:
* *
* - When a level interrupt is moved onto a vcpu, the corresponding * - When a level interrupt is moved onto a vcpu, the corresponding
* bit in irq_active is set. As long as this bit is set, the line * bit in irq_queued is set. As long as this bit is set, the line
* will be ignored for further interrupts. The interrupt is injected * will be ignored for further interrupts. The interrupt is injected
* into the vcpu with the GICH_LR_EOI bit set (generate a * into the vcpu with the GICH_LR_EOI bit set (generate a
* maintenance interrupt on EOI). * maintenance interrupt on EOI).
* - When the interrupt is EOIed, the maintenance interrupt fires, * - When the interrupt is EOIed, the maintenance interrupt fires,
* and clears the corresponding bit in irq_active. This allow the * and clears the corresponding bit in irq_queued. This allows the
* interrupt line to be sampled again. * interrupt line to be sampled again.
*/ */
@ -196,25 +196,25 @@ static int vgic_irq_is_enabled(struct kvm_vcpu *vcpu, int irq)
return vgic_bitmap_get_irq_val(&dist->irq_enabled, vcpu->vcpu_id, irq); return vgic_bitmap_get_irq_val(&dist->irq_enabled, vcpu->vcpu_id, irq);
} }
static int vgic_irq_is_active(struct kvm_vcpu *vcpu, int irq) static int vgic_irq_is_queued(struct kvm_vcpu *vcpu, int irq)
{ {
struct vgic_dist *dist = &vcpu->kvm->arch.vgic; struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
return vgic_bitmap_get_irq_val(&dist->irq_active, vcpu->vcpu_id, irq); return vgic_bitmap_get_irq_val(&dist->irq_queued, vcpu->vcpu_id, irq);
} }
static void vgic_irq_set_active(struct kvm_vcpu *vcpu, int irq) static void vgic_irq_set_queued(struct kvm_vcpu *vcpu, int irq)
{ {
struct vgic_dist *dist = &vcpu->kvm->arch.vgic; struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
vgic_bitmap_set_irq_val(&dist->irq_active, vcpu->vcpu_id, irq, 1); vgic_bitmap_set_irq_val(&dist->irq_queued, vcpu->vcpu_id, irq, 1);
} }
static void vgic_irq_clear_active(struct kvm_vcpu *vcpu, int irq) static void vgic_irq_clear_queued(struct kvm_vcpu *vcpu, int irq)
{ {
struct vgic_dist *dist = &vcpu->kvm->arch.vgic; struct vgic_dist *dist = &vcpu->kvm->arch.vgic;
vgic_bitmap_set_irq_val(&dist->irq_active, vcpu->vcpu_id, irq, 0); vgic_bitmap_set_irq_val(&dist->irq_queued, vcpu->vcpu_id, irq, 0);
} }
static int vgic_dist_irq_is_pending(struct kvm_vcpu *vcpu, int irq) static int vgic_dist_irq_is_pending(struct kvm_vcpu *vcpu, int irq)
@ -256,6 +256,11 @@ static void vgic_cpu_irq_clear(struct kvm_vcpu *vcpu, int irq)
vcpu->arch.vgic_cpu.pending_shared); vcpu->arch.vgic_cpu.pending_shared);
} }
static bool vgic_can_sample_irq(struct kvm_vcpu *vcpu, int irq)
{
return vgic_irq_is_edge(vcpu, irq) || !vgic_irq_is_queued(vcpu, irq);
}
static u32 mmio_data_read(struct kvm_exit_mmio *mmio, u32 mask) static u32 mmio_data_read(struct kvm_exit_mmio *mmio, u32 mask)
{ {
return le32_to_cpu(*((u32 *)mmio->data)) & mask; return le32_to_cpu(*((u32 *)mmio->data)) & mask;
@ -1079,8 +1084,8 @@ static void vgic_retire_disabled_irqs(struct kvm_vcpu *vcpu)
if (!vgic_irq_is_enabled(vcpu, vlr.irq)) { if (!vgic_irq_is_enabled(vcpu, vlr.irq)) {
vgic_retire_lr(lr, vlr.irq, vcpu); vgic_retire_lr(lr, vlr.irq, vcpu);
if (vgic_irq_is_active(vcpu, vlr.irq)) if (vgic_irq_is_queued(vcpu, vlr.irq))
vgic_irq_clear_active(vcpu, vlr.irq); vgic_irq_clear_queued(vcpu, vlr.irq);
} }
} }
} }
@ -1170,7 +1175,7 @@ static bool vgic_queue_sgi(struct kvm_vcpu *vcpu, int irq)
static bool vgic_queue_hwirq(struct kvm_vcpu *vcpu, int irq) static bool vgic_queue_hwirq(struct kvm_vcpu *vcpu, int irq)
{ {
if (vgic_irq_is_active(vcpu, irq)) if (!vgic_can_sample_irq(vcpu, irq))
return true; /* level interrupt, already queued */ return true; /* level interrupt, already queued */
if (vgic_queue_irq(vcpu, 0, irq)) { if (vgic_queue_irq(vcpu, 0, irq)) {
@ -1178,7 +1183,7 @@ static bool vgic_queue_hwirq(struct kvm_vcpu *vcpu, int irq)
vgic_dist_irq_clear_pending(vcpu, irq); vgic_dist_irq_clear_pending(vcpu, irq);
vgic_cpu_irq_clear(vcpu, irq); vgic_cpu_irq_clear(vcpu, irq);
} else { } else {
vgic_irq_set_active(vcpu, irq); vgic_irq_set_queued(vcpu, irq);
} }
return true; return true;
@ -1262,7 +1267,7 @@ static bool vgic_process_maintenance(struct kvm_vcpu *vcpu)
for_each_set_bit(lr, eisr_ptr, vgic->nr_lr) { for_each_set_bit(lr, eisr_ptr, vgic->nr_lr) {
struct vgic_lr vlr = vgic_get_lr(vcpu, lr); struct vgic_lr vlr = vgic_get_lr(vcpu, lr);
vgic_irq_clear_active(vcpu, vlr.irq); vgic_irq_clear_queued(vcpu, vlr.irq);
WARN_ON(vlr.state & LR_STATE_MASK); WARN_ON(vlr.state & LR_STATE_MASK);
vlr.state = 0; vlr.state = 0;
vgic_set_lr(vcpu, lr, vlr); vgic_set_lr(vcpu, lr, vlr);
@ -1429,7 +1434,7 @@ static bool vgic_update_irq_pending(struct kvm *kvm, int cpuid,
goto out; goto out;
} }
if (level_triggered && vgic_irq_is_active(vcpu, irq_num)) { if (!vgic_can_sample_irq(vcpu, irq_num)) {
/* /*
* Level interrupt in progress, will be picked up * Level interrupt in progress, will be picked up
* when EOId. * when EOId.