* [PATCH v6 0/2] MTE support for KVM guest
@ 2020-11-27 15:21 Steven Price
2020-11-27 15:21 ` [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers Steven Price
` (2 more replies)
0 siblings, 3 replies; 9+ messages in thread
From: Steven Price @ 2020-11-27 15:21 UTC (permalink / raw)
To: Catalin Marinas, Marc Zyngier, Will Deacon
Cc: Steven Price, James Morse, Julien Thierry, Suzuki K Poulose,
kvmarm, linux-arm-kernel, linux-kernel, Dave Martin,
Mark Rutland, Thomas Gleixner, qemu-devel, Juan Quintela,
Dr. David Alan Gilbert, Richard Henderson, Peter Maydell,
Haibo Xu, Andrew Jones
It's been a week, and I think the comments on v5 made it clear that
enforcing PROT_MTE requirements on the VMM was probably the wrong
approach. So since I've got swap working correctly without that I
thought I'd post a v6 which hopefully addresses all the comments so far.
This series adds support for Arm's Memory Tagging Extension (MTE) to
KVM, allowing KVM guests to make use of it. This builds on the existing
user space support already in v5.10-rc4, see [1] for an overview.
[1] https://lwn.net/Articles/834289/
Changes since v5[2]:
* Revert back to not requiring the VMM to map all guest memory
PROT_MTE. Instead KVM will set the PG_mte_tagged flag automatically
if not present.
* Fixed swap behaviour vs v4 by always checking for saved MTE tags for
user entries in set_pte_at().
[2] https://lore.kernel.org/r/20201119153901.53705-1-steven.price%40arm.com
Steven Price (2):
arm64: kvm: Save/restore MTE registers
arm64: kvm: Introduce MTE VCPU feature
arch/arm64/include/asm/kvm_emulate.h | 3 +++
arch/arm64/include/asm/kvm_host.h | 8 ++++++++
arch/arm64/include/asm/pgtable.h | 2 +-
arch/arm64/include/asm/sysreg.h | 3 ++-
arch/arm64/kernel/mte.c | 18 +++++++++++++-----
arch/arm64/kvm/arm.c | 9 +++++++++
arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h | 14 ++++++++++++++
arch/arm64/kvm/mmu.c | 16 ++++++++++++++++
arch/arm64/kvm/sys_regs.c | 20 +++++++++++++++-----
include/uapi/linux/kvm.h | 1 +
10 files changed, 82 insertions(+), 12 deletions(-)
--
2.20.1
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers 2020-11-27 15:21 [PATCH v6 0/2] MTE support for KVM guest Steven Price @ 2020-11-27 15:21 ` Steven Price 2020-12-03 17:07 ` Marc Zyngier 2020-11-27 15:21 ` [PATCH v6 2/2] arm64: kvm: Introduce MTE VCPU feature Steven Price 2020-12-03 16:09 ` [PATCH v6 0/2] MTE support for KVM guest Mark Rutland 2 siblings, 1 reply; 9+ messages in thread From: Steven Price @ 2020-11-27 15:21 UTC (permalink / raw) To: Catalin Marinas, Marc Zyngier, Will Deacon Cc: Steven Price, James Morse, Julien Thierry, Suzuki K Poulose, kvmarm, linux-arm-kernel, linux-kernel, Dave Martin, Mark Rutland, Thomas Gleixner, qemu-devel, Juan Quintela, Dr. David Alan Gilbert, Richard Henderson, Peter Maydell, Haibo Xu, Andrew Jones Define the new system registers that MTE introduces and context switch them. The MTE feature is still hidden from the ID register as it isn't supported in a VM yet. Signed-off-by: Steven Price <steven.price@arm.com> --- arch/arm64/include/asm/kvm_host.h | 4 ++++ arch/arm64/include/asm/sysreg.h | 3 ++- arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h | 14 ++++++++++++++ arch/arm64/kvm/sys_regs.c | 14 ++++++++++---- 4 files changed, 30 insertions(+), 5 deletions(-) diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index 0cd9f0f75c13..d3e136343468 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -136,6 +136,8 @@ enum vcpu_sysreg { SCTLR_EL1, /* System Control Register */ ACTLR_EL1, /* Auxiliary Control Register */ CPACR_EL1, /* Coprocessor Access Control */ + RGSR_EL1, /* Random Allocation Tag Seed Register */ + GCR_EL1, /* Tag Control Register */ ZCR_EL1, /* SVE Control */ TTBR0_EL1, /* Translation Table Base Register 0 */ TTBR1_EL1, /* Translation Table Base Register 1 */ @@ -152,6 +154,8 @@ enum vcpu_sysreg { TPIDR_EL1, /* Thread ID, Privileged */ AMAIR_EL1, /* Aux Memory Attribute Indirection Register */ CNTKCTL_EL1, /* Timer Control Register (EL1) */ + TFSRE0_EL1, /* Tag Fault Status Register (EL0) */ + TFSR_EL1, /* Tag Fault Stauts Register (EL1) */ PAR_EL1, /* Physical Address Register */ MDSCR_EL1, /* Monitor Debug System Control Register */ MDCCINT_EL1, /* Monitor Debug Comms Channel Interrupt Enable Reg */ diff --git a/arch/arm64/include/asm/sysreg.h b/arch/arm64/include/asm/sysreg.h index e2ef4c2edf06..b6668ffa04d9 100644 --- a/arch/arm64/include/asm/sysreg.h +++ b/arch/arm64/include/asm/sysreg.h @@ -569,7 +569,8 @@ #define SCTLR_ELx_M (BIT(0)) #define SCTLR_ELx_FLAGS (SCTLR_ELx_M | SCTLR_ELx_A | SCTLR_ELx_C | \ - SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB) + SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB | \ + SCTLR_ELx_ITFSB) /* SCTLR_EL2 specific flags. */ #define SCTLR_EL2_RES1 ((BIT(4)) | (BIT(5)) | (BIT(11)) | (BIT(16)) | \ diff --git a/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h b/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h index cce43bfe158f..45255ba60152 100644 --- a/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h +++ b/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h @@ -18,6 +18,11 @@ static inline void __sysreg_save_common_state(struct kvm_cpu_context *ctxt) { ctxt_sys_reg(ctxt, MDSCR_EL1) = read_sysreg(mdscr_el1); + if (system_supports_mte()) { + ctxt_sys_reg(ctxt, RGSR_EL1) = read_sysreg_s(SYS_RGSR_EL1); + ctxt_sys_reg(ctxt, GCR_EL1) = read_sysreg_s(SYS_GCR_EL1); + ctxt_sys_reg(ctxt, TFSRE0_EL1) = read_sysreg_s(SYS_TFSRE0_EL1); + } } static inline void __sysreg_save_user_state(struct kvm_cpu_context *ctxt) @@ -45,6 +50,8 @@ static inline void __sysreg_save_el1_state(struct kvm_cpu_context *ctxt) ctxt_sys_reg(ctxt, CNTKCTL_EL1) = read_sysreg_el1(SYS_CNTKCTL); ctxt_sys_reg(ctxt, PAR_EL1) = read_sysreg_par(); ctxt_sys_reg(ctxt, TPIDR_EL1) = read_sysreg(tpidr_el1); + if (system_supports_mte()) + ctxt_sys_reg(ctxt, TFSR_EL1) = read_sysreg_el1(SYS_TFSR); ctxt_sys_reg(ctxt, SP_EL1) = read_sysreg(sp_el1); ctxt_sys_reg(ctxt, ELR_EL1) = read_sysreg_el1(SYS_ELR); @@ -63,6 +70,11 @@ static inline void __sysreg_save_el2_return_state(struct kvm_cpu_context *ctxt) static inline void __sysreg_restore_common_state(struct kvm_cpu_context *ctxt) { write_sysreg(ctxt_sys_reg(ctxt, MDSCR_EL1), mdscr_el1); + if (system_supports_mte()) { + write_sysreg_s(ctxt_sys_reg(ctxt, RGSR_EL1), SYS_RGSR_EL1); + write_sysreg_s(ctxt_sys_reg(ctxt, GCR_EL1), SYS_GCR_EL1); + write_sysreg_s(ctxt_sys_reg(ctxt, TFSRE0_EL1), SYS_TFSRE0_EL1); + } } static inline void __sysreg_restore_user_state(struct kvm_cpu_context *ctxt) @@ -106,6 +118,8 @@ static inline void __sysreg_restore_el1_state(struct kvm_cpu_context *ctxt) write_sysreg_el1(ctxt_sys_reg(ctxt, CNTKCTL_EL1), SYS_CNTKCTL); write_sysreg(ctxt_sys_reg(ctxt, PAR_EL1), par_el1); write_sysreg(ctxt_sys_reg(ctxt, TPIDR_EL1), tpidr_el1); + if (system_supports_mte()) + write_sysreg_el1(ctxt_sys_reg(ctxt, TFSR_EL1), SYS_TFSR); if (!has_vhe() && cpus_have_final_cap(ARM64_WORKAROUND_SPECULATIVE_AT) && diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c index c1fac9836af1..4792d5249f07 100644 --- a/arch/arm64/kvm/sys_regs.c +++ b/arch/arm64/kvm/sys_regs.c @@ -1366,6 +1366,12 @@ static bool access_ccsidr(struct kvm_vcpu *vcpu, struct sys_reg_params *p, return true; } +static unsigned int mte_visibility(const struct kvm_vcpu *vcpu, + const struct sys_reg_desc *rd) +{ + return REG_HIDDEN; +} + /* sys_reg_desc initialiser for known cpufeature ID registers */ #define ID_SANITISED(name) { \ SYS_DESC(SYS_##name), \ @@ -1534,8 +1540,8 @@ static const struct sys_reg_desc sys_reg_descs[] = { { SYS_DESC(SYS_ACTLR_EL1), access_actlr, reset_actlr, ACTLR_EL1 }, { SYS_DESC(SYS_CPACR_EL1), NULL, reset_val, CPACR_EL1, 0 }, - { SYS_DESC(SYS_RGSR_EL1), undef_access }, - { SYS_DESC(SYS_GCR_EL1), undef_access }, + { SYS_DESC(SYS_RGSR_EL1), undef_access, reset_unknown, RGSR_EL1, .visibility = mte_visibility }, + { SYS_DESC(SYS_GCR_EL1), undef_access, reset_unknown, GCR_EL1, .visibility = mte_visibility }, { SYS_DESC(SYS_ZCR_EL1), NULL, reset_val, ZCR_EL1, 0, .visibility = sve_visibility }, { SYS_DESC(SYS_TTBR0_EL1), access_vm_reg, reset_unknown, TTBR0_EL1 }, @@ -1561,8 +1567,8 @@ static const struct sys_reg_desc sys_reg_descs[] = { { SYS_DESC(SYS_ERXMISC0_EL1), trap_raz_wi }, { SYS_DESC(SYS_ERXMISC1_EL1), trap_raz_wi }, - { SYS_DESC(SYS_TFSR_EL1), undef_access }, - { SYS_DESC(SYS_TFSRE0_EL1), undef_access }, + { SYS_DESC(SYS_TFSR_EL1), undef_access, reset_unknown, TFSR_EL1, .visibility = mte_visibility }, + { SYS_DESC(SYS_TFSRE0_EL1), undef_access, reset_unknown, TFSRE0_EL1, .visibility = mte_visibility }, { SYS_DESC(SYS_FAR_EL1), access_vm_reg, reset_unknown, FAR_EL1 }, { SYS_DESC(SYS_PAR_EL1), NULL, reset_unknown, PAR_EL1 }, -- 2.20.1 ^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers 2020-11-27 15:21 ` [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers Steven Price @ 2020-12-03 17:07 ` Marc Zyngier 2020-12-07 14:48 ` Steven Price 0 siblings, 1 reply; 9+ messages in thread From: Marc Zyngier @ 2020-12-03 17:07 UTC (permalink / raw) To: Steven Price Cc: Catalin Marinas, Will Deacon, James Morse, Julien Thierry, Suzuki K Poulose, kvmarm, linux-arm-kernel, linux-kernel, Dave Martin, Mark Rutland, Thomas Gleixner, qemu-devel, Juan Quintela, Dr. David Alan Gilbert, Richard Henderson, Peter Maydell, Haibo Xu, Andrew Jones > diff --git a/arch/arm64/include/asm/sysreg.h > b/arch/arm64/include/asm/sysreg.h > index e2ef4c2edf06..b6668ffa04d9 100644 > --- a/arch/arm64/include/asm/sysreg.h > +++ b/arch/arm64/include/asm/sysreg.h > @@ -569,7 +569,8 @@ > #define SCTLR_ELx_M (BIT(0)) > > #define SCTLR_ELx_FLAGS (SCTLR_ELx_M | SCTLR_ELx_A | SCTLR_ELx_C | \ > - SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB) > + SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB | \ > + SCTLR_ELx_ITFSB) > > /* SCTLR_EL2 specific flags. */ > #define SCTLR_EL2_RES1 ((BIT(4)) | (BIT(5)) | (BIT(11)) | (BIT(16)) > | \ > diff --git a/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h > b/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h > index cce43bfe158f..45255ba60152 100644 > --- a/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h > +++ b/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h > @@ -18,6 +18,11 @@ > static inline void __sysreg_save_common_state(struct kvm_cpu_context > *ctxt) > { > ctxt_sys_reg(ctxt, MDSCR_EL1) = read_sysreg(mdscr_el1); > + if (system_supports_mte()) { Please move the per-VM predicate to this patch so that it can be used not to save/restore the MTE registers if we don't need to. > + ctxt_sys_reg(ctxt, RGSR_EL1) = read_sysreg_s(SYS_RGSR_EL1); > + ctxt_sys_reg(ctxt, GCR_EL1) = read_sysreg_s(SYS_GCR_EL1); > + ctxt_sys_reg(ctxt, TFSRE0_EL1) = read_sysreg_s(SYS_TFSRE0_EL1); > + } Overall, I still don't understand how this is going to work once we have MTE in the kernel. You mentioned having the ability to create turn off the tag checks at times, but I don't see that in this patch (and I'm not sure we want that either). Thanks, M. -- Jazz is not dead. It just smells funny... ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers 2020-12-03 17:07 ` Marc Zyngier @ 2020-12-07 14:48 ` Steven Price 2020-12-07 15:55 ` Marc Zyngier 0 siblings, 1 reply; 9+ messages in thread From: Steven Price @ 2020-12-07 14:48 UTC (permalink / raw) To: Marc Zyngier Cc: Catalin Marinas, Will Deacon, James Morse, Julien Thierry, Suzuki K Poulose, kvmarm, linux-arm-kernel, linux-kernel, Dave Martin, Mark Rutland, Thomas Gleixner, qemu-devel, Juan Quintela, Dr. David Alan Gilbert, Richard Henderson, Peter Maydell, Haibo Xu, Andrew Jones On 03/12/2020 17:07, Marc Zyngier wrote: > >> diff --git a/arch/arm64/include/asm/sysreg.h >> b/arch/arm64/include/asm/sysreg.h >> index e2ef4c2edf06..b6668ffa04d9 100644 >> --- a/arch/arm64/include/asm/sysreg.h >> +++ b/arch/arm64/include/asm/sysreg.h >> @@ -569,7 +569,8 @@ >> #define SCTLR_ELx_M (BIT(0)) >> >> #define SCTLR_ELx_FLAGS (SCTLR_ELx_M | SCTLR_ELx_A | SCTLR_ELx_C | \ >> - SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB) >> + SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB | \ >> + SCTLR_ELx_ITFSB) >> >> /* SCTLR_EL2 specific flags. */ >> #define SCTLR_EL2_RES1 ((BIT(4)) | (BIT(5)) | (BIT(11)) | >> (BIT(16)) | \ >> diff --git a/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h >> b/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h >> index cce43bfe158f..45255ba60152 100644 >> --- a/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h >> +++ b/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h >> @@ -18,6 +18,11 @@ >> static inline void __sysreg_save_common_state(struct kvm_cpu_context >> *ctxt) >> { >> ctxt_sys_reg(ctxt, MDSCR_EL1) = read_sysreg(mdscr_el1); >> + if (system_supports_mte()) { > > Please move the per-VM predicate to this patch so that it can be used > not to save/restore the MTE registers if we don't need to. There isn't a valid struct kvm_vcpu or struct kvm here. I know there's ctx->__hyp_running_vcpu but AFAICT that is only valid with the host context. > >> + ctxt_sys_reg(ctxt, RGSR_EL1) = read_sysreg_s(SYS_RGSR_EL1); >> + ctxt_sys_reg(ctxt, GCR_EL1) = read_sysreg_s(SYS_GCR_EL1); >> + ctxt_sys_reg(ctxt, TFSRE0_EL1) = >> read_sysreg_s(SYS_TFSRE0_EL1); >> + } > > Overall, I still don't understand how this is going to work once > we have MTE in the kernel. You mentioned having the ability to > create turn off the tag checks at times, but I don't see that > in this patch (and I'm not sure we want that either). Given that this is now highly unlikely to be merged for v5.11, I'll rebase onto of the KASAN MTE series and double check exactly what happens. My thought was that it should be as simple as setting TCO, but your previous comment about moving the save/restore into assembler might be wise in case the compiler starts playing with TCO itself. Steve ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers 2020-12-07 14:48 ` Steven Price @ 2020-12-07 15:55 ` Marc Zyngier 0 siblings, 0 replies; 9+ messages in thread From: Marc Zyngier @ 2020-12-07 15:55 UTC (permalink / raw) To: Steven Price Cc: Catalin Marinas, Will Deacon, James Morse, Julien Thierry, Suzuki K Poulose, kvmarm, linux-arm-kernel, linux-kernel, Dave Martin, Mark Rutland, Thomas Gleixner, qemu-devel, Juan Quintela, Dr. David Alan Gilbert, Richard Henderson, Peter Maydell, Haibo Xu, Andrew Jones On 2020-12-07 14:48, Steven Price wrote: > On 03/12/2020 17:07, Marc Zyngier wrote: >> >>> diff --git a/arch/arm64/include/asm/sysreg.h >>> b/arch/arm64/include/asm/sysreg.h >>> index e2ef4c2edf06..b6668ffa04d9 100644 >>> --- a/arch/arm64/include/asm/sysreg.h >>> +++ b/arch/arm64/include/asm/sysreg.h >>> @@ -569,7 +569,8 @@ >>> #define SCTLR_ELx_M (BIT(0)) >>> >>> #define SCTLR_ELx_FLAGS (SCTLR_ELx_M | SCTLR_ELx_A | SCTLR_ELx_C >>> | \ >>> - SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB) >>> + SCTLR_ELx_SA | SCTLR_ELx_I | SCTLR_ELx_IESB | \ >>> + SCTLR_ELx_ITFSB) >>> >>> /* SCTLR_EL2 specific flags. */ >>> #define SCTLR_EL2_RES1 ((BIT(4)) | (BIT(5)) | (BIT(11)) | >>> (BIT(16)) | \ >>> diff --git a/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h >>> b/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h >>> index cce43bfe158f..45255ba60152 100644 >>> --- a/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h >>> +++ b/arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h >>> @@ -18,6 +18,11 @@ >>> static inline void __sysreg_save_common_state(struct kvm_cpu_context >>> *ctxt) >>> { >>> ctxt_sys_reg(ctxt, MDSCR_EL1) = read_sysreg(mdscr_el1); >>> + if (system_supports_mte()) { >> >> Please move the per-VM predicate to this patch so that it can be used >> not to save/restore the MTE registers if we don't need to. > > There isn't a valid struct kvm_vcpu or struct kvm here. I know there's > ctx->__hyp_running_vcpu but AFAICT that is only valid with the host > context. We have per-CPU variables for the host context. If ctx->__hyp_running_vcpu is non NULL, you know you're on the host. > >> >>> + ctxt_sys_reg(ctxt, RGSR_EL1) = >>> read_sysreg_s(SYS_RGSR_EL1); >>> + ctxt_sys_reg(ctxt, GCR_EL1) = read_sysreg_s(SYS_GCR_EL1); >>> + ctxt_sys_reg(ctxt, TFSRE0_EL1) = >>> read_sysreg_s(SYS_TFSRE0_EL1); >>> + } >> >> Overall, I still don't understand how this is going to work once >> we have MTE in the kernel. You mentioned having the ability to >> create turn off the tag checks at times, but I don't see that >> in this patch (and I'm not sure we want that either). > > Given that this is now highly unlikely to be merged for v5.11, I'll > rebase onto of the KASAN MTE series and double check exactly what > happens. My thought was that it should be as simple as setting TCO, > but your previous comment about moving the save/restore into assembler > might be wise in case the compiler starts playing with TCO itself. Indeed. Thanks, M. -- Jazz is not dead. It just smells funny... ^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH v6 2/2] arm64: kvm: Introduce MTE VCPU feature 2020-11-27 15:21 [PATCH v6 0/2] MTE support for KVM guest Steven Price 2020-11-27 15:21 ` [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers Steven Price @ 2020-11-27 15:21 ` Steven Price 2020-12-03 16:09 ` [PATCH v6 0/2] MTE support for KVM guest Mark Rutland 2 siblings, 0 replies; 9+ messages in thread From: Steven Price @ 2020-11-27 15:21 UTC (permalink / raw) To: Catalin Marinas, Marc Zyngier, Will Deacon Cc: Steven Price, James Morse, Julien Thierry, Suzuki K Poulose, kvmarm, linux-arm-kernel, linux-kernel, Dave Martin, Mark Rutland, Thomas Gleixner, qemu-devel, Juan Quintela, Dr. David Alan Gilbert, Richard Henderson, Peter Maydell, Haibo Xu, Andrew Jones Add a new VM feature 'KVM_ARM_CAP_MTE' which enables memory tagging for a VM. This exposes the feature to the guest and automatically tags memory pages touched by the VM as PG_mte_tagged (and clears the tags storage) to ensure that the guest cannot see stale tags, and so that the tags are correctly saved/restored across swap. Signed-off-by: Steven Price <steven.price@arm.com> --- arch/arm64/include/asm/kvm_emulate.h | 3 +++ arch/arm64/include/asm/kvm_host.h | 4 ++++ arch/arm64/include/asm/pgtable.h | 2 +- arch/arm64/kernel/mte.c | 18 +++++++++++++----- arch/arm64/kvm/arm.c | 9 +++++++++ arch/arm64/kvm/mmu.c | 16 ++++++++++++++++ arch/arm64/kvm/sys_regs.c | 6 +++++- include/uapi/linux/kvm.h | 1 + 8 files changed, 52 insertions(+), 7 deletions(-) diff --git a/arch/arm64/include/asm/kvm_emulate.h b/arch/arm64/include/asm/kvm_emulate.h index 5ef2669ccd6c..7791ef044b7f 100644 --- a/arch/arm64/include/asm/kvm_emulate.h +++ b/arch/arm64/include/asm/kvm_emulate.h @@ -79,6 +79,9 @@ static inline void vcpu_reset_hcr(struct kvm_vcpu *vcpu) if (cpus_have_const_cap(ARM64_MISMATCHED_CACHE_TYPE) || vcpu_el1_is_32bit(vcpu)) vcpu->arch.hcr_el2 |= HCR_TID2; + + if (kvm_has_mte(vcpu->kvm)) + vcpu->arch.hcr_el2 |= HCR_ATA; } static inline unsigned long *vcpu_hcr(struct kvm_vcpu *vcpu) diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index d3e136343468..aeff10bc5b31 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -120,6 +120,8 @@ struct kvm_arch { unsigned int pmuver; u8 pfr0_csv2; + /* Memory Tagging Extension enabled for the guest */ + bool mte_enabled; }; struct kvm_vcpu_fault_info { @@ -658,4 +660,6 @@ bool kvm_arm_vcpu_is_finalized(struct kvm_vcpu *vcpu); #define kvm_arm_vcpu_sve_finalized(vcpu) \ ((vcpu)->arch.flags & KVM_ARM64_VCPU_SVE_FINALIZED) +#define kvm_has_mte(kvm) (system_supports_mte() && (kvm)->arch.mte_enabled) + #endif /* __ARM64_KVM_HOST_H__ */ diff --git a/arch/arm64/include/asm/pgtable.h b/arch/arm64/include/asm/pgtable.h index 4ff12a7adcfd..74dfd9df38fb 100644 --- a/arch/arm64/include/asm/pgtable.h +++ b/arch/arm64/include/asm/pgtable.h @@ -304,7 +304,7 @@ static inline void set_pte_at(struct mm_struct *mm, unsigned long addr, __sync_icache_dcache(pte); if (system_supports_mte() && - pte_present(pte) && pte_tagged(pte) && !pte_special(pte)) + pte_present(pte) && pte_valid_user(pte) && !pte_special(pte)) mte_sync_tags(ptep, pte); __check_racy_pte_update(mm, ptep, pte); diff --git a/arch/arm64/kernel/mte.c b/arch/arm64/kernel/mte.c index 52a0638ed967..e0c252de25cd 100644 --- a/arch/arm64/kernel/mte.c +++ b/arch/arm64/kernel/mte.c @@ -20,18 +20,24 @@ #include <asm/ptrace.h> #include <asm/sysreg.h> -static void mte_sync_page_tags(struct page *page, pte_t *ptep, bool check_swap) +static void mte_sync_page_tags(struct page *page, pte_t *ptep, bool check_swap, + bool pte_is_tagged) { pte_t old_pte = READ_ONCE(*ptep); if (check_swap && is_swap_pte(old_pte)) { swp_entry_t entry = pte_to_swp_entry(old_pte); - if (!non_swap_entry(entry) && mte_restore_tags(entry, page)) + if (!non_swap_entry(entry) && mte_restore_tags(entry, page)) { + set_bit(PG_mte_tagged, &page->flags); return; + } } - mte_clear_page_tags(page_address(page)); + if (pte_is_tagged) { + set_bit(PG_mte_tagged, &page->flags); + mte_clear_page_tags(page_address(page)); + } } void mte_sync_tags(pte_t *ptep, pte_t pte) @@ -39,11 +45,13 @@ void mte_sync_tags(pte_t *ptep, pte_t pte) struct page *page = pte_page(pte); long i, nr_pages = compound_nr(page); bool check_swap = nr_pages == 1; + bool pte_is_tagged = pte_tagged(pte); /* if PG_mte_tagged is set, tags have already been initialised */ for (i = 0; i < nr_pages; i++, page++) { - if (!test_and_set_bit(PG_mte_tagged, &page->flags)) - mte_sync_page_tags(page, ptep, check_swap); + if (!test_bit(PG_mte_tagged, &page->flags)) + mte_sync_page_tags(page, ptep, check_swap, + pte_is_tagged); } } diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c index c0ffb019ca8b..da4aeba1855c 100644 --- a/arch/arm64/kvm/arm.c +++ b/arch/arm64/kvm/arm.c @@ -89,6 +89,12 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm, r = 0; kvm->arch.return_nisv_io_abort_to_user = true; break; + case KVM_CAP_ARM_MTE: + if (!system_supports_mte() || kvm->created_vcpus) + return -EINVAL; + r = 0; + kvm->arch.mte_enabled = true; + break; default: r = -EINVAL; break; @@ -226,6 +232,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) */ r = 1; break; + case KVM_CAP_ARM_MTE: + r = system_supports_mte(); + break; case KVM_CAP_STEAL_TIME: r = kvm_arm_pvtime_supported(); break; diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c index 1a01da9fdc99..014a7ab7c2e7 100644 --- a/arch/arm64/kvm/mmu.c +++ b/arch/arm64/kvm/mmu.c @@ -877,6 +877,22 @@ static int user_mem_abort(struct kvm_vcpu *vcpu, phys_addr_t fault_ipa, if (vma_pagesize == PAGE_SIZE && !force_pte) vma_pagesize = transparent_hugepage_adjust(memslot, hva, &pfn, &fault_ipa); + + if (kvm_has_mte(kvm) && pfn_valid(pfn)) { + /* + * VM will be able to see the page's tags, so we must ensure + * they have been initialised. + */ + struct page *page = pfn_to_page(pfn); + long i, nr_pages = compound_nr(page); + + /* if PG_mte_tagged is set, tags have already been initialised */ + for (i = 0; i < nr_pages; i++, page++) { + if (!test_and_set_bit(PG_mte_tagged, &page->flags)) + mte_clear_page_tags(page_address(page)); + } + } + if (writable) { prot |= KVM_PGTABLE_PROT_W; kvm_set_pfn_dirty(pfn); diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c index 4792d5249f07..469b0ef3eb07 100644 --- a/arch/arm64/kvm/sys_regs.c +++ b/arch/arm64/kvm/sys_regs.c @@ -1123,7 +1123,8 @@ static u64 read_id_reg(const struct kvm_vcpu *vcpu, val &= ~(0xfUL << ID_AA64PFR0_CSV2_SHIFT); val |= ((u64)vcpu->kvm->arch.pfr0_csv2 << ID_AA64PFR0_CSV2_SHIFT); } else if (id == SYS_ID_AA64PFR1_EL1) { - val &= ~(0xfUL << ID_AA64PFR1_MTE_SHIFT); + if (!kvm_has_mte(vcpu->kvm)) + val &= ~(0xfUL << ID_AA64PFR1_MTE_SHIFT); } else if (id == SYS_ID_AA64ISAR1_EL1 && !vcpu_has_ptrauth(vcpu)) { val &= ~((0xfUL << ID_AA64ISAR1_APA_SHIFT) | (0xfUL << ID_AA64ISAR1_API_SHIFT) | @@ -1369,6 +1370,9 @@ static bool access_ccsidr(struct kvm_vcpu *vcpu, struct sys_reg_params *p, 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; } diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h index ca41220b40b8..3e6fb5b580a9 100644 --- a/include/uapi/linux/kvm.h +++ b/include/uapi/linux/kvm.h @@ -1053,6 +1053,7 @@ struct kvm_ppc_resize_hpt { #define KVM_CAP_X86_USER_SPACE_MSR 188 #define KVM_CAP_X86_MSR_FILTER 189 #define KVM_CAP_ENFORCE_PV_FEATURE_CPUID 190 +#define KVM_CAP_ARM_MTE 191 #ifdef KVM_CAP_IRQ_ROUTING -- 2.20.1 ^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [PATCH v6 0/2] MTE support for KVM guest 2020-11-27 15:21 [PATCH v6 0/2] MTE support for KVM guest Steven Price 2020-11-27 15:21 ` [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers Steven Price 2020-11-27 15:21 ` [PATCH v6 2/2] arm64: kvm: Introduce MTE VCPU feature Steven Price @ 2020-12-03 16:09 ` Mark Rutland 2020-12-03 16:49 ` Steven Price 2 siblings, 1 reply; 9+ messages in thread From: Mark Rutland @ 2020-12-03 16:09 UTC (permalink / raw) To: Steven Price Cc: Catalin Marinas, Marc Zyngier, Will Deacon, James Morse, Julien Thierry, Suzuki K Poulose, kvmarm, linux-arm-kernel, linux-kernel, Dave Martin, Thomas Gleixner, qemu-devel, Juan Quintela, Dr. David Alan Gilbert, Richard Henderson, Peter Maydell, Haibo Xu, Andrew Jones On Fri, Nov 27, 2020 at 03:21:11PM +0000, Steven Price wrote: > It's been a week, and I think the comments on v5 made it clear that > enforcing PROT_MTE requirements on the VMM was probably the wrong > approach. So since I've got swap working correctly without that I > thought I'd post a v6 which hopefully addresses all the comments so far. > > This series adds support for Arm's Memory Tagging Extension (MTE) to > KVM, allowing KVM guests to make use of it. This builds on the existing > user space support already in v5.10-rc4, see [1] for an overview. > arch/arm64/include/asm/kvm_emulate.h | 3 +++ > arch/arm64/include/asm/kvm_host.h | 8 ++++++++ > arch/arm64/include/asm/pgtable.h | 2 +- > arch/arm64/include/asm/sysreg.h | 3 ++- > arch/arm64/kernel/mte.c | 18 +++++++++++++----- > arch/arm64/kvm/arm.c | 9 +++++++++ > arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h | 14 ++++++++++++++ > arch/arm64/kvm/mmu.c | 16 ++++++++++++++++ > arch/arm64/kvm/sys_regs.c | 20 +++++++++++++++----- > include/uapi/linux/kvm.h | 1 + > 10 files changed, 82 insertions(+), 12 deletions(-) I note that doesn't fixup arch/arm64/kvm/inject_fault.c, where in enter_exception64() we have: | // TODO: TCO (if/when ARMv8.5-MemTag is exposed to guests) ... and IIUC when MTE is present, TCO should be set when delivering an exception, so I believe that needs to be updated to set TCO. Given that MTE-capable HW does that unconditionally, this is going to be a mess for big.LITTLE. :/ Thanks, Mark. ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v6 0/2] MTE support for KVM guest 2020-12-03 16:09 ` [PATCH v6 0/2] MTE support for KVM guest Mark Rutland @ 2020-12-03 16:49 ` Steven Price 2020-12-03 16:58 ` Mark Rutland 0 siblings, 1 reply; 9+ messages in thread From: Steven Price @ 2020-12-03 16:49 UTC (permalink / raw) To: Mark Rutland Cc: Catalin Marinas, Marc Zyngier, Will Deacon, James Morse, Julien Thierry, Suzuki K Poulose, kvmarm, linux-arm-kernel, linux-kernel, Dave Martin, Thomas Gleixner, qemu-devel, Juan Quintela, Dr. David Alan Gilbert, Richard Henderson, Peter Maydell, Haibo Xu, Andrew Jones On 03/12/2020 16:09, Mark Rutland wrote: > On Fri, Nov 27, 2020 at 03:21:11PM +0000, Steven Price wrote: >> It's been a week, and I think the comments on v5 made it clear that >> enforcing PROT_MTE requirements on the VMM was probably the wrong >> approach. So since I've got swap working correctly without that I >> thought I'd post a v6 which hopefully addresses all the comments so far. >> >> This series adds support for Arm's Memory Tagging Extension (MTE) to >> KVM, allowing KVM guests to make use of it. This builds on the existing >> user space support already in v5.10-rc4, see [1] for an overview. > >> arch/arm64/include/asm/kvm_emulate.h | 3 +++ >> arch/arm64/include/asm/kvm_host.h | 8 ++++++++ >> arch/arm64/include/asm/pgtable.h | 2 +- >> arch/arm64/include/asm/sysreg.h | 3 ++- >> arch/arm64/kernel/mte.c | 18 +++++++++++++----- >> arch/arm64/kvm/arm.c | 9 +++++++++ >> arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h | 14 ++++++++++++++ >> arch/arm64/kvm/mmu.c | 16 ++++++++++++++++ >> arch/arm64/kvm/sys_regs.c | 20 +++++++++++++++----- >> include/uapi/linux/kvm.h | 1 + >> 10 files changed, 82 insertions(+), 12 deletions(-) > > I note that doesn't fixup arch/arm64/kvm/inject_fault.c, where in > enter_exception64() we have: > > | // TODO: TCO (if/when ARMv8.5-MemTag is exposed to guests) > > ... and IIUC when MTE is present, TCO should be set when delivering an > exception, so I believe that needs to be updated to set TCO. Well spotted! As you say TCO should be set when delivering an exception, so we need the following: - // TODO: TCO (if/when ARMv8.5-MemTag is exposed to guests) + if (kvm_has_mte(vcpu->kvm)) + new |= PSR_TCO_BIT; > Given that MTE-capable HW does that unconditionally, this is going to be > a mess for big.LITTLE. :/ I'm not sure I follow. Either all CPUs support MTE in which this isn't a problem, or the MTE feature just isn't exposed. We don't support a mix of MTE and non-MTE CPUs. There are several aspects of MTE which effective mean it's an all-or-nothing feature for the system. Thanks, Steve ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v6 0/2] MTE support for KVM guest 2020-12-03 16:49 ` Steven Price @ 2020-12-03 16:58 ` Mark Rutland 0 siblings, 0 replies; 9+ messages in thread From: Mark Rutland @ 2020-12-03 16:58 UTC (permalink / raw) To: Steven Price Cc: Catalin Marinas, Marc Zyngier, Will Deacon, James Morse, Julien Thierry, Suzuki K Poulose, kvmarm, linux-arm-kernel, linux-kernel, Dave Martin, Thomas Gleixner, qemu-devel, Juan Quintela, Dr. David Alan Gilbert, Richard Henderson, Peter Maydell, Haibo Xu, Andrew Jones On Thu, Dec 03, 2020 at 04:49:49PM +0000, Steven Price wrote: > On 03/12/2020 16:09, Mark Rutland wrote: > > On Fri, Nov 27, 2020 at 03:21:11PM +0000, Steven Price wrote: > > > It's been a week, and I think the comments on v5 made it clear that > > > enforcing PROT_MTE requirements on the VMM was probably the wrong > > > approach. So since I've got swap working correctly without that I > > > thought I'd post a v6 which hopefully addresses all the comments so far. > > > > > > This series adds support for Arm's Memory Tagging Extension (MTE) to > > > KVM, allowing KVM guests to make use of it. This builds on the existing > > > user space support already in v5.10-rc4, see [1] for an overview. > > > > > arch/arm64/include/asm/kvm_emulate.h | 3 +++ > > > arch/arm64/include/asm/kvm_host.h | 8 ++++++++ > > > arch/arm64/include/asm/pgtable.h | 2 +- > > > arch/arm64/include/asm/sysreg.h | 3 ++- > > > arch/arm64/kernel/mte.c | 18 +++++++++++++----- > > > arch/arm64/kvm/arm.c | 9 +++++++++ > > > arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h | 14 ++++++++++++++ > > > arch/arm64/kvm/mmu.c | 16 ++++++++++++++++ > > > arch/arm64/kvm/sys_regs.c | 20 +++++++++++++++----- > > > include/uapi/linux/kvm.h | 1 + > > > 10 files changed, 82 insertions(+), 12 deletions(-) > > > > I note that doesn't fixup arch/arm64/kvm/inject_fault.c, where in > > enter_exception64() we have: > > > > | // TODO: TCO (if/when ARMv8.5-MemTag is exposed to guests) > > > > ... and IIUC when MTE is present, TCO should be set when delivering an > > exception, so I believe that needs to be updated to set TCO. > > Well spotted! As you say TCO should be set when delivering an exception, so > we need the following: > > - // TODO: TCO (if/when ARMv8.5-MemTag is exposed to guests) > + if (kvm_has_mte(vcpu->kvm)) > + new |= PSR_TCO_BIT; Something of that sort, yes. It'd be worth a look for any mention of TCO or MTE in case there are other bits that need a fixup. > > Given that MTE-capable HW does that unconditionally, this is going to be > > a mess for big.LITTLE. :/ > > I'm not sure I follow. Either all CPUs support MTE in which this isn't a > problem, or the MTE feature just isn't exposed. We don't support a mix of > MTE and non-MTE CPUs. There are several aspects of MTE which effective mean > it's an all-or-nothing feature for the system. So long as the host requires uniform MTE support, I agree that's not a problem. The fun is that the CPUs themselves will set TCO upon a real exception regardless of whether the host is aware, and on a mismatched system some CPUs will do that while others will not. In such a case the host and guest will end up seeing the SPSR TCO bit set sometimes upon exceptions from EL1 or EL2, and I hope that MTE-unaware CPUs ignore the bit upon ERET, or we're going to have significant problems. Thanks, Mark. ^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2020-12-07 15:56 UTC | newest] Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2020-11-27 15:21 [PATCH v6 0/2] MTE support for KVM guest Steven Price 2020-11-27 15:21 ` [PATCH v6 1/2] arm64: kvm: Save/restore MTE registers Steven Price 2020-12-03 17:07 ` Marc Zyngier 2020-12-07 14:48 ` Steven Price 2020-12-07 15:55 ` Marc Zyngier 2020-11-27 15:21 ` [PATCH v6 2/2] arm64: kvm: Introduce MTE VCPU feature Steven Price 2020-12-03 16:09 ` [PATCH v6 0/2] MTE support for KVM guest Mark Rutland 2020-12-03 16:49 ` Steven Price 2020-12-03 16:58 ` Mark Rutland
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).