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 #define _GNU_SOURCE
   8 #include <linux/kernel.h>
   9 #include <sys/syscall.h>
  10 #include <asm/kvm.h>
  11 #include <asm/kvm_para.h>
  12
  13 #include "test_util.h"
  14 #include "kvm_util.h"
  15 #include "processor.h"
  16
  17 #define NR_VCPUS                4
  18
  19 #define REDIST_REGION_ATTR_ADDR(count, base, flags, index) (((uint64_t)(count) << 52) | \
  20         ((uint64_t)((base) >> 16) << 16) | ((uint64_t)(flags) << 12) | index)
  21 #define REG_OFFSET(vcpu, offset) (((uint64_t)vcpu << 32) | offset)
  22
  23 #define GICR_TYPER 0x8
  24
  25 struct vm_gic {
  26         struct kvm_vm *vm;
  27         int gic_fd;
  28 };
  29
  30 static int max_ipa_bits;
  31
  32 /* helper to access a redistributor register */
  33 static int access_redist_reg(int gicv3_fd, int vcpu, int offset,
  34                              uint32_t *val, bool write)
  35 {
  36         uint64_t attr = REG_OFFSET(vcpu, offset);
  37
  38         return _kvm_device_access(gicv3_fd, KVM_DEV_ARM_VGIC_GRP_REDIST_REGS,
  39                                   attr, val, write);
  40 }
  41
  42 /* dummy guest code */
  43 static void guest_code(void)
  44 {
  45         GUEST_SYNC(0);
  46         GUEST_SYNC(1);
  47         GUEST_SYNC(2);
  48         GUEST_DONE();
  49 }
  50
  51 /* we don't want to assert on run execution, hence that helper */
  52 static int run_vcpu(struct kvm_vm *vm, uint32_t vcpuid)
  53 {
  54         ucall_init(vm, NULL);
  55         int ret = _vcpu_ioctl(vm, vcpuid, KVM_RUN, NULL);
  56         if (ret)
  57                 return -errno;
  58         return 0;
  59 }
  60
  61 static struct vm_gic vm_gic_create(void)
  62 {
  63         struct vm_gic v;
  64
  65         v.vm = vm_create_default_with_vcpus(NR_VCPUS, 0, 0, guest_code, NULL);
  66         v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, false);
  67
  68         return v;
  69 }
  70
  71 static void vm_gic_destroy(struct vm_gic *v)
  72 {
  73         close(v->gic_fd);
  74         kvm_vm_free(v->vm);
  75 }
  76
  77 /**
  78  * Helper routine that performs KVM device tests in general and
  79  * especially ARM_VGIC_V3 ones. Eventually the ARM_VGIC_V3
  80  * device gets created, a legacy RDIST region is set at @0x0
  81  * and a DIST region is set @0x60000
  82  */
  83 static void subtest_dist_rdist(struct vm_gic *v)
  84 {
  85         int ret;
  86         uint64_t addr;
  87
  88         /* Check existing group/attributes */
  89         kvm_device_check_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
  90                               KVM_VGIC_V3_ADDR_TYPE_DIST);
  91
  92         kvm_device_check_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
  93                               KVM_VGIC_V3_ADDR_TYPE_REDIST);
  94
  95         /* check non existing attribute */
  96         ret = _kvm_device_check_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR, 0);
  97         TEST_ASSERT(ret && errno == ENXIO, "attribute not supported");
  98
  99         /* misaligned DIST and REDIST address settings */
 100         addr = 0x1000;
 101         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 102                                  KVM_VGIC_V3_ADDR_TYPE_DIST, &addr, true);
 103         TEST_ASSERT(ret && errno == EINVAL, "GICv3 dist base not 64kB aligned");
 104
 105         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 106                                  KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr, true);
 107         TEST_ASSERT(ret && errno == EINVAL, "GICv3 redist base not 64kB aligned");
 108
 109         /* out of range address */
 110         if (max_ipa_bits) {
 111                 addr = 1ULL << max_ipa_bits;
 112                 ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 113                                          KVM_VGIC_V3_ADDR_TYPE_DIST, &addr, true);
 114                 TEST_ASSERT(ret && errno == E2BIG, "dist address beyond IPA limit");
 115
 116                 ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 117                                          KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr, true);
 118                 TEST_ASSERT(ret && errno == E2BIG, "redist address beyond IPA limit");
 119         }
 120
 121         /* set REDIST base address @0x0*/
 122         addr = 0x00000;
 123         kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 124                           KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr, true);
 125
 126         /* Attempt to create a second legacy redistributor region */
 127         addr = 0xE0000;
 128         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 129                                  KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr, true);
 130         TEST_ASSERT(ret && errno == EEXIST, "GICv3 redist base set again");
 131
 132         /* Attempt to mix legacy and new redistributor regions */
 133         addr = REDIST_REGION_ATTR_ADDR(NR_VCPUS, 0x100000, 0, 0);
 134         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 135                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 136         TEST_ASSERT(ret && errno == EINVAL, "attempt to mix GICv3 REDIST and REDIST_REGION");
 137
 138         /*
 139          * Set overlapping DIST / REDIST, cannot be detected here. Will be detected
 140          * on first vcpu run instead.
 141          */
 142         addr = 3 * 2 * 0x10000;
 143         kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR, KVM_VGIC_V3_ADDR_TYPE_DIST,
 144                           &addr, true);
 145 }
 146
 147 /* Test the new REDIST region API */
 148 static void subtest_redist_regions(struct vm_gic *v)
 149 {
 150         uint64_t addr, expected_addr;
 151         int ret;
 152
 153         ret = kvm_device_check_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 154                                      KVM_VGIC_V3_ADDR_TYPE_REDIST);
 155         TEST_ASSERT(!ret, "Multiple redist regions advertised");
 156
 157         addr = REDIST_REGION_ATTR_ADDR(NR_VCPUS, 0x100000, 2, 0);
 158         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 159                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 160         TEST_ASSERT(ret && errno == EINVAL, "redist region attr value with flags != 0");
 161
 162         addr = REDIST_REGION_ATTR_ADDR(0, 0x100000, 0, 0);
 163         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 164                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 165         TEST_ASSERT(ret && errno == EINVAL, "redist region attr value with count== 0");
 166
 167         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 1);
 168         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 169                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 170         TEST_ASSERT(ret && errno == EINVAL,
 171                     "attempt to register the first rdist region with index != 0");
 172
 173         addr = REDIST_REGION_ATTR_ADDR(2, 0x201000, 0, 1);
 174         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 175                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 176         TEST_ASSERT(ret && errno == EINVAL, "rdist region with misaligned address");
 177
 178         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 0);
 179         kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 180                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 181
 182         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 1);
 183         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 184                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 185         TEST_ASSERT(ret && errno == EINVAL, "register an rdist region with already used index");
 186
 187         addr = REDIST_REGION_ATTR_ADDR(1, 0x210000, 0, 2);
 188         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 189                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 190         TEST_ASSERT(ret && errno == EINVAL,
 191                     "register an rdist region overlapping with another one");
 192
 193         addr = REDIST_REGION_ATTR_ADDR(1, 0x240000, 0, 2);
 194         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 195                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 196         TEST_ASSERT(ret && errno == EINVAL, "register redist region with index not +1");
 197
 198         addr = REDIST_REGION_ATTR_ADDR(1, 0x240000, 0, 1);
 199         kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 200                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 201
 202         addr = REDIST_REGION_ATTR_ADDR(1, 1ULL << max_ipa_bits, 0, 2);
 203         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 204                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 205         TEST_ASSERT(ret && errno == E2BIG,
 206                     "register redist region with base address beyond IPA range");
 207
 208         addr = 0x260000;
 209         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 210                                  KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr, true);
 211         TEST_ASSERT(ret && errno == EINVAL,
 212                     "Mix KVM_VGIC_V3_ADDR_TYPE_REDIST and REDIST_REGION");
 213
 214         /*
 215          * Now there are 2 redist regions:
 216          * region 0 @ 0x200000 2 redists
 217          * region 1 @ 0x240000 1 redist
 218          * Attempt to read their characteristics
 219          */
 220
 221         addr = REDIST_REGION_ATTR_ADDR(0, 0, 0, 0);
 222         expected_addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 0);
 223         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 224                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, false);
 225         TEST_ASSERT(!ret && addr == expected_addr, "read characteristics of region #0");
 226
 227         addr = REDIST_REGION_ATTR_ADDR(0, 0, 0, 1);
 228         expected_addr = REDIST_REGION_ATTR_ADDR(1, 0x240000, 0, 1);
 229         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 230                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, false);
 231         TEST_ASSERT(!ret && addr == expected_addr, "read characteristics of region #1");
 232
 233         addr = REDIST_REGION_ATTR_ADDR(0, 0, 0, 2);
 234         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 235                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, false);
 236         TEST_ASSERT(ret && errno == ENOENT, "read characteristics of non existing region");
 237
 238         addr = 0x260000;
 239         kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 240                           KVM_VGIC_V3_ADDR_TYPE_DIST, &addr, true);
 241
 242         addr = REDIST_REGION_ATTR_ADDR(1, 0x260000, 0, 2);
 243         ret = _kvm_device_access(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 244                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 245         TEST_ASSERT(ret && errno == EINVAL, "register redist region colliding with dist");
 246 }
 247
 248 /*
 249  * VGIC KVM device is created and initialized before the secondary CPUs
 250  * get created
 251  */
 252 static void test_vgic_then_vcpus(void)
 253 {
 254         struct vm_gic v;
 255         int ret, i;
 256
 257         v.vm = vm_create_default(0, 0, guest_code);
 258         v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, false);
 259
 260         subtest_dist_rdist(&v);
 261
 262         /* Add the rest of the VCPUs */
 263         for (i = 1; i < NR_VCPUS; ++i)
 264                 vm_vcpu_add_default(v.vm, i, guest_code);
 265
 266         ret = run_vcpu(v.vm, 3);
 267         TEST_ASSERT(ret == -EINVAL, "dist/rdist overlap detected on 1st vcpu run");
 268
 269         vm_gic_destroy(&v);
 270 }
 271
 272 /* All the VCPUs are created before the VGIC KVM device gets initialized */
 273 static void test_vcpus_then_vgic(void)
 274 {
 275         struct vm_gic v;
 276         int ret;
 277
 278         v = vm_gic_create();
 279
 280         subtest_dist_rdist(&v);
 281
 282         ret = run_vcpu(v.vm, 3);
 283         TEST_ASSERT(ret == -EINVAL, "dist/rdist overlap detected on 1st vcpu run");
 284
 285         vm_gic_destroy(&v);
 286 }
 287
 288 static void test_new_redist_regions(void)
 289 {
 290         void *dummy = NULL;
 291         struct vm_gic v;
 292         uint64_t addr;
 293         int ret;
 294
 295         v = vm_gic_create();
 296         subtest_redist_regions(&v);
 297         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 298                           KVM_DEV_ARM_VGIC_CTRL_INIT, NULL, true);
 299
 300         ret = run_vcpu(v.vm, 3);
 301         TEST_ASSERT(ret == -ENXIO, "running without sufficient number of rdists");
 302         vm_gic_destroy(&v);
 303
 304         /* step2 */
 305
 306         v = vm_gic_create();
 307         subtest_redist_regions(&v);
 308
 309         addr = REDIST_REGION_ATTR_ADDR(1, 0x280000, 0, 2);
 310         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 311                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 312
 313         ret = run_vcpu(v.vm, 3);
 314         TEST_ASSERT(ret == -EBUSY, "running without vgic explicit init");
 315
 316         vm_gic_destroy(&v);
 317
 318         /* step 3 */
 319
 320         v = vm_gic_create();
 321         subtest_redist_regions(&v);
 322
 323         _kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 324                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, dummy, true);
 325         TEST_ASSERT(ret && errno == EFAULT,
 326                     "register a third region allowing to cover the 4 vcpus");
 327
 328         addr = REDIST_REGION_ATTR_ADDR(1, 0x280000, 0, 2);
 329         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 330                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 331
 332         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 333                           KVM_DEV_ARM_VGIC_CTRL_INIT, NULL, true);
 334
 335         ret = run_vcpu(v.vm, 3);
 336         TEST_ASSERT(!ret, "vcpu run");
 337
 338         vm_gic_destroy(&v);
 339 }
 340
 341 static void test_typer_accesses(void)
 342 {
 343         struct vm_gic v;
 344         uint64_t addr;
 345         uint32_t val;
 346         int ret, i;
 347
 348         v.vm = vm_create_default(0, 0, guest_code);
 349
 350         v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, false);
 351
 352         vm_vcpu_add_default(v.vm, 3, guest_code);
 353
 354         ret = access_redist_reg(v.gic_fd, 1, GICR_TYPER, &val, false);
 355         TEST_ASSERT(ret && errno == EINVAL, "attempting to read GICR_TYPER of non created vcpu");
 356
 357         vm_vcpu_add_default(v.vm, 1, guest_code);
 358
 359         ret = access_redist_reg(v.gic_fd, 1, GICR_TYPER, &val, false);
 360         TEST_ASSERT(ret && errno == EBUSY, "read GICR_TYPER before GIC initialized");
 361
 362         vm_vcpu_add_default(v.vm, 2, guest_code);
 363
 364         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 365                           KVM_DEV_ARM_VGIC_CTRL_INIT, NULL, true);
 366
 367         for (i = 0; i < NR_VCPUS ; i++) {
 368                 ret = access_redist_reg(v.gic_fd, 0, GICR_TYPER, &val, false);
 369                 TEST_ASSERT(!ret && !val, "read GICR_TYPER before rdist region setting");
 370         }
 371
 372         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 0);
 373         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 374                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 375
 376         /* The 2 first rdists should be put there (vcpu 0 and 3) */
 377         ret = access_redist_reg(v.gic_fd, 0, GICR_TYPER, &val, false);
 378         TEST_ASSERT(!ret && !val, "read typer of rdist #0");
 379
 380         ret = access_redist_reg(v.gic_fd, 3, GICR_TYPER, &val, false);
 381         TEST_ASSERT(!ret && val == 0x310, "read typer of rdist #1");
 382
 383         addr = REDIST_REGION_ATTR_ADDR(10, 0x100000, 0, 1);
 384         ret = _kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 385                                  KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 386         TEST_ASSERT(ret && errno == EINVAL, "collision with previous rdist region");
 387
 388         ret = access_redist_reg(v.gic_fd, 1, GICR_TYPER, &val, false);
 389         TEST_ASSERT(!ret && val == 0x100,
 390                     "no redist region attached to vcpu #1 yet, last cannot be returned");
 391
 392         ret = access_redist_reg(v.gic_fd, 2, GICR_TYPER, &val, false);
 393         TEST_ASSERT(!ret && val == 0x200,
 394                     "no redist region attached to vcpu #2, last cannot be returned");
 395
 396         addr = REDIST_REGION_ATTR_ADDR(10, 0x20000, 0, 1);
 397         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 398                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 399
 400         ret = access_redist_reg(v.gic_fd, 1, GICR_TYPER, &val, false);
 401         TEST_ASSERT(!ret && val == 0x100, "read typer of rdist #1");
 402
 403         ret = access_redist_reg(v.gic_fd, 2, GICR_TYPER, &val, false);
 404         TEST_ASSERT(!ret && val == 0x210,
 405                     "read typer of rdist #1, last properly returned");
 406
 407         vm_gic_destroy(&v);
 408 }
 409
 410 /**
 411  * Test GICR_TYPER last bit with new redist regions
 412  * rdist regions #1 and #2 are contiguous
 413  * rdist region #0 @0x100000 2 rdist capacity
 414  *     rdists: 0, 3 (Last)
 415  * rdist region #1 @0x240000 2 rdist capacity
 416  *     rdists:  5, 4 (Last)
 417  * rdist region #2 @0x200000 2 rdist capacity
 418  *     rdists: 1, 2
 419  */
 420 static void test_last_bit_redist_regions(void)
 421 {
 422         uint32_t vcpuids[] = { 0, 3, 5, 4, 1, 2 };
 423         struct vm_gic v;
 424         uint64_t addr;
 425         uint32_t val;
 426         int ret;
 427
 428         v.vm = vm_create_default_with_vcpus(6, 0, 0, guest_code, vcpuids);
 429
 430         v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, false);
 431
 432         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 433                           KVM_DEV_ARM_VGIC_CTRL_INIT, NULL, true);
 434
 435         addr = REDIST_REGION_ATTR_ADDR(2, 0x100000, 0, 0);
 436         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 437                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 438
 439         addr = REDIST_REGION_ATTR_ADDR(2, 0x240000, 0, 1);
 440         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 441                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 442
 443         addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 2);
 444         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 445                           KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr, true);
 446
 447         ret = access_redist_reg(v.gic_fd, 0, GICR_TYPER, &val, false);
 448         TEST_ASSERT(!ret && val == 0x000, "read typer of rdist #0");
 449
 450         ret = access_redist_reg(v.gic_fd, 1, GICR_TYPER, &val, false);
 451         TEST_ASSERT(!ret && val == 0x100, "read typer of rdist #1");
 452
 453         ret = access_redist_reg(v.gic_fd, 2, GICR_TYPER, &val, false);
 454         TEST_ASSERT(!ret && val == 0x200, "read typer of rdist #2");
 455
 456         ret = access_redist_reg(v.gic_fd, 3, GICR_TYPER, &val, false);
 457         TEST_ASSERT(!ret && val == 0x310, "read typer of rdist #3");
 458
 459         ret = access_redist_reg(v.gic_fd, 5, GICR_TYPER, &val, false);
 460         TEST_ASSERT(!ret && val == 0x500, "read typer of rdist #5");
 461
 462         ret = access_redist_reg(v.gic_fd, 4, GICR_TYPER, &val, false);
 463         TEST_ASSERT(!ret && val == 0x410, "read typer of rdist #4");
 464
 465         vm_gic_destroy(&v);
 466 }
 467
 468 /* Test last bit with legacy region */
 469 static void test_last_bit_single_rdist(void)
 470 {
 471         uint32_t vcpuids[] = { 0, 3, 5, 4, 1, 2 };
 472         struct vm_gic v;
 473         uint64_t addr;
 474         uint32_t val;
 475         int ret;
 476
 477         v.vm = vm_create_default_with_vcpus(6, 0, 0, guest_code, vcpuids);
 478
 479         v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, false);
 480
 481         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 482                           KVM_DEV_ARM_VGIC_CTRL_INIT, NULL, true);
 483
 484         addr = 0x10000;
 485         kvm_device_access(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 486                           KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr, true);
 487
 488         ret = access_redist_reg(v.gic_fd, 0, GICR_TYPER, &val, false);
 489         TEST_ASSERT(!ret && val == 0x000, "read typer of rdist #0");
 490
 491         ret = access_redist_reg(v.gic_fd, 3, GICR_TYPER, &val, false);
 492         TEST_ASSERT(!ret && val == 0x300, "read typer of rdist #1");
 493
 494         ret = access_redist_reg(v.gic_fd, 5, GICR_TYPER, &val, false);
 495         TEST_ASSERT(!ret && val == 0x500, "read typer of rdist #2");
 496
 497         ret = access_redist_reg(v.gic_fd, 1, GICR_TYPER, &val, false);
 498         TEST_ASSERT(!ret && val == 0x100, "read typer of rdist #3");
 499
 500         ret = access_redist_reg(v.gic_fd, 2, GICR_TYPER, &val, false);
 501         TEST_ASSERT(!ret && val == 0x210, "read typer of rdist #3");
 502
 503         vm_gic_destroy(&v);
 504 }
 505
 506 void test_kvm_device(void)
 507 {
 508         struct vm_gic v;
 509         int ret, fd;
 510
 511         v.vm = vm_create_default_with_vcpus(NR_VCPUS, 0, 0, guest_code, NULL);
 512
 513         /* try to create a non existing KVM device */
 514         ret = _kvm_create_device(v.vm, 0, true, &fd);
 515         TEST_ASSERT(ret && errno == ENODEV, "unsupported device");
 516
 517         /* trial mode with VGIC_V3 device */
 518         ret = _kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, true, &fd);
 519         if (ret) {
 520                 print_skip("GICv3 not supported");
 521                 exit(KSFT_SKIP);
 522         }
 523         v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, false);
 524
 525         ret = _kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, false, &fd);
 526         TEST_ASSERT(ret && errno == EEXIST, "create GICv3 device twice");
 527
 528         kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3, true);
 529
 530         if (!_kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V2, true, &fd)) {
 531                 ret = _kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V2, false, &fd);
 532                 TEST_ASSERT(ret && errno == EINVAL, "create GICv2 while v3 exists");
 533         }
 534
 535         vm_gic_destroy(&v);
 536 }
 537
 538 int main(int ac, char **av)
 539 {
 540         max_ipa_bits = kvm_check_cap(KVM_CAP_ARM_VM_IPA_SIZE);
 541
 542         test_kvm_device();
 543         test_vcpus_then_vgic();
 544         test_vgic_then_vcpus();
 545         test_new_redist_regions();
 546         test_typer_accesses();
 547         test_last_bit_redist_regions();
 548         test_last_bit_single_rdist();
 549
 550         return 0;
 551 }