KVM: arm64: selftests: vgic_irq: Exclude timer-controlled interrupts

The PPI injection API is clear that you can't inject the timer PPIs
from userspace, since they are controlled by the timers themselves.

Add an exclusion list for this purpose.

Tested-by: Fuad Tabba <tabba@google.com>
Signed-off-by: Marc Zyngier <maz@kernel.org>
Tested-by: Mark Brown <broonie@kernel.org>
Link: https://msgid.link/20251120172540.2267180-45-maz@kernel.org
Signed-off-by: Oliver Upton <oupton@kernel.org>

diff --git a/tools/testing/selftests/kvm/arm64/vgic_irq.c b/tools/testing/selftests/kvm/arm64/vgic_irq.c
index a8919ef3cea2ea17141b3f47bc7f8379310a6ba9..b0415bdb89524f5b8186d7c16c8587042256a0de 100644 (file)
--- a/tools/testing/selftests/kvm/arm64/vgic_irq.c
+++ b/tools/testing/selftests/kvm/arm64/vgic_irq.c
@@ -359,8 +359,9 @@ static uint32_t wait_for_and_activate_irq(void)
  * interrupts for the whole test.
  */
 static void test_inject_preemption(struct test_args *args,
-               uint32_t first_intid, int num,
-               kvm_inject_cmd cmd)
+                                  uint32_t first_intid, int num,
+                                  const unsigned long *exclude,
+                                  kvm_inject_cmd cmd)
 {
        uint32_t intid, prio, step = KVM_PRIO_STEPS;
        int i;
@@ -379,6 +380,10 @@ static void test_inject_preemption(struct test_args *args,
        for (i = 0; i < num; i++) {
                uint32_t tmp;
                intid = i + first_intid;
+
+               if (exclude && test_bit(i, exclude))
+                       continue;
+
                KVM_INJECT(cmd, intid);
                /* Each successive IRQ will preempt the previous one. */
                tmp = wait_for_and_activate_irq();
@@ -390,6 +395,10 @@ static void test_inject_preemption(struct test_args *args,
        /* finish handling the IRQs starting with the highest priority one. */
        for (i = 0; i < num; i++) {
                intid = num - i - 1 + first_intid;
+
+               if (exclude && test_bit(intid - first_intid, exclude))
+                       continue;
+
                gic_set_eoi(intid);
                if (args->eoi_split)
                        gic_set_dir(intid);
@@ -397,8 +406,12 @@ static void test_inject_preemption(struct test_args *args,
 
        local_irq_enable();
 
-       for (i = 0; i < num; i++)
+       for (i = 0; i < num; i++) {
+               if (exclude && test_bit(i, exclude))
+                       continue;
+
                GUEST_ASSERT(!gic_irq_get_active(i + first_intid));
+       }
        GUEST_ASSERT_EQ(gic_read_ap1r0(), 0);
        GUEST_ASSERT_IAR_EMPTY();
 
@@ -442,14 +455,20 @@ static void test_preemption(struct test_args *args, struct kvm_inject_desc *f)
         * number of concurrently active IRQs. The number of LRs implemented is
         * IMPLEMENTATION DEFINED, however, it seems that most implement 4.
         */
+       /* Timer PPIs cannot be injected from userspace */
+       static const unsigned long ppi_exclude = (BIT(27 - MIN_PPI) |
+                                                 BIT(30 - MIN_PPI) |
+                                                 BIT(28 - MIN_PPI) |
+                                                 BIT(26 - MIN_PPI));
+
        if (f->sgi)
-               test_inject_preemption(args, MIN_SGI, 4, f->cmd);
+               test_inject_preemption(args, MIN_SGI, 4, NULL, f->cmd);
 
        if (f->ppi)
-               test_inject_preemption(args, MIN_PPI, 4, f->cmd);
+               test_inject_preemption(args, MIN_PPI, 4, &ppi_exclude, f->cmd);
 
        if (f->spi)
-               test_inject_preemption(args, MIN_SPI, 4, f->cmd);
+               test_inject_preemption(args, MIN_SPI, 4, NULL, f->cmd);
 }
 
 static void test_restore_active(struct test_args *args, struct kvm_inject_desc *f)