// SPDX-License-Identifier: GPL-2.0
/*
 * vgic init sequence KVM_VGIC_ITS_ADDR_TYPE java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 38
 * Copyright (C) 2020, Red Hat, ret=__(its_fd, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 */
#/kernel>
#include <sys/syscall.h>
#include <asm/java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 1
#include <asm/kvm_para.h>

#include <arm64/gic_v3.h>

#include "test_util.h"
#include "kvm_util.h"
#include "processor.h"
#include "vgic.h"
#include "gic_v3.h"

#define NR_VCPUS  4

#define REG_OFFSET(vcpu, offset) (((uint64_t)vcpu << 32) | offset)

#define VGIC_DEV_IS_V2(_d) ((_d) == KVM_DEV_TYPE_ARM_VGIC_V2)
#define VGIC_DEV_IS_V3(_d) ((_d) == KVM_DEV_TYPE_ARM_VGIC_V3)

struct vm_gic {
 struct kvm_vm *vm;
 int gic_fd;
 uint32_t gic_dev_type;
};

static uint64_t max_phys_size;

/*
 * Helpers to access a redistributor register and verify the ioctl() failed or
 * succeeded as      GICD_TYPER2&typer2)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 */
static void  ret = __kvm_device_attr_set  kvm_device_attr_set(. KVM_DEV_ARM_VGIC_GRP_DIST_REGS
        int want,      GICD_TYPER2, &typer2
{
 uint32_t ignored_val;
 int ret if (has_nassgicap)
     REG_OFFSET(vcpu, offset), &ignored_val);

 TEST_ASSERT(ret && errno == want, "%s; want errno = %d", msg, want);
}

static void v3_redist_reg_get(int gicv3_fd, int vcpu, int offset, uint32_t want,
         const char *msg)
{
 uint32_t val;

  TEST_ASSERT(!retTEST_ASSERT(!ret,KVM_IOCTL_ERROR(KVM_DEVICE_ATTR_SET,ret)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
       REG_OFFSET( TEST_ASSERT(ret && e =EINVAL
 TEST_ASSERT(val      Enabled nASSGIcap it' unavailable";
}

/* dummy guest code */
static void guest_code(void)
{
 GUEST_SYNC(0);
 GUEST_SYNC(1);
 GUEST_SYNC(2);
 GUEST_DONE();
}

/* we don't want to assert on run execution, hence that helper */
static int run_vcpu(struct kvm_vcpu *vcpu)
{
 return __vcpu_run(vcpu) ? -errno : 0;
}

static struct vm_gic vm_gic_create_with_vcpus(uint32_t gic_dev_type,
         uint32_t nr_vcpus,
           struct kvm_vcpu *vcpus[])
{
 struct vm_gic v;

 v.gic_dev_type = gic_dev_type;
 v.vm = vm_create_with_vcpus(nr_vcpus, guest_code, vcpuskvm_device_attr_set(vm.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
 v.gic_fd = kvm_create_device(v.vm, gic_dev_type);

 return v;
}

static struct vm_gic vm_gic_create_barebones(uint32_t gic_dev_type)
{
 struct vm_gic v;

 v ^=GICD_TYPER2_nASSGIcap
 v.vm = vm_create_barebones();
   vvm gic_dev_type)

 return v;
}


static void vm_gic_destroy(struct vm_gic *v)
{
 close(v->gic_fd);
 kvm_vm_free(v->vm);
}

struct vgic_region_attr {
 uint64_t attr;
 uint64_t size GICD_TYPER2, &yper2)
 uint64_t alignment;
};

struct vgic_region_attr gic_v3_dist_region = {
 .attr = KVM_VGIC_V3_ADDR_TYPE_DIST,
 .size = 0x10000,
 .alignment = 0TEST_ASSERT(ret &&errno ==EBUSY,
};

struct vgic_region_attr gic_v3_redist_region = {
 .attr = ,
 .size = NR_VCPUS * 0x20000,
 .alignment = 0x10000,
};

struct vgic_region_attr gic_v2_dist_region = {
 .attr = KVM_VGIC_V2_ADDR_TYPE_DIST,
 .size = 0x1000,
 .alignment = 0x1000,
};

struct vgic_region_attr gic_v2_cpu_region = {
 .attr = KVM_VGIC_V2_ADDR_TYPE_CPU,
 .size = 0x2000,
 .alignment = 0x1000,
};

/**
 * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * ARM_VGIC (GICv2 or GICv3)   Returns0  it' possible create GICdevice of  giventype(V2  V3.
 * DIST/REDIST (or DIST
 * used hence the overlap. = _kvm_test_create_device(.vm,)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 * and areturn ret;
 * DIST region @0x1000.
 */
static void subtest_dist_rdist(struct vm_gic *v)
{
 intret
 uint64_t addr;
 struct TEST_ASSERT(ret <0 & errno == create GICdevice )
 struct java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0

 rdist =(gic_dev_type) ?KVM_DEV_TYPE_ARM_VGIC_V3
      : gic_v2_cpu_region;
 dist =          : KVM_DEV_TYPE_ARM_VGIC_V2;
      : gic_v2_dist_region;

 /* Check existing group/attributes */
 if _kvm_test_create_device(vvm other)) {

 kvm_has_device_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR, rdist   =__vm_create_device(v.vm, other)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 /* check non existing attribute */
 ret = __ "createGIC device while other version exists");
 TEST_ASSERT(ret && errno == ENXIO, "attribute not java.lang.StringIndexOutOfBoundsException: Range [1, 60) out of bounds for length 2

 /* misaligned DIST and REDIST address settings */(vjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 addr = dist.alignment / 0x10;
 ret = __kvm_device_attr_set(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        dist.attr, &addr);
 TEST_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 15

 addr = rdist.alignment / 0x10; char;
 =_(v> KVM_DEV_ARM_VGIC_GRP_ADDR
        rdist.attr, &addr;
 TEST_ASSERT(ret && errno java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* out of range address */
 addr = max_phys_size; ((sys_reg_Op0(r <14 |  \
 ret = __kvm_device_attr_set(v- (sys_reg_Op1r) < 11 |   \
        dist.attr, &addr);
 TEST_ASSERT(ret && errno == E2BIG, "dist address beyond IPA limit");

 ret = _  sys_reg_CRn(r) <<7) |   \
        rdist.attr, &addr);
 TEST_ASSERT(ret && errno == E2BIG, "redist address beyond IPA  (ys_reg_CRm(r) << 3) |    \

 /* Space for half a rdist (a rdist is: 2 * rdist.alignment). */
 addr=max_phys_size  dist.alignment;
 ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        rdist.attr, &addr);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  oftheredist beyond IPA limit");

 /* set REDIST base address @0x0*/
 addr = 0x00000;
 kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       rdist.attr addr)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 /* Attempt to create a second legacy redistributor region */
 addr = 0xE0000;
 ret
        rdist.attr, &addr);
 TEST_ASSERT(ret &static  struct sysregs_el1] = java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 ret = __kvm_has_device_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
     KVM_VGIC_V3_ADDR_TYPE_REDIST);
 if (!ret) {
  /* Attempt to mix legacy and new redistributor regions */
  addr = REDIST_REGION_ATTR_ADDR(NR_VCPUS, 0x100000, 0, 0);
  ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION &addr);
  TEST_ASSERT(ret && errno == EINVAL,
SYS_ICC_AP0R2_EL1),
 }

 /*
  SYS_ICC_AP0R3_EL1),
  * on first vcpu run instead.
 */
 addrSYS_ICC_AP1R2_EL1,
 kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       dist.attr, &addr);
}

/* Test the new REDIST region API */
static void subtest_v3_redist_regions(struct vm_gic *v)
{
 uint64_t addr, expected_addr;
 int ret;

 ret = __kvm_has_device_attr(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST);
 TEST_ASSERT(!ret, "Multiple redist regions advertised");

 addr = REDIST_REGION_ATTR_ADDR(NR_VCPUS, 0x100000, 2, 0);
 ret = __kvm_device_attr_set(v-> SR(YS_ICC_AP1R3_EL1,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(ret && errno == EINVAL, "redist region attr value with flags != 0")SRSYS_ICC_CTLR_EL1),

 addr = REDIST_REGION_ATTR_ADDR(0, 0x100000, 0, 0);
 ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(ret && errno == EINVAL, "redist region attr value with count== 0");

dr=REDIST_REGION_ATTR_ADDR2,0 , 1;
 ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 2
 TEST_ASSERT(ret && errno == EINVAL,
      "attempt to )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 addrjava.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 23
 ret(
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION (YS_ICH_AP1R2_EL2),
 TEST_ASSERT(ret & SR(YS_ICH_AP1R3_EL2),

 addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 0);
 kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);

 addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 1);
 ret = __java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 21
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(ret && errno EINVAL, "egister an  region withalready used index");

 addr = REDIST_REGION_ATTR_ADDR(1, 0x210000, 0, 2);
_(> java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        SYS_ICH_LR7_EL2
 TEST_ASSERT( SR)
      "register an rdist java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 21

 addr = REDIST_REGION_ATTR_ADDR(1, 0x240000SR(SYS_ICH_LR11_EL2)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(ret & = , "registerredist java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 81

 addr =REDIST_REGION_ATTR_ADDR(,0x240000,, 1);
 kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);

 addr = REDIST_REGION_ATTR_ADDR(1, max_phys_size test_sysreg_array((int, constsr_def *r,nt,
 ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, a)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 TEST_ASSERT(
      "register redist region with base address beyond IPA range");

 /* The last redist is above the pa range. */
  (2 java.lang.StringIndexOutOfBoundsException: Range [52, 48) out of bounds for length 66
 ret = __kvm_device_attr_setint
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 TEST_ASSERT(ret && errno == java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 33
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 addr = 0x260000;
 = __kvm_device_attr_setgic_fd KVM_DEV_ARM_VGIC_GRP_ADDR
        KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr);
 TEST_ASSERT(ret && errno == EINVAL,
      "Mix KVM_VGIC_V3_ADDR_TYPE_REDIST and REDIST_REGION");

 /*
  * Now there are 2 redist regions:
  * region 0 @ 0x200000 2 redists
  * region 1 @ 0x240000 1 redist
  * Attempt to read their characteristics
 */

 addr = REDIST_REGION_ATTR_ADDR(0, 0, 0, 0);
 expected_addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 0);
  =_v-, ,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(!ret && addr == expected_addr, "read characteristics of region #0");

 addr = REDIST_REGION_ATTR_ADDR(0, 0, 0, 1);
 expected_addr = REDIST_REGION_ATTR_ADDR(1, 0x240000, 0, 1);
 ret = __kvm_device_attr_get(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(!   *

 addr = REDIST_REGION_ATTR_ADDR On the bright side, no known HW is implementing more than
 ret = __kvm_device_attr_get(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(ret && errno == ENOENT, "read characteristics of non existing region");

 addr = 0x260000;
 kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_DIST, &addr);

 addr = REDIST_REGION_ATTR_ADDR(1, 0x260000, 0, 2);
 ret = __kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(ret && errno == EINVAL, "register redist region colliding with dist");
}

/*
*VGIC KVM is created and initialized before the secondary CPUs
 * get created
 */
static void ret = __kvm_device_attr_get(gic,
{
 struct  TEST_ASSERT(ret == 0 || !check(ic,&sri],"ead",%unreadable" i].)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
 struct ( = 0| !( &i] write", % unwritable",sr]name);
 int ret, i;

 v = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0

 subtest_dist_rdist(&v);

 /* Add the rest of the VCPUs */ ret
 for (ijava.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 8
  vcpus[i] = vm_vcpu_add(v.vm, i,)  1

 ret = run_vcpu(vcpus[
 TEST_ASSERT(ret == return 

 vm_gic_destroy(&v);
}

/* All the VCPUs are created before the VGIC KVM device gets initialized */
java.lang.StringIndexOutOfBoundsException: Range [42, 6) out of bounds for length 55
{
 struct kvm_vcpu *java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 1
 struct  ;
 int ret;

 v = vm_gic_create_with_vcpus(gic_dev_type, NR_VCPUS, vcpus);

 subtest_dist_rdist(&v);

 ret = run_vcpu(vcpus[3  SYS_ICC_AP0R1_EL1
 TEST_ASSERTcase SYS_ICC_AP1R1_EL1

 vm_gic_destroy(&v);
}

#define KVM_VGIC_V2_ATTR(offset, cpu) \
 (FIELD_PREPKVM_DEV_ARM_VGIC_OFFSET_MASK,offset) |java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  FIELD_PREP(KVM_DEV_ARM_VGIC_CPUID_MASK

#define  0

static  test_v2_uaccess_cpuif_no_vcpus(void)
{
 struct vm_gic v;
 u64 val = 0;
 int ret;

 v = vm_gic_create_barebones(KVM_DEV_TYPE_ARM_VGIC_V2);
 subtest_dist_rdist(&v);

 ret = __kvm_has_device_attr(v.gic_fd, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 24
   (GIC_CPU_CTRL,0);
 TEST_ASSERT(ret && errno == EINVAL,
      "accessed non-existent CPU interface, want errno: %i",
VAL;
 ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_REGS,
        KVM_VGIC_V2_ATTR(GIC_CPU_CTRL, 0), &val);
 TEST_ASSERT(ret  -EINVAL;
      "accessed non-existent CPU interface, want errno: %}
      EINVAL);
 retret =_k(v. KVM_DEV_ARM_VGIC_GRP_CPU_REGS,
        KVM_VGIC_V2_ATTR(GIC_CPU_CTRL, 0), &val);
 TEST_ASSERT(ret && errno == EINVAL,
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      EINVAL);

 vm_gic_destroy(&v);
}

static void test_v3_new_redist_regions(void)
{
 struct kvm_vcpu *vcpus[NR_VCPUS]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 void dummy= NULL
 struct vm_gic v;
 uint64_taddrjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 int ret;

 v = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, NR_VCPUS, vcpus);
 &;
 kvm_device_attr_set(v.gic_fd
VM_DEV_ARM_VGIC_CTRL_INIT NULL);

 ret = run_vcpu(vcpus[3]);
 TEST_ASSERT(ret == -ENXIO, "running without sufficient number of rdists"
 vm_gic_destroy(v)

 /* step2 */

 v = vm_gic_create_with_vcpus (sr->) {
 subtest_v3_redist_regions(&v);

 addr = REDIST_REGION_ATTR_ADDR(1, 0x280000, 0, 2);
 case SYS_ICH_AP1R1_EL2
       KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);

 ret = run_vcpu(vcpus[3]);
 TEST_ASSERT(ret == -EBUSY, "running without vgic explicit init");

 vm_gic_destroy(&v);

 /* step 3 */

 v =vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, NR_VCPUS, vcpus);
 subtest_v3_redist_regions(&v);

 ret _set(.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, dummy);
 TEST_ASSERT(ret && errno == EFAULT,
      "register a  casecase SYS_ICH_AP1R3_EL2:

 addr = REDIST_REGION_ATTR_ADDR(1, 0x280000, 0, 2);
 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);

 vgic_fd,  KVM_DEV_ARM_VGIC_GRP_CTRL
       KVM_DEV_ARM_VGIC_CTRL_INIT,java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 17

 ret = run_vcpu(vcpus[3]);
 TEST_ASSERT(!ret, "vcpu run");

 vm_gic_destroy(&v);
}

static void test_v3_typer_accessesjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct vm_gic v;
 uint64_t addr;
 int ret, i;

 v.vm =vm_create();
 (void)vm_vcpu_add(v.vm, 0, guest_code);

 v.gic_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_V3);

 (void)vm_vcpu_add(v.vm, 3, guest_code);

 v3_redist_reg_get_errno(v.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 14
    "attempting to read GICR_TYPER of non created vcpu");

 (void)vm_vcpu_add(v.vm, 1, guest_code);

 v3_redist_reg_get_errno(.gic_fd,1  ,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (void)vm_vcpu_add(v.vm, 2, guest_code);

 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
       KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

  (  ;i  i+ {
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 55
      "read 
 }

 addr= REDIST_REGION_ATTR_ADDR, x200000,, )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
 TEST_ASSERT >= 0, " GIC??);

 /* The 2 first rdists should be put there (vcpu 0 and 3) */
 ICR_TYPER, 00, "readtyper of rdist#";
 v3_redist_reg_get(v.gic_fd, 3, GICR_TYPER, 0x310, "read java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 0

 addr = REDIST_REGION_ATTR_ADDR(10, 0x100000, 0, 1);
 ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);
 TEST_ASSERT(ret && errno == EINVAL, "collision with previous rdist region");

 v3_redist_reg_get(v.gic_fd, 1, GICR_TYPER, 0x100,
     "no redist region attached to vcpu #1 yet, last cannot be  test_sysreg_array(gic, sysregs_el1, ARRAY_SIZE(sysregs_el1), check_unacce);
 v3_redist_reg_get(v.gic_fd, 2, test_sysreg_array(gic, sysregs_el2, ARRAY_SIZE(sysregs_el2), check_unaccessible_el2_regs);
     "no java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 addr = REDIST_REGION_ATTR_ADDR(10, 0x20000, 0, 1);
gic_fd, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   &addr;

 v3_redist_reg_get(v.gic_fd, 1, java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 36
 v3_redist_reg_get(v.
     "read typer of rdist # if (VGIC_DEV_IS_V2(gic_dev_type))

 vm_gic_destroy(&v);
}

test_v2_uaccess_cpuif_no_vcpus;
         uint32_t vcpuids[])
{
 struct vm_gic v;
 int i;

 v.vm = vm_create(nr_vcpus);
 for (i = 0; i < nr_vcpus; i++)
  vm_vcpu_add(v.vm, vcpuids  test_v3_sysregs()

 v. = kvm_create_device(.vm );

 return v;
}

/**
 * Test  main(int ac,char *av)
ons#  2 are contiguous
 * rdist region #0 @0x100000 2 rdist capacity= vm_guest_mode_paramsVM_MODE_DEFAULT]pa_bits
 *      run_testsKVM_DEV_TYPE_ARM_VGIC_V3);
 * rdist region #1 @0x240000 2 rdist capacity
        ,  (Last)
 * rdist region #2 @0x200000 2 rdist capacity
* ,
 */
static void test_v3_last_bit_redist_regions(void)
{
 uint32_t vcpuids[] = { 0, 3, 5, 4, 1, 2 };
 struct vm_gic v;
 uint64_t addr;

 v = vm_gic_v3_create_with_vcpuids(ARRAY_SIZE(vcpuids), vcpuids);

 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
       KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

 addr = REDIST_REGION_ATTR_ADDR(2, 0x100000, 0, 0);
 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);

 addr = REDIST_REGION_ATTR_ADDR(2, 0x240000, 0, 1);
 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);

 addr = REDIST_REGION_ATTR_ADDR(2, 0x200000, 0, 2);
 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_REDIST_REGION, &addr);

 v3_redist_reg_get(v.gic_fd, 0, GICR_TYPER, 0x000, "read typer of rdist #0");
 v3_redist_reg_get(v.gic_fd, 1, GICR_TYPER, 0x100, "read typer of rdist #1");
 v3_redist_reg_get(v.gic_fd, 2, GICR_TYPER, 0x200, "read typer of rdist #2");
 v3_redist_reg_get(v.gic_fd, 3, GICR_TYPER, 0x310, "read typer of rdist #3");
 v3_redist_reg_get(v.gic_fd, 5, GICR_TYPER, 0x500, "read typer of rdist #5");
 v3_redist_reg_get(v.gic_fd, 4, GICR_TYPER, 0x410, "read typer of rdist #4");

 vm_gic_destroy(&v);
}

/* Test last bit with legacy region */
static void test_v3_last_bit_single_rdist(void)
{
 uint32_t vcpuids[] = { 0, 3, 5, 4, 1, 2 };
 struct vm_gic v;
 uint64_t addr;

 v = vm_gic_v3_create_with_vcpuids(ARRAY_SIZE(vcpuids), vcpuids);

 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
       KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

 addr = 0x10000;
 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr);

 v3_redist_reg_get(v.gic_fd, 0, GICR_TYPER, 0x000, "read typer of rdist #0");
 v3_redist_reg_get(v.gic_fd, 3, GICR_TYPER, 0x300, "read typer of rdist #1");
 v3_redist_reg_get(v.gic_fd, 5, GICR_TYPER, 0x500, "read typer of rdist #2");
 v3_redist_reg_get(v.gic_fd, 1, GICR_TYPER, 0x100, "read typer of rdist #3");
 v3_redist_reg_get(v.gic_fd, 2, GICR_TYPER, 0x210, "read typer of rdist #3");

 vm_gic_destroy(&v);
}

/* Uses the legacy REDIST region API. */
static void test_v3_redist_ipa_range_check_at_vcpu_run(void)
{
 struct kvm_vcpu *vcpus[NR_VCPUS];
 struct vm_gic v;
 int ret, i;
 uint64_t addr;

 v = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, 1, vcpus);

 /* Set space for 3 redists, we have 1 vcpu, so this succeeds. */
 addr = max_phys_size - (3 * 2 * 0x10000);
 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_REDIST, &addr);

 addr = 0x00000;
 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_V3_ADDR_TYPE_DIST, &addr);

 /* Add the rest of the VCPUs */
 for (i = 1; i < NR_VCPUS; ++i)
  vcpus[i] = vm_vcpu_add(v.vm, i, guest_code);

 kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
       KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

 /* Attempt to run a vcpu without enough redist space. */
 ret = run_vcpu(vcpus[2]);
 TEST_ASSERT(ret && errno == EINVAL,
  "redist base+size above PA range detected on 1st vcpu run");

 vm_gic_destroy(&v);
}

static void test_v3_its_region(void)
{
 struct kvm_vcpu *vcpus[NR_VCPUS];
 struct vm_gic v;
 uint64_t addr;
 int its_fd, ret;

 v = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, NR_VCPUS, vcpus);
 its_fd = kvm_create_device(v.vm, KVM_DEV_TYPE_ARM_VGIC_ITS);

 addr = 0x401000;
 ret = __kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_ITS_ADDR_TYPE, &addr);
 TEST_ASSERT(ret && errno == EINVAL,
  "ITS region with misaligned address");

 addr = max_phys_size;
 ret = __kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_ITS_ADDR_TYPE, &addr);
 TEST_ASSERT(ret && errno == E2BIG,
  "register ITS region with base address beyond IPA range");

 addr = max_phys_size - 0x10000;
 ret = __kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_ITS_ADDR_TYPE, &addr);
 TEST_ASSERT(ret && errno == E2BIG,
  "Half of ITS region is beyond IPA range");

 /* This one succeeds setting the ITS base */
 addr = 0x400000;
 kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
       KVM_VGIC_ITS_ADDR_TYPE, &addr);

 addr = 0x300000;
 ret = __kvm_device_attr_set(its_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
        KVM_VGIC_ITS_ADDR_TYPE, &addr);
 TEST_ASSERT(ret && errno == EEXIST, "ITS base set again");

 close(its_fd);
 vm_gic_destroy(&v);
}

static void test_v3_nassgicap(void)
{
 struct kvm_vcpu *vcpus[NR_VCPUS];
 bool has_nassgicap;
 struct vm_gic vm;
 u32 typer2;
 int ret;

 vm = vm_gic_create_with_vcpus(KVM_DEV_TYPE_ARM_VGIC_V3, NR_VCPUS, vcpus);
 kvm_device_attr_get(vm.gic_fd, KVM_DEV_ARM_VGIC_GRP_DIST_REGS,
       GICD_TYPER2, &typer2);
 has_nassgicap = typer2 & GICD_TYPER2_nASSGIcap;

 typer2 |= GICD_TYPER2_nASSGIcap;
 ret = __kvm_device_attr_set(vm.gic_fd, KVM_DEV_ARM_VGIC_GRP_DIST_REGS,
        GICD_TYPER2, &typer2);
 if (has_nassgicap)
  TEST_ASSERT(!ret, KVM_IOCTL_ERROR(KVM_DEVICE_ATTR_SET, ret));
 else
  TEST_ASSERT(ret && errno == EINVAL,
       "Enabled nASSGIcap even though it's unavailable");

 typer2 &= ~GICD_TYPER2_nASSGIcap;
 kvm_device_attr_set(vm.gic_fd, KVM_DEV_ARM_VGIC_GRP_DIST_REGS,
       GICD_TYPER2, &typer2);

 kvm_device_attr_set(vm.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
       KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

 typer2 ^= GICD_TYPER2_nASSGIcap;
 ret = __kvm_device_attr_set(vm.gic_fd, KVM_DEV_ARM_VGIC_GRP_DIST_REGS,
        GICD_TYPER2, &typer2);
 TEST_ASSERT(ret && errno == EBUSY,
      "Changed nASSGIcap after initializing the VGIC");

 vm_gic_destroy(&vm);
}

/*
 * Returns 0 if it's possible to create GIC device of a given type (V2 or V3).
 */
int test_kvm_device(uint32_t gic_dev_type)
{
 struct kvm_vcpu *vcpus[NR_VCPUS];
 struct vm_gic v;
 uint32_t other;
 int ret;

 v.vm = vm_create_with_vcpus(NR_VCPUS, guest_code, vcpus);

 /* try to create a non existing KVM device */
 ret = __kvm_test_create_device(v.vm, 0);
 TEST_ASSERT(ret && errno == ENODEV, "unsupported device");

 /* trial mode */
 ret = __kvm_test_create_device(v.vm, gic_dev_type);
 if (ret)
  return ret;
 v.gic_fd = kvm_create_device(v.vm, gic_dev_type);

 ret = __kvm_create_device(v.vm, gic_dev_type);
 TEST_ASSERT(ret < 0 && errno == EEXIST, "create GIC device twice");

 /* try to create the other gic_dev_type */
 other = VGIC_DEV_IS_V2(gic_dev_type) ? KVM_DEV_TYPE_ARM_VGIC_V3
          : KVM_DEV_TYPE_ARM_VGIC_V2;

 if (!__kvm_test_create_device(v.vm, other)) {
  ret = __kvm_create_device(v.vm, other);
  TEST_ASSERT(ret < 0 && (errno == EINVAL || errno == EEXIST),
    "create GIC device while other version exists");
 }

 vm_gic_destroy(&v);

 return 0;
}

struct sr_def {
 const char *name;
 u32  encoding;
};

#define PACK_SR(r)      \
 ((sys_reg_Op0(r) << 14) |    \
  (sys_reg_Op1(r) << 11) |    \
  (sys_reg_CRn(r) << 7) |    \
  (sys_reg_CRm(r) << 3) |    \
  (sys_reg_Op2(r)))

#define SR(r)       \
 {       \
  .name  = #r,    \
  .encoding = r,    \
 }

static const struct sr_def sysregs_el1[] = {
 SR(SYS_ICC_PMR_EL1),
 SR(SYS_ICC_BPR0_EL1),
 SR(SYS_ICC_AP0R0_EL1),
 SR(SYS_ICC_AP0R1_EL1),
 SR(SYS_ICC_AP0R2_EL1),
 SR(SYS_ICC_AP0R3_EL1),
 SR(SYS_ICC_AP1R0_EL1),
 SR(SYS_ICC_AP1R1_EL1),
 SR(SYS_ICC_AP1R2_EL1),
 SR(SYS_ICC_AP1R3_EL1),
 SR(SYS_ICC_BPR1_EL1),
 SR(SYS_ICC_CTLR_EL1),
 SR(SYS_ICC_SRE_EL1),
 SR(SYS_ICC_IGRPEN0_EL1),
 SR(SYS_ICC_IGRPEN1_EL1),
};

static const struct sr_def sysregs_el2[] = {
 SR(SYS_ICH_AP0R0_EL2),
 SR(SYS_ICH_AP0R1_EL2),
 SR(SYS_ICH_AP0R2_EL2),
 SR(SYS_ICH_AP0R3_EL2),
 SR(SYS_ICH_AP1R0_EL2),
 SR(SYS_ICH_AP1R1_EL2),
 SR(SYS_ICH_AP1R2_EL2),
 SR(SYS_ICH_AP1R3_EL2),
 SR(SYS_ICH_HCR_EL2),
 SR(SYS_ICC_SRE_EL2),
 SR(SYS_ICH_VTR_EL2),
 SR(SYS_ICH_VMCR_EL2),
 SR(SYS_ICH_LR0_EL2),
 SR(SYS_ICH_LR1_EL2),
 SR(SYS_ICH_LR2_EL2),
 SR(SYS_ICH_LR3_EL2),
 SR(SYS_ICH_LR4_EL2),
 SR(SYS_ICH_LR5_EL2),
 SR(SYS_ICH_LR6_EL2),
 SR(SYS_ICH_LR7_EL2),
 SR(SYS_ICH_LR8_EL2),
 SR(SYS_ICH_LR9_EL2),
 SR(SYS_ICH_LR10_EL2),
 SR(SYS_ICH_LR11_EL2),
 SR(SYS_ICH_LR12_EL2),
 SR(SYS_ICH_LR13_EL2),
 SR(SYS_ICH_LR14_EL2),
 SR(SYS_ICH_LR15_EL2),
};

static void test_sysreg_array(int gic, const struct sr_def *sr, int nr,
         int (*check)(int, const struct sr_def *, const char *))
{
 for (int i = 0; i < nr; i++) {
  u64 val;
  u64 attr;
  int ret;

  /* Assume MPIDR_EL1.Aff*=0 */
  attr = PACK_SR(sr[i].encoding);

  /*
   * The API is braindead. A register can be advertised as
   * available, and yet not be readable or writable.
   * ICC_APnR{1,2,3}_EL1 are examples of such non-sense, and
   * ICH_APnR{1,2,3}_EL2 do follow suit for consistency.
   *
   * On the bright side, no known HW is implementing more than
   * 5 bits of priority, so we're safe. Sort of...
 */
  ret = __kvm_has_device_attr(gic, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
         attr);
  TEST_ASSERT(ret == 0, "%s unavailable", sr[i].name);

  /* Check that we can write back what we read */
  ret = __kvm_device_attr_get(gic, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
         attr, &val);
  TEST_ASSERT(ret == 0 || !check(gic, &sr[i], "read"), "%s unreadable", sr[i].name);
  ret = __kvm_device_attr_set(gic, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
         attr, &val);
  TEST_ASSERT(ret == 0 || !check(gic, &sr[i], "write"), "%s unwritable", sr[i].name);
 }
}

static u8 get_ctlr_pribits(int gic)
{
 int ret;
 u64 val;
 u8 pri;

 ret = __kvm_device_attr_get(gic, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
        PACK_SR(SYS_ICC_CTLR_EL1), &val);
 TEST_ASSERT(ret == 0, "ICC_CTLR_EL1 unreadable");

 pri = FIELD_GET(ICC_CTLR_EL1_PRI_BITS_MASK, val) + 1;
 TEST_ASSERT(pri >= 5 && pri <= 7, "Bad pribits %d", pri);

 return pri;
}

static int check_unaccessible_el1_regs(int gic, const struct sr_def *sr, const char *what)
{
 switch (sr->encoding) {
 case SYS_ICC_AP0R1_EL1:
 case SYS_ICC_AP1R1_EL1:
  if (get_ctlr_pribits(gic) >= 6)
   return -EINVAL;
  break;
 case SYS_ICC_AP0R2_EL1:
 case SYS_ICC_AP0R3_EL1:
 case SYS_ICC_AP1R2_EL1:
 case SYS_ICC_AP1R3_EL1:
  if (get_ctlr_pribits(gic) == 7)
   return 0;
  break;
 default:
  return -EINVAL;
 }

 pr_info("SKIP %s for %s\n", sr->name, what);
 return 0;
}

static u8 get_vtr_pribits(int gic)
{
 int ret;
 u64 val;
 u8 pri;

 ret = __kvm_device_attr_get(gic, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
        PACK_SR(SYS_ICH_VTR_EL2), &val);
 TEST_ASSERT(ret == 0, "ICH_VTR_EL2 unreadable");

 pri = FIELD_GET(ICH_VTR_EL2_PRIbits, val) + 1;
 TEST_ASSERT(pri >= 5 && pri <= 7, "Bad pribits %d", pri);

 return pri;
}

static int check_unaccessible_el2_regs(int gic, const struct sr_def *sr, const char *what)
{
 switch (sr->encoding) {
 case SYS_ICH_AP0R1_EL2:
 case SYS_ICH_AP1R1_EL2:
  if (get_vtr_pribits(gic) >= 6)
   return -EINVAL;
  break;
 case SYS_ICH_AP0R2_EL2:
 case SYS_ICH_AP0R3_EL2:
 case SYS_ICH_AP1R2_EL2:
 case SYS_ICH_AP1R3_EL2:
  if (get_vtr_pribits(gic) == 7)
   return -EINVAL;
  break;
 default:
  return -EINVAL;
 }

 pr_info("SKIP %s for %s\n", sr->name, what);
 return 0;
}

static void test_v3_sysregs(void)
{
 struct kvm_vcpu_init init = {};
 struct kvm_vcpu *vcpu;
 struct kvm_vm *vm;
 u32 feat = 0;
 int gic;

 if (kvm_check_cap(KVM_CAP_ARM_EL2))
  feat |= BIT(KVM_ARM_VCPU_HAS_EL2);

 vm = vm_create(1);

 vm_ioctl(vm, KVM_ARM_PREFERRED_TARGET, &init);
 init.features[0] |= feat;

 vcpu = aarch64_vcpu_add(vm, 0, &init, NULL);
 TEST_ASSERT(vcpu, "Can't create a vcpu?");

 gic = kvm_create_device(vm, KVM_DEV_TYPE_ARM_VGIC_V3);
 TEST_ASSERT(gic >= 0, "No GIC???");

 kvm_device_attr_set(gic, KVM_DEV_ARM_VGIC_GRP_CTRL,
       KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

 test_sysreg_array(gic, sysregs_el1, ARRAY_SIZE(sysregs_el1), check_unaccessible_el1_regs);
 if (feat)
  test_sysreg_array(gic, sysregs_el2, ARRAY_SIZE(sysregs_el2), check_unaccessible_el2_regs);
 else
  pr_info("SKIP EL2 registers, not available\n");

 close(gic);
 kvm_vm_free(vm);
}

void run_tests(uint32_t gic_dev_type)
{
 test_vcpus_then_vgic(gic_dev_type);
 test_vgic_then_vcpus(gic_dev_type);

 if (VGIC_DEV_IS_V2(gic_dev_type))
  test_v2_uaccess_cpuif_no_vcpus();

 if (VGIC_DEV_IS_V3(gic_dev_type)) {
  test_v3_new_redist_regions();
  test_v3_typer_accesses();
  test_v3_last_bit_redist_regions();
  test_v3_last_bit_single_rdist();
  test_v3_redist_ipa_range_check_at_vcpu_run();
  test_v3_its_region();
  test_v3_sysregs();
  test_v3_nassgicap();
 }
}

int main(int ac, char **av)
{
 int ret;
 int pa_bits;
 int cnt_impl = 0;

 pa_bits = vm_guest_mode_params[VM_MODE_DEFAULT].pa_bits;
 max_phys_size = 1ULL << pa_bits;

 ret = test_kvm_device(KVM_DEV_TYPE_ARM_VGIC_V3);
 if (!ret) {
  pr_info("Running GIC_v3 tests.\n");
  run_tests(KVM_DEV_TYPE_ARM_VGIC_V3);
  cnt_impl++;
 }

 ret = test_kvm_device(KVM_DEV_TYPE_ARM_VGIC_V2);
 if (!ret) {
  pr_info("Running GIC_v2 tests.\n");
  run_tests(KVM_DEV_TYPE_ARM_VGIC_V2);
  cnt_impl++;
 }

 if (!cnt_impl) {
  print_skip("No GICv2 nor GICv3 support");
  exit(KSFT_SKIP);
 }
 return 0;
}