tools/testing/selftests/kvm/aarch64/vgic_init.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * vgic init sequence tests
   4  *
   5  * Copyright (C) 2020, Red Hat, Inc.
   6  */
   7 #include <linux/kernel.h>
   8 #include <sys/syscall.h>
   9 #include <asm/kvm.h>
  10 #include <asm/kvm_para.h>
  11
  12 #include "test_util.h"
  13 #include "kvm_util.h"
  14 #include "processor.h"
  15 #include "vgic.h"
  16
  17 #define NR_VCPUS                4
  18
  19 #define REG_OFFSET(vcpu, offset) (((uint64_t)vcpu << 32) | offset)
  20
  21 #define GICR_TYPER 0x8
  22
  23 #define VGIC_DEV_IS_V2(_d) ((_d) == KVM_DEV_TYPE_ARM_VGIC_V2)
  24 #define VGIC_DEV_IS_V3(_d) ((_d) == KVM_DEV_TYPE_ARM_VGIC_V3)
  25
  26 struct vm_gic {
  27         struct kvm_vm *vm;
  28         int gic_fd;
  29         uint32_t gic_dev_type;
  30 };
  31
  32 static uint64_t max_phys_size;
  33
  34 /*
  35  * Helpers to access a redistributor register and verify the ioctl() failed or
  36  * succeeded as expected, and provided the correct value on success.
  37  */
  38 static void v3_redist_reg_get_errno(int gicv3_fd, int vcpu, int offset,
  39                                     int want, const char *msg)
  40 {
  41         uint32_t ignored_val;
  42         int ret = __kvm_device_attr_get(gicv3_fd, KVM_DEV_ARM_VGIC_GRP_REDIST_REGS,
  43                                         REG_OFFSET(vcpu, offset), &ignored_val);
  44
  45         TEST_ASSERT(ret && errno == want, "%s; want errno = %d", msg, want);
  46 }
  47
  48 static void v3_redist_reg_get(int gicv3_fd, int vcpu, int offset, uint32_t want,
  49                               const char *msg)
  50 {
  51         uint32_t val;
  52
  53         kvm_device_attr_get(gicv3_fd, KVM_DEV_ARM_VGIC_GRP_REDIST_REGS,
  54                             REG_OFFSET(vcpu, offset), &val);
  55         TEST_ASSERT(val == want, "%s; want '0x%x', got '0x%x'", msg, want, val);
  56 }
  57
  58 /* dummy guest code */
  59 static void guest_code(void)
  60 {
  61         GUEST_SYNC(0);
  62         GUEST_SYNC(1);
  63         GUEST_SYNC(2);
  64         GUEST_DONE();
  65 }
  66
  67 /* we don't want to assert on run execution, hence that helper */
  68 static int run_vcpu(struct kvm_vcpu *vcpu)
  69 {
  70         return __vcpu_run(vcpu) ? -errno : 0;
  71 }
  72
  73 static struct vm_gic vm_gic_create_with_vcpus(uint32_t gic_dev_type,
  74                                               uint32_t nr_vcpus,
  75                                               struct kvm_vcpu *vcpus[])
  76 {
  77         struct vm_gic v;
  78
  79         v.gic_dev_type = gic_dev_type;
  80         v.vm = vm_create_with_vcpus(nr_vcpus, guest_code, vcpus);
  81         v.gic_fd = kvm_create_device(v.vm, gic_dev_type);
  82
  83         return v;
  84 }
  85
  86 static struct vm_gic vm_gic_create_barebones(uint32_t gic_dev_type)
  87 {
  88         struct vm_gic v;
  89
  90         v.gic_dev_type = gic_dev_type;
  91         v.vm = vm_create_barebones();
  92         v.gic_fd = kvm_create_device(v.vm, gic_dev_type);
  93
  94         return v;
  95 }
  96
  97
  98 static void vm_gic_destroy(struct vm_gic *v)
  99 {
 100         close(v->gic_fd);
 101         kvm_vm_free(v->vm);
 102 }
 103
 104 struct vgic_region_attr {
 105         uint64_t attr;
 106         uint64_t size;
 107         uint64_t alignment;
 108 };
 109
 110 struct vgic_region_attr gic_v3_dist_region = {
 111         .attr = KVM_VGIC_V3_ADDR_TYPE_DIST,
 112         .size = 0x10000,
 113         .alignment = 0x10000,
 114 };
 115
 116 struct vgic_region_attr gic_v3_redist_region = {
 117         .attr = KVM_VGIC_V3_ADDR_TYPE_REDIST,
 118         .size = NR_VCPUS * 0x20000,
 119         .alignment = 0x10000,
 120 };
 121
 122 struct vgic_region_attr gic_v2_dist_region = {
 123         .attr = KVM_VGIC_V2_ADDR_TYPE_DIST,
 124         .size = 0x1000,
 125         .alignment = 0x1000,
 126 };
 127
 128 struct vgic_region_attr gic_v2_cpu_region = {
 129         .attr = KVM_VGIC_V2_ADDR_TYPE_CPU,
 130         .size = 0x2000,
 131         .alignment = 0x1000,
 132 };
 133
 134 /**
 135  * Helper routine that performs KVM device tests in general. Eventually the
 136  * ARM_VGIC (GICv2 or GICv3) device gets created with an overlapping
 137  * DIST/REDIST (or DIST/CPUIF for GICv2). Assumption is 4 vcpus are going to be
 138  * used hence the overlap. In the case of GICv3, A RDIST region is set at @0x0
 139  * and a DIST region is set @0x70000. The GICv2 case sets a CPUIF @0x0 and a
 140  * DIST region @0x1000.
 141  */
 142 static void subtest_dist_rdist(struct vm_gic *v)
 143 {
 144         int ret;
 145         uint64_t addr;
 146         struct vgic_region_attr rdist; /* CPU interface in GICv2*/
 147         struct vgic_region_attr dist;
 148
 149         rdist = VGIC_DEV_IS_V3(v->gic_dev_type) ? gic_v3_redist_region
 150                                                 : gic_v2_cpu_region;
 151         dist = VGIC_DEV_IS_V3(v->gic_dev_type) ? gic_v3_dist_region
 152                                                 : gic_v2_dist_region;
 153
 154         /* Check existing group/attributes */
 155         kvm_has_device_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR, dist.attr);
 156
 157         kvm_has_device_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR, rdist.attr);
 158
 159         /* check non existing attribute */
 160         ret = __kvm_has_device_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR, -1);
 161         TEST_ASSERT(ret && errno == ENXIO, "attribute not supported");
 162
 163         /* misaligned DIST and REDIST address settings */
 164         addr = dist.alignment / 0x10;
 165         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 166                                     dist.attr, &addr);
 167         TEST_ASSERT(ret && errno == EINVAL, "GIC dist base not aligned");
 168
 169         addr = rdist.alignment / 0x10;
 170         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 171                                     rdist.attr, &addr);
 172         TEST_ASSERT(ret && errno == EINVAL, "GIC redist/cpu base not aligned");
 173
 174         /* out of range address */
 175         addr = max_phys_size;
 176         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 177                                     dist.attr, &addr);
 178         TEST_ASSERT(ret && errno == E2BIG, "dist address beyond IPA limit");
 179
 180         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 181                                     rdist.attr, &addr);
 182         TEST_ASSERT(ret && errno == E2BIG, "redist address beyond IPA limit");
 183
 184         /* Space for half a rdist (a rdist is: 2 * rdist.alignment). */
 185         addr = max_phys_size - dist.alignment;
 186         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 187                                     rdist.attr, &addr);
 188         TEST_ASSERT(ret && errno == E2BIG,
 189                         "half of the redist is beyond IPA limit");
 190
 191         /* set REDIST base address @0x0*/
 192         addr = 0x00000;
 193         kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 194                             rdist.attr, &addr);
 195
 196         /* Attempt to create a second legacy redistributor region */
 197         addr = 0xE0000;
 198         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 199                                     rdist.attr, &addr);
 200         TEST_ASSERT(ret && errno == EEXIST, "GIC redist base set again");
 201
 202         ret = __kvm_has_device_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 203                                      KVM_VGIC_V3_ADDR_TYPE_REDIST);
 204         if (!ret) {
 205                 /* Attempt to mix legacy and new redistributor regions */
 206                 addr = REDIST_REGION_ATTR_ADDR(NR_VCPUS, 0x100000, 0, 0);
 207                 ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 208                                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 209                 TEST_ASSERT(ret && errno == EINVAL,
 210                             "attempt to mix GICv3 REDIST and REDIST_REGION");
 211         }
 212
 213         /*
 214          * Set overlapping DIST / REDIST, cannot be detected here. Will be detected
 215          * on first vcpu run instead.
 216          */
 217         addr = rdist.size - rdist.alignment;
 218         kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 219                             dist.attr, &addr);
 220 }
 221
 222 /* Test the new REDIST region API */
 223 static void subtest_v3_redist_regions(struct vm_gic *v)
 224 {
 225         uint64_t addr, expected_addr;
 226         int ret;
 227
 228         ret = __kvm_has_device_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 229                                     KVM_VGIC_V3_ADDR_TYPE_REDIST);
 230         TEST_ASSERT(!ret, "Multiple redist regions advertised");
 231
 232         addr = REDIST_REGION_ATTR_ADDR(NR_VCPUS, 0x100000, 2, 0);
 233         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 234                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 235         TEST_ASSERT(ret && errno == EINVAL, "redist region attr value with flags != 0");
 236
 237         addr = REDIST_REGION_ATTR_ADDR(0, 0x100000, 0, 0);
 238         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 239                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 240         TEST_ASSERT(ret && errno == EINVAL, "redist region attr value with count== 0");
 241
 242         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 1);
 243         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 244                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 245         TEST_ASSERT(ret && errno == EINVAL,
 246                     "attempt to register the first rdist region with index != 0");
 247
 248         addr = REDIST_REGION_ATTR_ADDR(2, 0x201000, 0, 1);
 249         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 250                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 251         TEST_ASSERT(ret && errno == EINVAL, "rdist region with misaligned address");
 252
 253         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 0);
 254         kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 255                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 256
 257         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 1);
 258         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 259                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 260         TEST_ASSERT(ret && errno == EINVAL, "register an rdist region with already used index");
 261
 262         addr = REDIST_REGION_ATTR_ADDR(1, 0x210000, 0, 2);
 263         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 264                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 265         TEST_ASSERT(ret && errno == EINVAL,
 266                     "register an rdist region overlapping with another one");
 267
 268         addr = REDIST_REGION_ATTR_ADDR(1, 0x240000, 0, 2);
 269         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 270                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 271         TEST_ASSERT(ret && errno == EINVAL, "register redist region with index not +1");
 272
 273         addr = REDIST_REGION_ATTR_ADDR(1, 0x240000, 0, 1);
 274         kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 275                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 276
 277         addr = REDIST_REGION_ATTR_ADDR(1, max_phys_size, 0, 2);
 278         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 279                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 280         TEST_ASSERT(ret && errno == E2BIG,
 281                     "register redist region with base address beyond IPA range");
 282
 283         /* The last redist is above the pa range. */
 284         addr = REDIST_REGION_ATTR_ADDR(2, max_phys_size - 0x30000, 0, 2);
 285         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 286                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 287         TEST_ASSERT(ret && errno == E2BIG,
 288                     "register redist region with top address beyond IPA range");
 289
 290         addr = 0x260000;
 291         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 292                                     KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr);
 293         TEST_ASSERT(ret && errno == EINVAL,
 294                     "Mix KVM_VGIC_V3_ADDR_TYPE_REDIST and REDIST_REGION");
 295
 296         /*
 297          * Now there are 2 redist regions:
 298          * region 0 @ 0x200000 2 redists
 299          * region 1 @ 0x240000 1 redist
 300          * Attempt to read their characteristics
 301          */
 302
 303         addr = REDIST_REGION_ATTR_ADDR(0, 0, 0, 0);
 304         expected_addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 0);
 305         ret = __kvm_device_attr_get(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 306                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 307         TEST_ASSERT(!ret && addr == expected_addr, "read characteristics of region #0");
 308
 309         addr = REDIST_REGION_ATTR_ADDR(0, 0, 0, 1);
 310         expected_addr = REDIST_REGION_ATTR_ADDR(1, 0x240000, 0, 1);
 311         ret = __kvm_device_attr_get(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 312                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 313         TEST_ASSERT(!ret && addr == expected_addr, "read characteristics of region #1");
 314
 315         addr = REDIST_REGION_ATTR_ADDR(0, 0, 0, 2);
 316         ret = __kvm_device_attr_get(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 317                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 318         TEST_ASSERT(ret && errno == ENOENT, "read characteristics of non existing region");
 319
 320         addr = 0x260000;
 321         kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 322                             KVM_VGIC_V3_ADDR_TYPE_DIST, &addr);
 323
 324         addr = REDIST_REGION_ATTR_ADDR(1, 0x260000, 0, 2);
 325         ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 326                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 327         TEST_ASSERT(ret && errno == EINVAL, "register redist region colliding with dist");
 328 }
 329
 330 /*
 331  * VGIC KVM device is created and initialized before the secondary CPUs
 332  * get created
 333  */
 334 static void test_vgic_then_vcpus(uint32_t gic_dev_type)
 335 {
 336         struct kvm_vcpu *vcpus[NR_VCPUS];
 337         struct vm_gic v;
 338         int ret, i;
 339
 340         v = vm_gic_create_with_vcpus(gic_dev_type, 1, vcpus);
 341
 342         subtest_dist_rdist(&v);
 343
 344         /* Add the rest of the VCPUs */
 345         for (i = 1; i < NR_VCPUS; ++i)
 346                 vcpus[i] = vm_vcpu_add(v.vm, i, guest_code);
 347
 348         ret = run_vcpu(vcpus[3]);
 349         TEST_ASSERT(ret == -EINVAL, "dist/rdist overlap detected on 1st vcpu run");
 350
 351         vm_gic_destroy(&v);
 352 }
 353
 354 /* All the VCPUs are created before the VGIC KVM device gets initialized */
 355 static void test_vcpus_then_vgic(uint32_t gic_dev_type)
 356 {
 357         struct kvm_vcpu *vcpus[NR_VCPUS];
 358         struct vm_gic v;
 359         int ret;
 360
 361         v = vm_gic_create_with_vcpus(gic_dev_type, NR_VCPUS, vcpus);
 362
 363         subtest_dist_rdist(&v);
 364
 365         ret = run_vcpu(vcpus[3]);
 366         TEST_ASSERT(ret == -EINVAL, "dist/rdist overlap detected on 1st vcpu run");
 367
 368         vm_gic_destroy(&v);
 369 }
 370
 371 #define KVM_VGIC_V2_ATTR(offset, cpu) \
 372         (FIELD_PREP(KVM_DEV_ARM_VGIC_OFFSET_MASK, offset) | \
 373          FIELD_PREP(KVM_DEV_ARM_VGIC_CPUID_MASK, cpu))
 374
 375 #define GIC_CPU_CTRL    0x00
 376
 377 static void test_v2_uaccess_cpuif_no_vcpus(void)
 378 {
 379         struct vm_gic v;
 380         u64 val = 0;
 381         int ret;
 382
 383         v = vm_gic_create_barebones(KVM_DEV_TYPE_ARM_VGIC_V2);
 384         subtest_dist_rdist(&v);
 385
 386         ret = __kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_REGS,
 387                                     KVM_VGIC_V2_ATTR(GIC_CPU_CTRL, 0));
 388         TEST_ASSERT(ret && errno == EINVAL,
 389                     "accessed non-existent CPU interface, want errno: %i",
 390                     EINVAL);
 391         ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_REGS,
 392                                     KVM_VGIC_V2_ATTR(GIC_CPU_CTRL, 0), &val);
 393         TEST_ASSERT(ret && errno == EINVAL,
 394                     "accessed non-existent CPU interface, want errno: %i",
 395                     EINVAL);
 396         ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_REGS,
 397                                     KVM_VGIC_V2_ATTR(GIC_CPU_CTRL, 0), &val);
 398         TEST_ASSERT(ret && errno == EINVAL,
 399                     "accessed non-existent CPU interface, want errno: %i",
 400                     EINVAL);
 401
 402         vm_gic_destroy(&v);
 403 }
 404
 405 static void test_v3_new_redist_regions(void)
 406 {
 407         struct kvm_vcpu *vcpus[NR_VCPUS];
 408         void *dummy = NULL;
 409         struct vm_gic v;
 410         uint64_t addr;
 411         int ret;
 412
 413         v = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, NR_VCPUS, vcpus);
 414         subtest_v3_redist_regions(&v);
 415         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 416                             KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
 417
 418         ret = run_vcpu(vcpus[3]);
 419         TEST_ASSERT(ret == -ENXIO, "running without sufficient number of rdists");
 420         vm_gic_destroy(&v);
 421
 422         /* step2 */
 423
 424         v = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, NR_VCPUS, vcpus);
 425         subtest_v3_redist_regions(&v);
 426
 427         addr = REDIST_REGION_ATTR_ADDR(1, 0x280000, 0, 2);
 428         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 429                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 430
 431         ret = run_vcpu(vcpus[3]);
 432         TEST_ASSERT(ret == -EBUSY, "running without vgic explicit init");
 433
 434         vm_gic_destroy(&v);
 435
 436         /* step 3 */
 437
 438         v = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, NR_VCPUS, vcpus);
 439         subtest_v3_redist_regions(&v);
 440
 441         ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 442                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, dummy);
 443         TEST_ASSERT(ret && errno == EFAULT,
 444                     "register a third region allowing to cover the 4 vcpus");
 445
 446         addr = REDIST_REGION_ATTR_ADDR(1, 0x280000, 0, 2);
 447         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 448                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 449
 450         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 451                             KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
 452
 453         ret = run_vcpu(vcpus[3]);
 454         TEST_ASSERT(!ret, "vcpu run");
 455
 456         vm_gic_destroy(&v);
 457 }
 458
 459 static void test_v3_typer_accesses(void)
 460 {
 461         struct vm_gic v;
 462         uint64_t addr;
 463         int ret, i;
 464
 465         v.vm = vm_create(NR_VCPUS);
 466         (void)vm_vcpu_add(v.vm, 0, guest_code);
 467
 468         v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3);
 469
 470         (void)vm_vcpu_add(v.vm, 3, guest_code);
 471
 472         v3_redist_reg_get_errno(v.gic_fd, 1, GICR_TYPER, EINVAL,
 473                                 "attempting to read GICR_TYPER of non created vcpu");
 474
 475         (void)vm_vcpu_add(v.vm, 1, guest_code);
 476
 477         v3_redist_reg_get_errno(v.gic_fd, 1, GICR_TYPER, EBUSY,
 478                                 "read GICR_TYPER before GIC initialized");
 479
 480         (void)vm_vcpu_add(v.vm, 2, guest_code);
 481
 482         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 483                             KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
 484
 485         for (i = 0; i < NR_VCPUS ; i++) {
 486                 v3_redist_reg_get(v.gic_fd, i, GICR_TYPER, i * 0x100,
 487                                   "read GICR_TYPER before rdist region setting");
 488         }
 489
 490         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 0);
 491         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 492                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 493
 494         /* The 2 first rdists should be put there (vcpu 0 and 3) */
 495         v3_redist_reg_get(v.gic_fd, 0, GICR_TYPER, 0x0, "read typer of rdist #0");
 496         v3_redist_reg_get(v.gic_fd, 3, GICR_TYPER, 0x310, "read typer of rdist #1");
 497
 498         addr = REDIST_REGION_ATTR_ADDR(10, 0x100000, 0, 1);
 499         ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 500                                     KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 501         TEST_ASSERT(ret && errno == EINVAL, "collision with previous rdist region");
 502
 503         v3_redist_reg_get(v.gic_fd, 1, GICR_TYPER, 0x100,
 504                           "no redist region attached to vcpu #1 yet, last cannot be returned");
 505         v3_redist_reg_get(v.gic_fd, 2, GICR_TYPER, 0x200,
 506                           "no redist region attached to vcpu #2, last cannot be returned");
 507
 508         addr = REDIST_REGION_ATTR_ADDR(10, 0x20000, 0, 1);
 509         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 510                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 511
 512         v3_redist_reg_get(v.gic_fd, 1, GICR_TYPER, 0x100, "read typer of rdist #1");
 513         v3_redist_reg_get(v.gic_fd, 2, GICR_TYPER, 0x210,
 514                           "read typer of rdist #1, last properly returned");
 515
 516         vm_gic_destroy(&v);
 517 }
 518
 519 static struct vm_gic vm_gic_v3_create_with_vcpuids(int nr_vcpus,
 520                                                    uint32_t vcpuids[])
 521 {
 522         struct vm_gic v;
 523         int i;
 524
 525         v.vm = vm_create(nr_vcpus);
 526         for (i = 0; i < nr_vcpus; i++)
 527                 vm_vcpu_add(v.vm, vcpuids[i], guest_code);
 528
 529         v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3);
 530
 531         return v;
 532 }
 533
 534 /**
 535  * Test GICR_TYPER last bit with new redist regions
 536  * rdist regions #1 and #2 are contiguous
 537  * rdist region #0 @0x100000 2 rdist capacity
 538  *     rdists: 0, 3 (Last)
 539  * rdist region #1 @0x240000 2 rdist capacity
 540  *     rdists:  5, 4 (Last)
 541  * rdist region #2 @0x200000 2 rdist capacity
 542  *     rdists: 1, 2
 543  */
 544 static void test_v3_last_bit_redist_regions(void)
 545 {
 546         uint32_t vcpuids[] = { 0, 3, 5, 4, 1, 2 };
 547         struct vm_gic v;
 548         uint64_t addr;
 549
 550         v = vm_gic_v3_create_with_vcpuids(ARRAY_SIZE(vcpuids), vcpuids);
 551
 552         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 553                             KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
 554
 555         addr = REDIST_REGION_ATTR_ADDR(2, 0x100000, 0, 0);
 556         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 557                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 558
 559         addr = REDIST_REGION_ATTR_ADDR(2, 0x240000, 0, 1);
 560         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 561                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 562
 563         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 2);
 564         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 565                             KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 566
 567         v3_redist_reg_get(v.gic_fd, 0, GICR_TYPER, 0x000, "read typer of rdist #0");
 568         v3_redist_reg_get(v.gic_fd, 1, GICR_TYPER, 0x100, "read typer of rdist #1");
 569         v3_redist_reg_get(v.gic_fd, 2, GICR_TYPER, 0x200, "read typer of rdist #2");
 570         v3_redist_reg_get(v.gic_fd, 3, GICR_TYPER, 0x310, "read typer of rdist #3");
 571         v3_redist_reg_get(v.gic_fd, 5, GICR_TYPER, 0x500, "read typer of rdist #5");
 572         v3_redist_reg_get(v.gic_fd, 4, GICR_TYPER, 0x410, "read typer of rdist #4");
 573
 574         vm_gic_destroy(&v);
 575 }
 576
 577 /* Test last bit with legacy region */
 578 static void test_v3_last_bit_single_rdist(void)
 579 {
 580         uint32_t vcpuids[] = { 0, 3, 5, 4, 1, 2 };
 581         struct vm_gic v;
 582         uint64_t addr;
 583
 584         v = vm_gic_v3_create_with_vcpuids(ARRAY_SIZE(vcpuids), vcpuids);
 585
 586         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 587                             KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
 588
 589         addr = 0x10000;
 590         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 591                             KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr);
 592
 593         v3_redist_reg_get(v.gic_fd, 0, GICR_TYPER, 0x000, "read typer of rdist #0");
 594         v3_redist_reg_get(v.gic_fd, 3, GICR_TYPER, 0x300, "read typer of rdist #1");
 595         v3_redist_reg_get(v.gic_fd, 5, GICR_TYPER, 0x500, "read typer of rdist #2");
 596         v3_redist_reg_get(v.gic_fd, 1, GICR_TYPER, 0x100, "read typer of rdist #3");
 597         v3_redist_reg_get(v.gic_fd, 2, GICR_TYPER, 0x210, "read typer of rdist #3");
 598
 599         vm_gic_destroy(&v);
 600 }
 601
 602 /* Uses the legacy REDIST region API. */
 603 static void test_v3_redist_ipa_range_check_at_vcpu_run(void)
 604 {
 605         struct kvm_vcpu *vcpus[NR_VCPUS];
 606         struct vm_gic v;
 607         int ret, i;
 608         uint64_t addr;
 609
 610         v = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, 1, vcpus);
 611
 612         /* Set space for 3 redists, we have 1 vcpu, so this succeeds. */
 613         addr = max_phys_size - (3 * 2 * 0x10000);
 614         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 615                             KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr);
 616
 617         addr = 0x00000;
 618         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 619                             KVM_VGIC_V3_ADDR_TYPE_DIST, &addr);
 620
 621         /* Add the rest of the VCPUs */
 622         for (i = 1; i < NR_VCPUS; ++i)
 623                 vcpus[i] = vm_vcpu_add(v.vm, i, guest_code);
 624
 625         kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 626                             KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
 627
 628         /* Attempt to run a vcpu without enough redist space. */
 629         ret = run_vcpu(vcpus[2]);
 630         TEST_ASSERT(ret && errno == EINVAL,
 631                 "redist base+size above PA range detected on 1st vcpu run");
 632
 633         vm_gic_destroy(&v);
 634 }
 635
 636 static void test_v3_its_region(void)
 637 {
 638         struct kvm_vcpu *vcpus[NR_VCPUS];
 639         struct vm_gic v;
 640         uint64_t addr;
 641         int its_fd, ret;
 642
 643         v = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, NR_VCPUS, vcpus);
 644         its_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_ITS);
 645
 646         addr = 0x401000;
 647         ret = __kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 648                                     KVM_VGIC_ITS_ADDR_TYPE, &addr);
 649         TEST_ASSERT(ret && errno == EINVAL,
 650                 "ITS region with misaligned address");
 651
 652         addr = max_phys_size;
 653         ret = __kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 654                                     KVM_VGIC_ITS_ADDR_TYPE, &addr);
 655         TEST_ASSERT(ret && errno == E2BIG,
 656                 "register ITS region with base address beyond IPA range");
 657
 658         addr = max_phys_size - 0x10000;
 659         ret = __kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 660                                     KVM_VGIC_ITS_ADDR_TYPE, &addr);
 661         TEST_ASSERT(ret && errno == E2BIG,
 662                 "Half of ITS region is beyond IPA range");
 663
 664         /* This one succeeds setting the ITS base */
 665         addr = 0x400000;
 666         kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 667                             KVM_VGIC_ITS_ADDR_TYPE, &addr);
 668
 669         addr = 0x300000;
 670         ret = __kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 671                                     KVM_VGIC_ITS_ADDR_TYPE, &addr);
 672         TEST_ASSERT(ret && errno == EEXIST, "ITS base set again");
 673
 674         close(its_fd);
 675         vm_gic_destroy(&v);
 676 }
 677
 678 /*
 679  * Returns 0 if it's possible to create GIC device of a given type (V2 or V3).
 680  */
 681 int test_kvm_device(uint32_t gic_dev_type)
 682 {
 683         struct kvm_vcpu *vcpus[NR_VCPUS];
 684         struct vm_gic v;
 685         uint32_t other;
 686         int ret;
 687
 688         v.vm = vm_create_with_vcpus(NR_VCPUS, guest_code, vcpus);
 689
 690         /* try to create a non existing KVM device */
 691         ret = __kvm_test_create_device(v.vm, 0);
 692         TEST_ASSERT(ret && errno == ENODEV, "unsupported device");
 693
 694         /* trial mode */
 695         ret = __kvm_test_create_device(v.vm, gic_dev_type);
 696         if (ret)
 697                 return ret;
 698         v.gic_fd = kvm_create_device(v.vm, gic_dev_type);
 699
 700         ret = __kvm_create_device(v.vm, gic_dev_type);
 701         TEST_ASSERT(ret < 0 && errno == EEXIST, "create GIC device twice");
 702
 703         /* try to create the other gic_dev_type */
 704         other = VGIC_DEV_IS_V2(gic_dev_type) ? KVM_DEV_TYPE_ARM_VGIC_V3
 705                                              : KVM_DEV_TYPE_ARM_VGIC_V2;
 706
 707         if (!__kvm_test_create_device(v.vm, other)) {
 708                 ret = __kvm_create_device(v.vm, other);
 709                 TEST_ASSERT(ret < 0 && (errno == EINVAL || errno == EEXIST),
 710                                 "create GIC device while other version exists");
 711         }
 712
 713         vm_gic_destroy(&v);
 714
 715         return 0;
 716 }
 717
 718 void run_tests(uint32_t gic_dev_type)
 719 {
 720         test_vcpus_then_vgic(gic_dev_type);
 721         test_vgic_then_vcpus(gic_dev_type);
 722
 723         if (VGIC_DEV_IS_V2(gic_dev_type))
 724                 test_v2_uaccess_cpuif_no_vcpus();
 725
 726         if (VGIC_DEV_IS_V3(gic_dev_type)) {
 727                 test_v3_new_redist_regions();
 728                 test_v3_typer_accesses();
 729                 test_v3_last_bit_redist_regions();
 730                 test_v3_last_bit_single_rdist();
 731                 test_v3_redist_ipa_range_check_at_vcpu_run();
 732                 test_v3_its_region();
 733         }
 734 }
 735
 736 int main(int ac, char **av)
 737 {
 738         int ret;
 739         int pa_bits;
 740         int cnt_impl = 0;
 741
 742         pa_bits = vm_guest_mode_params[VM_MODE_DEFAULT].pa_bits;
 743         max_phys_size = 1ULL << pa_bits;
 744
 745         ret = test_kvm_device(KVM_DEV_TYPE_ARM_VGIC_V3);
 746         if (!ret) {
 747                 pr_info("Running GIC_v3 tests.\n");
 748                 run_tests(KVM_DEV_TYPE_ARM_VGIC_V3);
 749                 cnt_impl++;
 750         }
 751
 752         ret = test_kvm_device(KVM_DEV_TYPE_ARM_VGIC_V2);
 753         if (!ret) {
 754                 pr_info("Running GIC_v2 tests.\n");
 755                 run_tests(KVM_DEV_TYPE_ARM_VGIC_V2);
 756                 cnt_impl++;
 757         }
 758
 759         if (!cnt_impl) {
 760                 print_skip("No GICv2 nor GICv3 support");
 761                 exit(KSFT_SKIP);
 762         }
 763         return 0;
 764 }