// SPDX-License-Identifier: GPL-2.0

#include <linux/kernel.h>
#include <sys/syscall.h>
#include <asm/kvm.h>
#include <asm/kvm_para.h>

#include <arm64/gic_v5.h>

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

#define NR_VCPUS		1
#define VGIC_V5_LPI_NR_VCPUS	2
#define VGIC_V5_SPARSE_NR_VCPUS	2
#define VGIC_V5_SPARSE_VCPU0_ID	17
#define VGIC_V5_SPARSE_VCPU1_ID	3
#define VGIC_V5_LPI_MEMSLOT	1
#define VGIC_V5_NR_PRIVATE_IRQS	64
#define VGIC_V5_DEFAULT_NR_SPIS	32
#define VGIC_V5_MAX_NR_SPIS	BIT(10)
#define VGIC_V5_IRS_SIZE		0x20000
#define VGIC_V5_IRS_WAIT_RETRIES	1000000
#define VGIC_V5_LPI_IST_BASE_GPA	(GICV5_IRS_CONFIG_BASE_GPA + VGIC_V5_IRS_SIZE)
#define VGIC_V5_LPI_IST_SIZE		0x10000
#define LPI_TEST_TO_VPE1		0
#define LPI_TEST_TO_VPE0		1
#define RESTORE_TEST_LPI_PENDING		0
#define RESTORE_TEST_LPI_ENABLED		1
#define RESTORE_TEST_SPI_PRIO_HIGH		0
#define RESTORE_TEST_SPI_PRIO_LOW		1
#define RESTORE_TEST_SPI_PENDING_DISABLED	2
#define RESTORE_TEST_SPI_ENABLED		3
#define VGIC_V5_IST_PRIO_HIGH		0x08
#define VGIC_V5_IST_PRIO_LOW		0x10

static u64 max_phys_size;

#define VGIC_V5_TEST_IST_BASER_GPA	0x10000000ULL

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

#define GUEST_CMD_IRQ_CDIA	10
#define GUEST_CMD_IRQ_DIEOI	11
#define GUEST_CMD_IS_AWAKE	12
#define GUEST_CMD_IS_READY	13
#define GUEST_CMD_LPI_SENT	14
#define GUEST_CMD_LPI_REPLIED	15
#define GUEST_CMD_IST_SOURCE_READY	16
#define GUEST_CMD_IST_SPI_INJECT_READY	17
#define GUEST_CMD_IST_LPI_INJECT_READY	18

static struct kvm_vgic_v5_ist vgic_v5_ist_attr(void *spi_ist, size_t spi_size,
					       void *lpi_ist, size_t lpi_size)
{
	return (struct kvm_vgic_v5_ist) {
		.spi_ist_addr = (uintptr_t)spi_ist,
		.spi_ist_size = spi_size,
		.lpi_ist_addr = (uintptr_t)lpi_ist,
		.lpi_ist_size = lpi_size,
	};
}

static u32 spi_line_expected;
static bool spi_line_level_sensitive;
static bool lpi_ist_ready;
static u32 ist_restore_irq_count[VGIC_V5_LPI_NR_VCPUS];

static u64 gicv5_hwirq(u32 type, u32 intid)
{
	return FIELD_PREP(GICV5_HWIRQ_TYPE, type) |
	       FIELD_PREP(GICV5_HWIRQ_ID, intid);
}

static u64 gicv5_lpi_hwirq(u32 lpi)
{
	return gicv5_hwirq(GICV5_HWIRQ_TYPE_LPI, lpi);
}

static u64 gicv5_spi_hwirq(u32 spi)
{
	return gicv5_hwirq(GICV5_HWIRQ_TYPE_SPI, spi);
}

static void gicv5_setup_and_enable_hwirq(u64 hwirq, u32 target_vpe)
{
	u64 val;

	val = hwirq | FIELD_PREP(GICV5_GIC_CDPRI_PRIORITY_MASK,
				 GICV5_IRQ_DEFAULT_PRI);
	gic_insn(val, CDPRI);

	val = hwirq | FIELD_PREP(GICV5_GIC_CDAFF_IAFFID_MASK, target_vpe);
	gic_insn(val, CDAFF);

	gic_insn(hwirq, CDEN);
}

static void gicv5_set_hwirq_priority(u64 hwirq, u32 priority)
{
	u64 val;

	val = hwirq | FIELD_PREP(GICV5_GIC_CDPRI_PRIORITY_MASK, priority);
	gic_insn(val, CDPRI);
}

static void gicv5_set_hwirq_affinity(u64 hwirq, u32 target_vpe)
{
	u64 val;

	val = hwirq | FIELD_PREP(GICV5_GIC_CDAFF_IAFFID_MASK, target_vpe);
	gic_insn(val, CDAFF);
}

static void gicv5_enable_hwirq(u64 hwirq)
{
	gic_insn(hwirq, CDEN);
}

static void gicv5_enable_spi(u32 spi, u32 target_vpe)
{
	gicv5_setup_and_enable_hwirq(gicv5_spi_hwirq(spi), target_vpe);
}

static void gicv5_enable_lpi(u32 lpi, u32 target_vpe)
{
	gicv5_setup_and_enable_hwirq(gicv5_lpi_hwirq(lpi), target_vpe);
}

static void gicv5_send_lpi(u32 lpi)
{
	u64 hwirq = gicv5_lpi_hwirq(lpi);

	gic_insn(hwirq | GICV5_GIC_CDPEND_PENDING_MASK, CDPEND);
}

static void gicv5_wait_for_irs_idle(u32 reg, u32 idle)
{
	int i;

	for (i = 0; i < VGIC_V5_IRS_WAIT_RETRIES; i++) {
		if (readl(GICV5_IRS_CONFIG_BASE_GVA + reg) & idle)
			return;

		cpu_relax();
	}

	GUEST_FAIL("IRS operation did not become idle");
}

static void gicv5_configure_spi(u32 spi, bool level)
{
	u32 val;

	val = FIELD_PREP(GICV5_IRS_SPI_SELR_ID, spi);
	writel(val, GICV5_IRS_CONFIG_BASE_GVA + GICV5_IRS_SPI_SELR);
	gicv5_wait_for_irs_idle(GICV5_IRS_SPI_STATUSR,
				GICV5_IRS_SPI_STATUSR_IDLE);

	val = level ? GICV5_IRS_SPI_CFGR_TM : 0;
	writel(val, GICV5_IRS_CONFIG_BASE_GVA + GICV5_IRS_SPI_CFGR);
	gicv5_wait_for_irs_idle(GICV5_IRS_SPI_STATUSR,
				GICV5_IRS_SPI_STATUSR_IDLE);
}

static u32 gicv5_lpi_istsz(u32 idr2, u32 lpi_id_bits)
{
	if (!(idr2 & GICV5_IRS_IDR2_ISTMD))
		return GICV5_IRS_IST_CFGR_ISTSZ_4;

	if (lpi_id_bits >= FIELD_GET(GICV5_IRS_IDR2_ISTMD_SZ, idr2))
		return GICV5_IRS_IST_CFGR_ISTSZ_16;

	return GICV5_IRS_IST_CFGR_ISTSZ_8;
}

static void gicv5_configure_lpi_ist(void)
{
	u32 idr2, min_lpi_id_bits, lpi_id_bits, id_bits, istsz;
	u64 val;

	idr2 = readl(GICV5_IRS_CONFIG_BASE_GVA + GICV5_IRS_IDR2);
	GUEST_ASSERT(idr2 & GICV5_IRS_IDR2_LPI);

	min_lpi_id_bits = FIELD_GET(GICV5_IRS_IDR2_MIN_LPI_ID_BITS, idr2);
	id_bits = FIELD_GET(GICV5_IRS_IDR2_ID_BITS, idr2);
	/* Default to 32 LPIs, unless the min requirement is higher */
	lpi_id_bits = max(5U, min_lpi_id_bits);
	GUEST_ASSERT(lpi_id_bits <= id_bits);

	istsz = gicv5_lpi_istsz(idr2, lpi_id_bits);
	/*
	 * We allocate a fixed-size IST buffer on the host to avoid dynamic
	 * allocation from the guest. Make sure it fits the linear IST described
	 * by IDR2 before programming IRS_IST_BASER.
	 */
	GUEST_ASSERT((BIT_ULL(lpi_id_bits) << (istsz + 2)) <= VGIC_V5_LPI_IST_SIZE);

	val = FIELD_PREP(GICV5_IRS_IST_CFGR_LPI_ID_BITS, lpi_id_bits) |
	      FIELD_PREP(GICV5_IRS_IST_CFGR_ISTSZ, istsz);
	writel(val, GICV5_IRS_CONFIG_BASE_GVA + GICV5_IRS_IST_CFGR);

	val = FIELD_PREP(GICV5_IRS_IST_BASER_ADDR_MASK,
			 VGIC_V5_LPI_IST_BASE_GPA >> GICV5_IRS_IST_BASER_ADDR_SHIFT);
	val |= GICV5_IRS_IST_BASER_VALID;
	writeq(val, GICV5_IRS_CONFIG_BASE_GVA + GICV5_IRS_IST_BASER);

	GUEST_ASSERT_EQ(readl(GICV5_IRS_CONFIG_BASE_GVA + GICV5_IRS_IST_STATUSR),
			GICV5_IRS_IST_STATUSR_IDLE);

	/* The address is immutable while the BASER is valid. */
	writeq(val ^ FIELD_PREP(GICV5_IRS_IST_BASER_ADDR_MASK, 1),
	       GICV5_IRS_CONFIG_BASE_GVA + GICV5_IRS_IST_BASER);
	GUEST_ASSERT_EQ(readq(GICV5_IRS_CONFIG_BASE_GVA +
			      GICV5_IRS_IST_BASER), val);
}

static void gicv5_enable_irs(void)
{
	writel(GICV5_IRS_CR0_IRSEN,
	       GICV5_IRS_CONFIG_BASE_GVA + GICV5_IRS_CR0);
	gicv5_wait_for_irs_idle(GICV5_IRS_CR0, GICV5_IRS_CR0_IDLE);
}

static void gicv5_configure_test_lpis(void)
{
	gicv5_enable_lpi(LPI_TEST_TO_VPE1, 1);
	gicv5_enable_lpi(LPI_TEST_TO_VPE0, 0);
}

static void gicv5_set_pcr(u32 priority)
{
	u64 pcr;

	pcr = FIELD_PREP(ICC_PCR_EL1_PRIORITY, priority);
	write_sysreg_s(pcr, SYS_ICC_PCR_EL1);
	isb();
}

static void guest_ppi_irq_handler(struct ex_regs *regs)
{
	bool valid;
	u32 hwirq;
	u64 ia;
	static int count;

	/*
	 * We have pending interrupts. Should never actually enter WFI
	 * here!
	 */
	wfi();
	GUEST_SYNC(GUEST_CMD_IS_AWAKE);

	ia = gicr_insn(CDIA);
	valid = GICV5_GICR_CDIA_VALID(ia);

	GUEST_SYNC(GUEST_CMD_IRQ_CDIA);

	if (!valid)
		return;

	gsb_ack();
	isb();

	hwirq = FIELD_GET(GICV5_GICR_CDIA_INTID, ia);

	gic_insn(hwirq, CDDI);
	gic_insn(0, CDEOI);

	GUEST_SYNC(GUEST_CMD_IRQ_DIEOI);

	if (++count >= 2)
		GUEST_DONE();

	/* Ask for the next interrupt to be injected */
	GUEST_SYNC(GUEST_CMD_IS_READY);
}

static void guest_code(void)
{
	local_irq_disable();

	gicv5_cpu_enable_interrupts();
	local_irq_enable();

	/* Enable the SW_PPI (3) */
	write_sysreg_s(BIT_ULL(3), SYS_ICC_PPI_ENABLER0_EL1);

	/* Ask for the first interrupt to be injected */
	GUEST_SYNC(GUEST_CMD_IS_READY);

	/* Loop forever waiting for interrupts */
	for (;;)
		cpu_relax();
}

static void guest_iaffid_code(void)
{
	GUEST_SYNC(FIELD_GET(ICC_IAFFIDR_EL1_IAFFID,
				     read_sysreg_s(SYS_ICC_IAFFIDR_EL1)));
	GUEST_DONE();
}

static void guest_spi_irq_handler(struct ex_regs *regs)
{
	bool valid;
	u32 hwirq;
	u64 ia;

	ia = gicr_insn(CDIA);
	valid = GICV5_GICR_CDIA_VALID(ia);

	if (!valid)
		return;

	gsb_ack();
	isb();

	hwirq = FIELD_GET(GICV5_GICR_CDIA_INTID, ia);

	GUEST_ASSERT_EQ(hwirq, gicv5_spi_hwirq(READ_ONCE(spi_line_expected)));

	gic_insn(hwirq, CDDI);
	gic_insn(0, CDEOI);

	GUEST_DONE();
}

static void guest_spi_line_code(void)
{
	local_irq_disable();

	gicv5_enable_irs();
	gicv5_cpu_enable_interrupts();
	gicv5_configure_spi(READ_ONCE(spi_line_expected),
			    READ_ONCE(spi_line_level_sensitive));
	gicv5_enable_spi(READ_ONCE(spi_line_expected), 0);

	local_irq_enable();

	GUEST_SYNC(GUEST_CMD_IS_READY);

	while (1)
		wfi();
}

static void guest_lpi_irq_handler(struct ex_regs *regs)
{
	u32 vcpu_id = guest_get_vcpuid();
	u32 expected_lpi = vcpu_id ? LPI_TEST_TO_VPE1 : LPI_TEST_TO_VPE0;
	u64 expected_hwirq = gicv5_lpi_hwirq(expected_lpi);
	u32 hwirq;
	u64 ia;

	ia = gicr_insn(CDIA);
	if (!GICV5_GICR_CDIA_VALID(ia))
		return;

	gsb_ack();
	isb();

	hwirq = FIELD_GET(GICV5_GICR_CDIA_INTID, ia);
	GUEST_ASSERT_EQ(hwirq, expected_hwirq);

	gic_insn(hwirq, CDDI);
	gic_insn(0, CDEOI);

	if (vcpu_id) {
		gicv5_send_lpi(LPI_TEST_TO_VPE0);
		GUEST_SYNC(GUEST_CMD_LPI_REPLIED);
		while (1)
			wfi();
	}

	GUEST_DONE();
}

static void guest_unexpected_irq_handler(struct ex_regs *regs)
{
	GUEST_FAIL("Unexpected IRQ");
}

static void guest_lpi_code(void)
{
	u32 vcpu_id = guest_get_vcpuid();

	local_irq_disable();

	if (!vcpu_id) {
		gicv5_enable_irs();
		gicv5_configure_lpi_ist();
		gicv5_configure_test_lpis();
		WRITE_ONCE(lpi_ist_ready, true);
	}

	/* Go bang if we run VCPU1 before VCPU0 */
	GUEST_ASSERT(READ_ONCE(lpi_ist_ready));

	gicv5_cpu_enable_interrupts();
	local_irq_enable();

	GUEST_SYNC(GUEST_CMD_IS_READY);

	if (!vcpu_id) {
		gicv5_send_lpi(LPI_TEST_TO_VPE1);
		GUEST_SYNC(GUEST_CMD_LPI_SENT);
	}

	while (1)
		wfi();
}

static void restore_test_setup_hwirq(u64 hwirq, u32 target_vpe,
				     u32 priority, bool enable)
{
	gicv5_set_hwirq_priority(hwirq, priority);
	gicv5_set_hwirq_affinity(hwirq, target_vpe);

	if (enable)
		gicv5_enable_hwirq(hwirq);
}

/*
 * The source VM configures SPI and LPI state for the IST save/restore test.
 * It leaves interrupts disabled, allowing userspace to save the state before
 * the restore VM enables interrupts and checks delivery.
 */
static void guest_ist_source_code(void)
{
	local_irq_disable();

	gicv5_enable_irs();
	gicv5_configure_lpi_ist();

	restore_test_setup_hwirq(gicv5_lpi_hwirq(RESTORE_TEST_LPI_PENDING),
				 1, VGIC_V5_IST_PRIO_HIGH, true);
	restore_test_setup_hwirq(gicv5_lpi_hwirq(RESTORE_TEST_LPI_ENABLED),
				 1, VGIC_V5_IST_PRIO_HIGH, true);
	restore_test_setup_hwirq(gicv5_spi_hwirq(RESTORE_TEST_SPI_PRIO_HIGH),
				 0, VGIC_V5_IST_PRIO_HIGH, true);
	restore_test_setup_hwirq(gicv5_spi_hwirq(RESTORE_TEST_SPI_PRIO_LOW),
				 0, VGIC_V5_IST_PRIO_LOW, true);
	restore_test_setup_hwirq(gicv5_spi_hwirq(RESTORE_TEST_SPI_ENABLED),
				 0, VGIC_V5_IST_PRIO_HIGH, true);
	restore_test_setup_hwirq(gicv5_spi_hwirq(RESTORE_TEST_SPI_PENDING_DISABLED),
				 0, VGIC_V5_IST_PRIO_HIGH, false);

	gicv5_send_lpi(RESTORE_TEST_LPI_PENDING);

	GUEST_SYNC(GUEST_CMD_IST_SOURCE_READY);

	while (1)
		wfi();
}

/*
 * This is the restore VM for the IST save/restore test. The IRS regs and ISTs
 * have been restored before this code runs. Based on which VPE is running, a
 * different set of interrupts is expected. We check that we get what we
 * expected before terminating the test.
 *
 * The expected interrupts for VPE0 are:
 * - High-priority SPI, pending and enabled before save.
 * - Low-priority SPI, pending and enabled before save. This is only delivered
 *   after the guest lowers the masked priority via ICC_PCR_EL1.
 * - SPI that was pending but disabled before save. This is only delivered
 *   after the guest enables it after restore.
 * - SPI that was enabled but not pending before save. Userspace injects this
 *   after restore to check that the enable state and affinity were restored.
 *
 * The expected interrupts for VPE1 are:
 * - LPI that was pending and enabled before save.
 * - LPI that was enabled but not pending before save. The guest injects this
 *   after restore to check that the enable state and affinity were restored.
 */
static void guest_ist_restore_irq_handler(struct ex_regs *regs)
{
	u32 vcpu_id = guest_get_vcpuid();
	u32 count = ist_restore_irq_count[vcpu_id];
	u64 hwirq, expected_hwirq = 0;
	u64 ia;

	ia = gicr_insn(CDIA);
	if (!GICV5_GICR_CDIA_VALID(ia))
		return;

	gsb_ack();
	isb();

	hwirq = FIELD_GET(GICV5_GICR_CDIA_INTID, ia);

	if (!vcpu_id) {
		switch (count) {
		case 0:
			expected_hwirq = gicv5_spi_hwirq(RESTORE_TEST_SPI_PRIO_HIGH);
			break;
		case 1:
			expected_hwirq = gicv5_spi_hwirq(RESTORE_TEST_SPI_PRIO_LOW);
			break;
		case 2:
			expected_hwirq = gicv5_spi_hwirq(RESTORE_TEST_SPI_PENDING_DISABLED);
			break;
		case 3:
			expected_hwirq = gicv5_spi_hwirq(RESTORE_TEST_SPI_ENABLED);
			break;
		default:
			GUEST_FAIL("Unexpected VPE0 IST restore interrupt");
		}
	} else {
		switch (count) {
		case 0:
			expected_hwirq = gicv5_lpi_hwirq(RESTORE_TEST_LPI_PENDING);
			break;
		case 1:
			expected_hwirq = gicv5_lpi_hwirq(RESTORE_TEST_LPI_ENABLED);
			break;
		default:
			GUEST_FAIL("Unexpected VPE1 IST restore interrupt");
		}
	}

	GUEST_ASSERT_EQ(hwirq, expected_hwirq);

	gic_insn(hwirq, CDDI);
	gic_insn(0, CDEOI);
	ist_restore_irq_count[vcpu_id]++;

	if (!vcpu_id) {
		switch (count) {
		case 0:
			gicv5_set_pcr(VGIC_V5_IST_PRIO_LOW);
			break;
		case 1:
			gicv5_enable_hwirq(
				gicv5_spi_hwirq(RESTORE_TEST_SPI_PENDING_DISABLED));
			break;
		case 2:
			GUEST_SYNC(GUEST_CMD_IST_SPI_INJECT_READY);
			break;
		case 3:
			GUEST_DONE();
		}
	} else {
		switch (count) {
		case 0:
			gicv5_send_lpi(RESTORE_TEST_LPI_ENABLED);
			GUEST_SYNC(GUEST_CMD_IST_LPI_INJECT_READY);
			break;
		case 1:
			GUEST_DONE();
		}
	}
}

static void guest_ist_restore_code(void)
{
	local_irq_disable();

	gicv5_cpu_enable_interrupts();

	if (!guest_get_vcpuid())
		gicv5_set_pcr(VGIC_V5_IST_PRIO_HIGH);

	GUEST_SYNC(GUEST_CMD_IS_READY);

	local_irq_enable();

	while (1)
		wfi();
}

/* 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 void vm_gic_destroy(struct vm_gic *v)
{
	close(v->gic_fd);
	kvm_vm_free(v->vm);
}

static void vgic_v5_map_irs(struct kvm_vm *vm)
{
	unsigned int nr_irs_pages;

	nr_irs_pages = vm_calc_num_guest_pages(vm->mode, VGIC_V5_IRS_SIZE);

	/* Map the IRS at VA == IPA so guest MMIO writes hit the IRS IODEV. */
	virt_map(vm, GICV5_IRS_CONFIG_BASE_GPA,
		 GICV5_IRS_CONFIG_BASE_GPA, nr_irs_pages);
}

static u32 vgic_v5_irq_line_payload(u32 type, u32 num)
{
	return (type << KVM_ARM_IRQ_TYPE_SHIFT) |
	       FIELD_PREP(KVM_ARM_IRQ_NUM_MASK, num);
}

static int __vgic_v5_irq_line(struct kvm_vm *vm, u32 type, u32 num, int level)
{
	return _kvm_irq_line(vm, vgic_v5_irq_line_payload(type, num), level);
}

static void vgic_v5_spi_line(struct kvm_vm *vm, u32 spi, int level)
{
	int ret = __vgic_v5_irq_line(vm, KVM_ARM_IRQ_TYPE_SPI, spi, level);

	TEST_ASSERT(!ret, "KVM_IRQ_LINE failed for SPI %u level %d",
		    spi, level);
}

static void vgic_v5_spi_line_vm_create(struct vm_gic *v,
				       struct kvm_vcpu **vcpu,
				       u32 nr_spis)
{
	u64 attr;

	v->gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v->vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v->gic_fd = kvm_create_device(v->vm, v->gic_dev_type);
	*vcpu = vm_vcpu_add(v->vm, 0, guest_spi_line_code);
	TEST_ASSERT(*vcpu, "Failed to create vCPU");

	vm_init_descriptor_tables(v->vm);
	vm_install_exception_handler(v->vm, VECTOR_IRQ_CURRENT,
				     guest_spi_irq_handler);
	vcpu_init_descriptor_tables(*vcpu);

	kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS, 0,
			    &nr_spis);

	attr = GICV5_IRS_CONFIG_BASE_GPA;
	kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
			    KVM_VGIC_V5_ADDR_TYPE_IRS, &attr);
	vgic_v5_map_irs(v->vm);
	kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
}

static void vgic_v5_lpi_ist_vm_create(struct vm_gic *v,
				      struct kvm_vcpu *vcpus[VGIC_V5_LPI_NR_VCPUS],
				      void (*guest_code)(void),
				      void (*irq_handler)(struct ex_regs *))
{
	unsigned int nr_lpi_ist_pages;
	u64 attr;
	int i;

	v->gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v->vm = __vm_create(VM_SHAPE_DEFAULT, VGIC_V5_LPI_NR_VCPUS, 0);
	v->gic_fd = kvm_create_device(v->vm, v->gic_dev_type);

	for (i = 0; i < VGIC_V5_LPI_NR_VCPUS; i++) {
		vcpus[i] = vm_vcpu_add(v->vm, i, guest_code);
		TEST_ASSERT(vcpus[i], "Failed to create vCPU");
	}

	vm_init_descriptor_tables(v->vm);
	vm_install_exception_handler(v->vm, VECTOR_IRQ_CURRENT,
				     irq_handler);

	for (i = 0; i < VGIC_V5_LPI_NR_VCPUS; i++)
		vcpu_init_descriptor_tables(vcpus[i]);

	attr = GICV5_IRS_CONFIG_BASE_GPA;
	kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
			    KVM_VGIC_V5_ADDR_TYPE_IRS, &attr);
	vgic_v5_map_irs(v->vm);

	nr_lpi_ist_pages = vm_calc_num_guest_pages(v->vm->mode,
						   VGIC_V5_LPI_IST_SIZE);
	vm_userspace_mem_region_add(v->vm, VM_MEM_SRC_ANONYMOUS,
				    VGIC_V5_LPI_IST_BASE_GPA,
				    VGIC_V5_LPI_MEMSLOT,
				    nr_lpi_ist_pages, 0);
	/*
	 * Map the IST at VA == IPA so the guest can program the same BASER
	 * address.
	 */
	virt_map(v->vm, VGIC_V5_LPI_IST_BASE_GPA,
		 VGIC_V5_LPI_IST_BASE_GPA, nr_lpi_ist_pages);

	kvm_device_attr_set(v->gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
}

static void vgic_v5_lpi_vm_create(struct vm_gic *v,
				  struct kvm_vcpu *vcpus[VGIC_V5_LPI_NR_VCPUS])
{
	vgic_v5_lpi_ist_vm_create(v, vcpus, guest_lpi_code,
				  guest_lpi_irq_handler);
}

static void vgic_v5_ist_restore_vm_create(struct vm_gic *v,
					  struct kvm_vcpu *vcpus[VGIC_V5_LPI_NR_VCPUS],
					  void (*guest_code)(void),
					  void (*irq_handler)(struct ex_regs *))
{
	vgic_v5_lpi_ist_vm_create(v, vcpus, guest_code, irq_handler);
}

static void vgic_v5_run_spi_line_test(u32 nr_spis, u32 expected_spi,
				      bool level_sensitive,
				      bool lower_before_run)
{
	struct kvm_vcpu *vcpu;
	struct vm_gic v;
	struct ucall uc;
	int ret;

	spi_line_expected = expected_spi;
	spi_line_level_sensitive = level_sensitive;

	vgic_v5_spi_line_vm_create(&v, &vcpu, nr_spis);

	sync_global_to_guest(v.vm, spi_line_expected);
	sync_global_to_guest(v.vm, spi_line_level_sensitive);

	ret = run_vcpu(vcpu);
	TEST_ASSERT(!ret, "Failed to run GICv5 IRQ_LINE VM");
	TEST_ASSERT(get_ucall(vcpu, &uc) == UCALL_SYNC &&
		    uc.args[1] == GUEST_CMD_IS_READY,
		    "GICv5 IRQ_LINE guest did not become ready");

	vgic_v5_spi_line(v.vm, expected_spi, 1);
	/*
	 * For edge-triggered SPIs, a following low transition must be ignored:
	 * once the edge has made the SPI pending, it cannot be recalled. This
	 * allows us to test that.
	 */
	if (lower_before_run)
		vgic_v5_spi_line(v.vm, expected_spi, 0);

	while (1) {
		ret = run_vcpu(vcpu);
		TEST_ASSERT(!ret, "Failed to run GICv5 IRQ_LINE VM");

		switch (get_ucall(vcpu, &uc)) {
		case UCALL_ABORT:
			REPORT_GUEST_ASSERT(uc);
			break;
		case UCALL_DONE:
			goto done;
		default:
			TEST_FAIL("Unknown ucall %lu", uc.cmd);
		}
	}

done:
	vm_gic_destroy(&v);
}

static void vgic_v5_expect_sync(struct kvm_vcpu *vcpu, u64 cmd,
				const char *msg)
{
	struct ucall uc;

	TEST_ASSERT(get_ucall(vcpu, &uc) == UCALL_SYNC && uc.args[1] == cmd,
		    "%s", msg);
}

struct vgic_region_attr {
	u64 attr;
	u64 size;
	u64 alignment;
};

static const struct vgic_region_attr gic_v5_irs_region = {
	.attr = KVM_VGIC_V5_ADDR_TYPE_IRS,
	.size = GICV5_IRS_SIZE,
	.alignment = GICV5_IRS_ALIGN,
};

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

struct vgic_irs_reg_attr {
	const char	*name;
	u64		attr;
};

#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,				\
	}

#define IRS_REG(r)						\
	{							\
		.name		= #r,				\
		.attr		= r,				\
	}

static const struct vgic_irs_reg_attr gic_v5_irs_regs[] = {
	IRS_REG(GICV5_IRS_IDR0),
	IRS_REG(GICV5_IRS_IDR1),
	IRS_REG(GICV5_IRS_IDR2),
	IRS_REG(GICV5_IRS_IDR3),
	IRS_REG(GICV5_IRS_IDR4),
	IRS_REG(GICV5_IRS_IDR5),
	IRS_REG(GICV5_IRS_IDR6),
	IRS_REG(GICV5_IRS_IDR7),
	IRS_REG(GICV5_IRS_IIDR),
	IRS_REG(GICV5_IRS_AIDR),
	IRS_REG(GICV5_IRS_CR0),
	IRS_REG(GICV5_IRS_CR1),
	IRS_REG(GICV5_IRS_SYNCR),
	IRS_REG(GICV5_IRS_SYNC_STATUSR),
	IRS_REG(GICV5_IRS_SPI_VMR),
	IRS_REG(GICV5_IRS_SPI_SELR),
	IRS_REG(GICV5_IRS_SPI_DOMAINR),
	IRS_REG(GICV5_IRS_SPI_RESAMPLER),
	IRS_REG(GICV5_IRS_SPI_CFGR),
	IRS_REG(GICV5_IRS_SPI_STATUSR),
	IRS_REG(GICV5_IRS_PE_SELR),
	IRS_REG(GICV5_IRS_PE_STATUSR),
	IRS_REG(GICV5_IRS_PE_CR0),
	IRS_REG(GICV5_IRS_IST_BASER),
	IRS_REG(GICV5_IRS_IST_CFGR),
	IRS_REG(GICV5_IRS_IST_STATUSR),
	IRS_REG(GICV5_IRS_MAP_L2_ISTR),
	IRS_REG(GICV5_IRS_VMT_BASER),
	IRS_REG(GICV5_IRS_VMT_CFGR),
	IRS_REG(GICV5_IRS_VMT_STATUSR),
	IRS_REG(GICV5_IRS_VPE_SELR),
	IRS_REG(GICV5_IRS_VPE_DBR),
	IRS_REG(GICV5_IRS_VPE_HPPIR),
	IRS_REG(GICV5_IRS_VPE_CR0),
	IRS_REG(GICV5_IRS_VPE_STATUSR),
	IRS_REG(GICV5_IRS_VM_DBR),
	IRS_REG(GICV5_IRS_VM_SELR),
	IRS_REG(GICV5_IRS_VM_STATUSR),
	IRS_REG(GICV5_IRS_VMAP_L2_VMTR),
	IRS_REG(GICV5_IRS_VMAP_VMR),
	IRS_REG(GICV5_IRS_VMAP_VISTR),
	IRS_REG(GICV5_IRS_VMAP_L2_VISTR),
	IRS_REG(GICV5_IRS_VMAP_VPER),
	IRS_REG(GICV5_IRS_SAVE_VMR),
	IRS_REG(GICV5_IRS_SAVE_VM_STATUSR),
	IRS_REG(GICV5_IRS_MEC_IDR),
	IRS_REG(GICV5_IRS_MEC_MECID_R),
	IRS_REG(GICV5_IRS_MPAM_IDR),
	IRS_REG(GICV5_IRS_MPAM_PARTID_R),
	IRS_REG(GICV5_IRS_SWERR_STATUSR),
	IRS_REG(GICV5_IRS_SWERR_SYNDROMER0),
	IRS_REG(GICV5_IRS_SWERR_SYNDROMER1),
};

static const struct vgic_sysreg_attr gic_v5_cpu_sysregs[] = {
	SR(SYS_ICC_ICSR_EL1),
	SR(SYS_ICC_PPI_ENABLER0_EL1),
	SR(SYS_ICC_PPI_ENABLER1_EL1),
	SR(SYS_ICC_PPI_SACTIVER0_EL1),
	SR(SYS_ICC_PPI_SACTIVER1_EL1),
	SR(SYS_ICC_PPI_SPENDR0_EL1),
	SR(SYS_ICC_PPI_SPENDR1_EL1),
	SR(SYS_ICC_PPI_PRIORITYR0_EL1),
	SR(SYS_ICC_PPI_PRIORITYR1_EL1),
	SR(SYS_ICC_PPI_PRIORITYR2_EL1),
	SR(SYS_ICC_PPI_PRIORITYR3_EL1),
	SR(SYS_ICC_PPI_PRIORITYR4_EL1),
	SR(SYS_ICC_PPI_PRIORITYR5_EL1),
	SR(SYS_ICC_PPI_PRIORITYR6_EL1),
	SR(SYS_ICC_PPI_PRIORITYR7_EL1),
	SR(SYS_ICC_PPI_PRIORITYR8_EL1),
	SR(SYS_ICC_PPI_PRIORITYR9_EL1),
	SR(SYS_ICC_PPI_PRIORITYR10_EL1),
	SR(SYS_ICC_PPI_PRIORITYR11_EL1),
	SR(SYS_ICC_PPI_PRIORITYR12_EL1),
	SR(SYS_ICC_PPI_PRIORITYR13_EL1),
	SR(SYS_ICC_PPI_PRIORITYR14_EL1),
	SR(SYS_ICC_PPI_PRIORITYR15_EL1),
	SR(SYS_ICC_APR_EL1),
	SR(SYS_ICC_CR0_EL1),
	SR(SYS_ICC_PCR_EL1),
};

static void vgic_v5_save_irs_regs(struct vm_gic *v, u64 *regs)
{
	int ret, i;

	for (i = 0; i < ARRAY_SIZE(gic_v5_irs_regs); i++) {
		ret = __kvm_device_attr_get(v->gic_fd,
					    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
					    gic_v5_irs_regs[i].attr,
					    &regs[i]);
		TEST_ASSERT(!ret, "GICv5 IRS_REGS save failed for %s",
			    gic_v5_irs_regs[i].name);
	}
}

static void vgic_v5_restore_irs_regs(struct vm_gic *v, u64 *regs)
{
	int ret, i;

	for (i = 0; i < ARRAY_SIZE(gic_v5_irs_regs); i++) {
		ret = __kvm_device_attr_set(v->gic_fd,
					    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
					    gic_v5_irs_regs[i].attr,
					    &regs[i]);
		TEST_ASSERT(!ret, "GICv5 IRS_REGS restore failed for %s",
			    gic_v5_irs_regs[i].name);
	}
}

static u64 vgic_v5_saved_irs_reg(u64 *regs, u64 attr)
{
	for (int i = 0; i < ARRAY_SIZE(gic_v5_irs_regs); i++) {
		if (gic_v5_irs_regs[i].attr == attr)
			return regs[i];
	}

	TEST_FAIL("GICv5 IRS register 0x%lx was not saved", attr);
}

static size_t vgic_v5_lpi_ist_state_size(u64 *irs_regs)
{
	u64 cfgr = vgic_v5_saved_irs_reg(irs_regs, GICV5_IRS_IST_CFGR);
	u32 lpi_id_bits = FIELD_GET(GICV5_IRS_IST_CFGR_LPI_ID_BITS, cfgr);

	return BIT(lpi_id_bits) * sizeof(__u32);
}

static void test_vgic_v5_addr_attrs(void)
{
	struct kvm_vcpu *vcpu;
	struct vm_gic v;
	u64 addr;
	int ret;

	v.gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);

	/* Check existing group/attributes */
	kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR, gic_v5_irs_region.attr);

	/* check non existing attribute */
	ret = __kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR, -1);
	TEST_ASSERT(ret && errno == ENXIO, "attribute not supported");

	/* get IRS base address before setting*/
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
				    KVM_VGIC_V5_ADDR_TYPE_IRS, &addr);
	TEST_ASSERT(!ret && addr == (-1ULL), "GICv5 IRS returns VGIC_ADDR_UNDEF");

	/* misaligned IRS address settings */
	addr = gic_v5_irs_region.alignment / 0x10;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
				    KVM_VGIC_V5_ADDR_TYPE_IRS, &addr);
	TEST_ASSERT(ret && errno == EINVAL, "GIC IRS base not aligned");

	/* out of range address */
	addr = max_phys_size;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
				    KVM_VGIC_V5_ADDR_TYPE_IRS, &addr);
	TEST_ASSERT(ret && errno == E2BIG, "IRS address beyond IPA limit");

	/* Space for half an IRS (an IRS is: 2 * irs.alignment). */
	addr = max_phys_size - gic_v5_irs_region.alignment;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
				    KVM_VGIC_V5_ADDR_TYPE_IRS, &addr);
	TEST_ASSERT(ret && errno == E2BIG,
			"half of the IRS is beyond IPA limit");

	/* set IRS base address @0x0*/
	addr = 0x00000;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
				    KVM_VGIC_V5_ADDR_TYPE_IRS, &addr);
	TEST_ASSERT(!ret, "GICv5 IRS base correctly set");

	/* get IRS base address */
	addr = 0xbad;
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
				    KVM_VGIC_V5_ADDR_TYPE_IRS, &addr);
	TEST_ASSERT(!ret && addr == 0, "GICv5 IRS base correctly set");

	/* Attempt to create a second IRS region */
	addr = 0xE0000;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
				    KVM_VGIC_V5_ADDR_TYPE_IRS, &addr);
	TEST_ASSERT(ret && errno == EEXIST, "GICv5 IRS base set again");

	vm_gic_destroy(&v);

	/* Try running a VM without ever setting the IRS base addr */
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);
	vcpu = vm_vcpu_add(v.vm, 0, NULL);
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);
	ret = run_vcpu(vcpu);
	TEST_ASSERT(ret && errno == ENXIO, "GICv5 IRS base not set");

	vm_gic_destroy(&v);
}

static void test_vgic_v5_nr_irqs_attrs(void)
{
	struct kvm_vcpu *vcpu;
	struct vm_gic v;
	u32 nr_irqs;
	int ret;

	v.gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);

	/* Check existing group/attribute */
	kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS, 0);

	/* Before userspace sets NR_IRQS, no SPI count has been selected. */
	nr_irqs = 0xbad;
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(!ret && nr_irqs == 0, "GICv5 NR_IRQS defaults to 0 before init");

	/* Too few SPIs */
	nr_irqs = VGIC_V5_DEFAULT_NR_SPIS - 1;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 NR_IRQS below minimum");

	/* Not a multiple of 32 */
	nr_irqs = VGIC_V5_DEFAULT_NR_SPIS + 1;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 NR_IRQS not 32-aligned");

	/* Larger than KVM's supported VGICv5 SPI count */
	nr_irqs = VGIC_V5_MAX_NR_SPIS + 32;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 NR_IRQS above maximum");

	/* Valid custom SPI count */
	nr_irqs = VGIC_V5_MAX_NR_SPIS;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(!ret, "GICv5 NR_IRQS accepts valid custom SPI count");

	nr_irqs = 0xbad;
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(!ret && nr_irqs == VGIC_V5_MAX_NR_SPIS,
		    "GICv5 NR_IRQS returns SPI count only");

	/* A second successful configuration attempt must be rejected. */
	nr_irqs = VGIC_V5_DEFAULT_NR_SPIS;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 NR_IRQS set twice");

	/* The maximum supported count must also initialize successfully. */
	vcpu = vm_vcpu_add(v.vm, 0, NULL);
	TEST_ASSERT(vcpu, "Failed to create vCPU");
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

	vm_gic_destroy(&v);

	/* If userspace does not set NR_IRQS, init selects the default. */
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);
	vcpu = vm_vcpu_add(v.vm, 0, NULL);
	TEST_ASSERT(vcpu, "Failed to create vCPU");
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

	nr_irqs = 0xbad;
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(!ret && nr_irqs == VGIC_V5_DEFAULT_NR_SPIS,
		    "GICv5 NR_IRQS defaults to 32 SPIs after init");

	nr_irqs = VGIC_V5_DEFAULT_NR_SPIS * 2;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_NR_IRQS,
				    0, &nr_irqs);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 NR_IRQS set after init");

	vm_gic_destroy(&v);

}

static void test_vgic_v5_irs_regs_attrs(void)
{
	struct kvm_vcpu *vcpu;
	struct vm_gic v;
	u64 attr, val;
	int ret, i;

	v.gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);
	vcpu = vm_vcpu_add(v.vm, 0, NULL);
	TEST_ASSERT(vcpu, "Failed to create vCPU");

	/* IRS_REGS attributes can be probed before the IRS base is set. */
	kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
			    GICV5_IRS_IDR0);

	attr = GICV5_IRS_CONFIG_BASE_GPA;
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
			    KVM_VGIC_V5_ADDR_TYPE_IRS, &attr);

	/* Check existing group/attribute */
	kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
			    GICV5_IRS_IDR0);

	/* IRS_REGS are not accessible before the VGIC is initialized. */
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR0, &val);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 IRS_REGS get before init");

	val = 0;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR0, &val);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 IRS_REGS set before init");

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

	/* Read all supported IRS regs and write the value back. */
	for (i = 0; i < ARRAY_SIZE(gic_v5_irs_regs); i++) {
		attr = gic_v5_irs_regs[i].attr;
		ret = __kvm_has_device_attr(v.gic_fd,
					    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
					    attr);
		TEST_ASSERT(!ret, "GICv5 IRS_REGS missing %s",
			    gic_v5_irs_regs[i].name);

		val = 0xbad;
		ret = __kvm_device_attr_get(v.gic_fd,
					    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
					    attr, &val);
		TEST_ASSERT(!ret, "GICv5 IRS_REGS get failed for %s",
			    gic_v5_irs_regs[i].name);

		ret = __kvm_device_attr_set(v.gic_fd,
					    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
					    attr, &val);
		TEST_ASSERT(!ret, "GICv5 IRS_REGS set failed for %s",
			    gic_v5_irs_regs[i].name);
	}

	/* Check bad offsets */
	attr = 0x10000;
	ret = __kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    attr);
	TEST_ASSERT(ret && errno == ENXIO, "GICv5 IRS_REGS accepted bad offset");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    attr, &val);
	TEST_ASSERT(ret && errno == ENXIO, "GICv5 IRS_REGS get bad offset");

	/* Check alignment for 32-bit and 64-bit IRS regs. */
	attr = GICV5_IRS_IDR0 + 2;
	ret = __kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted unaligned 32-bit attr");

	attr = GICV5_IRS_IST_BASER + 4;
	ret = __kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted unaligned 64-bit attr");

	/* Check bad user pointers */
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR0, NULL);
	TEST_ASSERT(ret && errno == EFAULT, "GICv5 IRS_REGS get with bad pointer");

	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR0, NULL);
	TEST_ASSERT(ret && errno == EFAULT, "GICv5 IRS_REGS set with bad pointer");

	/* ID restore validation rejects unsupported values. */
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR0, &val);
	TEST_ASSERT(!ret, "GICv5 IRS_REGS get IDR0 failed");
	val &= ~GICV5_IRS_IDR0_INT_DOM;
	val |= FIELD_PREP(GICV5_IRS_IDR0_INT_DOM,
			  GICV5_IRS_IDR0_INT_DOM_SECURE);
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR0, &val);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted bad IDR0 domain");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR0, &val);
	TEST_ASSERT(!ret, "GICv5 IRS_REGS get IDR0 failed");
	val |= GICV5_IRS_IDR0_SETLPI;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR0, &val);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted unsupported IDR0");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR1, &val);
	TEST_ASSERT(!ret, "GICv5 IRS_REGS get IDR1 failed");
	val |= FIELD_PREP(GICV5_IRS_IDR1_PRIORITY_BITS, 0x7);
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR1, &val);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted bad IDR1");

	val = 0;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR2, &val);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted bad IDR2");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR5, &val);
	TEST_ASSERT(!ret, "GICv5 IRS_REGS get IDR5 failed");
	val++;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR5, &val);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted bad IDR5");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR6, &val);
	TEST_ASSERT(!ret, "GICv5 IRS_REGS get IDR6 failed");
	val++;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR6, &val);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted bad IDR6");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR7, &val);
	TEST_ASSERT(!ret, "GICv5 IRS_REGS get IDR7 failed");
	val++;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IDR7, &val);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IRS_REGS accepted bad IDR7");

	/* Status registers read as idle through userspace accessors. */
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_SYNC_STATUSR, &val);
	TEST_ASSERT(!ret && val == GICV5_IRS_SYNC_STATUSR_IDLE,
		    "GICv5 IRS_REGS SYNC_STATUSR is not idle");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_SPI_STATUSR, &val);
	TEST_ASSERT(!ret && val == GICV5_IRS_SPI_STATUSR_IDLE,
		    "GICv5 IRS_REGS SPI_STATUSR is not idle");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_PE_STATUSR, &val);
	TEST_ASSERT(!ret && val == GICV5_IRS_PE_STATUSR_IDLE,
		    "GICv5 IRS_REGS PE_STATUSR is not idle");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_STATUSR, &val);
	TEST_ASSERT(!ret && val == GICV5_IRS_IST_STATUSR_IDLE,
		    "GICv5 IRS_REGS IST_STATUSR is not idle");

	/*
	 * Userspace restores IST_BASER without allocating or accessing an IST.
	 * Supply a synthetic, aligned guest address only to verify the register
	 * round trip.
	 */
	val = FIELD_PREP(GICV5_IRS_IST_BASER_ADDR_MASK,
			 VGIC_V5_TEST_IST_BASER_GPA >> GICV5_IRS_IST_BASER_ADDR_SHIFT);
	val |= GICV5_IRS_IST_BASER_VALID;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_BASER, &val);
	TEST_ASSERT(!ret, "GICv5 IRS_REGS failed to restore IST_BASER");

	attr = 0xbad;
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_BASER, &attr);
	TEST_ASSERT(!ret && attr == val, "GICv5 IRS_REGS IST_BASER restore mismatch");

	vm_gic_destroy(&v);
}

static void test_vgic_v5_ist_attrs(void)
{
	struct kvm_vgic_v5_ist ist_attr;
	struct kvm_vcpu *vcpu;
	struct vm_gic v;
	u32 spi_ist[VGIC_V5_DEFAULT_NR_SPIS];
	u64 attr;
	int ret;

	v.gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);
	vcpu = vm_vcpu_add(v.vm, 0, NULL);
	TEST_ASSERT(vcpu, "Failed to create vCPU");

	/* Check existing group/attribute */
	kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST, 0);

	/* Check non-existing attribute */
	ret = __kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST, 1);
	TEST_ASSERT(ret && errno == ENXIO, "GICv5 IST accepted bad attr");

	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), NULL, 0);
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    1, &ist_attr);
	TEST_ASSERT(ret && errno == ENXIO, "GICv5 IST get accepted bad attr");

	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    1, &ist_attr);
	TEST_ASSERT(ret && errno == ENXIO, "GICv5 IST set accepted bad attr");

	attr = GICV5_IRS_CONFIG_BASE_GPA;
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
			    KVM_VGIC_V5_ADDR_TYPE_IRS, &attr);

	/* IST save/restore is not accessible before the VGIC is initialized. */
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 IST get before init");

	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 IST set before init");

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

	/* A VM with SPIs must provide a userspace IST descriptor. */
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, NULL);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST get accepted NULL descriptor");

	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, NULL);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST set accepted NULL descriptor");

	/* Check bad userspace IST descriptors. */
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, (void *)1);
	TEST_ASSERT(ret && errno == EFAULT, "GICv5 IST get with bad descriptor");

	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, (void *)1);
	TEST_ASSERT(ret && errno == EFAULT, "GICv5 IST set with bad descriptor");

	/* Check missing and incorrectly sized SPI IST buffers. */
	ist_attr = vgic_v5_ist_attr(NULL, 0, NULL, 0);
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST get accepted missing SPI buffer");
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST set accepted missing SPI buffer");

	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist) - sizeof(__u32),
					 NULL, 0);
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST set accepted bad SPI size");
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST get accepted bad SPI size");

	/* LPI storage must be absent when no LPI IST is configured. */
	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), spi_ist,
					 sizeof(__u32));
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST get accepted unexpected LPI buffer");
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST set accepted unexpected LPI buffer");

	vm_gic_destroy(&v);

	/* IST restore is rejected after the VM has run. */
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);
	vcpu = vm_vcpu_add(v.vm, 0, guest_code);

	attr = GICV5_IRS_CONFIG_BASE_GPA;
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
			    KVM_VGIC_V5_ADDR_TYPE_IRS, &attr);
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

	ret = run_vcpu(vcpu);
	TEST_ASSERT(!ret, "Failed to run GICv5 VM before IST restore test");

	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), NULL, 0);
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 IST restore after run");

	vm_gic_destroy(&v);
}

static void test_vgic_v5_userspace_ppis_attrs(void)
{
	struct kvm_vcpu *vcpu;
	struct vm_gic v;
	u64 user_ppis[2];
	int ret;

	v.gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);
	vcpu = vm_vcpu_add(v.vm, 0, NULL);
	TEST_ASSERT(vcpu, "Failed to create vCPU");

	kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_CTRL_INIT);
	kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_USERSPACE_PPIS);

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

	user_ppis[0] = 0;
	user_ppis[1] = 0xbad;
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
				    KVM_DEV_ARM_VGIC_USERSPACE_PPIS, user_ppis);
	TEST_ASSERT(!ret, "GICv5 USERSPACE_PPIS get failed");
	TEST_ASSERT(user_ppis[0] & BIT(GICV5_ARCH_PPI_SW_PPI),
		    "GICv5 USERSPACE_PPIS does not expose SW_PPI");
	TEST_ASSERT(!user_ppis[1], "GICv5 USERSPACE_PPIS upper word is not zero");

	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
				    KVM_DEV_ARM_VGIC_USERSPACE_PPIS, user_ppis);
	TEST_ASSERT(ret && errno == ENXIO, "GICv5 USERSPACE_PPIS set accepted");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
				    KVM_DEV_ARM_VGIC_USERSPACE_PPIS, NULL);
	TEST_ASSERT(ret && errno == EFAULT, "GICv5 USERSPACE_PPIS get with bad pointer");

	vm_gic_destroy(&v);
}

static void test_vgic_v5_cpu_sysreg_attrs(void)
{
	struct kvm_vcpu *vcpu;
	struct vm_gic v;
	u64 attr, val;
	int ret, i;

	v.gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);
	vcpu = vm_vcpu_add(v.vm, 0, NULL);
	TEST_ASSERT(vcpu, "Failed to create vCPU");

	/* Check existing group/attribute */
	attr = PACK_SR(SYS_ICC_CR0_EL1);
	kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS, attr);

	/* CPU sysregs are not accessible before the VGIC is initialized. */
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
				    attr, &val);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 CPU_SYSREGS get before init");

	val = 0;
	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
				    attr, &val);
	TEST_ASSERT(ret && errno == EBUSY, "GICv5 CPU_SYSREGS set before init");

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

	/* Read all exposed CPU sysregs and write the value back. */
	for (i = 0; i < ARRAY_SIZE(gic_v5_cpu_sysregs); i++) {
		attr = PACK_SR(gic_v5_cpu_sysregs[i].encoding);
		ret = __kvm_has_device_attr(v.gic_fd,
					    KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
					    attr);
		TEST_ASSERT(!ret, "GICv5 CPU_SYSREGS missing %s",
			    gic_v5_cpu_sysregs[i].name);

		val = 0xbad;
		ret = __kvm_device_attr_get(v.gic_fd,
					    KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
					    attr, &val);
		TEST_ASSERT(!ret, "GICv5 CPU_SYSREGS get failed for %s",
			    gic_v5_cpu_sysregs[i].name);

		ret = __kvm_device_attr_set(v.gic_fd,
					    KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
					    attr, &val);
		TEST_ASSERT(!ret, "GICv5 CPU_SYSREGS set failed for %s",
			    gic_v5_cpu_sysregs[i].name);
	}

	/* Check non existent GICv3 sysreg */
	attr = PACK_SR(SYS_ICC_CTLR_EL1);
	ret = __kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
				    attr);
	TEST_ASSERT(ret && errno == ENXIO, "GICv5 CPU_SYSREGS accepted bad sysreg");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
				    attr, &val);
	TEST_ASSERT(ret && errno == ENOENT, "GICv5 CPU_SYSREGS get bad sysreg");

	/* Check non existing vCPU */
	attr = PACK_SR(SYS_ICC_CR0_EL1) |
	       (1ULL << KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT);
	ret = __kvm_has_device_attr(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
				    attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 CPU_SYSREGS accepted bad MPIDR");

	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
				    attr, &val);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 CPU_SYSREGS get bad MPIDR");

	/* Check bad user pointers */
	attr = PACK_SR(SYS_ICC_CR0_EL1);
	ret = __kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
				    attr, NULL);
	TEST_ASSERT(ret && errno == EFAULT, "GICv5 CPU_SYSREGS get with bad pointer");

	ret = __kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS,
				    attr, NULL);
	TEST_ASSERT(ret && errno == EFAULT, "GICv5 CPU_SYSREGS set with bad pointer");

	vm_gic_destroy(&v);
}

static void test_vgic_v5_sparse_vcpu_ids(void)
{
	struct kvm_vcpu *vcpus[VGIC_V5_SPARSE_NR_VCPUS];
	const u32 vcpu_ids[VGIC_V5_SPARSE_NR_VCPUS] = {
		VGIC_V5_SPARSE_VCPU0_ID,
		VGIC_V5_SPARSE_VCPU1_ID,
	};
	int ret, i;
	struct ucall uc;
	struct vm_gic v;
	u64 attr;

	v.gic_dev_type = KVM_DEV_TYPE_ARM_VGIC_V5;
	v.vm = __vm_create(VM_SHAPE_DEFAULT, VGIC_V5_SPARSE_NR_VCPUS, 0);
	v.gic_fd = kvm_create_device(v.vm, v.gic_dev_type);

	/* Create two vCPUs with legal, albeit sparse, IDs. */
	for (i = 0; i < ARRAY_SIZE(vcpus); i++) {
		vcpus[i] = vm_vcpu_add(v.vm, vcpu_ids[i], guest_iaffid_code);
		TEST_ASSERT(vcpus[i], "Failed to create vCPU %u", vcpu_ids[i]);
	}

	attr = GICV5_IRS_CONFIG_BASE_GPA;
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
			    KVM_VGIC_V5_ADDR_TYPE_IRS, &attr);
	vgic_v5_map_irs(v.vm);
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_CTRL_INIT, NULL);

	/* Check both are runnable, and read back their correct IAFFIDs */
	for (i = 0; i < ARRAY_SIZE(vcpus); i++) {
		/* IAFFID is the VPE ID and must match the userspace vCPU ID. */
		ret = run_vcpu(vcpus[i]);
		TEST_ASSERT(!ret, "Failed to run GICv5 vCPU %u", vcpu_ids[i]);
		TEST_ASSERT(get_ucall(vcpus[i], &uc) == UCALL_SYNC &&
			    uc.args[1] == vcpu_ids[i],
			    "GICv5 vCPU %u IAFFID mismatch", vcpu_ids[i]);

		ret = run_vcpu(vcpus[i]);
		TEST_ASSERT(!ret, "Failed to complete GICv5 vCPU %u", vcpu_ids[i]);
		TEST_ASSERT(get_ucall(vcpus[i], NULL) == UCALL_DONE,
			    "GICv5 vCPU %u did not complete", vcpu_ids[i]);
	}

	vm_gic_destroy(&v);
}

static void test_vgic_v5_ppis(u32 gic_dev_type)
{
	struct kvm_vcpu *vcpus[NR_VCPUS];
	struct ucall uc;
	u64 user_ppis[2];
	struct vm_gic v;
	uint64_t attr;
	int ret, i;

	v.gic_dev_type = gic_dev_type;
	v.vm = __vm_create(VM_SHAPE_DEFAULT, NR_VCPUS, 0);

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

	for (i = 0; i < NR_VCPUS; i++)
		vcpus[i] = vm_vcpu_add(v.vm, i, guest_code);

	vm_init_descriptor_tables(v.vm);
	vm_install_exception_handler(v.vm, VECTOR_IRQ_CURRENT,
				     guest_ppi_irq_handler);

	for (i = 0; i < NR_VCPUS; i++)
		vcpu_init_descriptor_tables(vcpus[i]);

	/* Set the address of the IRS before initialising the GIC */
	attr = GICV5_IRS_CONFIG_BASE_GPA;
	kvm_device_attr_set(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_ADDR,
			    KVM_VGIC_V5_ADDR_TYPE_IRS, &attr);

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

	/* Read out the PPIs that user space is allowed to drive. */
	kvm_device_attr_get(v.gic_fd, KVM_DEV_ARM_VGIC_GRP_CTRL,
			    KVM_DEV_ARM_VGIC_USERSPACE_PPIS, &user_ppis);

	/* We should always be able to drive the SW_PPI. */
	TEST_ASSERT(user_ppis[0] & BIT(GICV5_ARCH_PPI_SW_PPI),
		"SW_PPI is not drivable by userspace");

	/* PPIs not explicitly exposed to userspace must be rejected. */
	for (i = 0; i < VGIC_V5_NR_PRIVATE_IRQS; i++) {
		if (user_ppis[i / 64] & BIT_ULL(i % 64))
			continue;

		ret = __vgic_v5_irq_line(v.vm, KVM_ARM_IRQ_TYPE_PPI, i, 1);
		TEST_ASSERT(ret && errno == EINVAL,
			    "GICv5 accepted non-userspace PPI %d", i);
	}

	ret = __vgic_v5_irq_line(v.vm, KVM_ARM_IRQ_TYPE_PPI,
				 VGIC_V5_NR_PRIVATE_IRQS, 1);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 accepted out-of-range PPI");

	while (1) {
		ret = run_vcpu(vcpus[0]);
		if (ret)
			break;

		switch (get_ucall(vcpus[0], &uc)) {
		case UCALL_SYNC:
			/*
			 * The guest is ready for the next level change. Set
			 * high if ready, and lower if it has been consumed.
			 */
			if (uc.args[1] == GUEST_CMD_IS_READY ||
			    uc.args[1] == GUEST_CMD_IRQ_DIEOI) {
				u64 irq;
				bool level = uc.args[1] == GUEST_CMD_IRQ_DIEOI ? 0 : 1;

				irq = FIELD_PREP(KVM_ARM_IRQ_NUM_MASK, 3);
				irq |= KVM_ARM_IRQ_TYPE_PPI << KVM_ARM_IRQ_TYPE_SHIFT;

				kvm_irq_line(v.vm, irq, level);
			} else if (uc.args[1] == GUEST_CMD_IS_AWAKE) {
				pr_debug("Guest skipping WFI due to pending IRQ\n");
			} else if (uc.args[1] == GUEST_CMD_IRQ_CDIA) {
				pr_debug("Guest acknowledged IRQ\n");
			}

			continue;
		case UCALL_ABORT:
			REPORT_GUEST_ASSERT(uc);
			break;
		case UCALL_DONE:
			goto done;
		default:
			TEST_FAIL("Unknown ucall %lu", uc.cmd);
		}
	}

done:
	TEST_ASSERT(ret == 0, "Failed to test GICv5 PPIs");

	vm_gic_destroy(&v);
}

static void test_vgic_v5_spis(void)
{
	struct kvm_vcpu *vcpu;
	struct vm_gic v;
	int ret;

	/* Default NR_IRQS exposes 32 SPIs, numbered 0..31 in KVM_IRQ_LINE. */
	vgic_v5_spi_line_vm_create(&v, &vcpu, VGIC_V5_DEFAULT_NR_SPIS);
	ret = __vgic_v5_irq_line(v.vm, KVM_ARM_IRQ_TYPE_SPI,
				 VGIC_V5_DEFAULT_NR_SPIS, 1);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 accepted first invalid SPI");

	vm_gic_destroy(&v);

	/* Basic SPI injection through KVM_IRQ_LINE. */
	vgic_v5_run_spi_line_test(VGIC_V5_DEFAULT_NR_SPIS, 0, false, false);

	/* The last valid SPI in the maximum configured range is injectable. */
	vgic_v5_run_spi_line_test(VGIC_V5_MAX_NR_SPIS,
				  VGIC_V5_MAX_NR_SPIS - 1, false, false);

	vgic_v5_spi_line_vm_create(&v, &vcpu, VGIC_V5_MAX_NR_SPIS);
	ret = __vgic_v5_irq_line(v.vm, KVM_ARM_IRQ_TYPE_SPI,
				 VGIC_V5_MAX_NR_SPIS, 1);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 accepted configured invalid SPI");
	vm_gic_destroy(&v);

	/*
	 * Edge SPIs remain pending after the line is lowered.  The low
	 * transition is injected before the guest runs and must be ignored:
	 * once an edge interrupt is pending, lowering the line cannot recall it.
	 */
	vgic_v5_run_spi_line_test(VGIC_V5_DEFAULT_NR_SPIS, 1, false, true);

	/* Level SPIs can be raised and delivered through KVM_IRQ_LINE. */
	vgic_v5_run_spi_line_test(VGIC_V5_DEFAULT_NR_SPIS, 2, true, false);
}

static void test_vgic_v5_lpis(void)
{
	struct kvm_vcpu *vcpus[VGIC_V5_LPI_NR_VCPUS];
	struct ucall uc;
	struct vm_gic v;
	int ret;

	lpi_ist_ready = false;
	vgic_v5_lpi_vm_create(&v, vcpus);
	sync_global_to_guest(v.vm, lpi_ist_ready);

	/* VPE0 programs a linear LPI IST from the virtual IRS ID registers. */
	ret = run_vcpu(vcpus[0]);
	TEST_ASSERT(!ret, "Failed to run GICv5 LPI vCPU0");
	TEST_ASSERT(get_ucall(vcpus[0], &uc) == UCALL_SYNC &&
		    uc.args[1] == GUEST_CMD_IS_READY,
		    "GICv5 LPI vCPU0 did not become ready");

	/* VPE1 waits for the shared LPI setup and enables its CPU interface. */
	ret = run_vcpu(vcpus[1]);
	TEST_ASSERT(!ret, "Failed to run GICv5 LPI vCPU1");
	TEST_ASSERT(get_ucall(vcpus[1], &uc) == UCALL_SYNC &&
		    uc.args[1] == GUEST_CMD_IS_READY,
		    "GICv5 LPI vCPU1 did not become ready");

	/* VPE0 sends an LPI to VPE1. */
	ret = run_vcpu(vcpus[0]);
	TEST_ASSERT(!ret, "Failed to run GICv5 LPI vCPU0 sender");
	TEST_ASSERT(get_ucall(vcpus[0], &uc) == UCALL_SYNC &&
		    uc.args[1] == GUEST_CMD_LPI_SENT,
		    "GICv5 LPI vCPU0 did not send LPI");

	/* VPE1 consumes the LPI and replies with another LPI. */
	ret = run_vcpu(vcpus[1]);
	TEST_ASSERT(!ret, "Failed to run GICv5 LPI vCPU1 receiver");
	TEST_ASSERT(get_ucall(vcpus[1], &uc) == UCALL_SYNC &&
		    uc.args[1] == GUEST_CMD_LPI_REPLIED,
		    "GICv5 LPI vCPU1 did not reply");

	/* VPE0 consumes the reply LPI and ends the test. */
	ret = run_vcpu(vcpus[0]);
	TEST_ASSERT(!ret, "Failed to run GICv5 LPI vCPU0 receiver");
	TEST_ASSERT(get_ucall(vcpus[0], &uc) == UCALL_DONE,
		    "GICv5 LPI vCPU0 did not complete");

	vm_gic_destroy(&v);
}

static void test_vgic_v5_ist_save_restore(void)
{
	static u32 lpi_ist[VGIC_V5_LPI_IST_SIZE / sizeof(u32)];
	static u32 lpi_ist_resave[VGIC_V5_LPI_IST_SIZE / sizeof(u32)];
	static u32 spi_ist[VGIC_V5_DEFAULT_NR_SPIS];
	static u32 spi_ist_resave[VGIC_V5_DEFAULT_NR_SPIS];
	static u64 irs_regs[ARRAY_SIZE(gic_v5_irs_regs)];
	struct kvm_vcpu *vcpus[VGIC_V5_LPI_NR_VCPUS];
	struct kvm_vgic_v5_ist ist_attr;
	struct vm_gic src, dst;
	u64 ist_baser, bad_ist_baser;
	u64 ist_cfgr, bad_ist_cfgr;
	size_t lpi_ist_size;
	int ret;

	memset(ist_restore_irq_count, 0, sizeof(ist_restore_irq_count));

	vgic_v5_ist_restore_vm_create(&src, vcpus, guest_ist_source_code,
				      guest_unexpected_irq_handler);

	ret = run_vcpu(vcpus[0]);
	TEST_ASSERT(!ret, "Failed to run GICv5 IST save source VM");
	vgic_v5_expect_sync(vcpus[0], GUEST_CMD_IST_SOURCE_READY,
			    "GICv5 IST source guest did not become ready");

	/*
	 * The guest configured enable/priority/affinity state. Make selected
	 * SPIs pending from userspace so the SPI IST save path sees them.
	 */
	vgic_v5_spi_line(src.vm, RESTORE_TEST_SPI_PRIO_HIGH, 1);
	vgic_v5_spi_line(src.vm, RESTORE_TEST_SPI_PRIO_LOW, 1);
	vgic_v5_spi_line(src.vm, RESTORE_TEST_SPI_PENDING_DISABLED, 1);

	vgic_v5_save_irs_regs(&src, irs_regs);
	lpi_ist_size = vgic_v5_lpi_ist_state_size(irs_regs);

	/*
	 * VCPU0 has configured the initial state. KVM must reject missing or
	 * incorrectly sized LPI storage before accepting the complete IST image.
	 */
	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), NULL, 0);
	ret = __kvm_device_attr_get(src.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST save accepted missing LPI buffer");

	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), lpi_ist,
					 lpi_ist_size - sizeof(__u32));
	ret = __kvm_device_attr_get(src.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST save accepted bad LPI size");

	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), lpi_ist,
					 lpi_ist_size);
	ret = __kvm_device_attr_get(src.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(!ret, "GICv5 IST save failed");

	vm_gic_destroy(&src);

	/* Create the guest that we are restoring state into */
	memset(ist_restore_irq_count, 0, sizeof(ist_restore_irq_count));
	vgic_v5_ist_restore_vm_create(&dst, vcpus, guest_ist_restore_code,
				      guest_ist_restore_irq_handler);
	sync_global_to_guest(dst.vm, ist_restore_irq_count);

	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), lpi_ist,
					 lpi_ist_size);
	ret = __kvm_device_attr_set(dst.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST restore before IRS state");

	vgic_v5_restore_irs_regs(&dst, irs_regs);

	/* BASER remains mutable until the host LPI IST has been allocated. */
	ist_baser = vgic_v5_saved_irs_reg(irs_regs, GICV5_IRS_IST_BASER);
	bad_ist_baser = ist_baser ^
			 FIELD_PREP(GICV5_IRS_IST_BASER_ADDR_MASK, 1);
	ret = __kvm_device_attr_set(dst.gic_fd,
				    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_BASER, &bad_ist_baser);
	TEST_ASSERT(!ret, "GICv5 rejected changed unallocated IST_BASER");

	bad_ist_baser = ist_baser & ~GICV5_IRS_IST_BASER_VALID;
	ret = __kvm_device_attr_set(dst.gic_fd,
				    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_BASER, &bad_ist_baser);
	TEST_ASSERT(!ret, "GICv5 rejected invalidated unallocated IST_BASER");

	ret = __kvm_device_attr_set(dst.gic_fd,
				    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_BASER, &ist_baser);
	TEST_ASSERT(!ret, "GICv5 failed to restore IST_BASER");

	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), NULL, 0);
	ret = __kvm_device_attr_set(dst.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST restore accepted missing LPI buffer");

	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), lpi_ist,
					 lpi_ist_size - sizeof(__u32));
	ret = __kvm_device_attr_set(dst.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(ret && errno == EINVAL, "GICv5 IST restore accepted bad LPI size");

	/* Restore the VMM-owned SPI and LPI IST images. */
	ist_attr = vgic_v5_ist_attr(spi_ist, sizeof(spi_ist), lpi_ist,
					 lpi_ist_size);
	ret = __kvm_device_attr_set(dst.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(!ret, "GICv5 IST restore failed");

	/* A live IST makes BASER and the guest-visible configuration immutable. */
	ret = __kvm_device_attr_set(dst.gic_fd,
				    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_BASER, &ist_baser);
	TEST_ASSERT(!ret, "GICv5 rejected unchanged live IST_BASER");

	bad_ist_baser = ist_baser ^
			 FIELD_PREP(GICV5_IRS_IST_BASER_ADDR_MASK, 1);
	ret = __kvm_device_attr_set(dst.gic_fd,
				    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_BASER, &bad_ist_baser);
	TEST_ASSERT(ret && errno == EINVAL,
		    "GICv5 accepted changed live IST_BASER");

	bad_ist_baser = ist_baser & ~GICV5_IRS_IST_BASER_VALID;
	ret = __kvm_device_attr_set(dst.gic_fd,
				    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_BASER, &bad_ist_baser);
	TEST_ASSERT(ret && errno == EINVAL,
		    "GICv5 accepted invalidated live IST_BASER");

	ist_cfgr = vgic_v5_saved_irs_reg(irs_regs, GICV5_IRS_IST_CFGR);
	ret = __kvm_device_attr_set(dst.gic_fd,
				    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_CFGR, &ist_cfgr);
	TEST_ASSERT(!ret, "GICv5 rejected unchanged live IST_CFGR");

	bad_ist_cfgr = ist_cfgr ^
			FIELD_PREP(GICV5_IRS_IST_CFGR_LPI_ID_BITS, 1);
	ret = __kvm_device_attr_set(dst.gic_fd,
				    KVM_DEV_ARM_VGIC_GRP_IRS_REGS,
				    GICV5_IRS_IST_CFGR, &bad_ist_cfgr);
	TEST_ASSERT(ret && errno == EINVAL,
		    "GICv5 accepted changed live IST_CFGR");

	/*
	 * Re-save the restored IST image before the destination VM runs, so a
	 * dropped serialized field fails independently of later interrupt
	 * delivery.
	 */
	ist_attr = vgic_v5_ist_attr(spi_ist_resave, sizeof(spi_ist_resave),
				     lpi_ist_resave, lpi_ist_size);
	ret = __kvm_device_attr_get(dst.gic_fd, KVM_DEV_ARM_VGIC_GRP_IST,
				    0, &ist_attr);
	TEST_ASSERT(!ret, "GICv5 IST re-save failed");
	TEST_ASSERT(!memcmp(spi_ist, spi_ist_resave, sizeof(spi_ist)),
		    "GICv5 SPI IST state changed across restore");
	TEST_ASSERT(!memcmp(lpi_ist, lpi_ist_resave, lpi_ist_size),
		    "GICv5 LPI IST state changed across restore");

	/*
	 * At this stage, the guest's IST state should match what was saved. Run
	 * each vcpu once to let it enable interrupts, etc.
	 */
	ret = run_vcpu(vcpus[0]);
	TEST_ASSERT(!ret, "Failed to run GICv5 IST restore vCPU0");
	vgic_v5_expect_sync(vcpus[0], GUEST_CMD_IS_READY,
			    "GICv5 IST restore vCPU0 did not become ready");

	ret = run_vcpu(vcpus[1]);
	TEST_ASSERT(!ret, "Failed to run GICv5 IST restore vCPU1");
	vgic_v5_expect_sync(vcpus[1], GUEST_CMD_IS_READY,
			    "GICv5 IST restore vCPU1 did not become ready");

	/*
	 * VPE0 consumes two pending SPIs in restored priority order, then
	 * enables a restored pending-but-disabled SPI.
	 */
	ret = run_vcpu(vcpus[0]);
	TEST_ASSERT(!ret, "Failed to consume restored GICv5 SPIs");
	vgic_v5_expect_sync(vcpus[0], GUEST_CMD_IST_SPI_INJECT_READY,
			    "GICv5 IST restore vCPU0 did not consume restored SPIs");

	/*
	 * This SPI was enabled before save, but not pending.  Inject it after
	 * restore to prove enable, priority and affinity were restored.
	 */
	vgic_v5_spi_line(dst.vm, RESTORE_TEST_SPI_ENABLED, 1);

	ret = run_vcpu(vcpus[0]);
	TEST_ASSERT(!ret, "Failed to consume post-restore GICv5 SPI");
	TEST_ASSERT(get_ucall(vcpus[0], NULL) == UCALL_DONE,
		    "GICv5 IST restore vCPU0 did not complete");

	/*
	 * VPE1 consumes a restored pending LPI, then pends another LPI that
	 * was enabled before save but not pending.
	 */
	ret = run_vcpu(vcpus[1]);
	TEST_ASSERT(!ret, "Failed to consume restored GICv5 LPI");
	vgic_v5_expect_sync(vcpus[1], GUEST_CMD_IST_LPI_INJECT_READY,
			    "GICv5 IST restore vCPU1 did not consume restored LPI");

	ret = run_vcpu(vcpus[1]);
	TEST_ASSERT(!ret, "Failed to consume post-restore GICv5 LPI");
	TEST_ASSERT(get_ucall(vcpus[1], NULL) == UCALL_DONE,
		    "GICv5 IST restore vCPU1 did not complete");

	vm_gic_destroy(&dst);
}

/*
 * Returns 0 if it's possible to create GIC device of a given type (V5).
 */
int test_kvm_device(u32 gic_dev_type)
{
	struct kvm_vcpu *vcpus[NR_VCPUS];
	struct vm_gic v;
	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");

	vm_gic_destroy(&v);

	return 0;
}

static void test_vgic_v3_its_with_vgic_v5(void)
{
	struct kvm_vm *vm = vm_create_barebones();
	int gic_fd, its_fd, ret;

	if (__kvm_test_create_device(vm, KVM_DEV_TYPE_ARM_VGIC_ITS)) {
		pr_info("No GICv3 ITS support; skipping mixed-model test.\n");
		kvm_vm_free(vm);
		return;
	}

	gic_fd = kvm_create_device(vm, KVM_DEV_TYPE_ARM_VGIC_V5);
	ret = __kvm_create_device(vm, KVM_DEV_TYPE_ARM_VGIC_ITS);
	TEST_ASSERT(ret < 0 && errno == ENODEV,
		    "GICv3 ITS created after GICv5 VGIC: ret=%d errno=%d",
		    ret, errno);
	close(gic_fd);
	kvm_vm_free(vm);

	vm = vm_create_barebones();
	its_fd = kvm_create_device(vm, KVM_DEV_TYPE_ARM_VGIC_ITS);
	ret = __kvm_create_device(vm, KVM_DEV_TYPE_ARM_VGIC_V5);
	TEST_ASSERT(ret < 0 && errno == ENODEV,
		    "GICv5 VGIC created after GICv3 ITS: ret=%d errno=%d",
		    ret, errno);
	close(its_fd);
	kvm_vm_free(vm);
}

void run_tests(u32 gic_dev_type)
{
	pr_info("Test VGICv5 and GICv3 ITS model mismatch\n");
	test_vgic_v3_its_with_vgic_v5();

	pr_info("Test VGICv5 address attrs\n");
	test_vgic_v5_addr_attrs();

	pr_info("Test VGICv5 NR_IRQS attrs\n");
	test_vgic_v5_nr_irqs_attrs();

	pr_info("Test VGICv5 IRS_REGS attrs\n");
	test_vgic_v5_irs_regs_attrs();

	pr_info("Test VGICv5 IST attrs\n");
	test_vgic_v5_ist_attrs();

	pr_info("Test VGICv5 userspace PPI attrs\n");
	test_vgic_v5_userspace_ppis_attrs();

	pr_info("Test VGICv5 CPU sysreg attrs\n");
	test_vgic_v5_cpu_sysreg_attrs();

	pr_info("Test VGICv5 sparse vCPU IDs\n");
	test_vgic_v5_sparse_vcpu_ids();

	pr_info("Test VGICv5 PPIs\n");
	test_vgic_v5_ppis(gic_dev_type);

	pr_info("Test VGICv5 SPIs\n");
	test_vgic_v5_spis();

	pr_info("Test VGICv5 LPIs\n");
	test_vgic_v5_lpis();

	pr_info("Test VGICv5 IST save/restore\n");
	test_vgic_v5_ist_save_restore();
}

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

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

	test_disable_default_vgic();

	ret = test_kvm_device(KVM_DEV_TYPE_ARM_VGIC_V5);
	if (ret) {
		pr_info("No GICv5 support; Not running GIC_v5 tests.\n");
		exit(KSFT_SKIP);
	}

	pr_info("Running VGIC_V5 tests.\n");
	run_tests(KVM_DEV_TYPE_ARM_VGIC_V5);

	return 0;
}