Quelle  sys_regs.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2012,2013 - ARM Ltd
 * Author: Marc Zyngier <marc.zyngier@arm.com>
 *
 * Derived from arch/arm/kvm/coproc.c:
 * Copyright (C) 2012 - Virtual Open Systems and Columbia University
 * Authors: Rusty Russell <rusty@rustcorp.com.au>
 *          Christoffer Dall <c.dall@virtualopensystems.com>
 */

#include <linux/bitfield.h>
#include <linux/bsearch.h>
#include <linux/cacheinfo.h>
#include <linux/debugfs.h>
#include <linux/kvm_host.h>
#include <linux/mm.h>
#include <linux/printk.h>
#include <linux/uaccess.h>
#include <linux/irqchip/arm-gic-v3.h>

#include <asm/arm_pmuv3.h>
#include <asm/cacheflush.h>
#include <asm/cputype.h>
#include <asm/debug-monitors.h>
#include <asm/esr.h>
#include <asm/kvm_arm.h>
#include <asm/kvm_emulate.h>
#include <asm/kvm_hyp.h>
#include <asm/kvm_mmu.h>
#include <asm/kvm_nested.h>
#include <asm/perf_event.h>
#include <asm/sysreg.h>

#include <trace/events/kvm.h>

#include "sys_regs.h"
#include "vgic/vgic.h"

#include "trace.h"

/*
 * For AArch32, we only take care of what is being trapped. Anything
 * that has to do with init and userspace access has to go via the
 * 64bit interface.
 */

static u64 sys_reg_to_index(const struct sys_reg_desc *reg);
static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
        u64 val);

static bool undef_access(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
    const struct sys_reg_desc *r)
{
 kvm_inject_undefined(vcpu);
 return false;
}

static bool bad_trap(struct kvm_vcpu *vcpu,
       struct sys_reg_params *params,
       const struct sys_reg_desc *r,
       const char *msg)
{
 WARN_ONCE(1, "Unexpected %s\n", msg);
 print_sys_reg_instr(params);
 return undef_access(vcpu, params, r);
}

static bool read_from_write_only(struct kvm_vcpu *vcpu,
     struct sys_reg_params *params,
     const struct sys_reg_desc *r)
{
 return bad_trap(vcpu, params, r,
   "sys_reg read to write-only register");
}

static bool write_to_read_only(struct kvm_vcpu *vcpu,
          struct sys_reg_params *params,
          const struct sys_reg_desc *r)
{
 return bad_trap(vcpu, params, r,
   "sys_reg write to read-only register");
}

enum sr_loc_attr {
 SR_LOC_MEMORY = 0,   /* Register definitely in memory */
 SR_LOC_LOADED = BIT(0), /* Register on CPU, unless it cannot */
 SR_LOC_MAPPED = BIT(1), /* Register in a different CPU register */
 SR_LOC_XLATED = BIT(2), /* Register translated to fit another reg */
 SR_LOC_SPECIAL = BIT(3), /* Demanding register, implies loaded */
};

struct sr_loc {
 enum sr_loc_attr loc;
 enum vcpu_sysreg map_reg;
 u64   (*xlate)(u64);
};

static enum sr_loc_attr locate_direct_register(const struct kvm_vcpu *vcpu,
            enum vcpu_sysreg reg)
{
 switch (reg) {
 case SCTLR_EL1:
 case CPACR_EL1:
 case TTBR0_EL1:
 case TTBR1_EL1:
 case TCR_EL1:
 case TCR2_EL1:
 case PIR_EL1:
 case PIRE0_EL1:
 case POR_EL1:
 case ESR_EL1:
 case AFSR0_EL1:
 case AFSR1_EL1:
 case FAR_EL1:
 case MAIR_EL1:
 case VBAR_EL1:
 case CONTEXTIDR_EL1:
 case AMAIR_EL1:
 case CNTKCTL_EL1:
 case ELR_EL1:
 case SPSR_EL1:
 case ZCR_EL1:
 case SCTLR2_EL1:
  /*
 * EL1 registers which have an ELx2 mapping are loaded if
 * we're not in hypervisor context.
 */
  return is_hyp_ctxt(vcpu) ? SR_LOC_MEMORY : SR_LOC_LOADED;

 case TPIDR_EL0:
 case TPIDRRO_EL0:
 case TPIDR_EL1:
 case PAR_EL1:
 case DACR32_EL2:
 case IFSR32_EL2:
 case DBGVCR32_EL2:
  /* These registers are always loaded, no matter what */
  return SR_LOC_LOADED;

 default:
  /* Non-mapped EL2 registers are by definition in memory. */
  return SR_LOC_MEMORY;
 }
}

static void locate_mapped_el2_register(const struct kvm_vcpu *vcpu,
           enum vcpu_sysreg reg,
           enum vcpu_sysreg map_reg,
           u64 (*xlate)(u64),
           struct sr_loc *loc)
{
 if (!is_hyp_ctxt(vcpu)) {
  loc->loc = SR_LOC_MEMORY;
  return;
 }

 loc->loc = SR_LOC_LOADED | SR_LOC_MAPPED;
 loc->map_reg = map_reg;

 WARN_ON(locate_direct_register(vcpu, map_reg) != SR_LOC_MEMORY);

 if (xlate != NULL && !vcpu_el2_e2h_is_set(vcpu)) {
  loc->loc |= SR_LOC_XLATED;
  loc->xlate = xlate;
 }
}

#define MAPPED_EL2_SYSREG(r, m, t)     \
 case r: {       \
  locate_mapped_el2_register(vcpu, r, m, t, loc);  \
  break;       \
 }

static void locate_register(const struct kvm_vcpu *vcpu, enum vcpu_sysreg reg,
       struct sr_loc *loc)
{
 if (!vcpu_get_flag(vcpu, SYSREGS_ON_CPU)) {
  loc->loc = SR_LOC_MEMORY;
  return;
 }

 switch (reg) {
  MAPPED_EL2_SYSREG(SCTLR_EL2,   SCTLR_EL1,
      translate_sctlr_el2_to_sctlr_el1      );
  MAPPED_EL2_SYSREG(CPTR_EL2,    CPACR_EL1,
      translate_cptr_el2_to_cpacr_el1      );
  MAPPED_EL2_SYSREG(TTBR0_EL2,   TTBR0_EL1,
      translate_ttbr0_el2_to_ttbr0_el1      );
  MAPPED_EL2_SYSREG(TTBR1_EL2,   TTBR1_EL1,   NULL      );
  MAPPED_EL2_SYSREG(TCR_EL2,     TCR_EL1,
      translate_tcr_el2_to_tcr_el1       );
  MAPPED_EL2_SYSREG(VBAR_EL2,    VBAR_EL1,    NULL      );
  MAPPED_EL2_SYSREG(AFSR0_EL2,   AFSR0_EL1,   NULL      );
  MAPPED_EL2_SYSREG(AFSR1_EL2,   AFSR1_EL1,   NULL      );
  MAPPED_EL2_SYSREG(ESR_EL2,     ESR_EL1,     NULL      );
  MAPPED_EL2_SYSREG(FAR_EL2,     FAR_EL1,     NULL      );
  MAPPED_EL2_SYSREG(MAIR_EL2,    MAIR_EL1,    NULL      );
  MAPPED_EL2_SYSREG(TCR2_EL2,    TCR2_EL1,    NULL      );
  MAPPED_EL2_SYSREG(PIR_EL2,     PIR_EL1,     NULL      );
  MAPPED_EL2_SYSREG(PIRE0_EL2,   PIRE0_EL1,   NULL      );
  MAPPED_EL2_SYSREG(POR_EL2,     POR_EL1,     NULL      );
  MAPPED_EL2_SYSREG(AMAIR_EL2,   AMAIR_EL1,   NULL      );
  MAPPED_EL2_SYSREG(ELR_EL2,     ELR_EL1,     NULL      );
  MAPPED_EL2_SYSREG(SPSR_EL2,    SPSR_EL1,    NULL      );
  MAPPED_EL2_SYSREG(ZCR_EL2,     ZCR_EL1,     NULL      );
  MAPPED_EL2_SYSREG(CONTEXTIDR_EL2, CONTEXTIDR_EL1, NULL      );
  MAPPED_EL2_SYSREG(SCTLR2_EL2,  SCTLR2_EL1,  NULL      );
 case CNTHCTL_EL2:
  /* CNTHCTL_EL2 is super special, until we support NV2.1 */
  loc->loc = ((is_hyp_ctxt(vcpu) && vcpu_el2_e2h_is_set(vcpu)) ?
       SR_LOC_SPECIAL : SR_LOC_MEMORY);
  break;
 default:
  loc->loc = locate_direct_register(vcpu, reg);
 }
}

static u64 read_sr_from_cpu(enum vcpu_sysreg reg)
{
 u64 val = 0x8badf00d8badf00d;

 switch (reg) {
 case SCTLR_EL1:  val = read_sysreg_s(SYS_SCTLR_EL12); break;
 case CPACR_EL1:  val = read_sysreg_s(SYS_CPACR_EL12); break;
 case TTBR0_EL1:  val = read_sysreg_s(SYS_TTBR0_EL12); break;
 case TTBR1_EL1:  val = read_sysreg_s(SYS_TTBR1_EL12); break;
 case TCR_EL1:  val = read_sysreg_s(SYS_TCR_EL12); break;
 case TCR2_EL1:  val = read_sysreg_s(SYS_TCR2_EL12); break;
 case PIR_EL1:  val = read_sysreg_s(SYS_PIR_EL12); break;
 case PIRE0_EL1:  val = read_sysreg_s(SYS_PIRE0_EL12); break;
 case POR_EL1:  val = read_sysreg_s(SYS_POR_EL12); break;
 case ESR_EL1:  val = read_sysreg_s(SYS_ESR_EL12); break;
 case AFSR0_EL1:  val = read_sysreg_s(SYS_AFSR0_EL12); break;
 case AFSR1_EL1:  val = read_sysreg_s(SYS_AFSR1_EL12); break;
 case FAR_EL1:  val = read_sysreg_s(SYS_FAR_EL12); break;
 case MAIR_EL1:  val = read_sysreg_s(SYS_MAIR_EL12); break;
 case VBAR_EL1:  val = read_sysreg_s(SYS_VBAR_EL12); break;
 case CONTEXTIDR_EL1: val = read_sysreg_s(SYS_CONTEXTIDR_EL12);break;
 case AMAIR_EL1:  val = read_sysreg_s(SYS_AMAIR_EL12); break;
 case CNTKCTL_EL1: val = read_sysreg_s(SYS_CNTKCTL_EL12); break;
 case ELR_EL1:  val = read_sysreg_s(SYS_ELR_EL12); break;
 case SPSR_EL1:  val = read_sysreg_s(SYS_SPSR_EL12); break;
 case ZCR_EL1:  val = read_sysreg_s(SYS_ZCR_EL12); break;
 case SCTLR2_EL1: val = read_sysreg_s(SYS_SCTLR2_EL12); break;
 case TPIDR_EL0:  val = read_sysreg_s(SYS_TPIDR_EL0); break;
 case TPIDRRO_EL0: val = read_sysreg_s(SYS_TPIDRRO_EL0); break;
 case TPIDR_EL1:  val = read_sysreg_s(SYS_TPIDR_EL1); break;
 case PAR_EL1:  val = read_sysreg_par();  break;
 case DACR32_EL2: val = read_sysreg_s(SYS_DACR32_EL2); break;
 case IFSR32_EL2: val = read_sysreg_s(SYS_IFSR32_EL2); break;
 case DBGVCR32_EL2: val = read_sysreg_s(SYS_DBGVCR32_EL2); break;
 default:  WARN_ON_ONCE(1);
 }

 return val;
}

static void write_sr_to_cpu(enum vcpu_sysreg reg, u64 val)
{
 switch (reg) {
 case SCTLR_EL1:  write_sysreg_s(val, SYS_SCTLR_EL12); break;
 case CPACR_EL1:  write_sysreg_s(val, SYS_CPACR_EL12); break;
 case TTBR0_EL1:  write_sysreg_s(val, SYS_TTBR0_EL12); break;
 case TTBR1_EL1:  write_sysreg_s(val, SYS_TTBR1_EL12); break;
 case TCR_EL1:  write_sysreg_s(val, SYS_TCR_EL12); break;
 case TCR2_EL1:  write_sysreg_s(val, SYS_TCR2_EL12); break;
 case PIR_EL1:  write_sysreg_s(val, SYS_PIR_EL12); break;
 case PIRE0_EL1:  write_sysreg_s(val, SYS_PIRE0_EL12); break;
 case POR_EL1:  write_sysreg_s(val, SYS_POR_EL12); break;
 case ESR_EL1:  write_sysreg_s(val, SYS_ESR_EL12); break;
 case AFSR0_EL1:  write_sysreg_s(val, SYS_AFSR0_EL12); break;
 case AFSR1_EL1:  write_sysreg_s(val, SYS_AFSR1_EL12); break;
 case FAR_EL1:  write_sysreg_s(val, SYS_FAR_EL12); break;
 case MAIR_EL1:  write_sysreg_s(val, SYS_MAIR_EL12); break;
 case VBAR_EL1:  write_sysreg_s(val, SYS_VBAR_EL12); break;
 case CONTEXTIDR_EL1: write_sysreg_s(val, SYS_CONTEXTIDR_EL12);break;
 case AMAIR_EL1:  write_sysreg_s(val, SYS_AMAIR_EL12); break;
 case CNTKCTL_EL1: write_sysreg_s(val, SYS_CNTKCTL_EL12); break;
 case ELR_EL1:  write_sysreg_s(val, SYS_ELR_EL12); break;
 case SPSR_EL1:  write_sysreg_s(val, SYS_SPSR_EL12); break;
 case ZCR_EL1:  write_sysreg_s(val, SYS_ZCR_EL12); break;
 case SCTLR2_EL1: write_sysreg_s(val, SYS_SCTLR2_EL12); break;
 case TPIDR_EL0:  write_sysreg_s(val, SYS_TPIDR_EL0); break;
 case TPIDRRO_EL0: write_sysreg_s(val, SYS_TPIDRRO_EL0); break;
 case TPIDR_EL1:  write_sysreg_s(val, SYS_TPIDR_EL1); break;
 case PAR_EL1:  write_sysreg_s(val, SYS_PAR_EL1); break;
 case DACR32_EL2: write_sysreg_s(val, SYS_DACR32_EL2); break;
 case IFSR32_EL2: write_sysreg_s(val, SYS_IFSR32_EL2); break;
 case DBGVCR32_EL2: write_sysreg_s(val, SYS_DBGVCR32_EL2); break;
 default:  WARN_ON_ONCE(1);
 }
}

u64 vcpu_read_sys_reg(const struct kvm_vcpu *vcpu, enum vcpu_sysreg reg)
{
 struct sr_loc loc = {};

 locate_register(vcpu, reg, &loc);

 WARN_ON_ONCE(!has_vhe() && loc.loc != SR_LOC_MEMORY);

 if (loc.loc & SR_LOC_SPECIAL) {
  u64 val;

  WARN_ON_ONCE(loc.loc & ~SR_LOC_SPECIAL);

  /*
 * CNTHCTL_EL2 requires some special treatment to account
 * for the bits that can be set via CNTKCTL_EL1 when E2H==1.
 */
  switch (reg) {
  case CNTHCTL_EL2:
   val = read_sysreg_el1(SYS_CNTKCTL);
   val &= CNTKCTL_VALID_BITS;
   val |= __vcpu_sys_reg(vcpu, reg) & ~CNTKCTL_VALID_BITS;
   return val;
  default:
   WARN_ON_ONCE(1);
  }
 }

 if (loc.loc & SR_LOC_LOADED) {
  enum vcpu_sysreg map_reg = reg;

  if (loc.loc & SR_LOC_MAPPED)
   map_reg = loc.map_reg;

  if (!(loc.loc & SR_LOC_XLATED)) {
   u64 val = read_sr_from_cpu(map_reg);

   if (reg >= __SANITISED_REG_START__)
    val = kvm_vcpu_apply_reg_masks(vcpu, reg, val);

   return val;
  }
 }

 return __vcpu_sys_reg(vcpu, reg);
}

void vcpu_write_sys_reg(struct kvm_vcpu *vcpu, u64 val, enum vcpu_sysreg reg)
{
 struct sr_loc loc = {};

 locate_register(vcpu, reg, &loc);

 WARN_ON_ONCE(!has_vhe() && loc.loc != SR_LOC_MEMORY);

 if (loc.loc & SR_LOC_SPECIAL) {

  WARN_ON_ONCE(loc.loc & ~SR_LOC_SPECIAL);

  switch (reg) {
  case CNTHCTL_EL2:
   /*
 * If E2H=1, some of the bits are backed by
 * CNTKCTL_EL1, while the rest is kept in memory.
 * Yes, this is fun stuff.
 */
   write_sysreg_el1(val, SYS_CNTKCTL);
   break;
  default:
   WARN_ON_ONCE(1);
  }
 }

 if (loc.loc & SR_LOC_LOADED) {
  enum vcpu_sysreg map_reg = reg;
  u64 xlated_val;

  if (reg >= __SANITISED_REG_START__)
   val = kvm_vcpu_apply_reg_masks(vcpu, reg, val);

  if (loc.loc & SR_LOC_MAPPED)
   map_reg = loc.map_reg;

  if (loc.loc & SR_LOC_XLATED)
   xlated_val = loc.xlate(val);
  else
   xlated_val = val;

  write_sr_to_cpu(map_reg, xlated_val);

  /*
 * Fall through to write the backing store anyway, which
 * allows translated registers to be directly read without a
 * reverse translation.
 */
 }

 __vcpu_assign_sys_reg(vcpu, reg, val);
}

/* CSSELR values; used to index KVM_REG_ARM_DEMUX_ID_CCSIDR */
#define CSSELR_MAX 14

/*
 * Returns the minimum line size for the selected cache, expressed as
 * Log2(bytes).
 */
static u8 get_min_cache_line_size(bool icache)
{
 u64 ctr = read_sanitised_ftr_reg(SYS_CTR_EL0);
 u8 field;

 if (icache)
  field = SYS_FIELD_GET(CTR_EL0, IminLine, ctr);
 else
  field = SYS_FIELD_GET(CTR_EL0, DminLine, ctr);

 /*
 * Cache line size is represented as Log2(words) in CTR_EL0.
 * Log2(bytes) can be derived with the following:
 *
 * Log2(words) + 2 = Log2(bytes / 4) + 2
 *     = Log2(bytes) - 2 + 2
 *     = Log2(bytes)
 */
 return field + 2;
}

/* Which cache CCSIDR represents depends on CSSELR value. */
static u32 get_ccsidr(struct kvm_vcpu *vcpu, u32 csselr)
{
 u8 line_size;

 if (vcpu->arch.ccsidr)
  return vcpu->arch.ccsidr[csselr];

 line_size = get_min_cache_line_size(csselr & CSSELR_EL1_InD);

 /*
 * Fabricate a CCSIDR value as the overriding value does not exist.
 * The real CCSIDR value will not be used as it can vary by the
 * physical CPU which the vcpu currently resides in.
 *
 * The line size is determined with get_min_cache_line_size(), which
 * should be valid for all CPUs even if they have different cache
 * configuration.
 *
 * The associativity bits are cleared, meaning the geometry of all data
 * and unified caches (which are guaranteed to be PIPT and thus
 * non-aliasing) are 1 set and 1 way.
 * Guests should not be doing cache operations by set/way at all, and
 * for this reason, we trap them and attempt to infer the intent, so
 * that we can flush the entire guest's address space at the appropriate
 * time. The exposed geometry minimizes the number of the traps.
 * [If guests should attempt to infer aliasing properties from the
 * geometry (which is not permitted by the architecture), they would
 * only do so for virtually indexed caches.]
 *
 * We don't check if the cache level exists as it is allowed to return
 * an UNKNOWN value if not.
 */
 return SYS_FIELD_PREP(CCSIDR_EL1, LineSize, line_size - 4);
}

static int set_ccsidr(struct kvm_vcpu *vcpu, u32 csselr, u32 val)
{
 u8 line_size = FIELD_GET(CCSIDR_EL1_LineSize, val) + 4;
 u32 *ccsidr = vcpu->arch.ccsidr;
 u32 i;

 if ((val & CCSIDR_EL1_RES0) ||
     line_size < get_min_cache_line_size(csselr & CSSELR_EL1_InD))
  return -EINVAL;

 if (!ccsidr) {
  if (val == get_ccsidr(vcpu, csselr))
   return 0;

  ccsidr = kmalloc_array(CSSELR_MAX, sizeof(u32), GFP_KERNEL_ACCOUNT);
  if (!ccsidr)
   return -ENOMEM;

  for (i = 0; i < CSSELR_MAX; i++)
   ccsidr[i] = get_ccsidr(vcpu, i);

  vcpu->arch.ccsidr = ccsidr;
 }

 ccsidr[csselr] = val;

 return 0;
}

static bool access_rw(struct kvm_vcpu *vcpu,
        struct sys_reg_params *p,
        const struct sys_reg_desc *r)
{
 if (p->is_write)
  vcpu_write_sys_reg(vcpu, p->regval, r->reg);
 else
  p->regval = vcpu_read_sys_reg(vcpu, r->reg);

 return true;
}

/*
 * See note at ARMv7 ARM B1.14.4 (TL;DR: S/W ops are not easily virtualized).
 */
static bool access_dcsw(struct kvm_vcpu *vcpu,
   struct sys_reg_params *p,
   const struct sys_reg_desc *r)
{
 if (!p->is_write)
  return read_from_write_only(vcpu, p, r);

 /*
 * Only track S/W ops if we don't have FWB. It still indicates
 * that the guest is a bit broken (S/W operations should only
 * be done by firmware, knowing that there is only a single
 * CPU left in the system, and certainly not from non-secure
 * software).
 */
 if (!cpus_have_final_cap(ARM64_HAS_STAGE2_FWB))
  kvm_set_way_flush(vcpu);

 return true;
}

static bool access_dcgsw(struct kvm_vcpu *vcpu,
    struct sys_reg_params *p,
    const struct sys_reg_desc *r)
{
 if (!kvm_has_mte(vcpu->kvm))
  return undef_access(vcpu, p, r);

 /* Treat MTE S/W ops as we treat the classic ones: with contempt */
 return access_dcsw(vcpu, p, r);
}

static void get_access_mask(const struct sys_reg_desc *r, u64 *mask, u64 *shift)
{
 switch (r->aarch32_map) {
 case AA32_LO:
  *mask = GENMASK_ULL(31, 0);
  *shift = 0;
  break;
 case AA32_HI:
  *mask = GENMASK_ULL(63, 32);
  *shift = 32;
  break;
 default:
  *mask = GENMASK_ULL(63, 0);
  *shift = 0;
  break;
 }
}

/*
 * Generic accessor for VM registers. Only called as long as HCR_TVM
 * is set. If the guest enables the MMU, we stop trapping the VM
 * sys_regs and leave it in complete control of the caches.
 */
static bool access_vm_reg(struct kvm_vcpu *vcpu,
     struct sys_reg_params *p,
     const struct sys_reg_desc *r)
{
 bool was_enabled = vcpu_has_cache_enabled(vcpu);
 u64 val, mask, shift;

 BUG_ON(!p->is_write);

 get_access_mask(r, &mask, &shift);

 if (~mask) {
  val = vcpu_read_sys_reg(vcpu, r->reg);
  val &= ~mask;
 } else {
  val = 0;
 }

 val |= (p->regval & (mask >> shift)) << shift;
 vcpu_write_sys_reg(vcpu, val, r->reg);

 kvm_toggle_cache(vcpu, was_enabled);
 return true;
}

static bool access_actlr(struct kvm_vcpu *vcpu,
    struct sys_reg_params *p,
    const struct sys_reg_desc *r)
{
 u64 mask, shift;

 if (p->is_write)
  return ignore_write(vcpu, p);

 get_access_mask(r, &mask, &shift);
 p->regval = (vcpu_read_sys_reg(vcpu, r->reg) & mask) >> shift;

 return true;
}

/*
 * Trap handler for the GICv3 SGI generation system register.
 * Forward the request to the VGIC emulation.
 * The cp15_64 code makes sure this automatically works
 * for both AArch64 and AArch32 accesses.
 */
static bool access_gic_sgi(struct kvm_vcpu *vcpu,
      struct sys_reg_params *p,
      const struct sys_reg_desc *r)
{
 bool g1;

 if (!kvm_has_gicv3(vcpu->kvm))
  return undef_access(vcpu, p, r);

 if (!p->is_write)
  return read_from_write_only(vcpu, p, r);

 /*
 * In a system where GICD_CTLR.DS=1, a ICC_SGI0R_EL1 access generates
 * Group0 SGIs only, while ICC_SGI1R_EL1 can generate either group,
 * depending on the SGI configuration. ICC_ASGI1R_EL1 is effectively
 * equivalent to ICC_SGI0R_EL1, as there is no "alternative" secure
 * group.
 */
 if (p->Op0 == 0) {  /* AArch32 */
  switch (p->Op1) {
  default:  /* Keep GCC quiet */
  case 0:   /* ICC_SGI1R */
   g1 = true;
   break;
  case 1:   /* ICC_ASGI1R */
  case 2:   /* ICC_SGI0R */
   g1 = false;
   break;
  }
 } else {   /* AArch64 */
  switch (p->Op2) {
  default:  /* Keep GCC quiet */
  case 5:   /* ICC_SGI1R_EL1 */
   g1 = true;
   break;
  case 6:   /* ICC_ASGI1R_EL1 */
  case 7:   /* ICC_SGI0R_EL1 */
   g1 = false;
   break;
  }
 }

 vgic_v3_dispatch_sgi(vcpu, p->regval, g1);

 return true;
}

static bool access_gic_sre(struct kvm_vcpu *vcpu,
      struct sys_reg_params *p,
      const struct sys_reg_desc *r)
{
 if (!kvm_has_gicv3(vcpu->kvm))
  return undef_access(vcpu, p, r);

 if (p->is_write)
  return ignore_write(vcpu, p);

 if (p->Op1 == 4) { /* ICC_SRE_EL2 */
  p->regval = KVM_ICC_SRE_EL2;
 } else {  /* ICC_SRE_EL1 */
  p->regval = vcpu->arch.vgic_cpu.vgic_v3.vgic_sre;
 }

 return true;
}

static bool trap_raz_wi(struct kvm_vcpu *vcpu,
   struct sys_reg_params *p,
   const struct sys_reg_desc *r)
{
 if (p->is_write)
  return ignore_write(vcpu, p);
 else
  return read_zero(vcpu, p);
}

/*
 * ARMv8.1 mandates at least a trivial LORegion implementation, where all the
 * RW registers are RES0 (which we can implement as RAZ/WI). On an ARMv8.0
 * system, these registers should UNDEF. LORID_EL1 being a RO register, we
 * treat it separately.
 */
static bool trap_loregion(struct kvm_vcpu *vcpu,
     struct sys_reg_params *p,
     const struct sys_reg_desc *r)
{
 u32 sr = reg_to_encoding(r);

 if (!kvm_has_feat(vcpu->kvm, ID_AA64MMFR1_EL1, LO, IMP))
  return undef_access(vcpu, p, r);

 if (p->is_write && sr == SYS_LORID_EL1)
  return write_to_read_only(vcpu, p, r);

 return trap_raz_wi(vcpu, p, r);
}

static bool trap_oslar_el1(struct kvm_vcpu *vcpu,
      struct sys_reg_params *p,
      const struct sys_reg_desc *r)
{
 if (!p->is_write)
  return read_from_write_only(vcpu, p, r);

 kvm_debug_handle_oslar(vcpu, p->regval);
 return true;
}

static bool trap_oslsr_el1(struct kvm_vcpu *vcpu,
      struct sys_reg_params *p,
      const struct sys_reg_desc *r)
{
 if (p->is_write)
  return write_to_read_only(vcpu, p, r);

 p->regval = __vcpu_sys_reg(vcpu, r->reg);
 return true;
}

static int set_oslsr_el1(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
    u64 val)
{
 /*
 * The only modifiable bit is the OSLK bit. Refuse the write if
 * userspace attempts to change any other bit in the register.
 */
 if ((val ^ rd->val) & ~OSLSR_EL1_OSLK)
  return -EINVAL;

 __vcpu_assign_sys_reg(vcpu, rd->reg, val);
 return 0;
}

static bool trap_dbgauthstatus_el1(struct kvm_vcpu *vcpu,
       struct sys_reg_params *p,
       const struct sys_reg_desc *r)
{
 if (p->is_write) {
  return ignore_write(vcpu, p);
 } else {
  p->regval = read_sysreg(dbgauthstatus_el1);
  return true;
 }
}

static bool trap_debug_regs(struct kvm_vcpu *vcpu,
       struct sys_reg_params *p,
       const struct sys_reg_desc *r)
{
 access_rw(vcpu, p, r);

 kvm_debug_set_guest_ownership(vcpu);
 return true;
}

/*
 * reg_to_dbg/dbg_to_reg
 *
 * A 32 bit write to a debug register leave top bits alone
 * A 32 bit read from a debug register only returns the bottom bits
 */
static void reg_to_dbg(struct kvm_vcpu *vcpu,
         struct sys_reg_params *p,
         const struct sys_reg_desc *rd,
         u64 *dbg_reg)
{
 u64 mask, shift, val;

 get_access_mask(rd, &mask, &shift);

 val = *dbg_reg;
 val &= ~mask;
 val |= (p->regval & (mask >> shift)) << shift;
 *dbg_reg = val;
}

static void dbg_to_reg(struct kvm_vcpu *vcpu,
         struct sys_reg_params *p,
         const struct sys_reg_desc *rd,
         u64 *dbg_reg)
{
 u64 mask, shift;

 get_access_mask(rd, &mask, &shift);
 p->regval = (*dbg_reg & mask) >> shift;
}

static u64 *demux_wb_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd)
{
 struct kvm_guest_debug_arch *dbg = &vcpu->arch.vcpu_debug_state;

 switch (rd->Op2) {
 case 0b100:
  return &dbg->dbg_bvr[rd->CRm];
 case 0b101:
  return &dbg->dbg_bcr[rd->CRm];
 case 0b110:
  return &dbg->dbg_wvr[rd->CRm];
 case 0b111:
  return &dbg->dbg_wcr[rd->CRm];
 default:
  KVM_BUG_ON(1, vcpu->kvm);
  return NULL;
 }
}

static bool trap_dbg_wb_reg(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
       const struct sys_reg_desc *rd)
{
 u64 *reg = demux_wb_reg(vcpu, rd);

 if (!reg)
  return false;

 if (p->is_write)
  reg_to_dbg(vcpu, p, rd, reg);
 else
  dbg_to_reg(vcpu, p, rd, reg);

 kvm_debug_set_guest_ownership(vcpu);
 return true;
}

static int set_dbg_wb_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
     u64 val)
{
 u64 *reg = demux_wb_reg(vcpu, rd);

 if (!reg)
  return -EINVAL;

 *reg = val;
 return 0;
}

static int get_dbg_wb_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
     u64 *val)
{
 u64 *reg = demux_wb_reg(vcpu, rd);

 if (!reg)
  return -EINVAL;

 *val = *reg;
 return 0;
}

static u64 reset_dbg_wb_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd)
{
 u64 *reg = demux_wb_reg(vcpu, rd);

 /*
 * Bail early if we couldn't find storage for the register, the
 * KVM_BUG_ON() in demux_wb_reg() will prevent this VM from ever
 * being run.
 */
 if (!reg)
  return 0;

 *reg = rd->val;
 return rd->val;
}

static u64 reset_amair_el1(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 u64 amair = read_sysreg(amair_el1);
 vcpu_write_sys_reg(vcpu, amair, AMAIR_EL1);
 return amair;
}

static u64 reset_actlr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 u64 actlr = read_sysreg(actlr_el1);
 vcpu_write_sys_reg(vcpu, actlr, ACTLR_EL1);
 return actlr;
}

static u64 reset_mpidr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 u64 mpidr;

 /*
 * Map the vcpu_id into the first three affinity level fields of
 * the MPIDR. We limit the number of VCPUs in level 0 due to a
 * limitation to 16 CPUs in that level in the ICC_SGIxR registers
 * of the GICv3 to be able to address each CPU directly when
 * sending IPIs.
 */
 mpidr = (vcpu->vcpu_id & 0x0f) << MPIDR_LEVEL_SHIFT(0);
 mpidr |= ((vcpu->vcpu_id >> 4) & 0xff) << MPIDR_LEVEL_SHIFT(1);
 mpidr |= ((vcpu->vcpu_id >> 12) & 0xff) << MPIDR_LEVEL_SHIFT(2);
 mpidr |= (1ULL << 31);
 vcpu_write_sys_reg(vcpu, mpidr, MPIDR_EL1);

 return mpidr;
}

static unsigned int hidden_visibility(const struct kvm_vcpu *vcpu,
          const struct sys_reg_desc *r)
{
 return REG_HIDDEN;
}

static unsigned int pmu_visibility(const struct kvm_vcpu *vcpu,
       const struct sys_reg_desc *r)
{
 if (kvm_vcpu_has_pmu(vcpu))
  return 0;

 return REG_HIDDEN;
}

static u64 reset_pmu_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 u64 mask = BIT(ARMV8_PMU_CYCLE_IDX);
 u8 n = vcpu->kvm->arch.nr_pmu_counters;

 if (n)
  mask |= GENMASK(n - 1, 0);

 reset_unknown(vcpu, r);
 __vcpu_rmw_sys_reg(vcpu, r->reg, &=, mask);

 return __vcpu_sys_reg(vcpu, r->reg);
}

static u64 reset_pmevcntr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 reset_unknown(vcpu, r);
 __vcpu_rmw_sys_reg(vcpu, r->reg, &=, GENMASK(31, 0));

 return __vcpu_sys_reg(vcpu, r->reg);
}

static u64 reset_pmevtyper(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 /* This thing will UNDEF, who cares about the reset value? */
 if (!kvm_vcpu_has_pmu(vcpu))
  return 0;

 reset_unknown(vcpu, r);
 __vcpu_rmw_sys_reg(vcpu, r->reg, &=, kvm_pmu_evtyper_mask(vcpu->kvm));

 return __vcpu_sys_reg(vcpu, r->reg);
}

static u64 reset_pmselr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 reset_unknown(vcpu, r);
 __vcpu_rmw_sys_reg(vcpu, r->reg, &=, PMSELR_EL0_SEL_MASK);

 return __vcpu_sys_reg(vcpu, r->reg);
}

static u64 reset_pmcr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 u64 pmcr = 0;

 if (!kvm_supports_32bit_el0())
  pmcr |= ARMV8_PMU_PMCR_LC;

 /*
 * The value of PMCR.N field is included when the
 * vCPU register is read via kvm_vcpu_read_pmcr().
 */
 __vcpu_assign_sys_reg(vcpu, r->reg, pmcr);

 return __vcpu_sys_reg(vcpu, r->reg);
}

static bool check_pmu_access_disabled(struct kvm_vcpu *vcpu, u64 flags)
{
 u64 reg = __vcpu_sys_reg(vcpu, PMUSERENR_EL0);
 bool enabled = (reg & flags) || vcpu_mode_priv(vcpu);

 if (!enabled)
  kvm_inject_undefined(vcpu);

 return !enabled;
}

static bool pmu_access_el0_disabled(struct kvm_vcpu *vcpu)
{
 return check_pmu_access_disabled(vcpu, ARMV8_PMU_USERENR_EN);
}

static bool pmu_write_swinc_el0_disabled(struct kvm_vcpu *vcpu)
{
 return check_pmu_access_disabled(vcpu, ARMV8_PMU_USERENR_SW | ARMV8_PMU_USERENR_EN);
}

static bool pmu_access_cycle_counter_el0_disabled(struct kvm_vcpu *vcpu)
{
 return check_pmu_access_disabled(vcpu, ARMV8_PMU_USERENR_CR | ARMV8_PMU_USERENR_EN);
}

static bool pmu_access_event_counter_el0_disabled(struct kvm_vcpu *vcpu)
{
 return check_pmu_access_disabled(vcpu, ARMV8_PMU_USERENR_ER | ARMV8_PMU_USERENR_EN);
}

static bool access_pmcr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
   const struct sys_reg_desc *r)
{
 u64 val;

 if (pmu_access_el0_disabled(vcpu))
  return false;

 if (p->is_write) {
  /*
 * Only update writeable bits of PMCR (continuing into
 * kvm_pmu_handle_pmcr() as well)
 */
  val = kvm_vcpu_read_pmcr(vcpu);
  val &= ~ARMV8_PMU_PMCR_MASK;
  val |= p->regval & ARMV8_PMU_PMCR_MASK;
  if (!kvm_supports_32bit_el0())
   val |= ARMV8_PMU_PMCR_LC;
  kvm_pmu_handle_pmcr(vcpu, val);
 } else {
  /* PMCR.P & PMCR.C are RAZ */
  val = kvm_vcpu_read_pmcr(vcpu)
        & ~(ARMV8_PMU_PMCR_P | ARMV8_PMU_PMCR_C);
  p->regval = val;
 }

 return true;
}

static bool access_pmselr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
     const struct sys_reg_desc *r)
{
 if (pmu_access_event_counter_el0_disabled(vcpu))
  return false;

 if (p->is_write)
  __vcpu_assign_sys_reg(vcpu, PMSELR_EL0, p->regval);
 else
  /* return PMSELR.SEL field */
  p->regval = __vcpu_sys_reg(vcpu, PMSELR_EL0)
       & PMSELR_EL0_SEL_MASK;

 return true;
}

static bool access_pmceid(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
     const struct sys_reg_desc *r)
{
 u64 pmceid, mask, shift;

 BUG_ON(p->is_write);

 if (pmu_access_el0_disabled(vcpu))
  return false;

 get_access_mask(r, &mask, &shift);

 pmceid = kvm_pmu_get_pmceid(vcpu, (p->Op2 & 1));
 pmceid &= mask;
 pmceid >>= shift;

 p->regval = pmceid;

 return true;
}

static bool pmu_counter_idx_valid(struct kvm_vcpu *vcpu, u64 idx)
{
 u64 pmcr, val;

 pmcr = kvm_vcpu_read_pmcr(vcpu);
 val = FIELD_GET(ARMV8_PMU_PMCR_N, pmcr);
 if (idx >= val && idx != ARMV8_PMU_CYCLE_IDX) {
  kvm_inject_undefined(vcpu);
  return false;
 }

 return true;
}

static int get_pmu_evcntr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,
     u64 *val)
{
 u64 idx;

 if (r->CRn == 9 && r->CRm == 13 && r->Op2 == 0)
  /* PMCCNTR_EL0 */
  idx = ARMV8_PMU_CYCLE_IDX;
 else
  /* PMEVCNTRn_EL0 */
  idx = ((r->CRm & 3) << 3) | (r->Op2 & 7);

 *val = kvm_pmu_get_counter_value(vcpu, idx);
 return 0;
}

static int set_pmu_evcntr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,
     u64 val)
{
 u64 idx;

 if (r->CRn == 9 && r->CRm == 13 && r->Op2 == 0)
  /* PMCCNTR_EL0 */
  idx = ARMV8_PMU_CYCLE_IDX;
 else
  /* PMEVCNTRn_EL0 */
  idx = ((r->CRm & 3) << 3) | (r->Op2 & 7);

 kvm_pmu_set_counter_value_user(vcpu, idx, val);
 return 0;
}

static bool access_pmu_evcntr(struct kvm_vcpu *vcpu,
         struct sys_reg_params *p,
         const struct sys_reg_desc *r)
{
 u64 idx = ~0UL;

 if (r->CRn == 9 && r->CRm == 13) {
  if (r->Op2 == 2) {
   /* PMXEVCNTR_EL0 */
   if (pmu_access_event_counter_el0_disabled(vcpu))
    return false;

   idx = SYS_FIELD_GET(PMSELR_EL0, SEL,
         __vcpu_sys_reg(vcpu, PMSELR_EL0));
  } else if (r->Op2 == 0) {
   /* PMCCNTR_EL0 */
   if (pmu_access_cycle_counter_el0_disabled(vcpu))
    return false;

   idx = ARMV8_PMU_CYCLE_IDX;
  }
 } else if (r->CRn == 0 && r->CRm == 9) {
  /* PMCCNTR */
  if (pmu_access_event_counter_el0_disabled(vcpu))
   return false;

  idx = ARMV8_PMU_CYCLE_IDX;
 } else if (r->CRn == 14 && (r->CRm & 12) == 8) {
  /* PMEVCNTRn_EL0 */
  if (pmu_access_event_counter_el0_disabled(vcpu))
   return false;

  idx = ((r->CRm & 3) << 3) | (r->Op2 & 7);
 }

 /* Catch any decoding mistake */
 WARN_ON(idx == ~0UL);

 if (!pmu_counter_idx_valid(vcpu, idx))
  return false;

 if (p->is_write) {
  if (pmu_access_el0_disabled(vcpu))
   return false;

  kvm_pmu_set_counter_value(vcpu, idx, p->regval);
 } else {
  p->regval = kvm_pmu_get_counter_value(vcpu, idx);
 }

 return true;
}

static bool access_pmu_evtyper(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
          const struct sys_reg_desc *r)
{
 u64 idx, reg;

 if (pmu_access_el0_disabled(vcpu))
  return false;

 if (r->CRn == 9 && r->CRm == 13 && r->Op2 == 1) {
  /* PMXEVTYPER_EL0 */
  idx = SYS_FIELD_GET(PMSELR_EL0, SEL, __vcpu_sys_reg(vcpu, PMSELR_EL0));
  reg = PMEVTYPER0_EL0 + idx;
 } else if (r->CRn == 14 && (r->CRm & 12) == 12) {
  idx = ((r->CRm & 3) << 3) | (r->Op2 & 7);
  if (idx == ARMV8_PMU_CYCLE_IDX)
   reg = PMCCFILTR_EL0;
  else
   /* PMEVTYPERn_EL0 */
   reg = PMEVTYPER0_EL0 + idx;
 } else {
  BUG();
 }

 if (!pmu_counter_idx_valid(vcpu, idx))
  return false;

 if (p->is_write) {
  kvm_pmu_set_counter_event_type(vcpu, p->regval, idx);
  kvm_vcpu_pmu_restore_guest(vcpu);
 } else {
  p->regval = __vcpu_sys_reg(vcpu, reg);
 }

 return true;
}

static int set_pmreg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r, u64 val)
{
 u64 mask = kvm_pmu_accessible_counter_mask(vcpu);

 __vcpu_assign_sys_reg(vcpu, r->reg, val & mask);
 kvm_make_request(KVM_REQ_RELOAD_PMU, vcpu);

 return 0;
}

static int get_pmreg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r, u64 *val)
{
 u64 mask = kvm_pmu_accessible_counter_mask(vcpu);

 *val = __vcpu_sys_reg(vcpu, r->reg) & mask;
 return 0;
}

static bool access_pmcnten(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
      const struct sys_reg_desc *r)
{
 u64 val, mask;

 if (pmu_access_el0_disabled(vcpu))
  return false;

 mask = kvm_pmu_accessible_counter_mask(vcpu);
 if (p->is_write) {
  val = p->regval & mask;
  if (r->Op2 & 0x1)
   /* accessing PMCNTENSET_EL0 */
   __vcpu_rmw_sys_reg(vcpu, PMCNTENSET_EL0, |=, val);
  else
   /* accessing PMCNTENCLR_EL0 */
   __vcpu_rmw_sys_reg(vcpu, PMCNTENSET_EL0, &=, ~val);

  kvm_pmu_reprogram_counter_mask(vcpu, val);
 } else {
  p->regval = __vcpu_sys_reg(vcpu, PMCNTENSET_EL0);
 }

 return true;
}

static bool access_pminten(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
      const struct sys_reg_desc *r)
{
 u64 mask = kvm_pmu_accessible_counter_mask(vcpu);

 if (check_pmu_access_disabled(vcpu, 0))
  return false;

 if (p->is_write) {
  u64 val = p->regval & mask;

  if (r->Op2 & 0x1)
   /* accessing PMINTENSET_EL1 */
   __vcpu_rmw_sys_reg(vcpu, PMINTENSET_EL1, |=, val);
  else
   /* accessing PMINTENCLR_EL1 */
   __vcpu_rmw_sys_reg(vcpu, PMINTENSET_EL1, &=, ~val);
 } else {
  p->regval = __vcpu_sys_reg(vcpu, PMINTENSET_EL1);
 }

 return true;
}

static bool access_pmovs(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
    const struct sys_reg_desc *r)
{
 u64 mask = kvm_pmu_accessible_counter_mask(vcpu);

 if (pmu_access_el0_disabled(vcpu))
  return false;

 if (p->is_write) {
  if (r->CRm & 0x2)
   /* accessing PMOVSSET_EL0 */
   __vcpu_rmw_sys_reg(vcpu, PMOVSSET_EL0, |=, (p->regval & mask));
  else
   /* accessing PMOVSCLR_EL0 */
   __vcpu_rmw_sys_reg(vcpu, PMOVSSET_EL0, &=, ~(p->regval & mask));
 } else {
  p->regval = __vcpu_sys_reg(vcpu, PMOVSSET_EL0);
 }

 return true;
}

static bool access_pmswinc(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
      const struct sys_reg_desc *r)
{
 u64 mask;

 if (!p->is_write)
  return read_from_write_only(vcpu, p, r);

 if (pmu_write_swinc_el0_disabled(vcpu))
  return false;

 mask = kvm_pmu_accessible_counter_mask(vcpu);
 kvm_pmu_software_increment(vcpu, p->regval & mask);
 return true;
}

static bool access_pmuserenr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
        const struct sys_reg_desc *r)
{
 if (p->is_write) {
  if (!vcpu_mode_priv(vcpu))
   return undef_access(vcpu, p, r);

  __vcpu_assign_sys_reg(vcpu, PMUSERENR_EL0,
          (p->regval & ARMV8_PMU_USERENR_MASK));
 } else {
  p->regval = __vcpu_sys_reg(vcpu, PMUSERENR_EL0)
       & ARMV8_PMU_USERENR_MASK;
 }

 return true;
}

static int get_pmcr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,
      u64 *val)
{
 *val = kvm_vcpu_read_pmcr(vcpu);
 return 0;
}

static int set_pmcr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r,
      u64 val)
{
 u8 new_n = FIELD_GET(ARMV8_PMU_PMCR_N, val);
 struct kvm *kvm = vcpu->kvm;

 mutex_lock(&kvm->arch.config_lock);

 /*
 * The vCPU can't have more counters than the PMU hardware
 * implements. Ignore this error to maintain compatibility
 * with the existing KVM behavior.
 */
 if (!kvm_vm_has_ran_once(kvm) &&
     !vcpu_has_nv(vcpu)       &&
     new_n <= kvm_arm_pmu_get_max_counters(kvm))
  kvm->arch.nr_pmu_counters = new_n;

 mutex_unlock(&kvm->arch.config_lock);

 /*
 * Ignore writes to RES0 bits, read only bits that are cleared on
 * vCPU reset, and writable bits that KVM doesn't support yet.
 * (i.e. only PMCR.N and bits [7:0] are mutable from userspace)
 * The LP bit is RES0 when FEAT_PMUv3p5 is not supported on the vCPU.
 * But, we leave the bit as it is here, as the vCPU's PMUver might
 * be changed later (NOTE: the bit will be cleared on first vCPU run
 * if necessary).
 */
 val &= ARMV8_PMU_PMCR_MASK;

 /* The LC bit is RES1 when AArch32 is not supported */
 if (!kvm_supports_32bit_el0())
  val |= ARMV8_PMU_PMCR_LC;

 __vcpu_assign_sys_reg(vcpu, r->reg, val);
 kvm_make_request(KVM_REQ_RELOAD_PMU, vcpu);

 return 0;
}

/* Silly macro to expand the DBG{BCR,BVR,WVR,WCR}n_EL1 registers in one go */
#define DBG_BCR_BVR_WCR_WVR_EL1(n)     \
 { SYS_DESC(SYS_DBGBVRn_EL1(n)),     \
   trap_dbg_wb_reg, reset_dbg_wb_reg, 0, 0,   \
   get_dbg_wb_reg, set_dbg_wb_reg },    \
 { SYS_DESC(SYS_DBGBCRn_EL1(n)),     \
   trap_dbg_wb_reg, reset_dbg_wb_reg, 0, 0,   \
   get_dbg_wb_reg, set_dbg_wb_reg },    \
 { SYS_DESC(SYS_DBGWVRn_EL1(n)),     \
   trap_dbg_wb_reg, reset_dbg_wb_reg, 0, 0,   \
   get_dbg_wb_reg, set_dbg_wb_reg },    \
 { SYS_DESC(SYS_DBGWCRn_EL1(n)),     \
   trap_dbg_wb_reg, reset_dbg_wb_reg, 0, 0,   \
   get_dbg_wb_reg, set_dbg_wb_reg }

#define PMU_SYS_REG(name)      \
 SYS_DESC(SYS_##name), .reset = reset_pmu_reg,   \
 .visibility = pmu_visibility

/* Macro to expand the PMEVCNTRn_EL0 register */
#define PMU_PMEVCNTR_EL0(n)      \
 { PMU_SYS_REG(PMEVCNTRn_EL0(n)),    \
   .reset = reset_pmevcntr, .get_user = get_pmu_evcntr,  \
   .set_user = set_pmu_evcntr,     \
   .access = access_pmu_evcntr, .reg = (PMEVCNTR0_EL0 + n), }

/* Macro to expand the PMEVTYPERn_EL0 register */
#define PMU_PMEVTYPER_EL0(n)      \
 { PMU_SYS_REG(PMEVTYPERn_EL0(n)),    \
   .reset = reset_pmevtyper,     \
   .access = access_pmu_evtyper, .reg = (PMEVTYPER0_EL0 + n), }

/* Macro to expand the AMU counter and type registers*/
#define AMU_AMEVCNTR0_EL0(n) { SYS_DESC(SYS_AMEVCNTR0_EL0(n)), undef_access }
#define AMU_AMEVTYPER0_EL0(n) { SYS_DESC(SYS_AMEVTYPER0_EL0(n)), undef_access }
#define AMU_AMEVCNTR1_EL0(n) { SYS_DESC(SYS_AMEVCNTR1_EL0(n)), undef_access }
#define AMU_AMEVTYPER1_EL0(n) { SYS_DESC(SYS_AMEVTYPER1_EL0(n)), undef_access }

static unsigned int ptrauth_visibility(const struct kvm_vcpu *vcpu,
   const struct sys_reg_desc *rd)
{
 return vcpu_has_ptrauth(vcpu) ? 0 : REG_HIDDEN;
}

/*
 * If we land here on a PtrAuth access, that is because we didn't
 * fixup the access on exit by allowing the PtrAuth sysregs. The only
 * way this happens is when the guest does not have PtrAuth support
 * enabled.
 */
#define __PTRAUTH_KEY(k)      \
 { SYS_DESC(SYS_## k), undef_access, reset_unknown, k,  \
 .visibility = ptrauth_visibility}

#define PTRAUTH_KEY(k)       \
 __PTRAUTH_KEY(k ## KEYLO_EL1),     \
 __PTRAUTH_KEY(k ## KEYHI_EL1)

static bool access_arch_timer(struct kvm_vcpu *vcpu,
         struct sys_reg_params *p,
         const struct sys_reg_desc *r)
{
 enum kvm_arch_timers tmr;
 enum kvm_arch_timer_regs treg;
 u64 reg = reg_to_encoding(r);

 switch (reg) {
 case SYS_CNTP_TVAL_EL0:
  if (is_hyp_ctxt(vcpu) && vcpu_el2_e2h_is_set(vcpu))
   tmr = TIMER_HPTIMER;
  else
   tmr = TIMER_PTIMER;
  treg = TIMER_REG_TVAL;
  break;

 case SYS_CNTV_TVAL_EL0:
  if (is_hyp_ctxt(vcpu) && vcpu_el2_e2h_is_set(vcpu))
   tmr = TIMER_HVTIMER;
  else
   tmr = TIMER_VTIMER;
  treg = TIMER_REG_TVAL;
  break;

 case SYS_AARCH32_CNTP_TVAL:
 case SYS_CNTP_TVAL_EL02:
  tmr = TIMER_PTIMER;
  treg = TIMER_REG_TVAL;
  break;

 case SYS_CNTV_TVAL_EL02:
  tmr = TIMER_VTIMER;
  treg = TIMER_REG_TVAL;
  break;

 case SYS_CNTHP_TVAL_EL2:
  tmr = TIMER_HPTIMER;
  treg = TIMER_REG_TVAL;
  break;

 case SYS_CNTHV_TVAL_EL2:
  tmr = TIMER_HVTIMER;
  treg = TIMER_REG_TVAL;
  break;

 case SYS_CNTP_CTL_EL0:
  if (is_hyp_ctxt(vcpu) && vcpu_el2_e2h_is_set(vcpu))
   tmr = TIMER_HPTIMER;
  else
   tmr = TIMER_PTIMER;
  treg = TIMER_REG_CTL;
  break;

 case SYS_CNTV_CTL_EL0:
  if (is_hyp_ctxt(vcpu) && vcpu_el2_e2h_is_set(vcpu))
   tmr = TIMER_HVTIMER;
  else
   tmr = TIMER_VTIMER;
  treg = TIMER_REG_CTL;
  break;

 case SYS_AARCH32_CNTP_CTL:
 case SYS_CNTP_CTL_EL02:
  tmr = TIMER_PTIMER;
  treg = TIMER_REG_CTL;
  break;

 case SYS_CNTV_CTL_EL02:
  tmr = TIMER_VTIMER;
  treg = TIMER_REG_CTL;
  break;

 case SYS_CNTHP_CTL_EL2:
  tmr = TIMER_HPTIMER;
  treg = TIMER_REG_CTL;
  break;

 case SYS_CNTHV_CTL_EL2:
  tmr = TIMER_HVTIMER;
  treg = TIMER_REG_CTL;
  break;

 case SYS_CNTP_CVAL_EL0:
  if (is_hyp_ctxt(vcpu) && vcpu_el2_e2h_is_set(vcpu))
   tmr = TIMER_HPTIMER;
  else
   tmr = TIMER_PTIMER;
  treg = TIMER_REG_CVAL;
  break;

 case SYS_CNTV_CVAL_EL0:
  if (is_hyp_ctxt(vcpu) && vcpu_el2_e2h_is_set(vcpu))
   tmr = TIMER_HVTIMER;
  else
   tmr = TIMER_VTIMER;
  treg = TIMER_REG_CVAL;
  break;

 case SYS_AARCH32_CNTP_CVAL:
 case SYS_CNTP_CVAL_EL02:
  tmr = TIMER_PTIMER;
  treg = TIMER_REG_CVAL;
  break;

 case SYS_CNTV_CVAL_EL02:
  tmr = TIMER_VTIMER;
  treg = TIMER_REG_CVAL;
  break;

 case SYS_CNTHP_CVAL_EL2:
  tmr = TIMER_HPTIMER;
  treg = TIMER_REG_CVAL;
  break;

 case SYS_CNTHV_CVAL_EL2:
  tmr = TIMER_HVTIMER;
  treg = TIMER_REG_CVAL;
  break;

 case SYS_CNTPCT_EL0:
 case SYS_CNTPCTSS_EL0:
  if (is_hyp_ctxt(vcpu))
   tmr = TIMER_HPTIMER;
  else
   tmr = TIMER_PTIMER;
  treg = TIMER_REG_CNT;
  break;

 case SYS_AARCH32_CNTPCT:
 case SYS_AARCH32_CNTPCTSS:
  tmr = TIMER_PTIMER;
  treg = TIMER_REG_CNT;
  break;

 case SYS_CNTVCT_EL0:
 case SYS_CNTVCTSS_EL0:
  if (is_hyp_ctxt(vcpu))
   tmr = TIMER_HVTIMER;
  else
   tmr = TIMER_VTIMER;
  treg = TIMER_REG_CNT;
  break;

 case SYS_AARCH32_CNTVCT:
 case SYS_AARCH32_CNTVCTSS:
  tmr = TIMER_VTIMER;
  treg = TIMER_REG_CNT;
  break;

 default:
  print_sys_reg_msg(p, "%s", "Unhandled trapped timer register");
  return undef_access(vcpu, p, r);
 }

 if (p->is_write)
  kvm_arm_timer_write_sysreg(vcpu, tmr, treg, p->regval);
 else
  p->regval = kvm_arm_timer_read_sysreg(vcpu, tmr, treg);

 return true;
}

static bool access_hv_timer(struct kvm_vcpu *vcpu,
       struct sys_reg_params *p,
       const struct sys_reg_desc *r)
{
 if (!vcpu_el2_e2h_is_set(vcpu))
  return undef_access(vcpu, p, r);

 return access_arch_timer(vcpu, p, r);
}

static s64 kvm_arm64_ftr_safe_value(u32 id, const struct arm64_ftr_bits *ftrp,
        s64 new, s64 cur)
{
 struct arm64_ftr_bits kvm_ftr = *ftrp;

 /* Some features have different safe value type in KVM than host features */
 switch (id) {
 case SYS_ID_AA64DFR0_EL1:
  switch (kvm_ftr.shift) {
  case ID_AA64DFR0_EL1_PMUVer_SHIFT:
   kvm_ftr.type = FTR_LOWER_SAFE;
   break;
  case ID_AA64DFR0_EL1_DebugVer_SHIFT:
   kvm_ftr.type = FTR_LOWER_SAFE;
   break;
  }
  break;
 case SYS_ID_DFR0_EL1:
  if (kvm_ftr.shift == ID_DFR0_EL1_PerfMon_SHIFT)
   kvm_ftr.type = FTR_LOWER_SAFE;
  break;
 }

 return arm64_ftr_safe_value(&kvm_ftr, new, cur);
}

/*
 * arm64_check_features() - Check if a feature register value constitutes
 * a subset of features indicated by the idreg's KVM sanitised limit.
 *
 * This function will check if each feature field of @val is the "safe" value
 * against idreg's KVM sanitised limit return from reset() callback.
 * If a field value in @val is the same as the one in limit, it is always
 * considered the safe value regardless For register fields that are not in
 * writable, only the value in limit is considered the safe value.
 *
 * Return: 0 if all the fields are safe. Otherwise, return negative errno.
 */
static int arm64_check_features(struct kvm_vcpu *vcpu,
    const struct sys_reg_desc *rd,
    u64 val)
{
 const struct arm64_ftr_reg *ftr_reg;
 const struct arm64_ftr_bits *ftrp = NULL;
 u32 id = reg_to_encoding(rd);
 u64 writable_mask = rd->val;
 u64 limit = rd->reset(vcpu, rd);
 u64 mask = 0;

 /*
 * Hidden and unallocated ID registers may not have a corresponding
 * struct arm64_ftr_reg. Of course, if the register is RAZ we know the
 * only safe value is 0.
 */
 if (sysreg_visible_as_raz(vcpu, rd))
  return val ? -E2BIG : 0;

 ftr_reg = get_arm64_ftr_reg(id);
 if (!ftr_reg)
  return -EINVAL;

 ftrp = ftr_reg->ftr_bits;

 for (; ftrp && ftrp->width; ftrp++) {
  s64 f_val, f_lim, safe_val;
  u64 ftr_mask;

  ftr_mask = arm64_ftr_mask(ftrp);
  if ((ftr_mask & writable_mask) != ftr_mask)
   continue;

  f_val = arm64_ftr_value(ftrp, val);
  f_lim = arm64_ftr_value(ftrp, limit);
  mask |= ftr_mask;

  if (f_val == f_lim)
   safe_val = f_val;
  else
   safe_val = kvm_arm64_ftr_safe_value(id, ftrp, f_val, f_lim);

  if (safe_val != f_val)
   return -E2BIG;
 }

 /* For fields that are not writable, values in limit are the safe values. */
 if ((val & ~mask) != (limit & ~mask))
  return -E2BIG;

 return 0;
}

static u8 pmuver_to_perfmon(u8 pmuver)
{
 switch (pmuver) {
 case ID_AA64DFR0_EL1_PMUVer_IMP:
  return ID_DFR0_EL1_PerfMon_PMUv3;
 case ID_AA64DFR0_EL1_PMUVer_IMP_DEF:
  return ID_DFR0_EL1_PerfMon_IMPDEF;
 default:
  /* Anything ARMv8.1+ and NI have the same value. For now. */
  return pmuver;
 }
}

static u64 sanitise_id_aa64pfr0_el1(const struct kvm_vcpu *vcpu, u64 val);
static u64 sanitise_id_aa64pfr1_el1(const struct kvm_vcpu *vcpu, u64 val);
static u64 sanitise_id_aa64dfr0_el1(const struct kvm_vcpu *vcpu, u64 val);

/* Read a sanitised cpufeature ID register by sys_reg_desc */
static u64 __kvm_read_sanitised_id_reg(const struct kvm_vcpu *vcpu,
           const struct sys_reg_desc *r)
{
 u32 id = reg_to_encoding(r);
 u64 val;

 if (sysreg_visible_as_raz(vcpu, r))
  return 0;

 val = read_sanitised_ftr_reg(id);

 switch (id) {
 case SYS_ID_AA64DFR0_EL1:
  val = sanitise_id_aa64dfr0_el1(vcpu, val);
  break;
 case SYS_ID_AA64PFR0_EL1:
  val = sanitise_id_aa64pfr0_el1(vcpu, val);
  break;
 case SYS_ID_AA64PFR1_EL1:
  val = sanitise_id_aa64pfr1_el1(vcpu, val);
  break;
 case SYS_ID_AA64PFR2_EL1:
  val &= ID_AA64PFR2_EL1_FPMR |
   (kvm_has_mte(vcpu->kvm) ?
    ID_AA64PFR2_EL1_MTEFAR | ID_AA64PFR2_EL1_MTESTOREONLY :
    0);
  break;
 case SYS_ID_AA64ISAR1_EL1:
  if (!vcpu_has_ptrauth(vcpu))
   val &= ~(ID_AA64ISAR1_EL1_APA |
     ID_AA64ISAR1_EL1_API |
     ID_AA64ISAR1_EL1_GPA |
     ID_AA64ISAR1_EL1_GPI);
  break;
 case SYS_ID_AA64ISAR2_EL1:
  if (!vcpu_has_ptrauth(vcpu))
   val &= ~(ID_AA64ISAR2_EL1_APA3 |
     ID_AA64ISAR2_EL1_GPA3);
  if (!cpus_have_final_cap(ARM64_HAS_WFXT) ||
      has_broken_cntvoff())
   val &= ~ID_AA64ISAR2_EL1_WFxT;
  break;
 case SYS_ID_AA64ISAR3_EL1:
  val &= ID_AA64ISAR3_EL1_FPRCVT | ID_AA64ISAR3_EL1_FAMINMAX;
  break;
 case SYS_ID_AA64MMFR2_EL1:
  val &= ~ID_AA64MMFR2_EL1_CCIDX_MASK;
  val &= ~ID_AA64MMFR2_EL1_NV;
  break;
 case SYS_ID_AA64MMFR3_EL1:
  val &= ID_AA64MMFR3_EL1_TCRX |
         ID_AA64MMFR3_EL1_SCTLRX |
         ID_AA64MMFR3_EL1_S1POE |
         ID_AA64MMFR3_EL1_S1PIE;
  break;
 case SYS_ID_MMFR4_EL1:
  val &= ~ID_MMFR4_EL1_CCIDX;
  break;
 }

 if (vcpu_has_nv(vcpu))
  val = limit_nv_id_reg(vcpu->kvm, id, val);

 return val;
}

static u64 kvm_read_sanitised_id_reg(struct kvm_vcpu *vcpu,
         const struct sys_reg_desc *r)
{
 return __kvm_read_sanitised_id_reg(vcpu, r);
}

static u64 read_id_reg(const struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 return kvm_read_vm_id_reg(vcpu->kvm, reg_to_encoding(r));
}

static bool is_feature_id_reg(u32 encoding)
{
 return (sys_reg_Op0(encoding) == 3 &&
  (sys_reg_Op1(encoding) < 2 || sys_reg_Op1(encoding) == 3) &&
  sys_reg_CRn(encoding) == 0 &&
  sys_reg_CRm(encoding) <= 7);
}

/*
 * Return true if the register's (Op0, Op1, CRn, CRm, Op2) is
 * (3, 0, 0, crm, op2), where 1<=crm<8, 0<=op2<8, which is the range of ID
 * registers KVM maintains on a per-VM basis.
 *
 * Additionally, the implementation ID registers and CTR_EL0 are handled as
 * per-VM registers.
 */
static inline bool is_vm_ftr_id_reg(u32 id)
{
 switch (id) {
 case SYS_CTR_EL0:
 case SYS_MIDR_EL1:
 case SYS_REVIDR_EL1:
 case SYS_AIDR_EL1:
  return true;
 default:
  return (sys_reg_Op0(id) == 3 && sys_reg_Op1(id) == 0 &&
   sys_reg_CRn(id) == 0 && sys_reg_CRm(id) >= 1 &&
   sys_reg_CRm(id) < 8);

 }
}

static inline bool is_vcpu_ftr_id_reg(u32 id)
{
 return is_feature_id_reg(id) && !is_vm_ftr_id_reg(id);
}

static inline bool is_aa32_id_reg(u32 id)
{
 return (sys_reg_Op0(id) == 3 && sys_reg_Op1(id) == 0 &&
  sys_reg_CRn(id) == 0 && sys_reg_CRm(id) >= 1 &&
  sys_reg_CRm(id) <= 3);
}

static unsigned int id_visibility(const struct kvm_vcpu *vcpu,
      const struct sys_reg_desc *r)
{
 u32 id = reg_to_encoding(r);

 switch (id) {
 case SYS_ID_AA64ZFR0_EL1:
  if (!vcpu_has_sve(vcpu))
   return REG_RAZ;
  break;
 }

 return 0;
}

static unsigned int aa32_id_visibility(const struct kvm_vcpu *vcpu,
           const struct sys_reg_desc *r)
{
 /*
 * AArch32 ID registers are UNKNOWN if AArch32 isn't implemented at any
 * EL. Promote to RAZ/WI in order to guarantee consistency between
 * systems.
 */
 if (!kvm_supports_32bit_el0())
  return REG_RAZ | REG_USER_WI;

 return id_visibility(vcpu, r);
}

static unsigned int raz_visibility(const struct kvm_vcpu *vcpu,
       const struct sys_reg_desc *r)
{
 return REG_RAZ;
}

/* cpufeature ID register access trap handlers */

static bool access_id_reg(struct kvm_vcpu *vcpu,
     struct sys_reg_params *p,
     const struct sys_reg_desc *r)
{
 if (p->is_write)
  return write_to_read_only(vcpu, p, r);

 p->regval = read_id_reg(vcpu, r);

 return true;
}

/* Visibility overrides for SVE-specific control registers */
static unsigned int sve_visibility(const struct kvm_vcpu *vcpu,
       const struct sys_reg_desc *rd)
{
 if (vcpu_has_sve(vcpu))
  return 0;

 return REG_HIDDEN;
}

static unsigned int sme_visibility(const struct kvm_vcpu *vcpu,
       const struct sys_reg_desc *rd)
{
 if (kvm_has_feat(vcpu->kvm, ID_AA64PFR1_EL1, SME, IMP))
  return 0;

 return REG_HIDDEN;
}

static unsigned int fp8_visibility(const struct kvm_vcpu *vcpu,
       const struct sys_reg_desc *rd)
{
 if (kvm_has_fpmr(vcpu->kvm))
  return 0;

 return REG_HIDDEN;
}

static u64 sanitise_id_aa64pfr0_el1(const struct kvm_vcpu *vcpu, u64 val)
{
 if (!vcpu_has_sve(vcpu))
  val &= ~ID_AA64PFR0_EL1_SVE_MASK;

 /*
 * The default is to expose CSV2 == 1 if the HW isn't affected.
 * Although this is a per-CPU feature, we make it global because
 * asymmetric systems are just a nuisance.
 *
 * Userspace can override this as long as it doesn't promise
 * the impossible.
 */
 if (arm64_get_spectre_v2_state() == SPECTRE_UNAFFECTED) {
  val &= ~ID_AA64PFR0_EL1_CSV2_MASK;
  val |= SYS_FIELD_PREP_ENUM(ID_AA64PFR0_EL1, CSV2, IMP);
 }
 if (arm64_get_meltdown_state() == SPECTRE_UNAFFECTED) {
  val &= ~ID_AA64PFR0_EL1_CSV3_MASK;
  val |= SYS_FIELD_PREP_ENUM(ID_AA64PFR0_EL1, CSV3, IMP);
 }

 if (vgic_is_v3(vcpu->kvm)) {
  val &= ~ID_AA64PFR0_EL1_GIC_MASK;
  val |= SYS_FIELD_PREP_ENUM(ID_AA64PFR0_EL1, GIC, IMP);
 }

 val &= ~ID_AA64PFR0_EL1_AMU_MASK;

 /*
 * MPAM is disabled by default as KVM also needs a set of PARTID to
 * program the MPAMVPMx_EL2 PARTID remapping registers with. But some
 * older kernels let the guest see the ID bit.
 */
 val &= ~ID_AA64PFR0_EL1_MPAM_MASK;

 return val;
}

static u64 sanitise_id_aa64pfr1_el1(const struct kvm_vcpu *vcpu, u64 val)
{
 u64 pfr0 = read_sanitised_ftr_reg(SYS_ID_AA64PFR0_EL1);

 if (!kvm_has_mte(vcpu->kvm)) {
  val &= ~ID_AA64PFR1_EL1_MTE;
  val &= ~ID_AA64PFR1_EL1_MTE_frac;
 }

 if (!(cpus_have_final_cap(ARM64_HAS_RASV1P1_EXTN) &&
       SYS_FIELD_GET(ID_AA64PFR0_EL1, RAS, pfr0) == ID_AA64PFR0_EL1_RAS_IMP))
  val &= ~ID_AA64PFR1_EL1_RAS_frac;

 val &= ~ID_AA64PFR1_EL1_SME;
 val &= ~ID_AA64PFR1_EL1_RNDR_trap;
 val &= ~ID_AA64PFR1_EL1_NMI;
 val &= ~ID_AA64PFR1_EL1_GCS;
 val &= ~ID_AA64PFR1_EL1_THE;
 val &= ~ID_AA64PFR1_EL1_MTEX;
 val &= ~ID_AA64PFR1_EL1_PFAR;
 val &= ~ID_AA64PFR1_EL1_MPAM_frac;

 return val;
}

static u64 sanitise_id_aa64dfr0_el1(const struct kvm_vcpu *vcpu, u64 val)
{
 val = ID_REG_LIMIT_FIELD_ENUM(val, ID_AA64DFR0_EL1, DebugVer, V8P8);

 /*
 * Only initialize the PMU version if the vCPU was configured with one.
 */
 val &= ~ID_AA64DFR0_EL1_PMUVer_MASK;
 if (kvm_vcpu_has_pmu(vcpu))
  val |= SYS_FIELD_PREP(ID_AA64DFR0_EL1, PMUVer,
          kvm_arm_pmu_get_pmuver_limit());

 /* Hide SPE from guests */
 val &= ~ID_AA64DFR0_EL1_PMSVer_MASK;

 /* Hide BRBE from guests */
 val &= ~ID_AA64DFR0_EL1_BRBE_MASK;

 return val;
}

static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
          const struct sys_reg_desc *rd,
          u64 val)
{
 u8 debugver = SYS_FIELD_GET(ID_AA64DFR0_EL1, DebugVer, val);
 u8 pmuver = SYS_FIELD_GET(ID_AA64DFR0_EL1, PMUVer, val);

 /*
 * Prior to commit 3d0dba5764b9 ("KVM: arm64: PMU: Move the
 * ID_AA64DFR0_EL1.PMUver limit to VM creation"), KVM erroneously
 * exposed an IMP_DEF PMU to userspace and the guest on systems w/
 * non-architectural PMUs. Of course, PMUv3 is the only game in town for
 * PMU virtualization, so the IMP_DEF value was rather user-hostile.
 *
 * At minimum, we're on the hook to allow values that were given to
 * userspace by KVM. Cover our tracks here and replace the IMP_DEF value
 * with a more sensible NI. The value of an ID register changing under
 * the nose of the guest is unfortunate, but is certainly no more
 * surprising than an ill-guided PMU driver poking at impdef system
 * registers that end in an UNDEF...
 */
 if (pmuver == ID_AA64DFR0_EL1_PMUVer_IMP_DEF)
  val &= ~ID_AA64DFR0_EL1_PMUVer_MASK;

 /*
 * ID_AA64DFR0_EL1.DebugVer is one of those awkward fields with a
 * nonzero minimum safe value.
 */
 if (debugver < ID_AA64DFR0_EL1_DebugVer_IMP)
  return -EINVAL;

 return set_id_reg(vcpu, rd, val);
}

static u64 read_sanitised_id_dfr0_el1(struct kvm_vcpu *vcpu,
          const struct sys_reg_desc *rd)
{
 u8 perfmon;
 u64 val = read_sanitised_ftr_reg(SYS_ID_DFR0_EL1);

 val &= ~ID_DFR0_EL1_PerfMon_MASK;
 if (kvm_vcpu_has_pmu(vcpu)) {
  perfmon = pmuver_to_perfmon(kvm_arm_pmu_get_pmuver_limit());
  val |= SYS_FIELD_PREP(ID_DFR0_EL1, PerfMon, perfmon);
 }

 val = ID_REG_LIMIT_FIELD_ENUM(val, ID_DFR0_EL1, CopDbg, Debugv8p8);

 return val;
}

static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
      const struct sys_reg_desc *rd,
      u64 val)
{
 u8 perfmon = SYS_FIELD_GET(ID_DFR0_EL1, PerfMon, val);
 u8 copdbg = SYS_FIELD_GET(ID_DFR0_EL1, CopDbg, val);

 if (perfmon == ID_DFR0_EL1_PerfMon_IMPDEF) {
  val &= ~ID_DFR0_EL1_PerfMon_MASK;
  perfmon = 0;
 }

 /*
 * Allow DFR0_EL1.PerfMon to be set from userspace as long as
 * it doesn't promise more than what the HW gives us on the
 * AArch64 side (as everything is emulated with that), and
 * that this is a PMUv3.
 */
 if (perfmon != 0 && perfmon < ID_DFR0_EL1_PerfMon_PMUv3)
  return -EINVAL;

 if (copdbg < ID_DFR0_EL1_CopDbg_Armv8)
  return -EINVAL;

 return set_id_reg(vcpu, rd, val);
}

static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
          const struct sys_reg_desc *rd, u64 user_val)
{
 u64 hw_val = read_sanitised_ftr_reg(SYS_ID_AA64PFR0_EL1);
 u64 mpam_mask = ID_AA64PFR0_EL1_MPAM_MASK;

 /*
 * Commit 011e5f5bf529f ("arm64/cpufeature: Add remaining feature bits
 * in ID_AA64PFR0 register") exposed the MPAM field of AA64PFR0_EL1 to
 * guests, but didn't add trap handling. KVM doesn't support MPAM and
 * always returns an UNDEF for these registers. The guest must see 0
 * for this field.
 *
 * But KVM must also accept values from user-space that were provided
 * by KVM. On CPUs that support MPAM, permit user-space to write
 * the sanitizied value to ID_AA64PFR0_EL1.MPAM, but ignore this field.
 */
 if ((hw_val & mpam_mask) == (user_val & mpam_mask))
  user_val &= ~ID_AA64PFR0_EL1_MPAM_MASK;

 /* Fail the guest's request to disable the AA64 ISA at EL{0,1,2} */
 if (!FIELD_GET(ID_AA64PFR0_EL1_EL0, user_val) ||
     !FIELD_GET(ID_AA64PFR0_EL1_EL1, user_val) ||
     (vcpu_has_nv(vcpu) && !FIELD_GET(ID_AA64PFR0_EL1_EL2, user_val)))
  return -EINVAL;

 /*
 * If we are running on a GICv5 host and support FEAT_GCIE_LEGACY, then
 * we support GICv3. Fail attempts to do anything but set that to IMP.
 */
 if (vgic_is_v3_compat(vcpu->kvm) &&
     FIELD_GET(ID_AA64PFR0_EL1_GIC_MASK, user_val) != ID_AA64PFR0_EL1_GIC_IMP)
  return -EINVAL;

 return set_id_reg(vcpu, rd, user_val);
}

static int set_id_aa64pfr1_el1(struct kvm_vcpu *vcpu,
          const struct sys_reg_desc *rd, u64 user_val)
{
 u64 hw_val = read_sanitised_ftr_reg(SYS_ID_AA64PFR1_EL1);
 u64 mpam_mask = ID_AA64PFR1_EL1_MPAM_frac_MASK;
 u8 mte = SYS_FIELD_GET(ID_AA64PFR1_EL1, MTE, hw_val);
 u8 user_mte_frac = SYS_FIELD_GET(ID_AA64PFR1_EL1, MTE_frac, user_val);
 u8 hw_mte_frac = SYS_FIELD_GET(ID_AA64PFR1_EL1, MTE_frac, hw_val);

 /* See set_id_aa64pfr0_el1 for comment about MPAM */
 if ((hw_val & mpam_mask) == (user_val & mpam_mask))
  user_val &= ~ID_AA64PFR1_EL1_MPAM_frac_MASK;

 /*
 * Previously MTE_frac was hidden from guest. However, if the
 * hardware supports MTE2 but not MTE_ASYM_FAULT then a value
 * of 0 for this field indicates that the hardware supports
 * MTE_ASYNC. Whereas, 0xf indicates MTE_ASYNC is not supported.
 *
 * As KVM must accept values from KVM provided by user-space,
 * when ID_AA64PFR1_EL1.MTE is 2 allow user-space to set
 * ID_AA64PFR1_EL1.MTE_frac to 0. However, ignore it to avoid
 * incorrectly claiming hardware support for MTE_ASYNC in the
 * guest.
 */

 if (mte == ID_AA64PFR1_EL1_MTE_MTE2 &&
     hw_mte_frac == ID_AA64PFR1_EL1_MTE_frac_NI &&
     user_mte_frac == ID_AA64PFR1_EL1_MTE_frac_ASYNC) {
  user_val &= ~ID_AA64PFR1_EL1_MTE_frac_MASK;
  user_val |= hw_val & ID_AA64PFR1_EL1_MTE_frac_MASK;
 }

 return set_id_reg(vcpu, rd, user_val);
}

static int set_id_aa64mmfr0_el1(struct kvm_vcpu *vcpu,
    const struct sys_reg_desc *rd, u64 user_val)
{
 u64 sanitized_val = kvm_read_sanitised_id_reg(vcpu, rd);
 u64 tgran2_mask = ID_AA64MMFR0_EL1_TGRAN4_2_MASK |
     ID_AA64MMFR0_EL1_TGRAN16_2_MASK |
     ID_AA64MMFR0_EL1_TGRAN64_2_MASK;

 if (vcpu_has_nv(vcpu) &&
     ((sanitized_val & tgran2_mask) != (user_val & tgran2_mask)))
  return -EINVAL;

 return set_id_reg(vcpu, rd, user_val);
}

static int set_id_aa64mmfr2_el1(struct kvm_vcpu *vcpu,
    const struct sys_reg_desc *rd, u64 user_val)
{
 u64 hw_val = read_sanitised_ftr_reg(SYS_ID_AA64MMFR2_EL1);
 u64 nv_mask = ID_AA64MMFR2_EL1_NV_MASK;

 /*
 * We made the mistake to expose the now deprecated NV field,
 * so allow userspace to write it, but silently ignore it.
 */
 if ((hw_val & nv_mask) == (user_val & nv_mask))
  user_val &= ~nv_mask;

 return set_id_reg(vcpu, rd, user_val);
}

static int set_ctr_el0(struct kvm_vcpu *vcpu,
         const struct sys_reg_desc *rd, u64 user_val)
{
 u8 user_L1Ip = SYS_FIELD_GET(CTR_EL0, L1Ip, user_val);

 /*
 * Both AIVIVT (0b01) and VPIPT (0b00) are documented as reserved.
 * Hence only allow to set VIPT(0b10) or PIPT(0b11) for L1Ip based
 * on what hardware reports.
 *
 * Using a VIPT software model on PIPT will lead to over invalidation,
 * but still correct. Hence, we can allow downgrading PIPT to VIPT,
 * but not the other way around. This is handled via arm64_ftr_safe_value()
 * as CTR_EL0 ftr_bits has L1Ip field with type FTR_EXACT and safe value
 * set as VIPT.
 */
 switch (user_L1Ip) {
 case CTR_EL0_L1Ip_RESERVED_VPIPT:
 case CTR_EL0_L1Ip_RESERVED_AIVIVT:
  return -EINVAL;
 case CTR_EL0_L1Ip_VIPT:
 case CTR_EL0_L1Ip_PIPT:
  return set_id_reg(vcpu, rd, user_val);
 default:
  return -ENOENT;
 }
}

/*
 * cpufeature ID register user accessors
 *
 * For now, these registers are immutable for userspace, so no values
 * are stored, and for set_id_reg() we don't allow the effective value
 * to be changed.
 */
static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
        u64 *val)
{
 /*
 * Avoid locking if the VM has already started, as the ID registers are
 * guaranteed to be invariant at that point.
 */
 if (kvm_vm_has_ran_once(vcpu->kvm)) {
  *val = read_id_reg(vcpu, rd);
  return 0;
 }

 mutex_lock(&vcpu->kvm->arch.config_lock);
 *val = read_id_reg(vcpu, rd);
 mutex_unlock(&vcpu->kvm->arch.config_lock);

 return 0;
}

static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
        u64 val)
{
 u32 id = reg_to_encoding(rd);
 int ret;

 mutex_lock(&vcpu->kvm->arch.config_lock);

 /*
 * Once the VM has started the ID registers are immutable. Reject any
 * write that does not match the final register value.
 */
 if (kvm_vm_has_ran_once(vcpu->kvm)) {
  if (val != read_id_reg(vcpu, rd))
   ret = -EBUSY;
  else
   ret = 0;

  mutex_unlock(&vcpu->kvm->arch.config_lock);
  return ret;
 }

 ret = arm64_check_features(vcpu, rd, val);
 if (!ret)
  kvm_set_vm_id_reg(vcpu->kvm, id, val);

 mutex_unlock(&vcpu->kvm->arch.config_lock);

 /*
 * arm64_check_features() returns -E2BIG to indicate the register's
 * feature set is a superset of the maximally-allowed register value.
 * While it would be nice to precisely describe this to userspace, the
 * existing UAPI for KVM_SET_ONE_REG has it that invalid register
 * writes return -EINVAL.
 */
 if (ret == -E2BIG)
  ret = -EINVAL;
 return ret;
}

void kvm_set_vm_id_reg(struct kvm *kvm, u32 reg, u64 val)
{
 u64 *p = __vm_id_reg(&kvm->arch, reg);

 lockdep_assert_held(&kvm->arch.config_lock);

 if (KVM_BUG_ON(kvm_vm_has_ran_once(kvm) || !p, kvm))
  return;

 *p = val;
}

static int get_raz_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
         u64 *val)
{
 *val = 0;
 return 0;
}

static int set_wi_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
        u64 val)
{
 return 0;
}

static bool access_ctr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
         const struct sys_reg_desc *r)
{
 if (p->is_write)
  return write_to_read_only(vcpu, p, r);

 p->regval = kvm_read_vm_id_reg(vcpu->kvm, SYS_CTR_EL0);
 return true;
}

static bool access_clidr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
    const struct sys_reg_desc *r)
{
 if (p->is_write)
  return write_to_read_only(vcpu, p, r);

 p->regval = __vcpu_sys_reg(vcpu, r->reg);
 return true;
}

/*
 * Fabricate a CLIDR_EL1 value instead of using the real value, which can vary
 * by the physical CPU which the vcpu currently resides in.
 */
static u64 reset_clidr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)
{
 u64 ctr_el0 = read_sanitised_ftr_reg(SYS_CTR_EL0);
 u64 clidr;
 u8 loc;

 if ((ctr_el0 & CTR_EL0_IDC)) {
  /*
 * Data cache clean to the PoU is not required so LoUU and LoUIS
 * will not be set and a unified cache, which will be marked as
 * LoC, will be added.
 *
 * If not DIC, let the unified cache L2 so that an instruction
 * cache can be added as L1 later.
 */
  loc = (ctr_el0 & CTR_EL0_DIC) ? 1 : 2;
  clidr = CACHE_TYPE_UNIFIED << CLIDR_CTYPE_SHIFT(loc);
 } else {
  /*
 * Data cache clean to the PoU is required so let L1 have a data
 * cache and mark it as LoUU and LoUIS. As L1 has a data cache,
 * it can be marked as LoC too.
 */
  loc = 1;
  clidr = 1 << CLIDR_LOUU_SHIFT;
  clidr |= 1 << CLIDR_LOUIS_SHIFT;
  clidr |= CACHE_TYPE_DATA << CLIDR_CTYPE_SHIFT(1);
 }

 /*
 * Instruction cache invalidation to the PoU is required so let L1 have
 * an instruction cache. If L1 already has a data cache, it will be
 * CACHE_TYPE_SEPARATE.
 */
 if (!(ctr_el0 & CTR_EL0_DIC))
  clidr |= CACHE_TYPE_INST << CLIDR_CTYPE_SHIFT(1);

 clidr |= loc << CLIDR_LOC_SHIFT;

 /*
 * Add tag cache unified to data cache. Allocation tags and data are
 * unified in a cache line so that it looks valid even if there is only
 * one cache line.
 */
 if (kvm_has_mte(vcpu->kvm))
  clidr |= 2ULL << CLIDR_TTYPE_SHIFT(loc);

 __vcpu_assign_sys_reg(vcpu, r->reg, clidr);

 return __vcpu_sys_reg(vcpu, r->reg);
}

static int set_clidr(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
        u64 val)
{
 u64 ctr_el0 = read_sanitised_ftr_reg(SYS_CTR_EL0);
 u64 idc = !CLIDR_LOC(val) || (!CLIDR_LOUIS(val) && !CLIDR_LOUU(val));

 if ((val & CLIDR_EL1_RES0) || (!(ctr_el0 & CTR_EL0_IDC) && idc))
  return -EINVAL;

 __vcpu_assign_sys_reg(vcpu, rd->reg, val);

 return 0;
}

static bool access_csselr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
     const struct sys_reg_desc *r)
{
 int reg = r->reg;

 if (p->is_write)
  vcpu_write_sys_reg(vcpu, p->regval, reg);
 else
  p->regval = vcpu_read_sys_reg(vcpu, reg);
 return true;
}

static bool access_ccsidr(struct kvm_vcpu *vcpu, struct sys_reg_params *p,
     const struct sys_reg_desc *r)
{
 u32 csselr;

 if (p->is_write)
  return write_to_read_only(vcpu, p, r);

 csselr = vcpu_read_sys_reg(vcpu, CSSELR_EL1);
 csselr &= CSSELR_EL1_Level | CSSELR_EL1_InD;
 if (csselr < CSSELR_MAX)
  p->regval = get_ccsidr(vcpu, csselr);

 return true;
}

static unsigned int mte_visibility(const struct kvm_vcpu *vcpu,
       const struct sys_reg_desc *rd)
{
 if (kvm_has_mte(vcpu->kvm))
  return 0;

 return REG_HIDDEN;
}

#define MTE_REG(name) {    \
 SYS_DESC(SYS_##name),   \
 .access = undef_access,   \
 .reset = reset_unknown,   \
 .reg = name,    \
 .visibility = mte_visibility,  \
}

static unsigned int el2_visibility(const struct kvm_vcpu *vcpu,
       const struct sys_reg_desc *rd)
{
 if (vcpu_has_nv(vcpu))
  return 0;

 return REG_HIDDEN;
}

static bool bad_vncr_trap(struct kvm_vcpu *vcpu,
     struct sys_reg_params *p,
     const struct sys_reg_desc *r)
{
 /*
 * We really shouldn't be here, and this is likely the result
 * of a misconfigured trap, as this register should target the
 * VNCR page, and nothing else.
 */
 return bad_trap(vcpu, p, r,
   "trap of VNCR-backed register");
}

static bool bad_redir_trap(struct kvm_vcpu *vcpu,
      struct sys_reg_params *p,
      const struct sys_reg_desc *r)
{
 /*
 * We really shouldn't be here, and this is likely the result
 * of a misconfigured trap, as this register should target the
 * corresponding EL1, and nothing else.
 */
 return bad_trap(vcpu, p, r,
   "trap of EL2 register redirected to EL1");
}

#define EL2_REG_FILTERED(name, acc, rst, v, filter) { \
 SYS_DESC(SYS_##name),   \
 .access = acc,    \
 .reset = rst,    \
 .reg = name,    \
 .visibility = filter,   \
 .val = v,    \
}

#define EL2_REG(name, acc, rst, v)   \
 EL2_REG_FILTERED(name, acc, rst, v, el2_visibility)

#define EL2_REG_VNCR(name, rst, v) EL2_REG(name, bad_vncr_trap, rst, v)
#define EL2_REG_VNCR_FILT(name, vis)   \
 EL2_REG_FILTERED(name, bad_vncr_trap, reset_val, 0, vis)
#define EL2_REG_VNCR_GICv3(name)   \
 EL2_REG_VNCR_FILT(name, hidden_visibility)
#define EL2_REG_REDIR(name, rst, v) EL2_REG(name, bad_redir_trap, rst, v)

/*
 * Since reset() callback and field val are not used for idregs, they will be
 * used for specific purposes for idregs.
 * The reset() would return KVM sanitised register value. The value would be the
 * same as the host kernel sanitised value if there is no KVM sanitisation.
--> --------------------

--> maximum size reached

--> --------------------