* [PATCH v3 01/11] KVM: arm64: guest_memfd: Check mmap support when preparing memslot
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 16:43 ` [PATCH v3 02/11] KVM: arm64: CCA: Introduce Realms Steven Price
` (9 subsequent siblings)
10 siblings, 0 replies; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Steven Price, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Suzuki K Poulose, Zenghui Yu,
linux-arm-kernel, linux-kernel, Joey Gouly, Alexandru Elisei,
Christoffer Dall, Fuad Tabba, linux-coco, Ganapatrao Kulkarni,
Gavin Shan, Shanker Donthineni, Alper Gun, Aneesh Kumar K . V,
Emi Kisanuki, Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi,
Kohei Enju
Check the guest_memfd backing file when deciding whether an arm64
memslot has mappable memory rather than checking whether the slot is
gmem only. A public helper function is added to be able to reuse the
static kvm_gmem_supports_mmap() function.
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v2:
- Require mmap-capable guest_memfd backing for all arm64 VMs, as
shared-memory access can use the memslot HVA.
Changes since v1:
- New patch in v2. Check the guest_memfd backing file rather than the
memslot flag when deciding whether arm64 can map the backing memory.
---
arch/arm64/kvm/mmu.c | 6 +++---
include/linux/kvm_host.h | 1 +
virt/kvm/guest_memfd.c | 6 ++++++
3 files changed, 10 insertions(+), 3 deletions(-)
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 1db10d8d6db7..2825fccd2a19 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -2839,10 +2839,10 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,
return -EFAULT;
/*
- * Only support guest_memfd backed memslots with mappable memory, since
- * there aren't any CoCo VMs that support only private memory on arm64.
+ * All VMs need mappable guest_memfd memory, as the memslot's HVA may be
+ * used to access shared memory even if guest faults use guest_memfd.
*/
- if (kvm_slot_has_gmem(new) && !kvm_memslot_is_gmem_only(new))
+ if (kvm_slot_has_gmem(new) && !kvm_gmem_slot_supports_mmap(new))
return -EINVAL;
/* guest_memfd is incompatible with MTE. */
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index e7fc94e2910a..f65728a713ec 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -2614,6 +2614,7 @@ static inline bool kvm_is_private_gfn(struct kvm *kvm, gfn_t gfn)
#ifdef CONFIG_KVM_GUEST_MEMFD
bool kvm_gmem_is_private_gfn(struct kvm *kvm, gfn_t gfn);
+bool kvm_gmem_slot_supports_mmap(const struct kvm_memory_slot *slot);
bool kvm_arch_supports_gmem_init_shared(struct kvm *kvm);
static inline u64 kvm_gmem_get_supported_flags(struct kvm *kvm)
diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c
index 8c97a69b16dc..3dd8d227bebb 100644
--- a/virt/kvm/guest_memfd.c
+++ b/virt/kvm/guest_memfd.c
@@ -442,6 +442,12 @@ static bool kvm_gmem_supports_mmap(struct inode *inode)
return GMEM_I(inode)->flags & GUEST_MEMFD_FLAG_MMAP;
}
+bool kvm_gmem_slot_supports_mmap(const struct kvm_memory_slot *slot)
+{
+ /* The guest_memfd file is pinned while preparing a new memslot. */
+ return kvm_gmem_supports_mmap(file_inode(slot->gmem.file));
+}
+
static vm_fault_t kvm_gmem_fault_user_mapping(struct vm_fault *vmf)
{
struct inode *inode = file_inode(vmf->vma->vm_file);
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* [PATCH v3 02/11] KVM: arm64: CCA: Introduce Realms
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
2026-11-16 16:43 ` [PATCH v3 01/11] KVM: arm64: guest_memfd: Check mmap support when preparing memslot Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 16:43 ` [PATCH v3 03/11] KVM: arm64: Handle attributes in stage2_unmap_range Steven Price
` (8 subsequent siblings)
10 siblings, 0 replies; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Suzuki K Poulose, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Zenghui Yu, linux-arm-kernel,
linux-kernel, Joey Gouly, Alexandru Elisei, Christoffer Dall,
Fuad Tabba, linux-coco, Ganapatrao Kulkarni, Gavin Shan,
Shanker Donthineni, Alper Gun, Aneesh Kumar K . V, Emi Kisanuki,
Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi, Kohei Enju,
Steven Price
From: Suzuki K Poulose <suzuki.poulose@arm.com>
Introduce the Realm VM flavor and per-VM state tracking. Realm and
protected pKVM states are mutually exclusive, so share their storage
in kvm_arch. Adjust the protected VM helpers for the new flavor.
Realm VMs cannot be created yet; RMI initialization and the creation
UABI follow in later patches.
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v1:
- Move RMI initialization to the RMI checks patch and Realm vCPU
feature restrictions to the follow-on integration series. Keep
this patch focused on the Realm VM flavor and per-VM state.
- Limit pKVM power state handling to pKVM vCPUs.
---
arch/arm64/include/asm/kvm_emulate.h | 16 +++++++
arch/arm64/include/asm/kvm_host.h | 47 ++++++++++++--------
arch/arm64/include/asm/kvm_rmi.h | 59 ++++++++++++++++++++++++++
arch/arm64/kvm/arm.c | 7 ++-
arch/arm64/kvm/hyp/include/nvhe/pkvm.h | 2 +-
arch/arm64/kvm/hyp/nvhe/switch.c | 4 +-
arch/arm64/kvm/hyp/nvhe/timer-sr.c | 2 +-
arch/arm64/kvm/mmu.c | 1 +
arch/arm64/kvm/pkvm.c | 2 +-
arch/arm64/kvm/psci.c | 2 +-
10 files changed, 117 insertions(+), 25 deletions(-)
create mode 100644 arch/arm64/include/asm/kvm_rmi.h
diff --git a/arch/arm64/include/asm/kvm_emulate.h b/arch/arm64/include/asm/kvm_emulate.h
index 334211b8b2ee..32021bdf2610 100644
--- a/arch/arm64/include/asm/kvm_emulate.h
+++ b/arch/arm64/include/asm/kvm_emulate.h
@@ -831,4 +831,20 @@ static inline void kvm_reset_vcpu_psci(struct kvm_vcpu *vcpu,
vcpu_set_reg(vcpu, 0, reset_state->r0);
}
+static inline enum realm_state kvm_realm_state(struct kvm *kvm)
+{
+ return READ_ONCE(kvm->arch.realm.state);
+}
+
+static inline void kvm_set_realm_state(struct kvm *kvm,
+ enum realm_state new_state)
+{
+ WRITE_ONCE(kvm->arch.realm.state, new_state);
+}
+
+static inline bool kvm_realm_is_created(struct kvm *kvm)
+{
+ return kvm_vm_is_realm(kvm) && kvm_realm_state(kvm) != REALM_STATE_NONE;
+}
+
#endif /* __ARM64_KVM_EMULATE_H__ */
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index 97332ffcb130..0b6095886d54 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -29,6 +29,7 @@
#include <asm/kvm.h>
#include <asm/kvm_asm.h>
#include <asm/kvm_hcall.h>
+#include <asm/kvm_rmi.h>
#include <asm/vncr_mapping.h>
#define __KVM_HAVE_ARCH_INTC_INITIALIZED
@@ -408,6 +409,7 @@ enum kvm_arm_vm_flavor {
VM_PKVM, /* Normal guests on pKVM */
MARKER(__VM_PROTECTED),
VM_PROTECTED_PKVM, /* Protected VM */
+ VM_REALM, /* CCA */
VM_FLAVOR_MAX
};
@@ -501,11 +503,14 @@ struct kvm_arch {
/* Count the number of VNCR_EL2 TLBs */
atomic_t vncr_tlb_count;
- /*
- * For an untrusted host VM, 'pkvm.handle' is used to lookup
- * the associated pKVM instance in the hypervisor.
- */
- struct kvm_protected_vm pkvm;
+ union {
+ /*
+ * For an untrusted host VM, 'pkvm.handle' is used to lookup
+ * the associated pKVM instance in the hypervisor.
+ */
+ struct kvm_protected_vm pkvm;
+ struct realm realm;
+ };
#ifdef CONFIG_PTDUMP_STAGE2_DEBUGFS
/* Nested virtualization info */
@@ -1571,31 +1576,39 @@ struct kvm *kvm_arch_alloc_vm(void);
#define __KVM_HAVE_ARCH_FLUSH_REMOTE_TLBS_RANGE
-#ifdef __KVM_NVHE_HYPERVISOR__
+#define kvm_vm_is_protected(kvm) ((kvm)->arch.vm_flavor >= __VM_PROTECTED)
-#define kvm_vm_is_protected(kvm) \
- (is_protected_kvm_enabled() && ((kvm)->arch.vm_flavor == VM_PROTECTED_PKVM))
+#ifdef __KVM_NVHE_HYPERVISOR__
/*
* Accessing vcpu->kvm from nVHE hyp stub is tricky, as we need to convert the
* pointer to the hyp VA. With pKVM, the nVHE code runs with the hyp_vcpu,
- * which is populated correctly and is gated on is_protected_kvm_enabled().
+ * which is populated correctly. Always vcpu_is_protected_pkvm(), which is
+ * gated on is_protected_kvm_enabled().
*/
-#define vcpu_is_protected(vcpu) \
+#define vcpu_is_protected(vcpu) BUILD_BUG_ON(1)
+#else
+#define vcpu_is_protected(vcpu) kvm_vm_is_protected((vcpu)->kvm)
+#endif
+
+#define kvm_vm_is_protected_pkvm(kvm) \
+ (is_protected_kvm_enabled() && ((kvm)->arch.vm_flavor == VM_PROTECTED_PKVM))
+
+/*
+ * Rely on is_protected_kvm_enabled() check in kvm_vm_is_protected_pkvm() to
+ * make sure the vcpu->kvm is always valid VA in the context
+ */
+#define vcpu_is_protected_pkvm(vcpu) \
({ \
struct kvm *__kvm = READ_ONCE((vcpu)->kvm); \
\
- (__kvm && kvm_vm_is_protected(__kvm)); \
+ (__kvm && kvm_vm_is_protected_pkvm(__kvm)); \
})
-#else
-
-#define kvm_vm_is_protected(kvm) ((kvm)->arch.vm_flavor >= __VM_PROTECTED)
-#define vcpu_is_protected(vcpu) kvm_vm_is_protected((vcpu)->kvm)
+#define kvm_vm_is_realm(kvm) ((kvm)->arch.vm_flavor == VM_REALM)
+#define vcpu_is_rec(vcpu) kvm_vm_is_realm((vcpu)->kvm)
#define kvm_vm_hyp_is_distrusting(kvm) ((kvm)->arch.vm_flavor >= __VM_DISTRUSTING_HYP)
-#endif /* __KVM_NVHE_HYPERVISOR__ */
-
#define kvm_has_mte(kvm) \
(system_supports_mte() && \
test_bit(KVM_ARCH_FLAG_MTE_ENABLED, &(kvm)->arch.flags))
diff --git a/arch/arm64/include/asm/kvm_rmi.h b/arch/arm64/include/asm/kvm_rmi.h
new file mode 100644
index 000000000000..67f16793b4d0
--- /dev/null
+++ b/arch/arm64/include/asm/kvm_rmi.h
@@ -0,0 +1,59 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2023-2026 ARM Ltd.
+ */
+
+#ifndef __ASM_KVM_RMI_H
+#define __ASM_KVM_RMI_H
+
+/**
+ * enum realm_state - State of a Realm
+ *
+ * Mirrors the RMM's Realm lifecycle states where they are meaningful to KVM,
+ * with REALM_STATE_DYING being a KVM-internal state used to prevent further
+ * requests while teardown is in progress. KVM does not track REALM_SYSTEM_OFF
+ * or REALM_ZOMBIE separately as they naturally lead to teardown.
+ */
+enum realm_state {
+ /**
+ * @REALM_STATE_NONE:
+ * Realm has not yet been created. rmi_realm_create() has not
+ * yet been called.
+ */
+ REALM_STATE_NONE,
+ /**
+ * @REALM_STATE_NEW:
+ * Realm is under construction, Realm Descriptor has been created,
+ * but it is not yet activated. Memory may be populated.
+ */
+ REALM_STATE_NEW,
+ /**
+ * @REALM_STATE_ACTIVE:
+ * Realm has been created and is eligible for execution with
+ * rmi_rec_enter(). Memory may no longer be populated with known
+ * contents.
+ */
+ REALM_STATE_ACTIVE,
+ /**
+ * @REALM_STATE_DYING:
+ * Realm is in the process of being destroyed or has already been
+ * destroyed.
+ */
+ REALM_STATE_DYING,
+ /**
+ * @REALM_STATE_DEAD:
+ * Realm has been destroyed.
+ */
+ REALM_STATE_DEAD
+};
+
+/**
+ * struct realm - Additional per VM data for a Realm
+ *
+ * @state: The lifetime state machine for the realm
+ */
+struct realm {
+ enum realm_state state;
+};
+
+#endif /* __ASM_KVM_RMI_H */
diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index 157bf4b81202..e06cc390a3d6 100644
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -877,7 +877,8 @@ static void __kvm_arm_vcpu_power_off(struct kvm_vcpu *vcpu, u32 mp_state)
/* The guest's own CPU_OFF: EL2 has already powered the vCPU off. */
void kvm_arm_vcpu_power_off(struct kvm_vcpu *vcpu)
{
- u32 mp_state = vcpu_is_protected(vcpu) ? KVM_MP_STATE_UNINITIALIZED : KVM_MP_STATE_STOPPED;
+ u32 mp_state = vcpu_is_protected_pkvm(vcpu) ?
+ KVM_MP_STATE_UNINITIALIZED : KVM_MP_STATE_STOPPED;
spin_lock(&vcpu->arch.mp_state_lock);
__kvm_arm_vcpu_power_off(vcpu, mp_state);
@@ -906,7 +907,8 @@ static bool kvm_arm_vcpu_suspended(struct kvm_vcpu *vcpu)
/* Only the guest's CPU_ON may start a vCPU EL2 holds powered off. */
bool kvm_pkvm_vcpu_is_powered_off(struct kvm_vcpu *vcpu)
{
- return READ_ONCE(vcpu->arch.mp_state.mp_state) == KVM_MP_STATE_UNINITIALIZED;
+ return vcpu_is_protected_pkvm(vcpu) &&
+ READ_ONCE(vcpu->arch.mp_state.mp_state) == KVM_MP_STATE_UNINITIALIZED;
}
int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
@@ -2312,6 +2314,7 @@ static const struct kvm_vcpu_ops *arm64_vcpu_ops[] = {
KVM_VCPU_OPS(VM_VHE, vhe_vcpu_ops),
KVM_VCPU_OPS(VM_PKVM, pkvm_vcpu_ops),
KVM_VCPU_OPS(VM_PROTECTED_PKVM, pkvm_vcpu_ops),
+ [VM_REALM] = NULL,
};
static void kvm_init_vcpu_ops(struct kvm_vcpu *vcpu)
diff --git a/arch/arm64/kvm/hyp/include/nvhe/pkvm.h b/arch/arm64/kvm/hyp/include/nvhe/pkvm.h
index 0261b2bc681f..ae6ced6d7b9e 100644
--- a/arch/arm64/kvm/hyp/include/nvhe/pkvm.h
+++ b/arch/arm64/kvm/hyp/include/nvhe/pkvm.h
@@ -84,7 +84,7 @@ pkvm_hyp_vcpu_to_hyp_vm(struct pkvm_hyp_vcpu *hyp_vcpu)
static inline bool pkvm_hyp_vcpu_is_protected(struct pkvm_hyp_vcpu *hyp_vcpu)
{
- return vcpu_is_protected(&hyp_vcpu->vcpu);
+ return vcpu_is_protected_pkvm(&hyp_vcpu->vcpu);
}
static inline bool pkvm_hyp_vm_is_protected(struct pkvm_hyp_vm *hyp_vm)
diff --git a/arch/arm64/kvm/hyp/nvhe/switch.c b/arch/arm64/kvm/hyp/nvhe/switch.c
index 89fb9dd351ad..6c03f48e6be3 100644
--- a/arch/arm64/kvm/hyp/nvhe/switch.c
+++ b/arch/arm64/kvm/hyp/nvhe/switch.c
@@ -238,7 +238,7 @@ static const exit_handler_fn pvm_exit_handlers[] = {
static const exit_handler_fn *kvm_get_exit_handler_array(struct kvm_vcpu *vcpu)
{
- if (unlikely(vcpu_is_protected(vcpu)))
+ if (unlikely(vcpu_is_protected_pkvm(vcpu)))
return pvm_exit_handlers;
return hyp_exit_handlers;
@@ -259,7 +259,7 @@ static inline bool fixup_guest_exit(struct kvm_vcpu *vcpu, u64 *exit_code)
* it. The check below is based on the one in
* kvm_arch_vcpu_ioctl_run().
*/
- if (unlikely(vcpu_is_protected(vcpu) && vcpu_mode_is_32bit(vcpu))) {
+ if (unlikely(vcpu_is_protected_pkvm(vcpu) && vcpu_mode_is_32bit(vcpu))) {
/*
* As we have caught the guest red-handed, decide that it isn't
* fit for purpose anymore by making the vcpu invalid. The VMM
diff --git a/arch/arm64/kvm/hyp/nvhe/timer-sr.c b/arch/arm64/kvm/hyp/nvhe/timer-sr.c
index 993065716913..17bd1ff621ab 100644
--- a/arch/arm64/kvm/hyp/nvhe/timer-sr.c
+++ b/arch/arm64/kvm/hyp/nvhe/timer-sr.c
@@ -48,7 +48,7 @@ void __timer_enable_traps(struct kvm_vcpu *vcpu)
* or running a protected VM (we don't offset anything in this case).
*/
clr = CNTHCTL_EL1PCEN;
- if (vcpu_is_protected(vcpu) ||
+ if (vcpu_is_protected_pkvm(vcpu) ||
!timer_get_offset(vcpu_ptimer(vcpu)))
set |= CNTHCTL_EL1PCTEN;
else
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 2825fccd2a19..09c831a49ed3 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -3165,6 +3165,7 @@ static const struct kvm_vm_s2_ops *arm64_vm_s2_ops[] = {
KVM_VM_S2_OPS(VM_NVHE, kvm_default_vm_s2_ops),
KVM_VM_S2_OPS(VM_PKVM, pkvm_vm_s2_ops),
KVM_VM_S2_OPS(VM_PROTECTED_PKVM, protected_pkvm_vm_s2_ops),
+ [VM_REALM] = NULL,
};
static int kvm_vm_init_vm_s2_ops(struct kvm *kvm)
diff --git a/arch/arm64/kvm/pkvm.c b/arch/arm64/kvm/pkvm.c
index 016997288fd2..a5145bd75d0c 100644
--- a/arch/arm64/kvm/pkvm.c
+++ b/arch/arm64/kvm/pkvm.c
@@ -192,7 +192,7 @@ static int __pkvm_create_hyp_vcpu(struct kvm_vcpu *vcpu)
* Mirror EL2's seeding of power_state from mp_state. The hyp vCPU is
* published, so take mp_state_lock against kvm_psci_vcpu_on().
*/
- if (vcpu_is_protected(vcpu)) {
+ if (vcpu_is_protected_pkvm(vcpu)) {
spin_lock(&vcpu->arch.mp_state_lock);
if (kvm_arm_vcpu_stopped(vcpu))
WRITE_ONCE(vcpu->arch.mp_state.mp_state, KVM_MP_STATE_UNINITIALIZED);
diff --git a/arch/arm64/kvm/psci.c b/arch/arm64/kvm/psci.c
index b01f8d44033f..6674e8d6ff4c 100644
--- a/arch/arm64/kvm/psci.c
+++ b/arch/arm64/kvm/psci.c
@@ -68,7 +68,7 @@ static unsigned long kvm_psci_vcpu_on(struct kvm_vcpu *source_vcpu)
* STOPPED before that is the VMM's pause.
*/
if (!kvm_arm_vcpu_stopped(vcpu) ||
- (vcpu_is_protected(vcpu) && !kvm_pkvm_vcpu_is_powered_off(vcpu))) {
+ (vcpu_is_protected_pkvm(vcpu) && !kvm_pkvm_vcpu_is_powered_off(vcpu))) {
if (kvm_psci_version(source_vcpu) != KVM_ARM_PSCI_0_1)
ret = PSCI_RET_ALREADY_ON;
else
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* [PATCH v3 03/11] KVM: arm64: Handle attributes in stage2_unmap_range
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
2026-11-16 16:43 ` [PATCH v3 01/11] KVM: arm64: guest_memfd: Check mmap support when preparing memslot Steven Price
2026-11-16 16:43 ` [PATCH v3 02/11] KVM: arm64: CCA: Introduce Realms Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 16:43 ` [PATCH v3 04/11] KVM: arm64: CCA: Add basic infrastructure for creating a realm Steven Price
` (7 subsequent siblings)
10 siblings, 0 replies; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Suzuki K Poulose, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Zenghui Yu, linux-arm-kernel,
linux-kernel, Joey Gouly, Alexandru Elisei, Christoffer Dall,
Fuad Tabba, linux-coco, Ganapatrao Kulkarni, Gavin Shan,
Shanker Donthineni, Alper Gun, Aneesh Kumar K . V, Emi Kisanuki,
Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi, Kohei Enju,
Steven Price
From: Suzuki K Poulose <suzuki.poulose@arm.com>
With the introduction of private memory support, we need to
handle invalidation requests with filters for a given type.
Add support for passing the attributes down.
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Steven Price <steven.price@arm.com>
---
arch/arm64/include/asm/kvm_host.h | 4 +++-
arch/arm64/kvm/mmu.c | 31 +++++++++++++++++++++++--------
2 files changed, 26 insertions(+), 9 deletions(-)
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index 0b6095886d54..aaac97a7461c 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -233,6 +233,7 @@ struct kvm_vcpu_ops {
};
struct kvm_gfn_range;
+enum kvm_gfn_range_filter;
struct kvm_s2_fault_desc;
struct kvm_vm_s2_ops {
@@ -243,7 +244,8 @@ struct kvm_vm_s2_ops {
u64 nr_pages);
void (*vm_stage2_unmap_range)(struct kvm_s2_mmu *mmu,
phys_addr_t start, u64 size,
- bool may_block);
+ bool may_block,
+ enum kvm_gfn_range_filter filter);
int (*vm_mem_abort)(const struct kvm_s2_fault_desc *s2fd);
};
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 09c831a49ed3..8a9a80c7cfab 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -324,7 +324,8 @@ static int kvm_pgtable_stage2_unmap_tracked(struct kvm_pgtable *pgt,
static void kvm_vm_stage2_unmap_range(struct kvm_s2_mmu *mmu,
phys_addr_t start,
- u64 size, bool may_block)
+ u64 size, bool may_block,
+ enum kvm_gfn_range_filter filter)
{
struct kvm *kvm = kvm_s2_mmu_to_kvm(mmu);
int (*fn)(struct kvm_pgtable *, u64, u64);
@@ -339,14 +340,16 @@ static void kvm_vm_stage2_unmap_range(struct kvm_s2_mmu *mmu,
static void pkvm_stage2_unmap_range(struct kvm_s2_mmu *mmu,
phys_addr_t start,
- u64 size, bool may_block)
+ u64 size, bool may_block,
+ enum kvm_gfn_range_filter filter)
{
WARN_ON(stage2_apply_range(mmu, start, start + size,
pkvm_pgtable_stage2_unmap, may_block));
}
static void no_stage2_unmap_range(struct kvm_s2_mmu *mmu,
- phys_addr_t start, u64 size, bool may_block)
+ phys_addr_t start, u64 size, bool may_block,
+ enum kvm_gfn_range_filter filter)
{
}
@@ -388,25 +391,36 @@ static int kvm_pgtable_stage2_unmap_tracked(struct kvm_pgtable *pgt, u64 addr, u
}
/**
- * kvm_stage2_unmap_range -- Clear stage2 page table entries to unmap a range
+ * kvm_stage2_unmap_range_filter -- Clear stage2 page table entries to unmap a
+ * range
* @mmu: The KVM stage-2 MMU pointer
* @start: The intermediate physical base address of the range to unmap
* @size: The size of the area to unmap
* @may_block: Whether or not we are permitted to block
+ * @filter: Filter for the ipa range (private and/or shared)
*
* Clear a range of stage-2 mappings, lowering the various ref-counts. Must
* be called while holding mmu_lock otherwise another faulting VCPU may
* come in and mess with things behind our backs.
*/
-void kvm_stage2_unmap_range(struct kvm_s2_mmu *mmu, phys_addr_t start,
- u64 size, bool may_block)
+static void kvm_stage2_unmap_range_filter(struct kvm_s2_mmu *mmu, phys_addr_t start,
+ u64 size, bool may_block,
+ enum kvm_gfn_range_filter filter)
{
struct kvm *kvm = kvm_s2_mmu_to_kvm(mmu);
lockdep_assert_held_write(&kvm->mmu_lock);
WARN_ON(size & ~PAGE_MASK);
- kvm->arch.vm_s2_ops->vm_stage2_unmap_range(mmu, start, size, may_block);
+ kvm->arch.vm_s2_ops->vm_stage2_unmap_range(mmu, start, size,
+ may_block, filter);
+}
+
+void kvm_stage2_unmap_range(struct kvm_s2_mmu *mmu, phys_addr_t start,
+ u64 size, bool may_block)
+{
+ kvm_stage2_unmap_range_filter(mmu, start, size, may_block,
+ KVM_FILTER_PRIVATE | KVM_FILTER_SHARED);
}
void kvm_stage2_flush_range(struct kvm_s2_mmu *mmu, phys_addr_t addr, phys_addr_t end)
@@ -2597,7 +2611,8 @@ bool kvm_unmap_gfn_range(struct kvm *kvm, struct kvm_gfn_range *range)
if (!kvm->arch.mmu.pgt)
return false;
- kvm_stage2_unmap_range(&kvm->arch.mmu, gpa, size, may_block);
+ kvm_stage2_unmap_range_filter(&kvm->arch.mmu, gpa, size, may_block,
+ range->attr_filter);
kvm_nested_unmap_cipa_range(kvm, gpa, size, may_block);
return false;
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* [PATCH v3 04/11] KVM: arm64: CCA: Add basic infrastructure for creating a realm
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
` (2 preceding siblings ...)
2026-11-16 16:43 ` [PATCH v3 03/11] KVM: arm64: Handle attributes in stage2_unmap_range Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 16:43 ` [PATCH v3 05/11] KVM: arm64: CCA: Tear down RTTs Steven Price
` (6 subsequent siblings)
10 siblings, 0 replies; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Steven Price, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Suzuki K Poulose, Zenghui Yu,
linux-arm-kernel, linux-kernel, Joey Gouly, Alexandru Elisei,
Christoffer Dall, Fuad Tabba, linux-coco, Ganapatrao Kulkarni,
Gavin Shan, Shanker Donthineni, Alper Gun, Aneesh Kumar K . V,
Emi Kisanuki, Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi,
Kohei Enju
Introduce the skeleton functions for creating and destroying a realm.
The requested IPA size is checked against both the KVM and RMM limits.
The actual work of constructing the realm will be added in future
patches.
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v2:
- Move ARM_RMM_RMI selection and rmi.o build registration here.
Store the RD physical address from the outset and free SRO state
on Realm teardown errors.
Changes since v1:
- Cap the Realm IPA size at the smaller KVM and RMM limit, and record
the selected IPA size when initializing Realm state.
---
arch/arm64/include/asm/kvm_rmi.h | 21 +++++++++++
arch/arm64/kvm/Kconfig | 1 +
arch/arm64/kvm/Makefile | 2 +-
arch/arm64/kvm/arm.c | 9 +++++
arch/arm64/kvm/mmu.c | 18 ++++++++--
arch/arm64/kvm/rmi.c | 62 ++++++++++++++++++++++++++++++++
6 files changed, 110 insertions(+), 3 deletions(-)
create mode 100644 arch/arm64/kvm/rmi.c
diff --git a/arch/arm64/include/asm/kvm_rmi.h b/arch/arm64/include/asm/kvm_rmi.h
index 67f16793b4d0..6994756a14e6 100644
--- a/arch/arm64/include/asm/kvm_rmi.h
+++ b/arch/arm64/include/asm/kvm_rmi.h
@@ -6,6 +6,9 @@
#ifndef __ASM_KVM_RMI_H
#define __ASM_KVM_RMI_H
+#include <linux/arm-smccc-rmi.h>
+#include <linux/kvm.h>
+
/**
* enum realm_state - State of a Realm
*
@@ -50,10 +53,28 @@ enum realm_state {
/**
* struct realm - Additional per VM data for a Realm
*
+ * @rd_phys: Physical address of the RMM-managed Realm Descriptor (RD) granule
+ * @sro: Preallocated SRO state context for Realm MMU operations
* @state: The lifetime state machine for the realm
+ * @ia_bits: Number of valid Input Address bits in the IPA
*/
struct realm {
+ phys_addr_t rd_phys;
+ /*
+ * Reused by RTT map/unmap SRO commands. Those commands are only
+ * issued from Realm stage-2 map/unmap paths while kvm->mmu_lock is
+ * held for write, including Realm fault handling where
+ * kvm_fault_lock() takes the write side, so concurrent use is
+ * serialized.
+ */
+ struct rmi_sro_state *sro;
enum realm_state state;
+ unsigned int ia_bits;
};
+u32 kvm_rmm_ipa_limit(void);
+
+int kvm_init_realm(struct kvm *kvm);
+void kvm_destroy_realm(struct kvm *kvm);
+
#endif /* __ASM_KVM_RMI_H */
diff --git a/arch/arm64/kvm/Kconfig b/arch/arm64/kvm/Kconfig
index cecea0820e52..d067063a3686 100644
--- a/arch/arm64/kvm/Kconfig
+++ b/arch/arm64/kvm/Kconfig
@@ -34,6 +34,7 @@ menuconfig KVM
select GUEST_PERF_EVENTS if PERF_EVENTS
select KVM_GUEST_MEMFD
select KVM_GENERIC_PRE_FAULT_MEMORY
+ select ARM_RMM_RMI
help
Support hosting virtualized guest machines.
diff --git a/arch/arm64/kvm/Makefile b/arch/arm64/kvm/Makefile
index 7aaeeb84e788..66a719ab5b6b 100644
--- a/arch/arm64/kvm/Makefile
+++ b/arch/arm64/kvm/Makefile
@@ -16,7 +16,7 @@ CFLAGS_handle_exit.o += -Wno-override-init
kvm-y += arm.o mmu.o mmio.o psci.o hypercalls.o pvtime.o \
inject_fault.o va_layout.o handle_exit.o config.o \
guest.o debug.o reset.o sys_regs.o stacktrace.o \
- vgic-sys-reg-v3.o fpsimd.o pkvm.o \
+ vgic-sys-reg-v3.o fpsimd.o pkvm.o rmi.o \
arch_timer.o trng.o vmid.o emulate-nested.o nested.o at.o \
vgic/vgic.o vgic/vgic-init.o \
vgic/vgic-irqfd.o vgic/vgic-v2.o \
diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index e06cc390a3d6..821e27d07f6a 100644
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -300,6 +300,13 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
bitmap_zero(kvm->arch.vcpu_features, KVM_VCPU_MAX_FEATURES);
+ /* Initialise the realm bits after the generic bits are enabled */
+ if (kvm_vm_is_realm(kvm)) {
+ ret = kvm_init_realm(kvm);
+ if (ret)
+ goto err_uninit_mmu;
+ }
+
return 0;
err_uninit_mmu:
@@ -364,6 +371,8 @@ void kvm_arch_destroy_vm(struct kvm *kvm)
kvm_destroy_nested(kvm);
kvm_arm_teardown_hypercalls(kvm);
+ if (kvm_vm_is_realm(kvm))
+ kvm_destroy_realm(kvm);
}
static bool kvm_has_full_ptr_auth(void)
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 8a9a80c7cfab..ac72db3d4505 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -981,10 +981,14 @@ static struct kvm_pgtable_mm_ops kvm_s2_mm_ops = {
static int kvm_init_ipa_range(struct kvm_s2_mmu *mmu, unsigned long type)
{
+ struct kvm *kvm = kvm_s2_mmu_to_kvm(mmu);
u32 kvm_ipa_limit = get_kvm_ipa_limit();
u64 mmfr0, mmfr1;
u32 phys_shift;
+ if (kvm_vm_is_realm(kvm))
+ kvm_ipa_limit = min(kvm_ipa_limit, kvm_rmm_ipa_limit());
+
phys_shift = KVM_VM_TYPE_ARM_IPA_SIZE(type);
if (is_protected_kvm_enabled()) {
phys_shift = kvm_ipa_limit;
@@ -1034,9 +1038,18 @@ static void stage2_destroy_range(struct kvm_pgtable *pgt, phys_addr_t addr,
static void kvm_stage2_destroy(struct kvm_pgtable *pgt)
{
+ struct kvm *kvm = kvm_s2_mmu_to_kvm(pgt->mmu);
unsigned int ia_bits = VTCR_EL2_IPA(pgt->mmu->vtcr);
- stage2_destroy_range(pgt, 0, BIT(ia_bits));
+ /*
+ * Realm RTTs are inaccessible to the host and may contain stale data
+ * after the RMM has released them. The non-root RTTs are explicitly
+ * destroyed through RMI before the RD is destroyed; only the root PGD
+ * pages remain to be freed here.
+ */
+ if (!kvm_vm_is_realm(kvm))
+ stage2_destroy_range(pgt, 0, BIT(ia_bits));
+
KVM_PGT_FN(kvm_pgtable_stage2_destroy_pgd)(pgt);
}
@@ -1084,6 +1097,8 @@ int kvm_init_stage2_mmu(struct kvm *kvm, struct kvm_s2_mmu *mmu, unsigned long t
return -EINVAL;
}
+ mmu->arch = &kvm->arch;
+
err = kvm_init_ipa_range(mmu, type);
if (err)
return err;
@@ -1092,7 +1107,6 @@ int kvm_init_stage2_mmu(struct kvm *kvm, struct kvm_s2_mmu *mmu, unsigned long t
if (!pgt)
return -ENOMEM;
- mmu->arch = &kvm->arch;
err = KVM_PGT_FN(kvm_pgtable_stage2_init)(pgt, mmu, &kvm_s2_mm_ops);
if (err)
goto out_free_pgtable;
diff --git a/arch/arm64/kvm/rmi.c b/arch/arm64/kvm/rmi.c
new file mode 100644
index 000000000000..57f59b618a96
--- /dev/null
+++ b/arch/arm64/kvm/rmi.c
@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2023-2026 ARM Ltd.
+ */
+
+#include <linux/arm-rmi-cmds.h>
+#include <linux/kvm_host.h>
+
+#include <asm/kvm_emulate.h>
+#include <asm/kvm_mmu.h>
+#include <asm/kvm_pgtable.h>
+#include <asm/virt.h>
+
+u32 kvm_rmm_ipa_limit(void)
+{
+ return u64_get_bits(rmi_feat_reg(0), RMI_FEATURE_REGISTER_0_S2SZ);
+}
+
+void kvm_destroy_realm(struct kvm *kvm)
+{
+ struct realm *realm = &kvm->arch.realm;
+ size_t pgd_size = kvm_pgtable_stage2_pgd_size(kvm->arch.mmu.vtcr);
+
+ if (!kvm_realm_is_created(kvm))
+ goto out_free_sro;
+
+ kvm_set_realm_state(kvm, REALM_STATE_DYING);
+
+ if (realm->rd_phys) {
+ phys_addr_t rd_phys = realm->rd_phys;
+
+ if (WARN_ON(rmi_realm_terminate(rd_phys, realm->sro)))
+ goto out_free_sro;
+
+ if (WARN_ON(rmi_realm_destroy(rd_phys, realm->sro)))
+ goto out_free_sro;
+ rmi_free_delegated_page(rd_phys);
+ realm->rd_phys = 0;
+ }
+
+ if (WARN_ON(rmi_undelegate_range(kvm->arch.mmu.pgd_phys,
+ pgd_size)))
+ goto out_free_sro;
+
+ kvm_set_realm_state(kvm, REALM_STATE_DEAD);
+
+out_free_sro:
+ kfree(realm->sro);
+ realm->sro = NULL;
+}
+
+int kvm_init_realm(struct kvm *kvm)
+{
+ struct realm *realm = &kvm->arch.realm;
+
+ realm->ia_bits = VTCR_EL2_IPA(kvm->arch.mmu.vtcr);
+ realm->sro = kmalloc_obj(*realm->sro);
+ if (!realm->sro)
+ return -ENOMEM;
+
+ return 0;
+}
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* [PATCH v3 05/11] KVM: arm64: CCA: Tear down RTTs
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
` (3 preceding siblings ...)
2026-11-16 16:43 ` [PATCH v3 04/11] KVM: arm64: CCA: Add basic infrastructure for creating a realm Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 17:08 ` sashiko-bot
2026-11-16 16:43 ` [PATCH v3 06/11] KVM: arm64: CCA: Add Realm RTT mapping and invalidation helpers Steven Price
` (5 subsequent siblings)
10 siblings, 1 reply; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Steven Price, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Suzuki K Poulose, Zenghui Yu,
linux-arm-kernel, linux-kernel, Joey Gouly, Alexandru Elisei,
Christoffer Dall, Fuad Tabba, linux-coco, Ganapatrao Kulkarni,
Gavin Shan, Shanker Donthineni, Alper Gun, Aneesh Kumar K . V,
Emi Kisanuki, Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi,
Kohei Enju
The RMM owns the stage 2 page tables for a realm, and KVM must request
that the RMM creates/destroys entries as necessary. The physical pages
to store the page tables are delegated to the realm as required, and can
be undelegated when no longer used.
Creating new RTTs is the easy part, tearing down is a little more
tricky. The result of realm_rtt_destroy() can be used to effectively
walk the tree and destroy the entries (undelegating pages that were
given to the realm).
Tear down a created Realm whether it is still new or has been activated.
Unmap the Realm IPA space once during stage-2 teardown. Defer
destruction of non-root RTTs until final Realm destruction, after
REALM_TERMINATE and before destroying the RD; root RTTs remain until the
RD has gone away.
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v2:
- Use the actual stage-2 start level and correct the RTT skip
granularity. Free SRO state on final teardown errors.
Changes since v1:
- Tear down created Realms in both NEW and ACTIVE states. Fix the
RTT start level, page accounting on failed undelegation, and
handling of RTT granules returned by RMI.
---
arch/arm64/include/asm/kvm_rmi.h | 9 ++
arch/arm64/kvm/mmu.c | 18 ++-
arch/arm64/kvm/rmi.c | 194 +++++++++++++++++++++++++++++++
3 files changed, 220 insertions(+), 1 deletion(-)
diff --git a/arch/arm64/include/asm/kvm_rmi.h b/arch/arm64/include/asm/kvm_rmi.h
index 6994756a14e6..dd16c004b831 100644
--- a/arch/arm64/include/asm/kvm_rmi.h
+++ b/arch/arm64/include/asm/kvm_rmi.h
@@ -57,6 +57,7 @@ enum realm_state {
* @sro: Preallocated SRO state context for Realm MMU operations
* @state: The lifetime state machine for the realm
* @ia_bits: Number of valid Input Address bits in the IPA
+ * @stage2_unmapped: The Realm stage-2 mappings have been removed
*/
struct realm {
phys_addr_t rd_phys;
@@ -70,11 +71,19 @@ struct realm {
struct rmi_sro_state *sro;
enum realm_state state;
unsigned int ia_bits;
+ bool stage2_unmapped;
};
u32 kvm_rmm_ipa_limit(void);
int kvm_init_realm(struct kvm *kvm);
void kvm_destroy_realm(struct kvm *kvm);
+int kvm_realm_teardown_stage2(struct kvm *kvm);
+
+static inline bool kvm_realm_is_private_address(struct realm *realm,
+ unsigned long addr)
+{
+ return !(addr & BIT(realm->ia_bits - 1));
+}
#endif /* __ASM_KVM_RMI_H */
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index ac72db3d4505..9baf2352d2a8 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -1145,9 +1145,25 @@ int kvm_init_stage2_mmu(struct kvm *kvm, struct kvm_s2_mmu *mmu, unsigned long t
return err;
}
+static void kvm_realm_uninit_stage2(struct kvm_s2_mmu *mmu)
+{
+ struct kvm *kvm = kvm_s2_mmu_to_kvm(mmu);
+
+ mutex_lock(&kvm->arch.config_lock);
+ if (kvm_realm_state(kvm) == REALM_STATE_NEW ||
+ kvm_realm_state(kvm) == REALM_STATE_ACTIVE) {
+ kvm_set_realm_state(kvm, REALM_STATE_DYING);
+ WARN_ON(kvm_realm_teardown_stage2(kvm));
+ }
+ mutex_unlock(&kvm->arch.config_lock);
+}
+
void kvm_uninit_stage2_mmu(struct kvm *kvm)
{
- kvm_free_stage2_pgd(&kvm->arch.mmu);
+ if (kvm_realm_is_created(kvm))
+ kvm_realm_uninit_stage2(&kvm->arch.mmu);
+ else
+ kvm_free_stage2_pgd(&kvm->arch.mmu);
kvm_mmu_free_memory_cache(&kvm->arch.mmu.split_page_cache);
}
diff --git a/arch/arm64/kvm/rmi.c b/arch/arm64/kvm/rmi.c
index 57f59b618a96..74b89da4e801 100644
--- a/arch/arm64/kvm/rmi.c
+++ b/arch/arm64/kvm/rmi.c
@@ -16,22 +16,213 @@ u32 kvm_rmm_ipa_limit(void)
return u64_get_bits(rmi_feat_reg(0), RMI_FEATURE_REGISTER_0_S2SZ);
}
+static int get_start_level(struct realm *realm)
+{
+ /*
+ * kvm_init_ipa_range() enforces a minimum of 32 IPA bits
+ * (ARM64_MIN_PARANGE_BITS).
+ */
+ return 4 - stage2_pgtable_levels(realm->ia_bits);
+}
+
+static void free_rtt(phys_addr_t phys)
+{
+ kvm_account_pgtable_pages(phys_to_virt(phys), -1);
+ if (rmi_free_delegated_page(phys))
+ kvm_account_pgtable_pages(phys_to_virt(phys), 1);
+}
+
+/*
+ * realm_rtt_destroy - Destroy an RTT at @level for @addr.
+ *
+ * Returns - Result of the RMI_RTT_DESTROY call, and:
+ * @rtt_granule: RTT granule, if the RTT was destroyed.
+ * @next_addr: IPA corresponding to the next possible valid entry we
+ * can target
+ */
+static long realm_rtt_destroy(struct realm *realm, unsigned long addr,
+ int level, phys_addr_t *rtt_granule,
+ unsigned long *next_addr)
+{
+ unsigned long out_rtt;
+ long ret;
+
+ ret = rmi_rtt_destroy(realm->rd_phys, addr, level,
+ &out_rtt, next_addr);
+
+ if (ret == RMI_SUCCESS)
+ *rtt_granule = out_rtt;
+
+ return ret;
+}
+
+static int realm_tear_down_rtt_level(struct realm *realm, int level,
+ unsigned long start, unsigned long end)
+{
+ ssize_t map_size;
+ unsigned long addr, next_addr;
+
+ if (WARN_ON(level > KVM_PGTABLE_LAST_LEVEL))
+ return -EINVAL;
+
+ map_size = kvm_granule_size(level - 1);
+ if (WARN_ON(!IS_ALIGNED(start, map_size)))
+ return -EINVAL;
+
+ for (addr = start; addr < end; addr = next_addr) {
+ phys_addr_t rtt_granule;
+ long ret;
+ unsigned long align_addr = ALIGN(addr, map_size);
+
+ next_addr = ALIGN(addr + 1, map_size);
+
+ if (next_addr > end || align_addr != addr) {
+ /*
+ * The target range is smaller than what this level
+ * covers, recurse deeper.
+ */
+ ret = realm_tear_down_rtt_level(realm,
+ level + 1,
+ addr,
+ min(next_addr, end));
+ if (ret)
+ return ret;
+ continue;
+ }
+
+ ret = realm_rtt_destroy(realm, addr, level,
+ &rtt_granule, &next_addr);
+ if (ret < 0)
+ return ret;
+
+ switch (RMI_RESULT_STATUS(ret)) {
+ case RMI_SUCCESS:
+ free_rtt(rtt_granule);
+ break;
+ case RMI_ERROR_RTT:
+ if (next_addr > addr) {
+ /* Missing RTT, skip */
+ break;
+ }
+ /*
+ * We tear down the RTT range for the full IPA
+ * space, after everything is unmapped. Also we
+ * descend down only if we cannot tear down a
+ * top level RTT. Thus RMM must be able to walk
+ * to the requested level. e.g., a block mapping
+ * exists at L1 or L2.
+ */
+ if (WARN_ON(RMI_RESULT_DATA_LEVEL(ret) != level))
+ return -EBUSY;
+ if (WARN_ON(level == KVM_PGTABLE_LAST_LEVEL))
+ return -EBUSY;
+
+ /*
+ * The table has active entries in it, recurse deeper
+ * and tear down the RTTs.
+ */
+ next_addr = ALIGN(addr + 1, map_size);
+ ret = realm_tear_down_rtt_level(realm,
+ level + 1,
+ addr,
+ next_addr);
+ if (ret)
+ return ret;
+ /*
+ * Now that the child RTTs are destroyed,
+ * retry at this level.
+ */
+ next_addr = addr;
+ break;
+ default:
+ WARN_ON(1);
+ return -ENXIO;
+ }
+ }
+
+ return 0;
+}
+
+static int realm_tear_down_rtt_range(struct realm *realm,
+ unsigned long start, unsigned long end)
+{
+ /*
+ * Root level RTTs can only be destroyed after the RD is destroyed. So
+ * tear down everything below the root level
+ */
+ return realm_tear_down_rtt_level(realm, get_start_level(realm) + 1,
+ start, end);
+}
+
+static int realm_destroy_rtts(struct kvm *kvm)
+{
+ struct realm *realm = &kvm->arch.realm;
+ unsigned int ia_bits = realm->ia_bits;
+
+ lockdep_assert_held(&kvm->arch.config_lock);
+
+ return realm_tear_down_rtt_range(realm, 0, (1UL << ia_bits));
+}
+
+static void realm_unmap_stage2(struct kvm *kvm)
+{
+ struct realm *realm = &kvm->arch.realm;
+
+ lockdep_assert_held(&kvm->arch.config_lock);
+
+ if (realm->stage2_unmapped)
+ return;
+
+ write_lock(&kvm->mmu_lock);
+ kvm_stage2_unmap_range(&kvm->arch.mmu, 0,
+ BIT(realm->ia_bits - 1), true);
+ write_unlock(&kvm->mmu_lock);
+
+ realm->stage2_unmapped = true;
+}
+
+int kvm_realm_teardown_stage2(struct kvm *kvm)
+{
+ lockdep_assert_held(&kvm->arch.config_lock);
+
+ realm_unmap_stage2(kvm);
+ return 0;
+}
+
void kvm_destroy_realm(struct kvm *kvm)
{
struct realm *realm = &kvm->arch.realm;
size_t pgd_size = kvm_pgtable_stage2_pgd_size(kvm->arch.mmu.vtcr);
+ /*
+ * Serialize final RMM teardown with Realm creation and stage-2 teardown,
+ * which also access Realm state under config_lock.
+ */
+ guard(mutex)(&kvm->arch.config_lock);
+
if (!kvm_realm_is_created(kvm))
goto out_free_sro;
kvm_set_realm_state(kvm, REALM_STATE_DYING);
+ /*
+ * REALM_DESTROY requires the realm to be non-live: all RECs must have
+ * been destroyed and the root RTTs must be empty. Unmap the IPA space
+ * and destroy any non-root RTTs before tearing down the RD. The root
+ * RTT pages are still owned by the RMM at this point, so keep the KVM
+ * pgtable alive until after REALM_DESTROY and undelegation.
+ */
+ realm_unmap_stage2(kvm);
+
if (realm->rd_phys) {
phys_addr_t rd_phys = realm->rd_phys;
if (WARN_ON(rmi_realm_terminate(rd_phys, realm->sro)))
goto out_free_sro;
+ if (WARN_ON(realm_destroy_rtts(kvm)))
+ goto out_free_sro;
+
if (WARN_ON(rmi_realm_destroy(rd_phys, realm->sro)))
goto out_free_sro;
rmi_free_delegated_page(rd_phys);
@@ -44,6 +235,9 @@ void kvm_destroy_realm(struct kvm *kvm)
kvm_set_realm_state(kvm, REALM_STATE_DEAD);
+ /* Now that the realm is destroyed, free the entry-level RTTs. */
+ kvm_free_stage2_pgd(&kvm->arch.mmu);
+
out_free_sro:
kfree(realm->sro);
realm->sro = NULL;
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* Re: [PATCH v3 05/11] KVM: arm64: CCA: Tear down RTTs
2026-11-16 16:43 ` [PATCH v3 05/11] KVM: arm64: CCA: Tear down RTTs Steven Price
@ 2026-11-16 17:08 ` sashiko-bot
0 siblings, 0 replies; 15+ messages in thread
From: sashiko-bot @ 2026-11-16 17:08 UTC (permalink / raw)
To: Steven Price, kvm, kvmarm; +Cc: Oliver Upton, Marc Zyngier
Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [High] KVM: arm64: unclamped stage-2 levels in get_start_level() on
64K pages
- [Medium] KVM: arm64: CCA: unlocked kvm_realm_is_created() check in
kvm_uninit_stage2_mmu()
- [Low] KVM: arm64: mix of guard() and goto cleanup in
kvm_destroy_realm()
- [Low] KVM: arm64: possible skipped parent retry in
realm_tear_down_rtt_level()
--
commit 80a462fb8b46e04c72060d069b1296caf72d83ff
Author: Steven Price <steven.price@arm.com>
KVM: arm64: CCA: Tear down RTTs
This commit adds stage-2 unmapping and Realm Translation Table (RTT)
teardown for Arm CCA Realms during stage-2 MMU uninitialization and final
Realm destruction.
> diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
> index ac72db3d4505f..9baf2352d2a8f 100644
> --- a/arch/arm64/kvm/mmu.c
> +++ b/arch/arm64/kvm/mmu.c
> @@ -1145,9 +1145,25 @@ int kvm_init_stage2_mmu(struct kvm *kvm, struct kvm_s2_mmu *mmu, unsigned long t
> return err;
> }
>
> +static void kvm_realm_uninit_stage2(struct kvm_s2_mmu *mmu)
> +{
> + struct kvm *kvm = kvm_s2_mmu_to_kvm(mmu);
> +
> + mutex_lock(&kvm->arch.config_lock);
> + if (kvm_realm_state(kvm) == REALM_STATE_NEW ||
> + kvm_realm_state(kvm) == REALM_STATE_ACTIVE) {
> + kvm_set_realm_state(kvm, REALM_STATE_DYING);
> + WARN_ON(kvm_realm_teardown_stage2(kvm));
> + }
> + mutex_unlock(&kvm->arch.config_lock);
> +}
> +
> void kvm_uninit_stage2_mmu(struct kvm *kvm)
> {
> - kvm_free_stage2_pgd(&kvm->arch.mmu);
> + if (kvm_realm_is_created(kvm))
> + kvm_realm_uninit_stage2(&kvm->arch.mmu);
> + else
> + kvm_free_stage2_pgd(&kvm->arch.mmu);
> kvm_mmu_free_memory_cache(&kvm->arch.mmu.split_page_cache);
> }
[Severity: Medium]
Can kvm_uninit_stage2_mmu() race with Realm creation by checking
kvm_realm_is_created() outside kvm->arch.config_lock?
If kvm_mmu_notifier_release() -> kvm_arch_flush_shadow_all() runs before
or concurrently with Realm creation, kvm_uninit_stage2_mmu() takes the
else branch without holding config_lock, freeing mmu->pgt and clearing
mmu->pgd_phys while leaving realm.state at REALM_STATE_NONE. Checking
kvm_vm_is_realm(kvm) here and handling all realm.state transitions inside
kvm_realm_uninit_stage2() under config_lock (including moving
REALM_STATE_NONE to REALM_STATE_DEAD and freeing the PGD) would avoid the
race.
> diff --git a/arch/arm64/kvm/rmi.c b/arch/arm64/kvm/rmi.c
> index 57f59b618a96e..74b89da4e8015 100644
> --- a/arch/arm64/kvm/rmi.c
> +++ b/arch/arm64/kvm/rmi.c
> @@ -16,22 +16,213 @@ u32 kvm_rmm_ipa_limit(void)
> return u64_get_bits(rmi_feat_reg(0), RMI_FEATURE_REGISTER_0_S2SZ);
> }
>
> +static int get_start_level(struct realm *realm)
> +{
> + /*
> + * kvm_init_ipa_range() enforces a minimum of 32 IPA bits
> + * (ARM64_MIN_PARANGE_BITS).
> + */
> + return 4 - stage2_pgtable_levels(realm->ia_bits);
> +}
[Severity: High]
Does get_start_level() return 3 instead of 2 for a 32-bit or 33-bit IPA
Realm on CONFIG_ARM64_64K_PAGES?
stage2_pgtable_levels(ipa) evaluates ARM64_HW_PGTABLE_LEVELS((ipa) - 4),
which is 1 for 32 or 33 IPA bits with 64K pages, whereas kvm_get_vtcr()
clamps the stage-2 levels to at least 2:
arch/arm64/kvm/hyp/pgtable.c:kvm_get_vtcr() {
...
lvls = stage2_pgtable_levels(phys_shift);
if (lvls < 2)
lvls = 2;
...
}
When get_start_level() returns 3, realm_tear_down_rtt_range() calls
realm_tear_down_rtt_level() with level = 4 (> KVM_PGTABLE_LAST_LEVEL),
triggering WARN_ON() and returning -EINVAL, which causes
kvm_destroy_realm() to abort and leak the Realm Descriptor, RTT granules
and stage-2 PGD pages.
[ ... ]
> +static int realm_tear_down_rtt_level(struct realm *realm, int level,
> + unsigned long start, unsigned long end)
> +{
> + ssize_t map_size;
> + unsigned long addr, next_addr;
> +
> + if (WARN_ON(level > KVM_PGTABLE_LAST_LEVEL))
> + return -EINVAL;
> +
> + map_size = kvm_granule_size(level - 1);
> + if (WARN_ON(!IS_ALIGNED(start, map_size)))
> + return -EINVAL;
> +
> + for (addr = start; addr < end; addr = next_addr) {
> + phys_addr_t rtt_granule;
> + long ret;
> + unsigned long align_addr = ALIGN(addr, map_size);
> +
> + next_addr = ALIGN(addr + 1, map_size);
> +
> + if (next_addr > end || align_addr != addr) {
> + /*
> + * The target range is smaller than what this level
> + * covers, recurse deeper.
> + */
> + ret = realm_tear_down_rtt_level(realm,
> + level + 1,
> + addr,
> + min(next_addr, end));
> + if (ret)
> + return ret;
> + continue;
> + }
> +
> + ret = realm_rtt_destroy(realm, addr, level,
> + &rtt_granule, &next_addr);
> + if (ret < 0)
> + return ret;
> +
> + switch (RMI_RESULT_STATUS(ret)) {
> + case RMI_SUCCESS:
> + free_rtt(rtt_granule);
> + break;
> + case RMI_ERROR_RTT:
> + if (next_addr > addr) {
> + /* Missing RTT, skip */
> + break;
> + }
> + /*
> + * We tear down the RTT range for the full IPA
> + * space, after everything is unmapped. Also we
> + * descend down only if we cannot tear down a
> + * top level RTT. Thus RMM must be able to walk
> + * to the requested level. e.g., a block mapping
> + * exists at L1 or L2.
> + */
> + if (WARN_ON(RMI_RESULT_DATA_LEVEL(ret) != level))
> + return -EBUSY;
[Severity: Low]
This question rests on an Arm CCA RMM specification detail that could not
be confirmed from the kernel source: when SMC_RMI_RTT_DESTROY fails with
RMI_ERROR_RTT because the RTT at @level still has live child table
entries, can the RMM return out_top > addr (with addr < next_addr <
addr + map_size) if the initial entries in that RTT are non-live, or report
RMI_RESULT_DATA_LEVEL(ret) == level - 1?
If out_top advances to the first live entry inside the RTT at @level, the
if (next_addr > addr) check treats the RTT as missing and advances addr to
that unaligned next_addr; the next iteration then sees align_addr != addr,
destroys the remaining child RTTs at level + 1, and continues to the next
map_size boundary without retrying realm_rtt_destroy() on the parent RTT
at @level, leaving it live and causing rmi_realm_destroy() to fail. If
instead the walk terminates at level - 1 with next_addr == addr,
WARN_ON(RMI_RESULT_DATA_LEVEL(ret) != level) fires and aborts teardown
with -EBUSY.
[ ... ]
> void kvm_destroy_realm(struct kvm *kvm)
> {
> struct realm *realm = &kvm->arch.realm;
> size_t pgd_size = kvm_pgtable_stage2_pgd_size(kvm->arch.mmu.vtcr);
>
> + /*
> + * Serialize final RMM teardown with Realm creation and stage-2 teardown,
> + * which also access Realm state under config_lock.
> + */
> + guard(mutex)(&kvm->arch.config_lock);
> +
> if (!kvm_realm_is_created(kvm))
> goto out_free_sro;
>
> kvm_set_realm_state(kvm, REALM_STATE_DYING);
>
> + /*
> + * REALM_DESTROY requires the realm to be non-live: all RECs must have
> + * been destroyed and the root RTTs must be empty. Unmap the IPA space
> + * and destroy any non-root RTTs before tearing down the RD. The root
> + * RTT pages are still owned by the RMM at this point, so keep the KVM
> + * pgtable alive until after REALM_DESTROY and undelegation.
> + */
> + realm_unmap_stage2(kvm);
> +
> if (realm->rd_phys) {
> phys_addr_t rd_phys = realm->rd_phys;
>
> if (WARN_ON(rmi_realm_terminate(rd_phys, realm->sro)))
> goto out_free_sro;
>
> + if (WARN_ON(realm_destroy_rtts(kvm)))
> + goto out_free_sro;
> +
> if (WARN_ON(rmi_realm_destroy(rd_phys, realm->sro)))
> goto out_free_sro;
> rmi_free_delegated_page(rd_phys);
> @@ -44,6 +235,9 @@ void kvm_destroy_realm(struct kvm *kvm)
>
> kvm_set_realm_state(kvm, REALM_STATE_DEAD);
>
> + /* Now that the realm is destroyed, free the entry-level RTTs. */
> + kvm_free_stage2_pgd(&kvm->arch.mmu);
> +
> out_free_sro:
> kfree(realm->sro);
> realm->sro = NULL;
[Severity: Low]
This isn't a bug, but kvm_destroy_realm() mixes guard(mutex) with goto
out_free_sro cleanup. Using __free(kfree) for realm->sro (or explicit
mutex_lock() and mutex_unlock()) would avoid mixing scope-based cleanup
and goto unwinding in the same function.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261116164358.142785-1-steven.price@arm.com?part=5
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH v3 06/11] KVM: arm64: CCA: Add Realm RTT mapping and invalidation helpers
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
` (4 preceding siblings ...)
2026-11-16 16:43 ` [PATCH v3 05/11] KVM: arm64: CCA: Tear down RTTs Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 17:21 ` sashiko-bot
2026-11-16 16:43 ` [PATCH v3 07/11] KVM: Allow architectures to reject memslot changes before invalidation Steven Price
` (4 subsequent siblings)
10 siblings, 1 reply; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Steven Price, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Suzuki K Poulose, Zenghui Yu,
linux-arm-kernel, linux-kernel, Joey Gouly, Alexandru Elisei,
Christoffer Dall, Fuad Tabba, linux-coco, Ganapatrao Kulkarni,
Gavin Shan, Shanker Donthineni, Alper Gun, Aneesh Kumar K . V,
Emi Kisanuki, Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi,
Kohei Enju
Add the RMI RTT creation and unmap helpers needed by CCA Realm stage-2
memory operations. REC exit handling and guest requested RIPAS changes
follow in the vCPU series.
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v2:
- Use a local MMU cache during notifier invalidation, handle
failed RTT splits, and validate RMI levels and cache state.
Changes since v1:
- Rework RTT creation and folding around missing or existing RTTs.
Use a shared RMI block-size helper and handle alignment, partial
progress and errors in range operations.
---
arch/arm64/include/asm/kvm_rmi.h | 8 +
arch/arm64/kvm/rmi.c | 421 +++++++++++++++++++++++++++++++
drivers/firmware/arm_rmm/rmi.c | 10 -
include/linux/arm-rmi-cmds.h | 8 +
4 files changed, 437 insertions(+), 10 deletions(-)
diff --git a/arch/arm64/include/asm/kvm_rmi.h b/arch/arm64/include/asm/kvm_rmi.h
index dd16c004b831..11e227172faf 100644
--- a/arch/arm64/include/asm/kvm_rmi.h
+++ b/arch/arm64/include/asm/kvm_rmi.h
@@ -80,6 +80,14 @@ int kvm_init_realm(struct kvm *kvm);
void kvm_destroy_realm(struct kvm *kvm);
int kvm_realm_teardown_stage2(struct kvm *kvm);
+enum kvm_gfn_range_filter;
+
+void kvm_realm_unmap_range_filter(struct kvm *kvm,
+ unsigned long ipa,
+ unsigned long size,
+ bool may_block,
+ enum kvm_gfn_range_filter attr_filter);
+
static inline bool kvm_realm_is_private_address(struct realm *realm,
unsigned long addr)
{
diff --git a/arch/arm64/kvm/rmi.c b/arch/arm64/kvm/rmi.c
index 74b89da4e801..838f95c201ad 100644
--- a/arch/arm64/kvm/rmi.c
+++ b/arch/arm64/kvm/rmi.c
@@ -25,6 +25,76 @@ static int get_start_level(struct realm *realm)
return 4 - stage2_pgtable_levels(realm->ia_bits);
}
+static int find_map_level(struct realm *realm,
+ unsigned long start,
+ unsigned long end)
+{
+ int start_level = get_start_level(realm);
+ int level = KVM_PGTABLE_LAST_LEVEL;
+
+ while (level > start_level) {
+ unsigned long map_size = kvm_granule_size(level - 1);
+
+ if (!IS_ALIGNED(start, map_size) ||
+ (start + map_size) > end)
+ break;
+
+ level--;
+ }
+
+ return level;
+}
+
+static int undelegate_range_desc(unsigned long desc)
+{
+ unsigned long size = rmi_addr_block_size_to_bytes(RMI_ADDR_RANGE_BLOCK_SIZE(desc));
+ unsigned long count = RMI_ADDR_RANGE_COUNT(desc);
+ unsigned long addr = RMI_ADDR_RANGE_ADDR(desc);
+ unsigned long state = RMI_ADDR_RANGE_STATE(desc);
+
+ if (state == RMI_OP_MEM_UNDELEGATED)
+ return 0;
+
+ if (size * count == 0)
+ return 0;
+
+ return rmi_undelegate_range(addr, size * count);
+}
+
+static phys_addr_t alloc_delegated_granule(struct kvm_mmu_memory_cache *mc)
+{
+ phys_addr_t phys;
+ void *virt;
+
+ if (mc && kvm_mmu_memory_cache_nr_free_objects(mc)) {
+ virt = kvm_mmu_memory_cache_alloc(mc);
+ } else {
+ virt = (void *)__get_free_page(GFP_ATOMIC | __GFP_ZERO |
+ __GFP_ACCOUNT);
+ }
+
+ if (!virt)
+ return PHYS_ADDR_MAX;
+
+ phys = virt_to_phys(virt);
+ if (rmi_delegate_page(phys)) {
+ free_page((unsigned long)virt);
+ return PHYS_ADDR_MAX;
+ }
+
+ return phys;
+}
+
+static phys_addr_t alloc_rtt(struct kvm_mmu_memory_cache *mc)
+{
+ phys_addr_t phys = alloc_delegated_granule(mc);
+
+ if (phys != PHYS_ADDR_MAX)
+ kvm_account_pgtable_pages(phys_to_virt(phys), 1);
+
+ return phys;
+}
+
static void free_rtt(phys_addr_t phys)
{
kvm_account_pgtable_pages(phys_to_virt(phys), -1);
@@ -32,6 +102,32 @@ static void free_rtt(phys_addr_t phys)
kvm_account_pgtable_pages(phys_to_virt(phys), 1);
}
+static long realm_rtt_create(struct realm *realm,
+ unsigned long addr,
+ int level,
+ phys_addr_t phys)
+{
+ addr = ALIGN_DOWN(addr, kvm_granule_size(level - 1));
+ return rmi_rtt_create(realm->rd_phys, phys, addr, level);
+}
+
+static long realm_rtt_fold(struct realm *realm,
+ unsigned long addr,
+ int level,
+ phys_addr_t *rtt_granule)
+{
+ unsigned long out_rtt;
+ long ret;
+
+ addr = ALIGN_DOWN(addr, kvm_granule_size(level - 1));
+ ret = rmi_rtt_fold(realm->rd_phys, addr, level, &out_rtt);
+
+ if (ret == RMI_SUCCESS && rtt_granule)
+ *rtt_granule = out_rtt;
+
+ return ret;
+}
+
/*
* realm_rtt_destroy - Destroy an RTT at @level for @addr.
*
@@ -56,6 +152,47 @@ static long realm_rtt_destroy(struct realm *realm, unsigned long addr,
return ret;
}
+static int realm_create_rtt_levels(struct realm *realm,
+ unsigned long ipa,
+ int level,
+ int max_level,
+ struct kvm_mmu_memory_cache *mc)
+{
+ long ret = 0;
+ phys_addr_t rtt = PHYS_ADDR_MAX;
+
+ while (level++ < max_level) {
+ if (rtt == PHYS_ADDR_MAX)
+ rtt = alloc_rtt(mc);
+ if (rtt == PHYS_ADDR_MAX)
+ return -ENOMEM;
+
+ ret = realm_rtt_create(realm, ipa, level, rtt);
+ if (ret < 0)
+ break;
+
+ if (RMI_RESULT_STATUS(ret) == RMI_ERROR_RTT &&
+ RMI_RESULT_DATA_LEVEL(ret) == level - 1) {
+ /* The RTT already exists, reuse the granule at the next level. */
+ ret = 0;
+ continue;
+ }
+
+ if (ret) {
+ WARN(1, "Failed to create RTT at level %d: %ld\n",
+ level, ret);
+ ret = -ENXIO;
+ break;
+ }
+ rtt = PHYS_ADDR_MAX;
+ }
+
+ if (rtt != PHYS_ADDR_MAX)
+ free_rtt(rtt);
+
+ return ret;
+}
+
static int realm_tear_down_rtt_level(struct realm *realm, int level,
unsigned long start, unsigned long end)
{
@@ -154,12 +291,94 @@ static int realm_tear_down_rtt_range(struct realm *realm,
start, end);
}
+/*
+ * Returns 0 on successful fold, a negative value on error, a positive value if
+ * we were not able to fold all tables at this level.
+ */
+static int realm_fold_rtt_level(struct realm *realm, int level,
+ unsigned long start, unsigned long end)
+{
+ int not_folded = 0;
+ ssize_t map_size;
+ unsigned long addr, next_addr;
+
+ if (WARN_ON(level > KVM_PGTABLE_LAST_LEVEL))
+ return -EINVAL;
+
+ map_size = kvm_granule_size(level - 1);
+
+ for (addr = start; addr < end; addr = next_addr) {
+ phys_addr_t rtt_granule;
+ long ret;
+
+ next_addr = ALIGN(addr + 1, map_size);
+
+ ret = realm_rtt_fold(realm, addr, level, &rtt_granule);
+ if (ret < 0)
+ return ret;
+
+ switch (RMI_RESULT_STATUS(ret)) {
+ case RMI_SUCCESS:
+ free_rtt(rtt_granule);
+ break;
+ case RMI_ERROR_RTT: {
+ int err_level = RMI_RESULT_DATA_LEVEL(ret);
+
+ if (err_level < level) {
+ /* No RTT at this level; skip the missing ancestor. */
+ if (WARN_ON(err_level < get_start_level(realm)))
+ return -EINVAL;
+ next_addr = ALIGN(addr + 1,
+ kvm_granule_size(err_level));
+ break;
+ }
+ if (level == KVM_PGTABLE_LAST_LEVEL) {
+ not_folded++;
+ break;
+ }
+ /* Recurse a level deeper */
+ ret = realm_fold_rtt_level(realm,
+ level + 1,
+ addr,
+ min(next_addr, end));
+ if (ret < 0)
+ return ret;
+ if (ret) {
+ not_folded++;
+ break;
+ }
+ /* Try once more after folding the child RTTs. */
+ ret = realm_rtt_fold(realm, addr, level, &rtt_granule);
+ if (ret < 0)
+ return ret;
+ if (RMI_RESULT_STATUS(ret) == RMI_SUCCESS) {
+ free_rtt(rtt_granule);
+ break;
+ }
+ if (RMI_RESULT_STATUS(ret) != RMI_ERROR_RTT) {
+ WARN_ON(1);
+ return -ENXIO;
+ }
+ not_folded++;
+ break;
+ }
+ default:
+ WARN_ON(1);
+ return -ENXIO;
+ }
+ }
+
+ return not_folded;
+}
+
static int realm_destroy_rtts(struct kvm *kvm)
{
struct realm *realm = &kvm->arch.realm;
unsigned int ia_bits = realm->ia_bits;
lockdep_assert_held(&kvm->arch.config_lock);
+ if (WARN_ON_ONCE(!realm->stage2_unmapped))
+ return -EINVAL;
return realm_tear_down_rtt_range(realm, 0, (1UL << ia_bits));
}
@@ -189,6 +408,208 @@ int kvm_realm_teardown_stage2(struct kvm *kvm)
return 0;
}
+static bool realm_unmap_cache_topup(struct kvm *kvm,
+ struct kvm_mmu_memory_cache *mc, int needed)
+{
+ int ret;
+
+ if (!mc || kvm_mmu_memory_cache_nr_free_objects(mc) >= needed)
+ return false;
+
+ lockdep_assert_held_write(&kvm->mmu_lock);
+ write_unlock(&kvm->mmu_lock);
+ ret = __kvm_mmu_topup_memory_cache(mc, KVM_PGTABLE_LAST_LEVEL, needed);
+ write_lock(&kvm->mmu_lock);
+
+ return !ret;
+}
+
+static void realm_unmap_shared_range(struct kvm *kvm,
+ unsigned long start,
+ unsigned long end,
+ bool may_block,
+ struct kvm_mmu_memory_cache *mc)
+{
+ struct realm *realm = &kvm->arch.realm;
+ unsigned long rd = realm->rd_phys;
+ unsigned long next_addr, addr;
+ unsigned long shared_bit = BIT(realm->ia_bits - 1);
+
+ if (start >= end)
+ return;
+
+ /*
+ * Callers may pass either an IPA range or its shared alias. Add the
+ * shared bit only for the former. Use addition so an exclusive end at
+ * shared_bit advances to the end of the IPA space.
+ */
+ if (start < shared_bit) {
+ start += shared_bit;
+ end += shared_bit;
+ }
+
+ for (addr = start; addr < end; addr = next_addr) {
+ long ret;
+
+ ret = rmi_rtt_unprot_unmap(rd, addr, end, RMI_ADDR_TYPE_NONE,
+ 0, &next_addr, NULL, NULL);
+ if (WARN_ON(ret < 0))
+ return;
+
+ switch (RMI_RESULT_STATUS(ret)) {
+ case RMI_SUCCESS:
+ break;
+ case RMI_ERROR_RTT: {
+ int err_level = RMI_RESULT_DATA_LEVEL(ret);
+ int level = find_map_level(realm, addr, end);
+
+ if (WARN_ON(err_level < get_start_level(realm) ||
+ err_level > KVM_PGTABLE_LAST_LEVEL))
+ return;
+
+ if (err_level >= level) {
+ /* Nothing present, so skip */
+ next_addr = ALIGN(addr + 1,
+ kvm_granule_size(err_level));
+ break;
+ }
+
+ if (may_block && realm_unmap_cache_topup(kvm, mc,
+ level - err_level)) {
+ next_addr = addr;
+ break;
+ }
+
+ ret = realm_create_rtt_levels(realm, addr, err_level,
+ level, mc);
+ if (!ret) {
+ /* Retry with the RTT levels in place. */
+ next_addr = addr;
+ break;
+ }
+ WARN_ON(ret != -ENOMEM);
+
+ /* Splitting failed; unmap the entire existing block. */
+ next_addr = ALIGN_DOWN(addr, kvm_granule_size(err_level));
+ end = max(end, next_addr + kvm_granule_size(err_level));
+ break;
+ }
+ default:
+ WARN_ON(1);
+ return;
+ }
+
+ if (may_block)
+ cond_resched_rwlock_write(&kvm->mmu_lock);
+ }
+
+ realm_fold_rtt_level(realm, get_start_level(realm) + 1,
+ start, end);
+}
+
+static void realm_unmap_private_range(struct kvm *kvm,
+ unsigned long start,
+ unsigned long end,
+ bool may_block,
+ struct kvm_mmu_memory_cache *mc)
+{
+ struct realm *realm = &kvm->arch.realm;
+ unsigned long rd = realm->rd_phys;
+ unsigned long next_addr, addr;
+ long ret;
+
+ for (addr = start; addr < end; addr = next_addr) {
+ unsigned long out_range;
+ unsigned long flags = RMI_ADDR_TYPE_SINGLE;
+ /* TODO: Optimise using RMI_ADDR_TYPE_LIST */
+
+ ret = rmi_rtt_data_unmap(rd, addr, end, flags, 0,
+ &next_addr, &out_range, NULL);
+ if (WARN_ON(ret < 0))
+ return;
+
+ switch (RMI_RESULT_STATUS(ret)) {
+ case RMI_SUCCESS:
+ ret = undelegate_range_desc(out_range);
+ if (WARN_ON(ret))
+ return;
+ break;
+ case RMI_ERROR_RTT: {
+ int err_level = RMI_RESULT_DATA_LEVEL(ret);
+ int level = find_map_level(realm, addr, end);
+
+ if (WARN_ON(err_level < get_start_level(realm) ||
+ err_level > KVM_PGTABLE_LAST_LEVEL))
+ return;
+
+ if (err_level >= level) {
+ /* Nothing present, so skip this RTT entry. */
+ next_addr = ALIGN(addr + 1,
+ kvm_granule_size(err_level));
+ break;
+ }
+
+ if (may_block && realm_unmap_cache_topup(kvm, mc,
+ level - err_level)) {
+ next_addr = addr;
+ break;
+ }
+
+ ret = realm_create_rtt_levels(realm, addr, err_level,
+ level, mc);
+ if (!ret) {
+ next_addr = addr;
+ break;
+ }
+
+ /* A failed split cannot leave the backing pages mapped. */
+ KVM_BUG_ON(1, kvm);
+ next_addr = ALIGN_DOWN(addr, kvm_granule_size(err_level));
+ end = max(end, next_addr + kvm_granule_size(err_level));
+ break;
+ }
+ default:
+ WARN_ON(1);
+ return;
+ }
+
+ if (may_block)
+ cond_resched_rwlock_write(&kvm->mmu_lock);
+ }
+
+ realm_fold_rtt_level(realm, get_start_level(realm) + 1,
+ start, end);
+}
+
+void kvm_realm_unmap_range_filter(struct kvm *kvm, unsigned long start,
+ unsigned long size, bool may_block,
+ enum kvm_gfn_range_filter attr_filter)
+{
+ /*
+ * MMU notifier callbacks cannot take slots_lock, which protects the
+ * eager split cache. Use a cache owned by this invalidation instead.
+ */
+ struct kvm_mmu_memory_cache cache = { .gfp_zero = __GFP_ZERO };
+ unsigned long end = start + size;
+ struct realm *realm = &kvm->arch.realm;
+
+ if (!kvm_realm_is_created(kvm))
+ return;
+
+ end = min(BIT(realm->ia_bits - 1), end);
+
+ if (attr_filter & KVM_FILTER_SHARED)
+ realm_unmap_shared_range(kvm, start, end, may_block, &cache);
+ if (attr_filter & KVM_FILTER_PRIVATE)
+ realm_unmap_private_range(kvm, start, end, may_block, &cache);
+
+ if (cache.objects) {
+ write_unlock(&kvm->mmu_lock);
+ kvm_mmu_free_memory_cache(&cache);
+ write_lock(&kvm->mmu_lock);
+ }
+}
+
void kvm_destroy_realm(struct kvm *kvm)
{
struct realm *realm = &kvm->arch.realm;
diff --git a/drivers/firmware/arm_rmm/rmi.c b/drivers/firmware/arm_rmm/rmi.c
index 77255a90e0a6..a9f42c9a4f79 100644
--- a/drivers/firmware/arm_rmm/rmi.c
+++ b/drivers/firmware/arm_rmm/rmi.c
@@ -11,7 +11,6 @@
#include <linux/slab.h>
#include <asm/memory.h>
-#include <asm/pgtable-hwdef.h>
/* RMM v2.0 defines RmiFeatureRegister0 to RmiFeatureRegister4. */
static unsigned long rmi_feat_reg_cache[5] __ro_after_init;
@@ -183,15 +182,6 @@ int rmi_free_delegated_page(phys_addr_t phys)
}
EXPORT_SYMBOL_GPL(rmi_free_delegated_page);
-/*
- * Convert the RmiAddrBlockSize to actual size. This is used in RmiDonateReq
- * and RmiAddrRangeDesc*.
- */
-static unsigned long rmi_addr_block_size_to_bytes(unsigned long block_size_fld)
-{
- return BIT(ARM64_HW_PGTABLE_LEVEL_SHIFT(3 - block_size_fld));
-}
-
/*
* free_addr_range: Free memory described by the address range entry, which may
* be partially consumed by RMM.
diff --git a/include/linux/arm-rmi-cmds.h b/include/linux/arm-rmi-cmds.h
index a84e50ac851c..1a885f1017df 100644
--- a/include/linux/arm-rmi-cmds.h
+++ b/include/linux/arm-rmi-cmds.h
@@ -13,8 +13,16 @@
#include <linux/string.h>
#include <linux/types.h>
+#include <asm/pgtable-hwdef.h>
+
#define RMI_MAX_ADDR_LIST 256
+/* Convert the block size used by RmiDonateReq and RmiAddrRangeDesc. */
+static inline unsigned long rmi_addr_block_size_to_bytes(unsigned long block_size)
+{
+ return BIT(ARM64_HW_PGTABLE_LEVEL_SHIFT(3 - block_size));
+}
+
struct rmi_sro_state {
struct arm_smccc_1_2_regs regs;
int addr_count;
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* Re: [PATCH v3 06/11] KVM: arm64: CCA: Add Realm RTT mapping and invalidation helpers
2026-11-16 16:43 ` [PATCH v3 06/11] KVM: arm64: CCA: Add Realm RTT mapping and invalidation helpers Steven Price
@ 2026-11-16 17:21 ` sashiko-bot
0 siblings, 0 replies; 15+ messages in thread
From: sashiko-bot @ 2026-11-16 17:21 UTC (permalink / raw)
To: Steven Price, kvm, kvmarm; +Cc: Oliver Upton, Marc Zyngier
Thank you for your contribution! Sashiko AI review found 5 potential
issues to consider:
- [Medium] KVM: arm64: cca: broken split-failure fallback in
realm_unmap_*_range()
- [Medium] KVM: arm64: cca: stale err_level after
realm_unmap_cache_topup() failure
- [Medium] KVM: arm64: cca: get_start_level() misses 2-level minimum on
64K pages
- [Medium] KVM: arm64: KVM_BUG_ON() on -ENOMEM in
realm_unmap_private_range()
- [Low] KVM: arm64: cca: possible RTT creation for unmapped entry in
realm_unmap_*()
--
commit 453fd020abf481912e2fee6d2f403740b481af92
Author: Steven Price <steven.price@arm.com>
KVM: arm64: CCA: Add Realm RTT mapping and invalidation helpers
This commit adds RMI RTT creation, folding, and unmap helpers for CCA
Realm stage-2 shared and private address ranges.
> diff --git a/arch/arm64/kvm/rmi.c b/arch/arm64/kvm/rmi.c
> index 74b89da4e8015..838f95c201ada 100644
> --- a/arch/arm64/kvm/rmi.c
> +++ b/arch/arm64/kvm/rmi.c
[ ... ]
> @@ -154,12 +291,94 @@ static int realm_tear_down_rtt_range(struct realm *realm,
> start, end);
> }
>
> +/*
> + * Returns 0 on successful fold, a negative value on error, a positive value if
> + * we were not able to fold all tables at this level.
> + */
> +static int realm_fold_rtt_level(struct realm *realm, int level,
> + unsigned long start, unsigned long end)
> +{
> + int not_folded = 0;
> + ssize_t map_size;
> + unsigned long addr, next_addr;
> +
> + if (WARN_ON(level > KVM_PGTABLE_LAST_LEVEL))
> + return -EINVAL;
[Severity: Medium]
On a CONFIG_ARM64_64K_PAGES kernel, can realm_fold_rtt_level() be called
with level == 4 and trigger this WARN_ON()?
For a 32-bit or 33-bit IPA, stage2_pgtable_levels(realm->ia_bits) returns
1 on 64K pages, so get_start_level() returns 4 - 1 = 3
(KVM_PGTABLE_LAST_LEVEL) even though kvm_get_vtcr() clamps stage-2 tables
to at least 2 levels (start_level = 2). When realm_unmap_shared_range()
or realm_unmap_private_range() then calls realm_fold_rtt_level(realm,
get_start_level(realm) + 1, start, end), level is 4, triggering the
warning and skipping RTT folding (and similarly in
realm_tear_down_rtt_range()).
[ ... ]
> @@ -189,6 +408,208 @@ int kvm_realm_teardown_stage2(struct kvm *kvm)
> return 0;
> }
>
> +static bool realm_unmap_cache_topup(struct kvm *kvm,
> + struct kvm_mmu_memory_cache *mc, int needed)
> +{
> + int ret;
> +
> + if (!mc || kvm_mmu_memory_cache_nr_free_objects(mc) >= needed)
> + return false;
> +
> + lockdep_assert_held_write(&kvm->mmu_lock);
> + write_unlock(&kvm->mmu_lock);
> + ret = __kvm_mmu_topup_memory_cache(mc, KVM_PGTABLE_LAST_LEVEL, needed);
> + write_lock(&kvm->mmu_lock);
> +
> + return !ret;
> +}
> +
> +static void realm_unmap_shared_range(struct kvm *kvm,
> + unsigned long start,
> + unsigned long end,
> + bool may_block,
> + struct kvm_mmu_memory_cache *mc)
> +{
> + struct realm *realm = &kvm->arch.realm;
> + unsigned long rd = realm->rd_phys;
> + unsigned long next_addr, addr;
> + unsigned long shared_bit = BIT(realm->ia_bits - 1);
> +
> + if (start >= end)
> + return;
> +
> + /*
> + * Callers may pass either an IPA range or its shared alias. Add the
> + * shared bit only for the former. Use addition so an exclusive end at
> + * shared_bit advances to the end of the IPA space.
> + */
> + if (start < shared_bit) {
> + start += shared_bit;
> + end += shared_bit;
> + }
> +
> + for (addr = start; addr < end; addr = next_addr) {
> + long ret;
> +
> + ret = rmi_rtt_unprot_unmap(rd, addr, end, RMI_ADDR_TYPE_NONE,
> + 0, &next_addr, NULL, NULL);
> + if (WARN_ON(ret < 0))
> + return;
> +
> + switch (RMI_RESULT_STATUS(ret)) {
> + case RMI_SUCCESS:
> + break;
> + case RMI_ERROR_RTT: {
> + int err_level = RMI_RESULT_DATA_LEVEL(ret);
> + int level = find_map_level(realm, addr, end);
> +
> + if (WARN_ON(err_level < get_start_level(realm) ||
> + err_level > KVM_PGTABLE_LAST_LEVEL))
> + return;
> +
> + if (err_level >= level) {
> + /* Nothing present, so skip */
> + next_addr = ALIGN(addr + 1,
> + kvm_granule_size(err_level));
> + break;
> + }
[Severity: Low]
This question rests on an RMM architecture detail that could not be
confirmed from the kernel source: can SMC_RMI_RTT_UNPROT_UNMAP or
SMC_RMI_RTT_DATA_UNMAP return RMI_ERROR_RTT with err_level < level when
the RTT walk stops at an unassigned ancestor entry (where neither a child
RTT nor a block mapping exists), rather than advancing next_addr across
the unmapped ancestor and returning RMI_SUCCESS?
If yes, unmapping a sub-block range (such as a single page where level is
KVM_PGTABLE_LAST_LEVEL) in an unpopulated region will fall through to
realm_create_rtt_levels() in both realm_unmap_shared_range() and
realm_unmap_private_range(), allocating and delegating intermediate RTTs
only to fold them again at the end of the function, and hitting
KVM_BUG_ON(1, kvm) in realm_unmap_private_range() if that allocation
fails.
> +
> + if (may_block && realm_unmap_cache_topup(kvm, mc,
> + level - err_level)) {
> + next_addr = addr;
> + break;
> + }
> +
> + ret = realm_create_rtt_levels(realm, addr, err_level,
> + level, mc);
[Severity: Medium]
Can realm_create_rtt_levels() run with a stale err_level if
__kvm_mmu_topup_memory_cache() fails inside realm_unmap_cache_topup()?
When the cache has fewer than needed objects and topup fails with
-ENOMEM, realm_unmap_cache_topup() still drops and re-acquires
kvm->mmu_lock before returning false. If another thread folds or modifies
the RTTs while mmu_lock is dropped, continuing into
realm_create_rtt_levels() with the pre-unlock err_level (in both
realm_unmap_shared_range() and realm_unmap_private_range()) can fail with
RMI_ERROR_RTT at an ancestor level and trigger the WARN() in
realm_create_rtt_levels().
> + if (!ret) {
> + /* Retry with the RTT levels in place. */
> + next_addr = addr;
> + break;
> + }
> + WARN_ON(ret != -ENOMEM);
> +
> + /* Splitting failed; unmap the entire existing block. */
> + next_addr = ALIGN_DOWN(addr, kvm_granule_size(err_level));
> + end = max(end, next_addr + kvm_granule_size(err_level));
> + break;
[Severity: Medium]
If realm_create_rtt_levels() fails partway through a multi-level split
(for example, after creating a level-2 RTT to split a 1 GiB level-1 block,
then failing with -ENOMEM at level 3), doesn't this fallback use the
initial err_level and widen the unmap to the full 1 GiB block instead of
the 2 MiB block at the last level created?
Also, when next_addr is aligned down below start, start is not updated, so
the realm_fold_rtt_level() call after the loop starts at the original
start and skips folding RTTs in [next_addr, start). Both issues also
apply to the fallback in realm_unmap_private_range().
[ ... ]
> +static void realm_unmap_private_range(struct kvm *kvm,
> + unsigned long start,
> + unsigned long end,
> + bool may_block,
> + struct kvm_mmu_memory_cache *mc)
> +{
[ ... ]
> + ret = realm_create_rtt_levels(realm, addr, err_level,
> + level, mc);
> + if (!ret) {
> + next_addr = addr;
> + break;
> + }
> +
> + /* A failed split cannot leave the backing pages mapped. */\n> + KVM_BUG_ON(1, kvm);
[Severity: Medium]
Can an RTT allocation failure (-ENOMEM) in realm_create_rtt_levels()
trigger a host WARN_ON_ONCE() via KVM_BUG_ON()?
Both __kvm_mmu_topup_memory_cache() and alloc_delegated_granule() use
__GFP_ACCOUNT, so a host VMM hitting its memcg limit or host memory
pressure can cause realm_create_rtt_levels() to return -ENOMEM. Unlike
realm_unmap_shared_range(), which guards its warning with WARN_ON(ret !=
-ENOMEM), KVM_BUG_ON(1, kvm) unconditionally warns even on -ENOMEM; using
WARN_ON(ret != -ENOMEM) and marking the VM dead or bugged without warning
on allocation failure would avoid a user-triggerable kernel warning.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261116164358.142785-1-steven.price@arm.com?part=6
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH v3 07/11] KVM: Allow architectures to reject memslot changes before invalidation
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
` (5 preceding siblings ...)
2026-11-16 16:43 ` [PATCH v3 06/11] KVM: arm64: CCA: Add Realm RTT mapping and invalidation helpers Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 16:43 ` [PATCH v3 08/11] KVM: arm64: CCA: Prevent memslot modifications after Realm creation Steven Price
` (3 subsequent siblings)
10 siblings, 0 replies; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Suzuki K Poulose, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Zenghui Yu, linux-arm-kernel,
linux-kernel, Joey Gouly, Alexandru Elisei, Christoffer Dall,
Fuad Tabba, linux-coco, Ganapatrao Kulkarni, Gavin Shan,
Shanker Donthineni, Alper Gun, Aneesh Kumar K . V, Emi Kisanuki,
Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi, Kohei Enju,
Steven Price
From: Suzuki K Poulose <suzuki.poulose@arm.com>
Architectures may need to reject deletion of a memory slot without
changing the guest's memory mappings. Currently, KVM invalidates the slot
and calls kvm_arch_flush_shadow_memslot() before
kvm_arch_prepare_memory_region() can reject the request. On arm64, this
unmaps the slot from stage-2. Restoring the old memslot on failure does not
restore those mappings, so even a rejected deletion has side effects.
Add kvm_arch_validate_memory_region() and invoke it before invalidating
the slot, with slots_lock and slots_arch_lock held. The hook performs
validation only, allowing architectures to reject a request without
changing the memslot or its mappings. Provide a weak no-op implementation
for architectures that do not need early validation.
Move arm64's protected VM checks into the new hook so that unsupported
deletions and moves are rejected before stage-2 unmapping. Keep resource
preparation after invalidation, since invalidation drops slots_arch_lock
and allows concurrent updates to architecture-specific memslot metadata.
Assisted-by: LLM
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Steven Price <steven.price@arm.com>
---
arch/arm64/kvm/mmu.c | 22 ++++++++++++++++------
arch/arm64/kvm/pkvm.c | 2 +-
include/linux/kvm_host.h | 4 ++++
virt/kvm/kvm_main.c | 33 ++++++++++++++++++++++++++-------
4 files changed, 47 insertions(+), 14 deletions(-)
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 9baf2352d2a8..759ac0453828 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -2851,13 +2851,12 @@ void kvm_arch_commit_memory_region(struct kvm *kvm,
}
}
-int kvm_arch_prepare_memory_region(struct kvm *kvm,
- const struct kvm_memory_slot *old,
- struct kvm_memory_slot *new,
- enum kvm_mr_change change)
+int kvm_arch_validate_memory_region(struct kvm *kvm,
+ const struct kvm_memory_slot *old,
+ const struct kvm_memory_slot *new,
+ enum kvm_mr_change change)
{
- hva_t hva, reg_end;
- int ret = 0;
+ lockdep_assert_held(&kvm->slots_lock);
if (kvm_vm_is_protected(kvm)) {
/* Cannot modify memslots once a pVM has run. */
@@ -2872,6 +2871,17 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,
}
}
+ return 0;
+}
+
+int kvm_arch_prepare_memory_region(struct kvm *kvm,
+ const struct kvm_memory_slot *old,
+ struct kvm_memory_slot *new,
+ enum kvm_mr_change change)
+{
+ hva_t hva, reg_end;
+ int ret = 0;
+
if (change != KVM_MR_CREATE && change != KVM_MR_MOVE &&
change != KVM_MR_FLAGS_ONLY)
return 0;
diff --git a/arch/arm64/kvm/pkvm.c b/arch/arm64/kvm/pkvm.c
index a5145bd75d0c..f4db0e051d6a 100644
--- a/arch/arm64/kvm/pkvm.c
+++ b/arch/arm64/kvm/pkvm.c
@@ -262,7 +262,7 @@ int pkvm_create_hyp_vm(struct kvm *kvm)
int ret = 0;
/*
- * Synchronise with kvm_arch_prepare_memory_region(), as we
+ * Synchronise with kvm_arch_validate_memory_region(), as we
* prevent memslot modifications on a pVM that has been run.
*/
mutex_lock(&kvm->slots_lock);
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index f65728a713ec..15848221860f 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -1255,6 +1255,10 @@ int kvm_set_internal_memslot(struct kvm *kvm,
const struct kvm_userspace_memory_region2 *mem);
void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *slot);
void kvm_arch_memslots_updated(struct kvm *kvm, u64 gen);
+int kvm_arch_validate_memory_region(struct kvm *kvm,
+ const struct kvm_memory_slot *old,
+ const struct kvm_memory_slot *new,
+ enum kvm_mr_change change);
int kvm_arch_prepare_memory_region(struct kvm *kvm,
const struct kvm_memory_slot *old,
struct kvm_memory_slot *new,
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index cf4cb586f140..3ef370d71818 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -1682,6 +1682,20 @@ static void kvm_swap_active_memslots(struct kvm *kvm, int as_id)
slots->generation = gen;
}
+/*
+ * Validate a memslot change before invalidation, which may irreversibly reclaim
+ * private guest memory. Called with slots_lock and slots_arch_lock held.
+ * Implementations must not modify memslot state or allocate resources; leave
+ * those operations to kvm_arch_prepare_memory_region().
+ */
+__weak int kvm_arch_validate_memory_region(struct kvm *kvm,
+ const struct kvm_memory_slot *old,
+ const struct kvm_memory_slot *new,
+ enum kvm_mr_change change)
+{
+ return 0;
+}
+
static int kvm_prepare_memory_region(struct kvm *kvm,
const struct kvm_memory_slot *old,
struct kvm_memory_slot *new,
@@ -1934,6 +1948,10 @@ static int kvm_set_memslot(struct kvm *kvm,
*/
mutex_lock(&kvm->slots_arch_lock);
+ r = kvm_arch_validate_memory_region(kvm, old, new, change);
+ if (r)
+ goto unlock_err;
+
/*
* Invalidate the old slot if it's being deleted or moved. This is
* done prior to actually deleting/moving the memslot to allow vCPUs to
@@ -1950,22 +1968,22 @@ static int kvm_set_memslot(struct kvm *kvm,
if (change == KVM_MR_DELETE || change == KVM_MR_MOVE) {
invalid_slot = kzalloc_obj(*invalid_slot, GFP_KERNEL_ACCOUNT);
if (!invalid_slot) {
- mutex_unlock(&kvm->slots_arch_lock);
- return -ENOMEM;
+ r = -ENOMEM;
+ goto unlock_err;
}
kvm_invalidate_memslot(kvm, old, invalid_slot);
}
r = kvm_prepare_memory_region(kvm, old, new, change);
if (r)
- goto err;
+ goto revert_slot;
if (change == KVM_MR_CREATE && (new->flags & KVM_MEM_GUEST_MEMFD)) {
r = kvm_gmem_commit_memory_region(kvm, new);
if (r) {
kvm_arch_free_memslot(kvm, new);
kvm_destroy_dirty_bitmap(new);
- goto err;
+ goto unlock_err;
}
}
@@ -2000,7 +2018,7 @@ static int kvm_set_memslot(struct kvm *kvm,
return 0;
-err:
+revert_slot:
/*
* For DELETE/MOVE, revert the above INVALID change. No modifications
* required since the original slot was preserved in the inactive slots.
@@ -2009,9 +2027,10 @@ static int kvm_set_memslot(struct kvm *kvm,
if (change == KVM_MR_DELETE || change == KVM_MR_MOVE) {
kvm_activate_memslot(kvm, invalid_slot, old);
kfree(invalid_slot);
- } else {
- mutex_unlock(&kvm->slots_arch_lock);
+ return r;
}
+unlock_err:
+ mutex_unlock(&kvm->slots_arch_lock);
return r;
}
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* [PATCH v3 08/11] KVM: arm64: CCA: Prevent memslot modifications after Realm creation
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
` (6 preceding siblings ...)
2026-11-16 16:43 ` [PATCH v3 07/11] KVM: Allow architectures to reject memslot changes before invalidation Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 16:43 ` [PATCH v3 09/11] KVM: arm64: CCA: Support runtime faulting of memory Steven Price
` (2 subsequent siblings)
10 siblings, 0 replies; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Suzuki K Poulose, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Zenghui Yu, linux-arm-kernel,
linux-kernel, Joey Gouly, Alexandru Elisei, Christoffer Dall,
Fuad Tabba, linux-coco, Ganapatrao Kulkarni, Gavin Shan,
Shanker Donthineni, Alper Gun, Aneesh Kumar K . V, Emi Kisanuki,
Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi, Kohei Enju,
Steven Price
From: Suzuki K Poulose <suzuki.poulose@arm.com>
Once the Realm is created, prevent changes to guest_memfd backed
memslots, which can provide private memory. Validate these changes
before KVM invalidates the old memslot, so a rejected deletion leaves
its stage-2 mappings intact. Realm stage-2 faults will also validate
the private memory backing in a later commit.
Require Realm memslots to lie in the lower half of the IPA space, as the
upper, shared half aliases the lower, protected half.
Define kvm_arch_has_private_mem() so generic KVM recognizes Realm VMs
as supporting private memory.
Additionally, similar to pKVM, do not support dirty logging or
read-only memslots.
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v1:
- Preserve private mappings if KVM invalidates a Realm guest_memfd
slot before the prepare hook rejects its deletion.
---
arch/arm64/include/asm/kvm_host.h | 2 ++
arch/arm64/kvm/mmu.c | 37 +++++++++++++++++++++++--------
2 files changed, 30 insertions(+), 9 deletions(-)
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index aaac97a7461c..2c8cd9a1dd52 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -1611,6 +1611,8 @@ struct kvm *kvm_arch_alloc_vm(void);
#define kvm_vm_hyp_is_distrusting(kvm) ((kvm)->arch.vm_flavor >= __VM_DISTRUSTING_HYP)
+#define kvm_arch_has_private_mem(kvm) kvm_vm_is_realm(kvm)
+
#define kvm_has_mte(kvm) \
(system_supports_mte() && \
test_bit(KVM_ARCH_FLAG_MTE_ENABLED, &(kvm)->arch.flags))
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 759ac0453828..0db3c293fdd5 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -2858,17 +2858,32 @@ int kvm_arch_validate_memory_region(struct kvm *kvm,
{
lockdep_assert_held(&kvm->slots_lock);
- if (kvm_vm_is_protected(kvm)) {
+ if (kvm_vm_is_protected(kvm) && new &&
+ (new->flags & (KVM_MEM_LOG_DIRTY_PAGES | KVM_MEM_READONLY)))
+ return -EPERM;
+
+ switch (kvm->arch.vm_flavor) {
+ case VM_PROTECTED_PKVM:
/* Cannot modify memslots once a pVM has run. */
if (pkvm_hyp_vm_is_created(kvm) &&
- (change == KVM_MR_DELETE || change == KVM_MR_MOVE)) {
+ (change == KVM_MR_DELETE || change == KVM_MR_MOVE))
return -EPERM;
- }
+ break;
+ case VM_REALM:
+ /*
+ * Once the Realm is created, we cannot modify any slots that
+ * could be providing private memory. i.e., guest_memfd backed
+ * slots.
+ * TODO: Handle trusted device private memory slots
+ */
+ if (!kvm_realm_is_created(kvm))
+ break;
- if (new &&
- new->flags & (KVM_MEM_LOG_DIRTY_PAGES | KVM_MEM_READONLY)) {
+ if (kvm_slot_has_gmem(old) || kvm_slot_has_gmem(new))
return -EPERM;
- }
+ break;
+ default:
+ break;
}
return 0;
@@ -2880,6 +2895,7 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,
enum kvm_mr_change change)
{
hva_t hva, reg_end;
+ gfn_t ipa_limit;
int ret = 0;
if (change != KVM_MR_CREATE && change != KVM_MR_MOVE &&
@@ -2887,10 +2903,13 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,
return 0;
/*
- * Prevent userspace from creating a memory region outside of the IPA
- * space addressable by the KVM guest IPA space.
+ * Realm shared IPAs alias the corresponding private IPAs, so memslots
+ * must reside entirely in the canonical lower half of the IPA space.
*/
- if ((new->base_gfn + new->npages) > (kvm_phys_size(&kvm->arch.mmu) >> PAGE_SHIFT))
+ ipa_limit = kvm_phys_size(&kvm->arch.mmu) >> PAGE_SHIFT;
+ if (kvm_vm_is_realm(kvm))
+ ipa_limit >>= 1;
+ if (new->base_gfn + new->npages > ipa_limit)
return -EFAULT;
/*
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* [PATCH v3 09/11] KVM: arm64: CCA: Support runtime faulting of memory
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
` (7 preceding siblings ...)
2026-11-16 16:43 ` [PATCH v3 08/11] KVM: arm64: CCA: Prevent memslot modifications after Realm creation Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 17:31 ` sashiko-bot
2026-11-16 16:43 ` [PATCH v3 10/11] KVM: arm64: Dispatch stage-2 destruction by VM flavor Steven Price
2026-11-16 16:43 ` [PATCH v3 11/11] KVM: arm64: CCA: Add Realm stage-2 MMU operations Steven Price
10 siblings, 1 reply; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Steven Price, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Suzuki K Poulose, Zenghui Yu,
linux-arm-kernel, linux-kernel, Joey Gouly, Alexandru Elisei,
Christoffer Dall, Fuad Tabba, linux-coco, Ganapatrao Kulkarni,
Gavin Shan, Shanker Donthineni, Alper Gun, Aneesh Kumar K . V,
Emi Kisanuki, Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi,
Kohei Enju
At runtime, if the realm guest accesses an IPA without a stage-2
mapping, then KVM fixes up the stage-2 mapping for the backing memory.
For memory in the lower (protected) region of IPA, verify that the
corresponding guest_memfd page is private before delegating to the RMM.
The RMM then maps the page into the realm and initializes its contents
to zero.
For memory in the upper (shared) IPA region, map the backing page as
non-secure memory. Check that a guest_memfd page is shared when the
fault uses guest_memfd; ordinary userspace-backed memslots can only be
mapped at unprotected IPAs and follow the normal user memory fault path.
If the fault IPA and guest_memfd attributes disagree then exit to
userspace with KVM_EXIT_MEMORY_FAULT so the VMM can perform the required
conversion. If a shared IPA has no memslot, KVM follows the existing
MMIO or abort-injection path. The latter can result in injecting a SEA
to the guest.
Realm faults may need to create RTTs, including when updating a
mapping after a permission fault. Take the write side of mmu_lock
and top up the MMU cache for these faults. Do not pre-fault Realm
memory.
Co-developed-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v2:
- Route all guest_memfd faults through gmem_abort(). Bound each
protected RMI map call to its encoded range, create the required
RTT levels, and tighten retry and error handling.
Changes since v1:
- Use the write side of mmu_lock and top up the MMU cache for Realm
faults that may create RTTs. Skip unnecessary cache flushing,
disable Realm pre-faulting, and tighten memory-fault and mapping
retry handling.
---
arch/arm64/include/asm/kvm_emulate.h | 13 ++
arch/arm64/include/asm/kvm_mmu.h | 4 +-
arch/arm64/include/asm/kvm_rmi.h | 6 +
arch/arm64/kvm/mmu.c | 96 ++++++++--
arch/arm64/kvm/rmi.c | 251 +++++++++++++++++++++++++++
5 files changed, 351 insertions(+), 19 deletions(-)
diff --git a/arch/arm64/include/asm/kvm_emulate.h b/arch/arm64/include/asm/kvm_emulate.h
index 32021bdf2610..8a71fddfdb85 100644
--- a/arch/arm64/include/asm/kvm_emulate.h
+++ b/arch/arm64/include/asm/kvm_emulate.h
@@ -847,4 +847,17 @@ static inline bool kvm_realm_is_created(struct kvm *kvm)
return kvm_vm_is_realm(kvm) && kvm_realm_state(kvm) != REALM_STATE_NONE;
}
+static inline gpa_t kvm_gpa_from_fault(struct kvm *kvm, phys_addr_t ipa)
+{
+ if (!kvm_vm_is_realm(kvm))
+ return ipa;
+
+ return ipa & ~BIT(kvm->arch.realm.ia_bits - 1);
+}
+
+static inline gfn_t kvm_gfn_from_fault(struct kvm *kvm, phys_addr_t ipa)
+{
+ return gpa_to_gfn(kvm_gpa_from_fault(kvm, ipa));
+}
+
#endif /* __ARM64_KVM_EMULATE_H__ */
diff --git a/arch/arm64/include/asm/kvm_mmu.h b/arch/arm64/include/asm/kvm_mmu.h
index 32392abf2e21..a70f8bd4b2b9 100644
--- a/arch/arm64/include/asm/kvm_mmu.h
+++ b/arch/arm64/include/asm/kvm_mmu.h
@@ -371,7 +371,7 @@ static inline bool kvm_is_nested_s2_mmu(struct kvm *kvm, struct kvm_s2_mmu *mmu)
static inline void kvm_fault_lock(struct kvm *kvm)
{
- if (is_protected_kvm_enabled())
+ if (kvm_vm_hyp_is_distrusting(kvm))
write_lock(&kvm->mmu_lock);
else
read_lock(&kvm->mmu_lock);
@@ -379,7 +379,7 @@ static inline void kvm_fault_lock(struct kvm *kvm)
static inline void kvm_fault_unlock(struct kvm *kvm)
{
- if (is_protected_kvm_enabled())
+ if (kvm_vm_hyp_is_distrusting(kvm))
write_unlock(&kvm->mmu_lock);
else
read_unlock(&kvm->mmu_lock);
diff --git a/arch/arm64/include/asm/kvm_rmi.h b/arch/arm64/include/asm/kvm_rmi.h
index 11e227172faf..698aa2cefc7b 100644
--- a/arch/arm64/include/asm/kvm_rmi.h
+++ b/arch/arm64/include/asm/kvm_rmi.h
@@ -6,6 +6,7 @@
#ifndef __ASM_KVM_RMI_H
#define __ASM_KVM_RMI_H
+#include <asm/kvm_pgtable.h>
#include <linux/arm-smccc-rmi.h>
#include <linux/kvm.h>
@@ -88,6 +89,11 @@ void kvm_realm_unmap_range_filter(struct kvm *kvm,
bool may_block,
enum kvm_gfn_range_filter attr_filter);
+int realm_map_ipa(struct kvm *kvm, phys_addr_t ipa,
+ kvm_pfn_t pfn, unsigned long map_size,
+ enum kvm_pgtable_prot prot,
+ struct kvm_mmu_memory_cache *memcache);
+
static inline bool kvm_realm_is_private_address(struct realm *realm,
unsigned long addr)
{
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 0db3c293fdd5..9b371159be92 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -450,6 +450,10 @@ static void stage2_flush_vm(struct kvm *kvm)
struct kvm_memory_slot *memslot;
int idx, bkt;
+ /* The RMM requires FWB, so Realm stage-2 mappings need no cache flush. */
+ if (kvm_vm_is_realm(kvm))
+ return;
+
idx = srcu_read_lock(&kvm->srcu);
write_lock(&kvm->mmu_lock);
@@ -1222,6 +1226,10 @@ void stage2_unmap_vm(struct kvm *kvm)
struct kvm_memory_slot *memslot;
int idx, bkt;
+ /* For realms this is handled by the RMM so nothing to do here */
+ if (kvm_vm_is_realm(kvm))
+ return;
+
idx = srcu_read_lock(&kvm->srcu);
mmap_read_lock(current->mm);
write_lock(&kvm->mmu_lock);
@@ -1791,12 +1799,18 @@ static int gmem_abort(const struct kvm_s2_fault_desc *s2fd,
void *memcache = NULL;
gfn_t canonical_gfn;
int ret;
+ bool is_private = false;
- if (!perm_fault) {
+ if (KVM_BUG_ON(!kvm_slot_has_gmem(s2fd->memslot), kvm))
+ return -EINVAL;
+
+ if (!perm_fault || kvm_arch_has_private_mem(kvm)) {
memcache = get_mmu_memcache(s2fd->vcpu);
ret = topup_mmu_memcache(s2fd->mmu, memcache);
if (ret)
return ret;
+ }
+ if (!perm_fault) {
if (kvm_is_nested_s2_mmu(kvm, pgt->mmu)) {
mapping = kmalloc_obj(struct kvm_guest_s2_mapping, GFP_KERNEL_ACCOUNT);
if (!mapping)
@@ -1805,7 +1819,7 @@ static int gmem_abort(const struct kvm_s2_fault_desc *s2fd,
}
s2vi.vma_pagesize = PAGE_SIZE;
- s2vi.gfn = ALIGN_DOWN(s2fd->fault_ipa, s2vi.vma_pagesize) >> PAGE_SHIFT;
+ s2vi.gfn = gpa_to_gfn(kvm_gpa_from_fault(kvm, s2fd->fault_ipa));
canonical_gfn = get_canonical_gfn(s2fd, &s2vi);
write_fault = kvm_s2_fault_is_write(s2fd);
@@ -1817,13 +1831,35 @@ static int gmem_abort(const struct kvm_s2_fault_desc *s2fd,
/* Pairs with the smp_wmb() in kvm_mmu_invalidate_end(). */
smp_rmb();
+ if (kvm_arch_has_private_mem(kvm)) {
+ switch (kvm->arch.vm_flavor) {
+ case VM_REALM:
+ is_private = kvm_realm_is_private_address(&kvm->arch.realm,
+ s2fd->fault_ipa);
+ break;
+ default:
+ break;
+ }
+
+ if (is_private != kvm_gmem_is_private_gfn(kvm, canonical_gfn)) {
+ if (!result)
+ kvm_prepare_memory_fault_exit(s2fd->vcpu,
+ gfn_to_gpa(canonical_gfn),
+ PAGE_SIZE,
+ write_fault, exec_fault,
+ is_private);
+ kfree(mapping);
+ return -EFAULT;
+ }
+ }
+
ret = kvm_gmem_get_pfn(kvm, s2fd->memslot, canonical_gfn, &s2vi.pfn, NULL);
if (ret) {
/* If result is non-NULL this is a synthetic fault. */
if (!result)
kvm_prepare_memory_fault_exit(s2fd->vcpu, gfn_to_gpa(canonical_gfn),
s2vi.vma_pagesize, write_fault, exec_fault,
- false);
+ is_private);
kfree(mapping);
return ret;
}
@@ -1846,6 +1882,16 @@ static int gmem_abort(const struct kvm_s2_fault_desc *s2fd,
goto out_unlock;
}
+ switch (kvm->arch.vm_flavor) {
+ case VM_REALM:
+ prot &= ~KVM_PGTABLE_PROT_X;
+ ret = realm_map_ipa(kvm, s2fd->fault_ipa, s2vi.pfn,
+ PAGE_SIZE, prot, memcache);
+ goto out_unlock;
+ default:
+ break;
+ }
+
if (perm_fault) {
/*
* Drop the SW bits in favour of those stored in the
@@ -2047,7 +2093,8 @@ static int kvm_s2_fault_get_vma_info(const struct kvm_s2_fault_desc *s2fd,
* mapping size to ensure we find the right PFN and lay down the
* mapping in the right place.
*/
- s2vi->gfn = ALIGN_DOWN(s2fd->fault_ipa, s2vi->vma_pagesize) >> PAGE_SHIFT;
+ s2vi->gfn = kvm_gfn_from_fault(kvm, ALIGN_DOWN(s2fd->fault_ipa,
+ s2vi->vma_pagesize));
s2vi->mte_allowed = kvm_vma_mte_allowed(vma);
@@ -2227,7 +2274,7 @@ static int kvm_s2_fault_map(const struct kvm_s2_fault_desc *s2fd,
* possible.
*/
if (mapping_size == PAGE_SIZE && s2vi->max_map_size != PAGE_SIZE) {
- if (perm_fault_granule > PAGE_SIZE) {
+ if (perm_fault_granule > PAGE_SIZE && !kvm_vm_is_realm(kvm)) {
mapping_size = perm_fault_granule;
} else {
mapping_size = transparent_hugepage_adjust(s2fd, &pfn, &gfn);
@@ -2242,12 +2289,15 @@ static int kvm_s2_fault_map(const struct kvm_s2_fault_desc *s2fd,
if (!perm_fault_granule && !s2vi->map_non_cacheable && kvm_has_mte(kvm))
sanitise_mte_tags(kvm, pfn, mapping_size);
- /*
- * Under the premise of getting a FSC_PERM fault, we just need to relax
- * permissions only if mapping_size equals perm_fault_granule. Otherwise,
- * kvm_pgtable_stage2_map() should be called to change block size.
- */
- if (mapping_size == perm_fault_granule) {
+ if (kvm_vm_is_realm(kvm)) {
+ ret = realm_map_ipa(kvm, s2fd->fault_ipa, pfn, mapping_size,
+ prot, memcache);
+ } else if (mapping_size == perm_fault_granule) {
+ /*
+ * Under the premise of getting a FSC_PERM fault, we just need to relax
+ * permissions only if mapping_size equals perm_fault_granule. Otherwise,
+ * kvm_pgtable_stage2_map() should be called to change block size.
+ */
/*
* Drop the SW bits in favour of those stored in the
* PTE, which will be preserved.
@@ -2306,15 +2356,16 @@ static int user_mem_abort(const struct kvm_s2_fault_desc *s2fd,
/*
* Permission faults just need to update the existing leaf entry,
* and so normally don't require allocations from the memcache. The
- * only exception to this is when dirty logging is enabled at runtime
+ * exceptions are when dirty logging is enabled at runtime
* and a fault needs to collapse a block entry into a table.
+ * Realms can also require new RTT levels when replacing a mapping.
* Under pKVM a permission fault can also collapse pages into a block,
* which needs a fresh mapping object, and the hypervisor requires the
* min-pages memcache even when the install allocates nothing.
*/
memcache = get_mmu_memcache(s2fd->vcpu);
if (!perm_fault || memslot_is_logging(s2fd->memslot) ||
- is_protected_kvm_enabled()) {
+ is_protected_kvm_enabled() || kvm_vm_is_realm(s2fd->vcpu->kvm)) {
ret = topup_mmu_memcache(s2fd->mmu, memcache);
if (ret)
return ret;
@@ -2340,12 +2391,22 @@ static int user_mem_abort(const struct kvm_s2_fault_desc *s2fd,
return kvm_s2_fault_map(s2fd, &s2vi, prot, memcache, result);
}
+static bool private_ipa_fault(struct kvm *kvm, phys_addr_t fault_ipa)
+{
+ return kvm_vm_is_realm(kvm) &&
+ kvm_realm_is_private_address(&kvm->arch.realm, fault_ipa);
+}
+
static int kvm_vm_mem_abort(const struct kvm_s2_fault_desc *s2fd)
{
VM_WARN_ON_ONCE(kvm_s2_fault_is_perm(s2fd) &&
!esr_abt_is_write_fault(s2fd->esr) &&
!kvm_s2_fault_is_exec(s2fd));
+ if (private_ipa_fault(s2fd->vcpu->kvm, s2fd->fault_ipa) &&
+ !kvm_slot_has_gmem(s2fd->memslot))
+ return -EINVAL;
+
if (kvm_slot_has_gmem(s2fd->memslot))
return gmem_abort(s2fd, NULL);
else
@@ -2458,10 +2519,10 @@ int kvm_handle_guest_sea(struct kvm_vcpu *vcpu)
*/
int kvm_handle_guest_abort(struct kvm_vcpu *vcpu)
{
+ struct kvm *kvm = vcpu->kvm;
struct kvm_s2_trans nested_trans, *nested = NULL;
unsigned long esr = kvm_vcpu_get_esr(vcpu);
struct kvm_s2_mmu *mmu = vcpu->arch.hw_mmu;
- struct kvm *kvm = vcpu->kvm;
phys_addr_t fault_ipa; /* The address we faulted on */
phys_addr_t ipa; /* Always the IPA in the L1 guest phys space */
struct kvm_memory_slot *memslot;
@@ -2554,8 +2615,9 @@ int kvm_handle_guest_abort(struct kvm_vcpu *vcpu)
nested = &nested_trans;
}
- gfn = ipa >> PAGE_SHIFT;
+ gfn = kvm_gfn_from_fault(kvm, ipa);
memslot = gfn_to_memslot(kvm, gfn);
+
hva = gfn_to_hva_memslot_prot(memslot, gfn, &writable);
write_fault = esr_abt_is_write_fault(esr);
if (kvm_is_error_hva(hva) || (write_fault && !writable)) {
@@ -2598,7 +2660,7 @@ int kvm_handle_guest_abort(struct kvm_vcpu *vcpu)
* of the page size.
*/
ipa |= FAR_TO_FIPA_OFFSET(kvm_vcpu_get_hfar(vcpu));
- ret = io_mem_abort(vcpu, ipa);
+ ret = io_mem_abort(vcpu, kvm_gpa_from_fault(kvm, ipa));
goto out_unlock;
}
@@ -3155,7 +3217,7 @@ pre_fault_bytes_consumed(gpa_t gpa, unsigned long granule_size,
int kvm_arch_pre_fault_allowed(struct kvm_vcpu *vcpu)
{
- if (is_protected_kvm_enabled())
+ if (is_protected_kvm_enabled() || kvm_vm_is_realm(vcpu->kvm))
return -EOPNOTSUPP;
if (!kvm_vcpu_initialized(vcpu))
return -ENOEXEC;
diff --git a/arch/arm64/kvm/rmi.c b/arch/arm64/kvm/rmi.c
index 838f95c201ad..4cacb9fe000f 100644
--- a/arch/arm64/kvm/rmi.c
+++ b/arch/arm64/kvm/rmi.c
@@ -610,6 +610,257 @@ void kvm_realm_unmap_range_filter(struct kvm *kvm, unsigned long start,
}
}
+static unsigned long addr_range_desc(struct realm *realm,
+ unsigned long ipa, unsigned long phys,
+ unsigned long size, unsigned long state)
+{
+ unsigned long count = 1;
+ unsigned long out;
+ int rmi_size;
+
+ for (rmi_size = KVM_PGTABLE_LAST_LEVEL - get_start_level(realm);
+ rmi_size >= 0; rmi_size--) {
+ unsigned long entry_size = rmi_addr_block_size_to_bytes(rmi_size);
+
+ if (size >= entry_size && IS_ALIGNED(ipa, entry_size) &&
+ IS_ALIGNED(phys, entry_size))
+ break;
+ }
+
+ if (rmi_size == 0) {
+ /*
+ * Stop at the next block boundary so that a later iteration can
+ * use a larger mapping when both addresses are aligned.
+ */
+ count = MIN(size >> PAGE_SHIFT, PTRS_PER_PTE - 1);
+ count = min(count, (PMD_SIZE - (ipa & (PMD_SIZE - 1))) >> PAGE_SHIFT);
+ count = min(count, (PMD_SIZE - (phys & (PMD_SIZE - 1))) >> PAGE_SHIFT);
+ }
+
+ WARN_ON(phys & ~PAGE_MASK);
+
+ out = FIELD_PREP(RMI_ADDR_RANGE_BLOCK_SIZE_MASK, rmi_size) |
+ FIELD_PREP(RMI_ADDR_RANGE_COUNT_MASK, count) |
+ FIELD_PREP(RMI_ADDR_RANGE_STATE_MASK, state);
+ out |= phys & PAGE_MASK;
+
+ return out;
+}
+
+static int realm_map_protected(struct kvm *kvm,
+ unsigned long ipa,
+ kvm_pfn_t pfn,
+ unsigned long map_size,
+ struct kvm_mmu_memory_cache *memcache)
+{
+ struct realm *realm = &kvm->arch.realm;
+ phys_addr_t phys = __pfn_to_phys(pfn);
+ phys_addr_t base_phys = phys;
+ phys_addr_t rd = realm->rd_phys;
+ phys_addr_t delegated_phys;
+ unsigned long base_ipa = ipa;
+ unsigned long ipa_top;
+ unsigned int retries = 0;
+ long ret = 0;
+
+ if (WARN_ON(!IS_ALIGNED(map_size, PAGE_SIZE) ||
+ !IS_ALIGNED(ipa, map_size)))
+ return -EINVAL;
+
+ if (rmi_delegate_range(phys, map_size, &delegated_phys)) {
+ if (delegated_phys == phys) {
+ /*
+ * It's likely we raced with another VCPU on the same
+ * fault. Assume the other VCPU has handled the fault
+ * and return to the guest.
+ */
+ return 0;
+ }
+ /* Partial delegation - map as much as we can */
+ map_size = delegated_phys - phys;
+ }
+
+ ipa_top = ipa + map_size;
+
+ while (ipa < ipa_top) {
+ unsigned long flags = RMI_ADDR_TYPE_SINGLE;
+ unsigned long range_desc = addr_range_desc(realm, ipa, phys,
+ ipa_top - ipa,
+ RMI_OP_MEM_DELEGATED);
+ unsigned long call_top = ipa + RMI_ADDR_RANGE_COUNT(range_desc) *
+ rmi_addr_block_size_to_bytes(RMI_ADDR_RANGE_BLOCK_SIZE(range_desc));
+ unsigned long out_top;
+
+ ret = rmi_rtt_data_map(rd, ipa, call_top, flags, range_desc,
+ &out_top);
+ if (ret < 0)
+ goto err_undelegate;
+
+ if (RMI_RESULT_STATUS(ret) == RMI_ERROR_RTT) {
+ /* Create missing RTTs and retry */
+ int level = RMI_RESULT_DATA_LEVEL(ret);
+ int req_level = KVM_PGTABLE_LAST_LEVEL -
+ RMI_ADDR_RANGE_BLOCK_SIZE(range_desc);
+
+ if (++retries > KVM_PGTABLE_LAST_LEVEL + 2 ||
+ level < get_start_level(realm) || level >= req_level) {
+ ret = -ENXIO;
+ goto err_undelegate;
+ }
+ ret = realm_create_rtt_levels(realm, ipa, level,
+ req_level,
+ memcache);
+ if (ret)
+ goto err_undelegate;
+
+ continue;
+ }
+
+ if (ret) {
+ ret = RMI_RESULT_STATUS(ret) == RMI_BLOCKED ? -EAGAIN : -ENXIO;
+ goto err_undelegate;
+ }
+
+ /* An IRQ can stop the RMM before it maps the first entry. */
+ if (out_top == ipa) {
+ ret = -EAGAIN;
+ goto err_undelegate;
+ }
+ if (WARN_ON_ONCE(out_top < ipa || out_top > call_top)) {
+ ret = -ENXIO;
+ goto err_undelegate;
+ }
+
+ phys += out_top - ipa;
+ ipa = out_top;
+ retries = 0;
+ }
+
+ return 0;
+
+err_undelegate:
+ realm_unmap_private_range(kvm, base_ipa, ipa, false, memcache);
+ /* A range which cannot be undelegated remains owned by the RMM. */
+ WARN_ON(rmi_undelegate_range(base_phys, map_size));
+ return ret < 0 ? ret : -ENXIO;
+}
+
+static int realm_map_unprotected(struct kvm *kvm,
+ unsigned long ipa,
+ kvm_pfn_t pfn,
+ unsigned long size,
+ enum kvm_pgtable_prot prot,
+ struct kvm_mmu_memory_cache *memcache)
+{
+ struct realm *realm = &kvm->arch.realm;
+ unsigned long attr, flags = 0;
+ phys_addr_t rd = realm->rd_phys;
+ phys_addr_t phys = __pfn_to_phys(pfn);
+ unsigned long ipa_top = ipa + size;
+ unsigned int retries = 0;
+ long ret;
+
+ if (WARN_ON(!IS_ALIGNED(size, PAGE_SIZE)))
+ return -EINVAL;
+
+ switch (prot & (KVM_PGTABLE_PROT_DEVICE | KVM_PGTABLE_PROT_NORMAL_NC)) {
+ case KVM_PGTABLE_PROT_DEVICE | KVM_PGTABLE_PROT_NORMAL_NC:
+ return -EINVAL;
+ case KVM_PGTABLE_PROT_DEVICE:
+ attr = MT_S2_FWB_DEVICE_nGnRE;
+ break;
+ case KVM_PGTABLE_PROT_NORMAL_NC:
+ attr = MT_S2_FWB_NORMAL_NC;
+ break;
+ default:
+ attr = MT_S2_FWB_NORMAL;
+ }
+
+ flags |= FIELD_PREP(RMI_RTT_UNPROT_MAP_FLAGS_MEMATTR_MASK, attr);
+
+ if (prot & KVM_PGTABLE_PROT_R)
+ flags |= FIELD_PREP(RMI_RTT_UNPROT_MAP_FLAGS_S2AP_MASK, RMI_S2AP_DIRECT_READ);
+ if (prot & KVM_PGTABLE_PROT_W)
+ flags |= FIELD_PREP(RMI_RTT_UNPROT_MAP_FLAGS_S2AP_MASK, RMI_S2AP_DIRECT_WRITE);
+
+ /* TODO: Batch mappings with RMI_ADDR_TYPE_LIST. */
+ flags |= RMI_ADDR_TYPE_SINGLE;
+
+ while (ipa < ipa_top) {
+ unsigned long range_desc = addr_range_desc(realm, ipa, phys,
+ ipa_top - ipa,
+ RMI_OP_MEM_UNDELEGATED);
+ unsigned long call_top = ipa + RMI_ADDR_RANGE_COUNT(range_desc) *
+ rmi_addr_block_size_to_bytes(RMI_ADDR_RANGE_BLOCK_SIZE(range_desc));
+ unsigned long out_top;
+
+ ret = rmi_rtt_unprot_map(rd, ipa, call_top, flags, range_desc,
+ &out_top);
+ if (ret < 0)
+ return ret;
+
+ if (ret) {
+ /* Create missing RTTs and retry */
+ int level = RMI_RESULT_DATA_LEVEL(ret);
+ int req_level = KVM_PGTABLE_LAST_LEVEL -
+ RMI_ADDR_RANGE_BLOCK_SIZE(range_desc);
+
+ if (RMI_RESULT_STATUS(ret) != RMI_ERROR_RTT ||
+ ++retries > KVM_PGTABLE_LAST_LEVEL + 2)
+ return -ENXIO;
+
+ /* Replace an existing mapping to update its permissions. */
+ if (level >= req_level) {
+ realm_unmap_shared_range(kvm, ipa, ipa_top, false,
+ memcache);
+ continue;
+ }
+
+ ret = realm_create_rtt_levels(realm, ipa, level,
+ req_level,
+ memcache);
+ if (ret)
+ return ret;
+
+ continue;
+ }
+
+ /* Retry the fault after releasing mmu_lock to service the IRQ. */
+ if (out_top == ipa)
+ return -EAGAIN;
+ if (WARN_ON_ONCE(out_top < ipa || out_top > call_top))
+ return -ENXIO;
+
+ phys += out_top - ipa;
+ ipa = out_top;
+ retries = 0;
+ }
+
+ return 0;
+}
+
+int realm_map_ipa(struct kvm *kvm, phys_addr_t ipa,
+ kvm_pfn_t pfn, unsigned long map_size,
+ enum kvm_pgtable_prot prot,
+ struct kvm_mmu_memory_cache *memcache)
+{
+ struct realm *realm = &kvm->arch.realm;
+
+ if (kvm_realm_state(kvm) != REALM_STATE_ACTIVE)
+ return -EBUSY;
+
+ ipa = ALIGN_DOWN(ipa, map_size);
+ if (!kvm_realm_is_private_address(realm, ipa)) {
+ return realm_map_unprotected(kvm, ipa, pfn, map_size, prot,
+ memcache);
+ }
+
+ /* It's impossible to map protected pages read-only. */
+ if (WARN_ON(!(prot & KVM_PGTABLE_PROT_W)))
+ return -EFAULT;
+ return realm_map_protected(kvm, ipa, pfn, map_size, memcache);
+}
+
void kvm_destroy_realm(struct kvm *kvm)
{
struct realm *realm = &kvm->arch.realm;
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* Re: [PATCH v3 09/11] KVM: arm64: CCA: Support runtime faulting of memory
2026-11-16 16:43 ` [PATCH v3 09/11] KVM: arm64: CCA: Support runtime faulting of memory Steven Price
@ 2026-11-16 17:31 ` sashiko-bot
0 siblings, 0 replies; 15+ messages in thread
From: sashiko-bot @ 2026-11-16 17:31 UTC (permalink / raw)
To: Steven Price, kvm, kvmarm; +Cc: Oliver Upton, Marc Zyngier
Thank you for your contribution! Sashiko AI review found 3 potential
issues to consider:
- [Medium] KVM: arm64: KVM_CAP_PRE_FAULT_MEMORY advertised for Realm VMs
- [Medium] KVM: arm64: missing unmap on partial failure in
realm_map_unprotected()
- [Low] KVM: arm64: unhandled exec fault on shared Realm IPA in
gmem_abort() and user_mem_abort()
--
commit 5a0919ef6adc946a1afb4f6ad7cf84e5573597f3
Author: Steven Price <steven.price@arm.com>
KVM: arm64: CCA: Support runtime faulting of memory
This commit adds runtime stage-2 fault handling for Realm VMs, delegating
and mapping private guest_memfd pages in the protected IPA region and
mapping shared pages in the unprotected IPA region via the RMM.
> diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
> index 0db3c293fdd52..9b371159be92c 100644
> --- a/arch/arm64/kvm/mmu.c
> +++ b/arch/arm64/kvm/mmu.c
[ ... ]
> @@ -1846,6 +1882,16 @@ static int gmem_abort(const struct kvm_s2_fault_desc *s2fd,
> goto out_unlock;
> }
>
> + switch (kvm->arch.vm_flavor) {
> + case VM_REALM:
> + prot &= ~KVM_PGTABLE_PROT_X;
> + ret = realm_map_ipa(kvm, s2fd->fault_ipa, s2vi.pfn,
> + PAGE_SIZE, prot, memcache);
> + goto out_unlock;
> + default:
> + break;
> + }
> +
[ ... ]
> @@ -2242,12 +2289,15 @@ static int kvm_s2_fault_map(const struct kvm_s2_fault_desc *s2fd,
> if (!perm_fault_granule && !s2vi->map_non_cacheable && kvm_has_mte(kvm))
> sanitise_mte_tags(kvm, pfn, mapping_size);
>
> - /*
> - * Under the premise of getting a FSC_PERM fault, we just need to relax
> - * permissions only if mapping_size equals perm_fault_granule. Otherwise,
> - * kvm_pgtable_stage2_map() should be called to change block size.
> - */
> - if (mapping_size == perm_fault_granule) {
> + if (kvm_vm_is_realm(kvm)) {
> + ret = realm_map_ipa(kvm, s2fd->fault_ipa, pfn, mapping_size,
> + prot, memcache);
[Severity: Low]
This question rests on an architecture detail that could not be confirmed
from the kernel source: can a Realm guest instruction fetch from an
unprotected (shared) IPA exit to the host as a stage-2 instruction abort
that reaches kvm_handle_guest_abort()?
If so, unprotected RTT mappings only encode RMI_S2AP_DIRECT_READ and
RMI_S2AP_DIRECT_WRITE and cannot grant execute permission, but neither
gmem_abort() nor user_mem_abort() rejects kvm_s2_fault_is_exec(s2fd) with
-ENOEXEC to inject an instruction abort. Instead, realm_map_unprotected()
installs a non-executable mapping, and on subsequent instruction permission
faults at the same IPA where level >= req_level, unmaps and remaps the page
with the same non-executable permissions and returns 0 in an endless fault
loop.
[ ... ]
> @@ -3155,7 +3217,7 @@ pre_fault_bytes_consumed(gpa_t gpa, unsigned long granule_size,
>
> int kvm_arch_pre_fault_allowed(struct kvm_vcpu *vcpu)
> {
> - if (is_protected_kvm_enabled())
> + if (is_protected_kvm_enabled() || kvm_vm_is_realm(vcpu->kvm))
> return -EOPNOTSUPP;
> if (!kvm_vcpu_initialized(vcpu))
> return -ENOEXEC;
[Severity: Medium]
Should kvm_vm_ioctl_check_extension() also report 0 for
KVM_CAP_PRE_FAULT_MEMORY when kvm && kvm_vm_is_realm(kvm)?
Currently kvm_vm_ioctl_check_extension() only gates capabilities on
is_protected_kvm_enabled() and otherwise unconditionally sets r = 1 for
KVM_CAP_PRE_FAULT_MEMORY, advertising the capability on a Realm VM file
descriptor even though KVM_PRE_FAULT_MEMORY always fails here with
-EOPNOTSUPP.
> diff --git a/arch/arm64/kvm/rmi.c b/arch/arm64/kvm/rmi.c
> index 838f95c201ada..4cacb9fe000f4 100644
> --- a/arch/arm64/kvm/rmi.c
> +++ b/arch/arm64/kvm/rmi.c
[ ... ]
> +static int realm_map_unprotected(struct kvm *kvm,
> + unsigned long ipa,
> + kvm_pfn_t pfn,
> + unsigned long size,
> + enum kvm_pgtable_prot prot,
> + struct kvm_mmu_memory_cache *memcache)
> +{
[ ... ]
> + while (ipa < ipa_top) {
> + unsigned long range_desc = addr_range_desc(realm, ipa, phys,
> + ipa_top - ipa,
> + RMI_OP_MEM_UNDELEGATED);
> + unsigned long call_top = ipa + RMI_ADDR_RANGE_COUNT(range_desc) *
> + rmi_addr_block_size_to_bytes(RMI_ADDR_RANGE_BLOCK_SIZE(range_desc));
> + unsigned long out_top;
> +
> + ret = rmi_rtt_unprot_map(rd, ipa, call_top, flags, range_desc,
> + &out_top);
> + if (ret < 0)
> + return ret;
> +
> + if (ret) {
> + /* Create missing RTTs and retry */
> + int level = RMI_RESULT_DATA_LEVEL(ret);
> + int req_level = KVM_PGTABLE_LAST_LEVEL -
> + RMI_ADDR_RANGE_BLOCK_SIZE(range_desc);
> +
> + if (RMI_RESULT_STATUS(ret) != RMI_ERROR_RTT ||
> + ++retries > KVM_PGTABLE_LAST_LEVEL + 2)
> + return -ENXIO;
> +
> + /* Replace an existing mapping to update its permissions. */
> + if (level >= req_level) {
> + realm_unmap_shared_range(kvm, ipa, ipa_top, false,
> + memcache);
> + continue;
> + }
> +
> + ret = realm_create_rtt_levels(realm, ipa, level,
> + req_level,
> + memcache);
> + if (ret)
> + return ret;
> +
> + continue;
> + }
> +
> + /* Retry the fault after releasing mmu_lock to service the IRQ. */
> + if (out_top == ipa)
> + return -EAGAIN;
> + if (WARN_ON_ONCE(out_top < ipa || out_top > call_top))
> + return -ENXIO;
> +
> + phys += out_top - ipa;
> + ipa = out_top;
> + retries = 0;
> + }
[Severity: Medium]
Can a multi-iteration call to realm_map_unprotected() leave a writable
prefix mapped when a later iteration fails or returns -EAGAIN?
For a Realm with a 32- to 34-bit IPA space on 4KB pages, get_start_level()
is 2, so addr_range_desc() caps rmi_size at 1 (PMD_SIZE). When a shared
memslot is backed by a 1GB hugetlbfs VMA, kvm_s2_fault_map() passes
mapping_size = PUD_SIZE and this loop runs across multiple 2MB iterations.
If an iteration after the first is interrupted (out_top == ipa) or hits an
error, realm_map_unprotected() returns non-zero without unmapping the
already-installed prefix (unlike realm_map_protected()). kvm_s2_fault_map()
then passes !!ret (unused = true) to kvm_release_faultin_page() and skips
mark_page_dirty_in_slot(), so if the faulting IPA lies in the mapped prefix,
the guest can write to the page without marking the host folio dirty.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261116164358.142785-1-steven.price@arm.com?part=9
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH v3 10/11] KVM: arm64: Dispatch stage-2 destruction by VM flavor
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
` (8 preceding siblings ...)
2026-11-16 16:43 ` [PATCH v3 09/11] KVM: arm64: CCA: Support runtime faulting of memory Steven Price
@ 2026-11-16 16:43 ` Steven Price
2026-11-16 16:43 ` [PATCH v3 11/11] KVM: arm64: CCA: Add Realm stage-2 MMU operations Steven Price
10 siblings, 0 replies; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Steven Price, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Suzuki K Poulose, Zenghui Yu,
linux-arm-kernel, linux-kernel, Joey Gouly, Alexandru Elisei,
Christoffer Dall, Fuad Tabba, linux-coco, Ganapatrao Kulkarni,
Gavin Shan, Shanker Donthineni, Alper Gun, Aneesh Kumar K . V,
Emi Kisanuki, Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi,
Kohei Enju
Select the stage-2 destruction functions through the VM's stage-2
operations. This keeps the native and pKVM paths explicit and lets a
Realm provide its own destruction callback when Realm stage-2
operations are registered.
The Realm callback will only free the root RTT pages, because RMI
teardown destroys the non-root RTTs separately.
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v2:
- New patch in v3; split stage-2 destruction dispatch out of the
Realm stage-2 MMU operations patch.
---
arch/arm64/include/asm/kvm_host.h | 1 +
arch/arm64/kvm/mmu.c | 37 ++++++++++++++++++-------------
2 files changed, 23 insertions(+), 15 deletions(-)
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index 2c8cd9a1dd52..52ccb8b4ccb2 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -242,6 +242,7 @@ struct kvm_vm_s2_ops {
int (*vm_flush_remote_tlbs)(struct kvm *kvm);
int (*vm_flush_remote_tlbs_range)(struct kvm *kvm, gfn_t gfn,
u64 nr_pages);
+ void (*vm_stage2_destroy)(struct kvm_pgtable *pgt);
void (*vm_stage2_unmap_range)(struct kvm_s2_mmu *mmu,
phys_addr_t start, u64 size,
bool may_block,
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 9b371159be92..46a83c58c12f 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -1026,35 +1026,39 @@ static int kvm_init_ipa_range(struct kvm_s2_mmu *mmu, unsigned long type)
* cond_resched() periodically to prevent hogging the CPU for a long time
* and schedule something else, if required.
*/
-static void stage2_destroy_range(struct kvm_pgtable *pgt, phys_addr_t addr,
- phys_addr_t end)
+static void stage2_destroy_range(struct kvm_pgtable *pgt,
+ void (*destroy_range)(struct kvm_pgtable *pgt,
+ u64 addr, u64 size))
{
+ u64 addr = 0;
+ u64 end = BIT(VTCR_EL2_IPA(pgt->mmu->vtcr));
u64 next;
do {
next = stage2_range_addr_end(addr, end);
- KVM_PGT_FN(kvm_pgtable_stage2_destroy_range)(pgt, addr,
- next - addr);
+ destroy_range(pgt, addr, next - addr);
if (next != end)
cond_resched();
} while (addr = next, addr != end);
}
+static void kvm_vm_stage2_destroy(struct kvm_pgtable *pgt)
+{
+ stage2_destroy_range(pgt, kvm_pgtable_stage2_destroy_range);
+ kvm_pgtable_stage2_destroy_pgd(pgt);
+}
+
+static void pkvm_stage2_destroy(struct kvm_pgtable *pgt)
+{
+ stage2_destroy_range(pgt, pkvm_pgtable_stage2_destroy_range);
+ pkvm_pgtable_stage2_destroy_pgd(pgt);
+}
+
static void kvm_stage2_destroy(struct kvm_pgtable *pgt)
{
struct kvm *kvm = kvm_s2_mmu_to_kvm(pgt->mmu);
- unsigned int ia_bits = VTCR_EL2_IPA(pgt->mmu->vtcr);
-
- /*
- * Realm RTTs are inaccessible to the host and may contain stale data
- * after the RMM has released them. The non-root RTTs are explicitly
- * destroyed through RMI before the RD is destroyed; only the root PGD
- * pages remain to be freed here.
- */
- if (!kvm_vm_is_realm(kvm))
- stage2_destroy_range(pgt, 0, BIT(ia_bits));
- KVM_PGT_FN(kvm_pgtable_stage2_destroy_pgd)(pgt);
+ kvm->arch.vm_s2_ops->vm_stage2_destroy(pgt);
}
/**
@@ -3267,6 +3271,7 @@ long kvm_arch_vcpu_pre_fault_memory(struct kvm_vcpu *vcpu,
}
static const struct kvm_vm_s2_ops protected_pkvm_vm_s2_ops = {
+ .vm_stage2_destroy = pkvm_stage2_destroy,
.vm_flush_remote_tlbs = pkvm_flush_remote_tlbs,
.vm_flush_remote_tlbs_range = pkvm_flush_remote_tlbs_range,
.vm_age_gfn = no_age_gfn,
@@ -3276,6 +3281,7 @@ static const struct kvm_vm_s2_ops protected_pkvm_vm_s2_ops = {
};
static const struct kvm_vm_s2_ops pkvm_vm_s2_ops = {
+ .vm_stage2_destroy = pkvm_stage2_destroy,
.vm_flush_remote_tlbs = pkvm_flush_remote_tlbs,
.vm_flush_remote_tlbs_range = pkvm_flush_remote_tlbs_range,
.vm_age_gfn = pkvm_age_gfn,
@@ -3285,6 +3291,7 @@ static const struct kvm_vm_s2_ops pkvm_vm_s2_ops = {
};
static const struct kvm_vm_s2_ops kvm_default_vm_s2_ops = {
+ .vm_stage2_destroy = kvm_vm_stage2_destroy,
.vm_flush_remote_tlbs = kvm_vm_flush_remote_tlbs,
.vm_flush_remote_tlbs_range = kvm_vm_flush_remote_tlbs_range,
.vm_age_gfn = kvm_vm_age_gfn,
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread* [PATCH v3 11/11] KVM: arm64: CCA: Add Realm stage-2 MMU operations
2026-11-16 16:43 [PATCH v3 00/11] KVM: arm64: CCA: Prepare Realm memory management Steven Price
` (9 preceding siblings ...)
2026-11-16 16:43 ` [PATCH v3 10/11] KVM: arm64: Dispatch stage-2 destruction by VM flavor Steven Price
@ 2026-11-16 16:43 ` Steven Price
10 siblings, 0 replies; 15+ messages in thread
From: Steven Price @ 2026-11-16 16:43 UTC (permalink / raw)
To: kvm, kvmarm
Cc: Suzuki K Poulose, Catalin Marinas, Marc Zyngier, Will Deacon,
James Morse, Oliver Upton, Zenghui Yu, linux-arm-kernel,
linux-kernel, Joey Gouly, Alexandru Elisei, Christoffer Dall,
Fuad Tabba, linux-coco, Ganapatrao Kulkarni, Gavin Shan,
Shanker Donthineni, Alper Gun, Aneesh Kumar K . V, Emi Kisanuki,
Vishal Annapurve, WeiLin.Chang, Lorenzo Pieralisi, Kohei Enju,
Steven Price
From: Suzuki K Poulose <suzuki.poulose@arm.com>
Register the Realm stage-2 MMU operations now that the RMM mapping
and unmapping helpers are available. Route unmapping through the
RMM, and use the existing fault handler for Realm memory faults.
The RMM handles TLB invalidation when stage-2 mappings change, so
the host has no separate TLB flush to perform. Realm stage-2 does
not support access flags, including for shared IPAs.
Realm teardown destroys non-root RTTs through RMI, so the Realm
stage-2 destruction callback frees only the root RTT pages.
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Steven Price <steven.price@arm.com>
---
Changes since v2:
- Move common stage-2 destruction dispatch to the preceding patch;
retain the Realm-specific destruction callback here.
---
arch/arm64/kvm/mmu.c | 45 +++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 44 insertions(+), 1 deletion(-)
diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c
index 46a83c58c12f..b3fa03d411fb 100644
--- a/arch/arm64/kvm/mmu.c
+++ b/arch/arm64/kvm/mmu.c
@@ -191,6 +191,12 @@ static int kvm_vm_flush_remote_tlbs(struct kvm *kvm)
return 0;
}
+static int realm_flush_remote_tlbs(struct kvm *kvm)
+{
+ /* Nothing to do here, RMM does the job */
+ return 0;
+}
+
/**
* kvm_arch_flush_remote_tlbs() - flush all VM TLB entries for v7/8
* @kvm: pointer to kvm structure.
@@ -218,6 +224,13 @@ static int kvm_vm_flush_remote_tlbs_range(struct kvm *kvm,
return 0;
}
+static int realm_flush_remote_tlbs_range(struct kvm *kvm,
+ gfn_t gfn, u64 nr_pages)
+{
+ /* Nothing to do here, RMM does the job */
+ return 0;
+}
+
int kvm_arch_flush_remote_tlbs_range(struct kvm *kvm,
gfn_t gfn, u64 nr_pages)
{
@@ -353,6 +366,15 @@ static void no_stage2_unmap_range(struct kvm_s2_mmu *mmu,
{
}
+static void realm_stage2_unmap_range(struct kvm_s2_mmu *mmu,
+ phys_addr_t start, u64 size, bool may_block,
+ enum kvm_gfn_range_filter filter)
+{
+ struct kvm *kvm = kvm_s2_mmu_to_kvm(mmu);
+
+ kvm_realm_unmap_range_filter(kvm, start, size, may_block, filter);
+}
+
/*
* Unmapping vs dcache management:
*
@@ -1054,6 +1076,17 @@ static void pkvm_stage2_destroy(struct kvm_pgtable *pgt)
pkvm_pgtable_stage2_destroy_pgd(pgt);
}
+static void realm_stage2_destroy(struct kvm_pgtable *pgt)
+{
+ /*
+ * Realm RTTs are inaccessible to the host and may contain stale data
+ * after the RMM has released them. The non-root RTTs are explicitly
+ * destroyed through RMI before the RD is destroyed; only the root PGD
+ * pages remain to be freed here.
+ */
+ kvm_pgtable_stage2_destroy_pgd(pgt);
+}
+
static void kvm_stage2_destroy(struct kvm_pgtable *pgt)
{
struct kvm *kvm = kvm_s2_mmu_to_kvm(pgt->mmu);
@@ -3300,6 +3333,16 @@ static const struct kvm_vm_s2_ops kvm_default_vm_s2_ops = {
.vm_mem_abort = kvm_vm_mem_abort,
};
+static const struct kvm_vm_s2_ops realm_vm_s2_ops = {
+ .vm_stage2_destroy = realm_stage2_destroy,
+ .vm_flush_remote_tlbs = realm_flush_remote_tlbs,
+ .vm_flush_remote_tlbs_range = realm_flush_remote_tlbs_range,
+ .vm_age_gfn = no_age_gfn,
+ .vm_test_age_gfn = no_age_gfn,
+ .vm_stage2_unmap_range = realm_stage2_unmap_range,
+ .vm_mem_abort = kvm_vm_mem_abort,
+};
+
#define KVM_VM_S2_OPS(flavor, ops) \
[(flavor)] = &(ops)
@@ -3308,7 +3351,7 @@ static const struct kvm_vm_s2_ops *arm64_vm_s2_ops[] = {
KVM_VM_S2_OPS(VM_NVHE, kvm_default_vm_s2_ops),
KVM_VM_S2_OPS(VM_PKVM, pkvm_vm_s2_ops),
KVM_VM_S2_OPS(VM_PROTECTED_PKVM, protected_pkvm_vm_s2_ops),
- [VM_REALM] = NULL,
+ KVM_VM_S2_OPS(VM_REALM, realm_vm_s2_ops),
};
static int kvm_vm_init_vm_s2_ops(struct kvm *kvm)
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread