Commit e47c2055 authored by Marc Zyngier's avatar Marc Zyngier
Browse files

KVM: arm64: Make struct kvm_regs userspace-only 



struct kvm_regs is used by userspace to indicate which register gets
accessed by the {GET,SET}_ONE_REG API. But as we're about to refactor
the layout of the in-kernel register structures, we need the kernel to
move away from it.

Let's make kvm_regs userspace only, and let the kernel map it to its own
internal representation.

Reviewed-by: default avatarJames Morse <james.morse@arm.com>
Signed-off-by: default avatarMarc Zyngier <maz@kernel.org>
parent 5b78077a

arch/arm64/include/asm/kvm_emulate.h

+9 −9
Original line number Diff line number Diff line
@@ -124,12 +124,12 @@ static inline void vcpu_set_vsesr(struct kvm_vcpu *vcpu, u64 vsesr) 


static __always_inline unsigned long *vcpu_pc(const struct kvm_vcpu *vcpu)

{

	return (unsigned long *)&vcpu_gp_regs(vcpu)->regs.pc;

	return (unsigned long *)&vcpu_gp_regs(vcpu)->pc;

}



static inline unsigned long *__vcpu_elr_el1(const struct kvm_vcpu *vcpu)

{

	return (unsigned long *)&vcpu_gp_regs(vcpu)->elr_el1;

	return (unsigned long *)&vcpu->arch.ctxt.elr_el1;

}



static inline unsigned long vcpu_read_elr_el1(const struct kvm_vcpu *vcpu)
@@ -150,7 +150,7 @@ static inline void vcpu_write_elr_el1(const struct kvm_vcpu *vcpu, unsigned long 


static __always_inline unsigned long *vcpu_cpsr(const struct kvm_vcpu *vcpu)

{

	return (unsigned long *)&vcpu_gp_regs(vcpu)->regs.pstate;

	return (unsigned long *)&vcpu_gp_regs(vcpu)->pstate;

}



static __always_inline bool vcpu_mode_is_32bit(const struct kvm_vcpu *vcpu)
@@ -179,14 +179,14 @@ static inline void vcpu_set_thumb(struct kvm_vcpu *vcpu) 
static __always_inline unsigned long vcpu_get_reg(const struct kvm_vcpu *vcpu,

					 u8 reg_num)

{

	return (reg_num == 31) ? 0 : vcpu_gp_regs(vcpu)->regs.regs[reg_num];

	return (reg_num == 31) ? 0 : vcpu_gp_regs(vcpu)->regs[reg_num];

}



static __always_inline void vcpu_set_reg(struct kvm_vcpu *vcpu, u8 reg_num,

				unsigned long val)

{

	if (reg_num != 31)

		vcpu_gp_regs(vcpu)->regs.regs[reg_num] = val;

		vcpu_gp_regs(vcpu)->regs[reg_num] = val;

}



static inline unsigned long vcpu_read_spsr(const struct kvm_vcpu *vcpu)
@@ -197,7 +197,7 @@ static inline unsigned long vcpu_read_spsr(const struct kvm_vcpu *vcpu) 
	if (vcpu->arch.sysregs_loaded_on_cpu)

		return read_sysreg_el1(SYS_SPSR);

	else

		return vcpu_gp_regs(vcpu)->spsr[KVM_SPSR_EL1];

		return vcpu->arch.ctxt.spsr[KVM_SPSR_EL1];

}



static inline void vcpu_write_spsr(struct kvm_vcpu *vcpu, unsigned long v)
@@ -210,7 +210,7 @@ static inline void vcpu_write_spsr(struct kvm_vcpu *vcpu, unsigned long v) 
	if (vcpu->arch.sysregs_loaded_on_cpu)

		write_sysreg_el1(v, SYS_SPSR);

	else

		vcpu_gp_regs(vcpu)->spsr[KVM_SPSR_EL1] = v;

		vcpu->arch.ctxt.spsr[KVM_SPSR_EL1] = v;

}



/*
@@ -519,11 +519,11 @@ static __always_inline void kvm_skip_instr(struct kvm_vcpu *vcpu, bool is_wide_i 
static __always_inline void __kvm_skip_instr(struct kvm_vcpu *vcpu)

{

	*vcpu_pc(vcpu) = read_sysreg_el2(SYS_ELR);

	vcpu->arch.ctxt.gp_regs.regs.pstate = read_sysreg_el2(SYS_SPSR);

	vcpu_gp_regs(vcpu)->pstate = read_sysreg_el2(SYS_SPSR);



	kvm_skip_instr(vcpu, kvm_vcpu_trap_il_is32bit(vcpu));



	write_sysreg_el2(vcpu->arch.ctxt.gp_regs.regs.pstate, SYS_SPSR);

	write_sysreg_el2(vcpu_gp_regs(vcpu)->pstate, SYS_SPSR);

	write_sysreg_el2(*vcpu_pc(vcpu), SYS_ELR);

}

arch/arm64/include/asm/kvm_host.h

+10 −2
Original line number Diff line number Diff line
@@ -236,7 +236,15 @@ enum vcpu_sysreg { 
#define NR_COPRO_REGS	(NR_SYS_REGS * 2)



struct kvm_cpu_context {

	struct kvm_regs	gp_regs;

	struct user_pt_regs regs;	/* sp = sp_el0 */



	u64	sp_el1;

	u64	elr_el1;



	u64	spsr[KVM_NR_SPSR];



	struct user_fpsimd_state fp_regs;



	union {

		u64 sys_regs[NR_SYS_REGS];

		u32 copro[NR_COPRO_REGS];
@@ -402,7 +410,7 @@ struct kvm_vcpu_arch { 
				  system_supports_generic_auth()) && \

				 ((vcpu)->arch.flags & KVM_ARM64_GUEST_HAS_PTRAUTH))



#define vcpu_gp_regs(v)		(&(v)->arch.ctxt.gp_regs)

#define vcpu_gp_regs(v)		(&(v)->arch.ctxt.regs)



/*

 * Only use __vcpu_sys_reg/ctxt_sys_reg if you know you want the

arch/arm64/kernel/asm-offsets.c

+1 −2
Original line number Diff line number Diff line
@@ -102,13 +102,12 @@ int main(void) 
  DEFINE(VCPU_FAULT_DISR,	offsetof(struct kvm_vcpu, arch.fault.disr_el1));

  DEFINE(VCPU_WORKAROUND_FLAGS,	offsetof(struct kvm_vcpu, arch.workaround_flags));

  DEFINE(VCPU_HCR_EL2,		offsetof(struct kvm_vcpu, arch.hcr_el2));

  DEFINE(CPU_GP_REGS,		offsetof(struct kvm_cpu_context, gp_regs));

  DEFINE(CPU_USER_PT_REGS,	offsetof(struct kvm_cpu_context, regs));

  DEFINE(CPU_APIAKEYLO_EL1,	offsetof(struct kvm_cpu_context, sys_regs[APIAKEYLO_EL1]));

  DEFINE(CPU_APIBKEYLO_EL1,	offsetof(struct kvm_cpu_context, sys_regs[APIBKEYLO_EL1]));

  DEFINE(CPU_APDAKEYLO_EL1,	offsetof(struct kvm_cpu_context, sys_regs[APDAKEYLO_EL1]));

  DEFINE(CPU_APDBKEYLO_EL1,	offsetof(struct kvm_cpu_context, sys_regs[APDBKEYLO_EL1]));

  DEFINE(CPU_APGAKEYLO_EL1,	offsetof(struct kvm_cpu_context, sys_regs[APGAKEYLO_EL1]));

  DEFINE(CPU_USER_PT_REGS,	offsetof(struct kvm_regs, regs));

  DEFINE(HOST_CONTEXT_VCPU,	offsetof(struct kvm_cpu_context, __hyp_running_vcpu));

  DEFINE(HOST_DATA_CONTEXT,	offsetof(struct kvm_host_data, host_ctxt));

#endif

arch/arm64/kvm/fpsimd.c

+1 −1
Original line number Diff line number Diff line
@@ -85,7 +85,7 @@ void kvm_arch_vcpu_ctxsync_fp(struct kvm_vcpu *vcpu) 
	WARN_ON_ONCE(!irqs_disabled());



	if (vcpu->arch.flags & KVM_ARM64_FP_ENABLED) {

		fpsimd_bind_state_to_cpu(&vcpu->arch.ctxt.gp_regs.fp_regs,

		fpsimd_bind_state_to_cpu(&vcpu->arch.ctxt.fp_regs,

					 vcpu->arch.sve_state,

					 vcpu->arch.sve_max_vl);

arch/arm64/kvm/guest.c

+56 −14
Original line number Diff line number Diff line
@@ -101,19 +101,60 @@ static int core_reg_size_from_offset(const struct kvm_vcpu *vcpu, u64 off) 
	return size;

}



static int validate_core_offset(const struct kvm_vcpu *vcpu,

				const struct kvm_one_reg *reg)

static void *core_reg_addr(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)

{

	u64 off = core_reg_offset_from_id(reg->id);

	int size = core_reg_size_from_offset(vcpu, off);



	if (size < 0)

		return -EINVAL;

		return NULL;



	if (KVM_REG_SIZE(reg->id) != size)

		return -EINVAL;

		return NULL;



	return 0;

	switch (off) {

	case KVM_REG_ARM_CORE_REG(regs.regs[0]) ...

	     KVM_REG_ARM_CORE_REG(regs.regs[30]):

		off -= KVM_REG_ARM_CORE_REG(regs.regs[0]);

		off /= 2;

		return &vcpu->arch.ctxt.regs.regs[off];



	case KVM_REG_ARM_CORE_REG(regs.sp):

		return &vcpu->arch.ctxt.regs.sp;



	case KVM_REG_ARM_CORE_REG(regs.pc):

		return &vcpu->arch.ctxt.regs.pc;



	case KVM_REG_ARM_CORE_REG(regs.pstate):

		return &vcpu->arch.ctxt.regs.pstate;



	case KVM_REG_ARM_CORE_REG(sp_el1):

		return &vcpu->arch.ctxt.sp_el1;



	case KVM_REG_ARM_CORE_REG(elr_el1):

		return &vcpu->arch.ctxt.elr_el1;



	case KVM_REG_ARM_CORE_REG(spsr[0]) ...

	     KVM_REG_ARM_CORE_REG(spsr[KVM_NR_SPSR - 1]):

		off -= KVM_REG_ARM_CORE_REG(spsr[0]);

		off /= 2;

		return &vcpu->arch.ctxt.spsr[off];



	case KVM_REG_ARM_CORE_REG(fp_regs.vregs[0]) ...

	     KVM_REG_ARM_CORE_REG(fp_regs.vregs[31]):

		off -= KVM_REG_ARM_CORE_REG(fp_regs.vregs[0]);

		off /= 4;

		return &vcpu->arch.ctxt.fp_regs.vregs[off];



	case KVM_REG_ARM_CORE_REG(fp_regs.fpsr):

		return &vcpu->arch.ctxt.fp_regs.fpsr;



	case KVM_REG_ARM_CORE_REG(fp_regs.fpcr):

		return &vcpu->arch.ctxt.fp_regs.fpcr;



	default:

		return NULL;

	}

}



static int get_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
@@ -125,8 +166,8 @@ static int get_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) 
	 * off the index in the "array".

	 */

	__u32 __user *uaddr = (__u32 __user *)(unsigned long)reg->addr;

	struct kvm_regs *regs = vcpu_gp_regs(vcpu);

	int nr_regs = sizeof(*regs) / sizeof(__u32);

	int nr_regs = sizeof(struct kvm_regs) / sizeof(__u32);

	void *addr;

	u32 off;



	/* Our ID is an index into the kvm_regs struct. */
@@ -135,10 +176,11 @@ static int get_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) 
	    (off + (KVM_REG_SIZE(reg->id) / sizeof(__u32))) >= nr_regs)

		return -ENOENT;



	if (validate_core_offset(vcpu, reg))

	addr = core_reg_addr(vcpu, reg);

	if (!addr)

		return -EINVAL;



	if (copy_to_user(uaddr, ((u32 *)regs) + off, KVM_REG_SIZE(reg->id)))

	if (copy_to_user(uaddr, addr, KVM_REG_SIZE(reg->id)))

		return -EFAULT;



	return 0;
@@ -147,10 +189,9 @@ static int get_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) 
static int set_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)

{

	__u32 __user *uaddr = (__u32 __user *)(unsigned long)reg->addr;

	struct kvm_regs *regs = vcpu_gp_regs(vcpu);

	int nr_regs = sizeof(*regs) / sizeof(__u32);

	int nr_regs = sizeof(struct kvm_regs) / sizeof(__u32);

	__uint128_t tmp;

	void *valp = &tmp;

	void *valp = &tmp, *addr;

	u64 off;

	int err = 0;
@@ -160,7 +201,8 @@ static int set_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) 
	    (off + (KVM_REG_SIZE(reg->id) / sizeof(__u32))) >= nr_regs)

		return -ENOENT;



	if (validate_core_offset(vcpu, reg))

	addr = core_reg_addr(vcpu, reg);

	if (!addr)

		return -EINVAL;



	if (KVM_REG_SIZE(reg->id) > sizeof(tmp))
@@ -198,7 +240,7 @@ static int set_core_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) 
		}

	}



	memcpy((u32 *)regs + off, valp, KVM_REG_SIZE(reg->id));

	memcpy(addr, valp, KVM_REG_SIZE(reg->id));



	if (*vcpu_cpsr(vcpu) & PSR_MODE32_BIT) {

		int i;