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