KVM: selftests: aarch64: Cmdline arg to set number of IRQs in vgic_irq test

Add the ability to specify the number of vIRQs exposed by KVM (arg
defaults to 64). Then extend the KVM_IRQ_LINE test by injecting all
available SPIs at once (specified by the nr-irqs arg). As a bonus,
inject all SGIs at once as well.

Signed-off-by: Ricardo Koller <ricarkol@google.com>
Acked-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20211109023906.1091208-9-ricarkol@google.com

diff --git a/tools/testing/selftests/kvm/aarch64/arch_timer.c b/tools/testing/selftests/kvm/aarch64/arch_timer.c
index bf6a45b0b8dcb2ad5580d6960fd1c292be737059..9ad38bd360a42ebd540c70a6b7663c72408ec311 100644 (file)
--- a/tools/testing/selftests/kvm/aarch64/arch_timer.c
+++ b/tools/testing/selftests/kvm/aarch64/arch_timer.c
@@ -382,7 +382,7 @@ static struct kvm_vm *test_vm_create(void)
 
        ucall_init(vm, NULL);
        test_init_timer_irq(vm);
-       vgic_v3_setup(vm, nr_vcpus, GICD_BASE_GPA, GICR_BASE_GPA);
+       vgic_v3_setup(vm, nr_vcpus, 64, GICD_BASE_GPA, GICR_BASE_GPA);
 
        /* Make all the test's cmdline args visible to the guest */
        sync_global_to_guest(vm, test_args);

diff --git a/tools/testing/selftests/kvm/aarch64/vgic_irq.c b/tools/testing/selftests/kvm/aarch64/vgic_irq.c
index f5d76fef22f0de980d913f339a9912bbf8938cce..0b89a29dfe79e9c17f62fc288613d11028b7d40e 100644 (file)
--- a/tools/testing/selftests/kvm/aarch64/vgic_irq.c
+++ b/tools/testing/selftests/kvm/aarch64/vgic_irq.c
@@ -23,6 +23,14 @@
 #define GICR_BASE_GPA          0x080A0000ULL
 #define VCPU_ID                        0
 
+/*
+ * Stores the user specified args; it's passed to the guest and to every test
+ * function.
+ */
+struct test_args {
+       uint32_t nr_irqs; /* number of KVM supported IRQs. */
+};
+
 /*
  * KVM implements 32 priority levels:
  * 0x00 (highest priority) - 0xF8 (lowest priority), in steps of 8
@@ -51,14 +59,18 @@ typedef enum {
 
 struct kvm_inject_args {
        kvm_inject_cmd cmd;
-       uint32_t intid;
+       uint32_t first_intid;
+       uint32_t num;
 };
 
 /* Used on the guest side to perform the hypercall. */
-static void kvm_inject_call(kvm_inject_cmd cmd, uint32_t intid);
+static void kvm_inject_call(kvm_inject_cmd cmd, uint32_t first_intid, uint32_t num);
 
 #define KVM_INJECT(cmd, intid)                                                 \
-       kvm_inject_call(cmd, intid)
+       kvm_inject_call(cmd, intid, 1)
+
+#define KVM_INJECT_MULTI(cmd, intid, num)                                      \
+       kvm_inject_call(cmd, intid, num)
 
 /* Used on the host side to get the hypercall info. */
 static void kvm_inject_get_call(struct kvm_vm *vm, struct ucall *uc,
@@ -122,11 +134,12 @@ static void guest_irq_handler(struct ex_regs *regs)
        GUEST_ASSERT(!gic_irq_get_pending(intid));
 }
 
-static void kvm_inject_call(kvm_inject_cmd cmd, uint32_t intid)
+static void kvm_inject_call(kvm_inject_cmd cmd, uint32_t first_intid, uint32_t num)
 {
        struct kvm_inject_args args = {
                .cmd = cmd,
-               .intid = intid,
+               .first_intid = first_intid,
+               .num = num,
        };
        GUEST_SYNC(&args);
 }
@@ -138,14 +151,30 @@ do {                                                                              \
        GUEST_ASSERT(_intid == 0 || _intid == IAR_SPURIOUS);                    \
 } while (0)
 
-static void guest_inject(uint32_t intid, kvm_inject_cmd cmd)
+static void reset_priorities(struct test_args *args)
+{
+       int i;
+
+       for (i = 0; i < args->nr_irqs; i++)
+               gic_set_priority(i, IRQ_DEFAULT_PRIO_REG);
+}
+
+static void guest_inject(struct test_args *args,
+               uint32_t first_intid, uint32_t num,
+               kvm_inject_cmd cmd)
 {
+       uint32_t i;
+
        reset_stats();
 
+       /* Cycle over all priorities to make things more interesting. */
+       for (i = first_intid; i < num + first_intid; i++)
+               gic_set_priority(i, (i % (KVM_NUM_PRIOS - 1)) << 3);
+
        asm volatile("msr daifset, #2" : : : "memory");
-       KVM_INJECT(cmd, intid);
+       KVM_INJECT_MULTI(cmd, first_intid, num);
 
-       while (irq_handled < 1) {
+       while (irq_handled < num) {
                asm volatile("wfi\n"
                             "msr daifclr, #2\n"
                             /* handle IRQ */
@@ -154,57 +183,72 @@ static void guest_inject(uint32_t intid, kvm_inject_cmd cmd)
        }
        asm volatile("msr daifclr, #2" : : : "memory");
 
-       GUEST_ASSERT_EQ(irq_handled, 1);
-       GUEST_ASSERT_EQ(irqnr_received[intid], 1);
+       GUEST_ASSERT_EQ(irq_handled, num);
+       for (i = first_intid; i < num + first_intid; i++)
+               GUEST_ASSERT_EQ(irqnr_received[i], 1);
        GUEST_ASSERT_IAR_EMPTY();
+
+       reset_priorities(args);
 }
 
-static void test_injection(struct kvm_inject_desc *f)
+static void test_injection(struct test_args *args, struct kvm_inject_desc *f)
 {
-       if (f->sgi)
-               guest_inject(MIN_SGI, f->cmd);
+       uint32_t nr_irqs = args->nr_irqs;
+
+       if (f->sgi) {
+               guest_inject(args, MIN_SGI, 1, f->cmd);
+               guest_inject(args, 0, 16, f->cmd);
+       }
 
        if (f->ppi)
-               guest_inject(MIN_PPI, f->cmd);
+               guest_inject(args, MIN_PPI, 1, f->cmd);
 
-       if (f->spi)
-               guest_inject(MIN_SPI, f->cmd);
+       if (f->spi) {
+               guest_inject(args, MIN_SPI, 1, f->cmd);
+               guest_inject(args, nr_irqs - 1, 1, f->cmd);
+               guest_inject(args, MIN_SPI, nr_irqs - MIN_SPI, f->cmd);
+       }
 }
 
-static void guest_code(void)
+static void guest_code(struct test_args args)
 {
-       uint32_t i;
-       uint32_t nr_irqs = 64; /* absolute minimum number of IRQs supported. */
+       uint32_t i, nr_irqs = args.nr_irqs;
        struct kvm_inject_desc *f;
 
        gic_init(GIC_V3, 1, dist, redist);
 
-       for (i = 0; i < nr_irqs; i++) {
+       for (i = 0; i < nr_irqs; i++)
                gic_irq_enable(i);
-               gic_set_priority(i, IRQ_DEFAULT_PRIO_REG);
-       }
 
+       reset_priorities(&args);
        gic_set_priority_mask(CPU_PRIO_MASK);
 
        local_irq_enable();
 
        /* Start the tests. */
        for_each_inject_fn(inject_edge_fns, f)
-               test_injection(f);
+               test_injection(&args, f);
 
        GUEST_DONE();
 }
 
 static void run_guest_cmd(struct kvm_vm *vm, int gic_fd,
-               struct kvm_inject_args *inject_args)
+               struct kvm_inject_args *inject_args,
+               struct test_args *test_args)
 {
        kvm_inject_cmd cmd = inject_args->cmd;
-       uint32_t intid = inject_args->intid;
+       uint32_t intid = inject_args->first_intid;
+       uint32_t num = inject_args->num;
+       uint32_t i;
+
+       assert(intid < UINT_MAX - num);
 
        switch (cmd) {
        case KVM_INJECT_EDGE_IRQ_LINE:
-               kvm_arm_irq_line(vm, intid, 1);
-               kvm_arm_irq_line(vm, intid, 0);
+               for (i = intid; i < intid + num; i++)
+                       kvm_arm_irq_line(vm, i, 1);
+               for (i = intid; i < intid + num; i++)
+                       kvm_arm_irq_line(vm, i, 0);
                break;
        default:
                break;
@@ -222,21 +266,35 @@ static void kvm_inject_get_call(struct kvm_vm *vm, struct ucall *uc,
        memcpy(args, kvm_args_hva, sizeof(struct kvm_inject_args));
 }
 
+static void print_args(struct test_args *args)
+{
+       printf("nr-irqs=%d\n", args->nr_irqs);
+}
 
-static void test_vgic(void)
+static void test_vgic(uint32_t nr_irqs)
 {
        struct ucall uc;
        int gic_fd;
        struct kvm_vm *vm;
        struct kvm_inject_args inject_args;
 
+       struct test_args args = {
+               .nr_irqs = nr_irqs,
+       };
+
+       print_args(&args);
+
        vm = vm_create_default(VCPU_ID, 0, guest_code);
        ucall_init(vm, NULL);
 
        vm_init_descriptor_tables(vm);
        vcpu_init_descriptor_tables(vm, VCPU_ID);
 
-       gic_fd = vgic_v3_setup(vm, 1, GICD_BASE_GPA, GICR_BASE_GPA);
+       /* Setup the guest args page (so it gets the args). */
+       vcpu_args_set(vm, 0, 1, args);
+
+       gic_fd = vgic_v3_setup(vm, 1, nr_irqs,
+                       GICD_BASE_GPA, GICR_BASE_GPA);
 
        vm_install_exception_handler(vm, VECTOR_IRQ_CURRENT,
                        guest_irq_handler);
@@ -247,7 +305,7 @@ static void test_vgic(void)
                switch (get_ucall(vm, VCPU_ID, &uc)) {
                case UCALL_SYNC:
                        kvm_inject_get_call(vm, &uc, &inject_args);
-                       run_guest_cmd(vm, gic_fd, &inject_args);
+                       run_guest_cmd(vm, gic_fd, &inject_args, &args);
                        break;
                case UCALL_ABORT:
                        TEST_FAIL("%s at %s:%ld\n\tvalues: %#lx, %#lx",
@@ -266,12 +324,39 @@ done:
        kvm_vm_free(vm);
 }
 
-int main(int ac, char **av)
+static void help(const char *name)
 {
+       printf(
+       "\n"
+       "usage: %s [-n num_irqs]\n", name);
+       printf(" -n: specify the number of IRQs to configure the vgic with.\n");
+       puts("");
+       exit(1);
+}
+
+int main(int argc, char **argv)
+{
+       uint32_t nr_irqs = 64;
+       int opt;
+
        /* Tell stdout not to buffer its content */
        setbuf(stdout, NULL);
 
-       test_vgic();
+       while ((opt = getopt(argc, argv, "hg:n:")) != -1) {
+               switch (opt) {
+               case 'n':
+                       nr_irqs = atoi(optarg);
+                       if (nr_irqs > 1024 || nr_irqs % 32)
+                               help(argv[0]);
+                       break;
+               case 'h':
+               default:
+                       help(argv[0]);
+                       break;
+               }
+       }
+
+       test_vgic(nr_irqs);
 
        return 0;
 }

diff --git a/tools/testing/selftests/kvm/include/aarch64/vgic.h b/tools/testing/selftests/kvm/include/aarch64/vgic.h
index ec8744bb2d4b8e396e58f2012347628b6de2ce81..ce6f0383c1a1b225ed142f3fb35b2a16e5fdf04b 100644 (file)
--- a/tools/testing/selftests/kvm/include/aarch64/vgic.h
+++ b/tools/testing/selftests/kvm/include/aarch64/vgic.h
@@ -14,7 +14,7 @@
        ((uint64_t)(flags) << 12) | \
        index)
 
-int vgic_v3_setup(struct kvm_vm *vm, unsigned int nr_vcpus,
+int vgic_v3_setup(struct kvm_vm *vm, unsigned int nr_vcpus, uint32_t nr_irqs,
                uint64_t gicd_base_gpa, uint64_t gicr_base_gpa);
 
 #define VGIC_MAX_RESERVED      1023

diff --git a/tools/testing/selftests/kvm/lib/aarch64/vgic.c b/tools/testing/selftests/kvm/lib/aarch64/vgic.c
index a1f1f6c8e2e08e30549c14413dd35e52524cc99b..84206d7c92b42354f9141db349be912026919e91 100644 (file)
--- a/tools/testing/selftests/kvm/lib/aarch64/vgic.c
+++ b/tools/testing/selftests/kvm/lib/aarch64/vgic.c
@@ -31,7 +31,7 @@
  * redistributor regions of the guest. Since it depends on the number of
  * vCPUs for the VM, it must be called after all the vCPUs have been created.
  */
-int vgic_v3_setup(struct kvm_vm *vm, unsigned int nr_vcpus,
+int vgic_v3_setup(struct kvm_vm *vm, unsigned int nr_vcpus, uint32_t nr_irqs,
                uint64_t gicd_base_gpa, uint64_t gicr_base_gpa)
 {
        int gic_fd;
@@ -53,6 +53,13 @@ int vgic_v3_setup(struct kvm_vm *vm, unsigned int nr_vcpus,
 
        /* Distributor setup */
        gic_fd = kvm_create_device(vm, KVM_DEV_TYPE_ARM_VGIC_V3, false);
+
+       kvm_device_access(gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
+                       0, &nr_irqs, true);
+
+       kvm_device_access(gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
+                       KVM_DEV_ARM_VGIC_CTRL_INIT, NULL, true);
+
        kvm_device_access(gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
                        KVM_VGIC_V3_ADDR_TYPE_DIST, &gicd_base_gpa, true);
        nr_gic_pages = vm_calc_num_guest_pages(vm->mode, KVM_VGIC_V3_DIST_SIZE);