From: Leonardo Bras <leo.bras@arm.com> The new walker cleans the dirty bit on leaf entries, as well as clean the DBM bit in blocks so it still faults for lazy hugepage splitting when we enable FEAT_HDBSS in future patches. With disabled HDBSS, there should be no change in faulting behavior. Link: https://lore.kernel.org/all/20260901171558.2674031-4-leo.bras@arm.com/ Signed-off-by: Leonardo Bras <leo.bras@arm.com> Signed-off-by: Tian Zheng <zhengtian10@huawei.com> --- arch/arm64/kvm/hyp/pgtable.c | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/arch/arm64/kvm/hyp/pgtable.c b/arch/arm64/kvm/hyp/pgtable.c index 2ff33d3e371e..2849c136f366 100644 --- a/arch/arm64/kvm/hyp/pgtable.c +++ b/arch/arm64/kvm/hyp/pgtable.c @@ -1294,12 +1294,30 @@ static int stage2_update_leaf_attrs(struct kvm_pgtable *pgt, u64 addr, return 0; } +static int stage2_wrprotect_walker(const struct kvm_pgtable_visit_ctx *ctx, + enum kvm_pgtable_walk_flags visit) +{ + kvm_pte_t new = ctx->old & ~KVM_PTE_LEAF_ATTR_LO_S2_S2AP_W; + + /* We remove DBM on blocks so they can fault and get split */ + if (ctx->level < KVM_PGTABLE_LAST_LEVEL) + new &= ~KVM_PTE_LEAF_ATTR_HI_S2_DBM; + + if (kvm_pte_valid(ctx->old) && ctx->old != new) + WRITE_ONCE(*ctx->ptep, new); + + return 0; +} + + int kvm_pgtable_stage2_wrprotect(struct kvm_pgtable *pgt, u64 addr, u64 size) { - return stage2_update_leaf_attrs(pgt, addr, size, 0, - KVM_PTE_LEAF_ATTR_LO_S2_S2AP_W, - NULL, NULL, - KVM_PGTABLE_WALK_IGNORE_EAGAIN); + struct kvm_pgtable_walker walker = { + .cb = stage2_wrprotect_walker, + .flags = KVM_PGTABLE_WALK_LEAF, + }; + + return kvm_pgtable_walk(pgt, addr, size, &walker); } void kvm_pgtable_stage2_mkyoung(struct kvm_pgtable *pgt, u64 addr, -- 2.33.0

With VTCR_EL2.HD set, hardware promotes writable-clean descriptors to writable-dirty without any VM exit, and nothing in the arm64 KVM unmap paths harvests the stage-2 dirty bit - stage2_unmap_walker() only puts the page-table page. A folio whose only dirty state lives in a hardware-promoted stage-2 PTE is therefore invisible to the host MM, and reclaim can discard written guest data (silent corruption). The fault paths mark the folio speculatively at fault-in time, but the mapping lifecycle still needs exact harvesting, mirroring zap_present_folio_ptes() in the generic mm: - stage2_unmap_walker(): before tearing down a valid leaf with S2AP[1] set, harvest its output address into the folio account. Exact accounting: the walk runs under the mmu write lock, so the PTE being removed is the one being harvested. - stage2_wrprotect_walker(): a writable-dirty page losing its dirty state (WD -> WC during CLEAR) is harvested before the clear, so the information survives even if the mapping is torn down before the dirty state is observed anywhere else. Both hooks go through a new kvm_pgtable_mm_ops::mark_page_dirty callback: the walkers live in the dual-compiled hyp/pgtable.c, while SetPageDirty() is host-only and must not be reached for pKVM's host stage-2 page tables, whose mm_ops leave the callback NULL. Block mappings always map a folio-aligned head page, so dirtying the head covers the whole block. MMIO/PFNMAP ranges and reserved pages are excluded, mirroring kvm_is_ad_tracked_page() in virt/kvm/kvm_main.c. Signed-off-by: Tian Zheng <zhengtian10@huawei.com> --- arch/arm64/include/asm/kvm_pgtable.h | 10 ++++++++++ arch/arm64/kvm/hyp/pgtable.c | 30 ++++++++++++++++++++++++++-- arch/arm64/kvm/mmu.c | 26 ++++++++++++++++++++++++ 3 files changed, 64 insertions(+), 2 deletions(-) diff --git a/arch/arm64/include/asm/kvm_pgtable.h b/arch/arm64/include/asm/kvm_pgtable.h index 379031c74cbc..6535f56db127 100644 --- a/arch/arm64/include/asm/kvm_pgtable.h +++ b/arch/arm64/include/asm/kvm_pgtable.h @@ -246,6 +246,16 @@ struct kvm_pgtable_mm_ops { phys_addr_t (*virt_to_phys)(void *addr); void (*dcache_clean_inval_poc)(void *addr, size_t size); void (*icache_inval_pou)(void *addr, size_t size); + /* + * Harvest the dirty state of a leaf mapping into the host folio + * account before the mapping (or its write permission) goes away. + * Called for valid leaf entries with S2AP[1] set, whose dirty state + * may have been set by hardware (HAFDBS/HDBSS) without KVM ever + * observing a write fault. Takes the output address of the mapping + * (physical). Host-only; implementations that do not track folios + * leave it NULL. + */ + void (*mark_page_dirty)(u64 pa); }; /** diff --git a/arch/arm64/kvm/hyp/pgtable.c b/arch/arm64/kvm/hyp/pgtable.c index 2849c136f366..1e7583c5abf9 100644 --- a/arch/arm64/kvm/hyp/pgtable.c +++ b/arch/arm64/kvm/hyp/pgtable.c @@ -1183,8 +1183,22 @@ static int stage2_unmap_walker(const struct kvm_pgtable_visit_ctx *ctx, if (mm_ops->page_count(childp) != 1) return 0; - } else if (stage2_pte_cacheable(pgt, ctx->old)) { - need_flush = !cpus_have_final_cap(ARM64_HAS_STAGE2_FWB); + } else { + if (stage2_pte_cacheable(pgt, ctx->old)) + need_flush = !cpus_have_final_cap(ARM64_HAS_STAGE2_FWB); + + /* + * Harvest the dirty state into the host folio account + * before the mapping goes away, mirroring + * zap_present_folio_ptes() in the generic mm: S2AP[1] may + * have been set by hardware (FEAT_HAFDBS) without KVM ever + * observing a write fault, so this is the last chance to + * account it. Block mappings always map a folio-aligned + * head page, so dirtying the head covers the whole block. + */ + if ((ctx->old & KVM_PTE_LEAF_ATTR_LO_S2_S2AP_W) && + mm_ops->mark_page_dirty) + mm_ops->mark_page_dirty(kvm_pte_to_phys(ctx->old)); } /* @@ -1303,6 +1317,18 @@ static int stage2_wrprotect_walker(const struct kvm_pgtable_visit_ctx *ctx, if (ctx->level < KVM_PGTABLE_LAST_LEVEL) new &= ~KVM_PTE_LEAF_ATTR_HI_S2_DBM; + /* + * A writable-dirty page is about to lose its dirty state. If + * hardware promoted it, S2AP[1] is the only record of the write + * outside the PTE: harvest the folio account before the clear so + * the dirty information survives the transition regardless of + * what happens to the mapping afterwards. + */ + if (kvm_pte_valid(ctx->old) && ctx->old != new && + (ctx->old & KVM_PTE_LEAF_ATTR_LO_S2_S2AP_W) && + ctx->mm_ops->mark_page_dirty) + ctx->mm_ops->mark_page_dirty(kvm_pte_to_phys(ctx->old)); + if (kvm_pte_valid(ctx->old) && ctx->old != new) WRITE_ONCE(*ctx->ptep, new); diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c index e01db87daa97..b1a6f743be7b 100644 --- a/arch/arm64/kvm/mmu.c +++ b/arch/arm64/kvm/mmu.c @@ -888,6 +888,31 @@ static int get_user_mapping_size(struct kvm *kvm, u64 addr) return BIT(ARM64_HW_PGTABLE_LEVEL_SHIFT(level)); } +/* + * Harvest the stage-2 dirty state of a mapping into the host folio + * account, wired into kvm_s2_mm_ops::mark_page_dirty for the unmap and + * write-protect walkers. The dirty bit may have been set by hardware + * (FEAT_HAFDBS) without KVM ever observing a write fault, so this is + * the exact accounting, unlike the speculative folio dirtying at + * fault-in time. MMIO/PFNMAP ranges and reserved pages are outside the + * page-dirty machinery (mirrors kvm_is_ad_tracked_page() in + * virt/kvm/kvm_main.c). + */ +static void kvm_s2_mark_page_dirty(u64 pa) +{ + unsigned long pfn = pa >> PAGE_SHIFT; + struct page *page; + + if (!pfn_valid(pfn)) + return; + + page = pfn_to_page(pfn); + if (PageReserved(page)) + return; + + SetPageDirty(page); +} + static struct kvm_pgtable_mm_ops kvm_s2_mm_ops = { .zalloc_page = stage2_memcache_zalloc_page, .zalloc_pages_exact = kvm_s2_zalloc_pages_exact, @@ -900,6 +925,7 @@ static struct kvm_pgtable_mm_ops kvm_s2_mm_ops = { .virt_to_phys = kvm_host_pa, .dcache_clean_inval_poc = clean_dcache_guest_page, .icache_inval_pou = invalidate_icache_guest_page, + .mark_page_dirty = kvm_s2_mark_page_dirty, }; static int kvm_init_ipa_range(struct kvm_s2_mmu *mmu, unsigned long type) -- 2.33.0

From: Eillon <yezhenyu2@huawei.com> Each vCPU needs its own HDBSS buffer, described to hardware through HDBSSBR_EL2 (base address and encoded size) and a producer index, HDBSSPROD_EL2, which hardware advances as entries are appended. Tie the buffer lifetime to the vCPU: allocate it at vCPU creation and free it at vCPU destruction, independent of dirty logging. A later patch enables and disables HDBSS purely by toggling VTCR_EL2 bits, so the buffer must already exist by the time HDBSS turns on, and must never be freed while a vCPU is in guest mode with the feature active. Save HDBSSPROD_EL2 on vCPU put and restore both registers on load: the index is per-CPU register state that is reprogrammed by the next vCPU load, so buffering it in the vCPU is the only way to carry it across context switches and migrations. Keep the buddy allocation order separate from the HDBSSBR_EL2.SZ encoding: the two only coincide on 4KB pages, and using the SZ encoding as the free order would release more pages than were allocated on 16KB/64KB granules. A vcpu_hdbss_enabled() helper checks whether HDBSS is active for the current vCPU by testing hw_mmu->vtcr, correctly handling nested virtualization, where the shadow stage-2 MMU does not have the HDBSS bits set. Rework the kvm_arch_vcpu_create() error paths to unwind kvm_share_hyp() when the HDBSS allocation fails. Signed-off-by: Eillon <yezhenyu2@huawei.com> Signed-off-by: Tian Zheng <zhengtian10@huawei.com> --- arch/arm64/include/asm/kvm_dirty_bit.h | 40 +++++++++++++++++ arch/arm64/include/asm/kvm_host.h | 13 ++++++ arch/arm64/include/asm/sysreg.h | 9 ++++ arch/arm64/kvm/Makefile | 1 + arch/arm64/kvm/arm.c | 14 +++++- arch/arm64/kvm/dirty_bit.c | 60 ++++++++++++++++++++++++++ arch/arm64/kvm/hyp/vhe/switch.c | 17 ++++++++ arch/arm64/kvm/reset.c | 3 ++ 8 files changed, 155 insertions(+), 2 deletions(-) create mode 100644 arch/arm64/include/asm/kvm_dirty_bit.h create mode 100644 arch/arm64/kvm/dirty_bit.c diff --git a/arch/arm64/include/asm/kvm_dirty_bit.h b/arch/arm64/include/asm/kvm_dirty_bit.h new file mode 100644 index 000000000000..ee4de4ba8f5c --- /dev/null +++ b/arch/arm64/include/asm/kvm_dirty_bit.h @@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Per-vCPU buffer management for HDBSS-based dirty page tracking. + * + * Copyright (C) 2026 Huawei Technologies Co., Ltd + * Author: Tian Zheng <zhengtian10@huawei.com> + */ + +#ifndef __ARM64_KVM_DIRTY_BIT_H__ +#define __ARM64_KVM_DIRTY_BIT_H__ + +#include <asm/kvm_pgtable.h> +#include <asm/sysreg.h> +#include <linux/sizes.h> + +#define KVM_ARM_HDBSS_DEFAULT_SIZE PAGE_SIZE +#define KVM_ARM_HDBSS_MAX_SIZE SZ_2M + +/* 0 means unconfigured, fall back to one page per vCPU. */ +static inline u32 kvm_hdbss_buffer_size(struct kvm *kvm) +{ + return kvm->arch.hdbss_buffer_size ?: KVM_ARM_HDBSS_DEFAULT_SIZE; +} + +/* + * Tests hw_mmu->vtcr, the stage-2 MMU in use for the vCPU's current + * execution context: when running L1, hw_mmu points to kvm->arch.mmu + * (HDBSS bits present); when running L2, it points to a shadow + * stage-2 MMU (HDBSS bits absent). + */ +static inline bool vcpu_hdbss_enabled(struct kvm_vcpu *vcpu) +{ + return vcpu->arch.hw_mmu && + (vcpu->arch.hw_mmu->vtcr & VTCR_EL2_HDBSS); +} + +int kvm_arm_vcpu_alloc_hdbss(struct kvm_vcpu *vcpu); +void kvm_arm_vcpu_free_hdbss(struct kvm_vcpu *vcpu); + +#endif /* __ARM64_KVM_DIRTY_BIT_H__ */ diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index 00fe169f239f..e25f1d40c114 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -425,6 +425,9 @@ struct kvm_arch { */ struct kvm_protected_vm pkvm; + /* HDBSS: per-VM buffer size in bytes (0 = not configured, use default) */ + u32 hdbss_buffer_size; + #ifdef CONFIG_PTDUMP_STAGE2_DEBUGFS /* Nested virtualization info */ struct dentry *debugfs_nv_dentry; @@ -844,6 +847,13 @@ struct vcpu_reset_state { bool reset; }; +struct vcpu_hdbss_state { + struct page *hdbss_pg; /* HDBSS buffer */ + u64 hdbssbr_el2; /* programmed into the CPU on load */ + u64 hdbssprod_el2; /* producer index, saved on put */ + unsigned int buddy_order; /* allocation order for __free_pages() */ +}; + struct vncr_tlb; struct kvm_vcpu_arch { @@ -951,6 +961,9 @@ struct kvm_vcpu_arch { /* Hyp-readable copy of kvm_vcpu::pid */ pid_t pid; + + /* HDBSS buffer state */ + struct vcpu_hdbss_state hdbss; }; /* diff --git a/arch/arm64/include/asm/sysreg.h b/arch/arm64/include/asm/sysreg.h index 7aa08d59d494..7c71560b57e4 100644 --- a/arch/arm64/include/asm/sysreg.h +++ b/arch/arm64/include/asm/sysreg.h @@ -1039,6 +1039,15 @@ #define GCS_CAP(x) ((((unsigned long)x) & GCS_CAP_ADDR_MASK) | \ GCS_CAP_VALID_TOKEN) + +/* + * Definitions for the HDBSS feature + */ +#define HDBSSBR_EL2(baddr, sz) (((baddr) & HDBSSBR_EL2_BADDR_MASK) | \ + FIELD_PREP(HDBSSBR_EL2_SZ_MASK, sz)) + +#define HDBSSPROD_IDX(prod) FIELD_GET(HDBSSPROD_EL2_INDEX_MASK, prod) + /* * Definitions for GICv5 instructions */ diff --git a/arch/arm64/kvm/Makefile b/arch/arm64/kvm/Makefile index 59612d2f277c..ec2749af64fa 100644 --- a/arch/arm64/kvm/Makefile +++ b/arch/arm64/kvm/Makefile @@ -18,6 +18,7 @@ kvm-y += arm.o mmu.o mmio.o psci.o hypercalls.o pvtime.o \ guest.o debug.o reset.o sys_regs.o stacktrace.o \ vgic-sys-reg-v3.o fpsimd.o pkvm.o \ arch_timer.o trng.o vmid.o emulate-nested.o nested.o at.o \ + dirty_bit.o \ vgic/vgic.o vgic/vgic-init.o \ vgic/vgic-irqfd.o vgic/vgic-v2.o \ vgic/vgic-v3.o vgic/vgic-v4.o \ diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c index 1e528d53d093..483b64e0b832 100644 --- a/arch/arm64/kvm/arm.c +++ b/arch/arm64/kvm/arm.c @@ -36,6 +36,7 @@ #include <asm/virt.h> #include <asm/kvm_arm.h> #include <asm/kvm_asm.h> +#include <asm/kvm_dirty_bit.h> #include <asm/kvm_emulate.h> #include <asm/kvm_hyp.h> #include <asm/kvm_mmu.h> @@ -576,10 +577,19 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu) } err = kvm_share_hyp(vcpu, vcpu + 1); - if (err) + if (err) { kvm_vgic_vcpu_destroy(vcpu); + return err; + } - return err; + err = kvm_arm_vcpu_alloc_hdbss(vcpu); + if (err) { + kvm_unshare_hyp(vcpu, vcpu + 1); + kvm_vgic_vcpu_destroy(vcpu); + return err; + } + + return 0; } void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu) diff --git a/arch/arm64/kvm/dirty_bit.c b/arch/arm64/kvm/dirty_bit.c new file mode 100644 index 000000000000..52ece46ddd0c --- /dev/null +++ b/arch/arm64/kvm/dirty_bit.c @@ -0,0 +1,60 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Per-vCPU HDBSS buffer management. + * + * Copyright (C) 2026 Huawei Technologies Co., Ltd + * Author: Tian Zheng <zhengtian10@huawei.com> + */ + +#include <asm/kvm_dirty_bit.h> +#include <asm/kvm_mmu.h> +#include <asm/sysreg.h> +#include <linux/gfp.h> +#include <linux/kconfig.h> +#include <linux/log2.h> +#include <linux/mm.h> + +int kvm_arm_vcpu_alloc_hdbss(struct kvm_vcpu *vcpu) +{ + struct page *hdbss_pg; + u32 size; + unsigned int buddy_order; + u32 sz_encoded; + + if (vcpu->arch.hdbss.hdbss_pg || !system_supports_hdbss()) + return 0; + + size = kvm_hdbss_buffer_size(vcpu->kvm); + + /* + * HDBSSBR_EL2.SZ is relative to 4KB, the buddy order to + * PAGE_SIZE: they differ on 16KB/64KB granules, and freeing + * with the SZ encoding over-releases. + */ + buddy_order = get_order(size); + sz_encoded = ilog2(size) - 12; + + hdbss_pg = alloc_pages(GFP_KERNEL_ACCOUNT, buddy_order); + if (!hdbss_pg) + return -ENOMEM; + + vcpu->arch.hdbss = (struct vcpu_hdbss_state) { + .hdbss_pg = hdbss_pg, + .hdbssbr_el2 = HDBSSBR_EL2(page_to_phys(hdbss_pg), sz_encoded), + .hdbssprod_el2 = 0, + .buddy_order = buddy_order, + }; + + return 0; +} + +void kvm_arm_vcpu_free_hdbss(struct kvm_vcpu *vcpu) +{ + if (!vcpu->arch.hdbss.hdbss_pg) + return; + + __free_pages(vcpu->arch.hdbss.hdbss_pg, vcpu->arch.hdbss.buddy_order); + + vcpu->arch.hdbss.hdbss_pg = NULL; + vcpu->arch.hdbss.hdbssbr_el2 = 0; +} diff --git a/arch/arm64/kvm/hyp/vhe/switch.c b/arch/arm64/kvm/hyp/vhe/switch.c index 7875911c0506..c575ee1e0c8b 100644 --- a/arch/arm64/kvm/hyp/vhe/switch.c +++ b/arch/arm64/kvm/hyp/vhe/switch.c @@ -19,6 +19,7 @@ #include <asm/cpufeature.h> #include <asm/kprobes.h> #include <asm/kvm_asm.h> +#include <asm/kvm_dirty_bit.h> #include <asm/kvm_emulate.h> #include <asm/kvm_hyp.h> #include <asm/kvm_mmu.h> @@ -219,6 +220,17 @@ static void __vcpu_put_deactivate_traps(struct kvm_vcpu *vcpu) local_irq_restore(flags); } +static void __load_hdbss(struct kvm_vcpu *vcpu) +{ + if (!vcpu_hdbss_enabled(vcpu)) + return; + + write_sysreg_s(vcpu->arch.hdbss.hdbssbr_el2, SYS_HDBSSBR_EL2); + write_sysreg_s(vcpu->arch.hdbss.hdbssprod_el2, SYS_HDBSSPROD_EL2); + + isb(); +} + void kvm_vcpu_load_vhe(struct kvm_vcpu *vcpu) { host_data_ptr(host_ctxt)->__hyp_running_vcpu = vcpu; @@ -226,10 +238,15 @@ void kvm_vcpu_load_vhe(struct kvm_vcpu *vcpu) __vcpu_load_switch_sysregs(vcpu); __vcpu_load_activate_traps(vcpu); __load_stage2(vcpu->arch.hw_mmu); + __load_hdbss(vcpu); } void kvm_vcpu_put_vhe(struct kvm_vcpu *vcpu) { + /* The producer index is per-CPU state, reprogrammed on next load. */ + if (vcpu_hdbss_enabled(vcpu)) + vcpu->arch.hdbss.hdbssprod_el2 = read_sysreg_s(SYS_HDBSSPROD_EL2); + __vcpu_put_deactivate_traps(vcpu); __vcpu_put_switch_sysregs(vcpu); diff --git a/arch/arm64/kvm/reset.c b/arch/arm64/kvm/reset.c index 10eb7249aa9e..05ebe304830e 100644 --- a/arch/arm64/kvm/reset.c +++ b/arch/arm64/kvm/reset.c @@ -25,6 +25,7 @@ #include <asm/ptrace.h> #include <asm/kvm_arm.h> #include <asm/kvm_asm.h> +#include <asm/kvm_dirty_bit.h> #include <asm/kvm_emulate.h> #include <asm/kvm_mmu.h> #include <asm/kvm_nested.h> @@ -149,6 +150,8 @@ void kvm_arm_vcpu_destroy(struct kvm_vcpu *vcpu) free_page((unsigned long)vcpu->arch.ctxt.vncr_array); kfree(vcpu->arch.vncr_tlb); kfree(vcpu->arch.ccsidr); + + kvm_arm_vcpu_free_hdbss(vcpu); } static void kvm_vcpu_reset_sve(struct kvm_vcpu *vcpu) -- 2.33.0

An architecture that keeps a CPU-side dirty log buffer drained into the dirty ring must size that buffer with the ring in mind, as the ring reserves room for a full buffer flush. Give architectures a chance to react when kvm->dirty_ring_size is set: call a new kvm_arch_dirty_ring_size_updated() hook right after the size is recorded, with a __weak no-op default so this changes nothing for existing architectures. arm64 will use this to pin its HDBSS buffer size in dirty-ring mode. Signed-off-by: Tian Zheng <zhengtian10@huawei.com> --- include/linux/kvm_dirty_ring.h | 1 + virt/kvm/dirty_ring.c | 4 ++++ virt/kvm/kvm_main.c | 1 + 3 files changed, 6 insertions(+) diff --git a/include/linux/kvm_dirty_ring.h b/include/linux/kvm_dirty_ring.h index eb10d87adf7d..c2b922791530 100644 --- a/include/linux/kvm_dirty_ring.h +++ b/include/linux/kvm_dirty_ring.h @@ -73,6 +73,7 @@ static inline void kvm_dirty_ring_free(struct kvm_dirty_ring *ring) #else /* CONFIG_HAVE_KVM_DIRTY_RING */ int kvm_cpu_dirty_log_size(struct kvm *kvm); +void kvm_arch_dirty_ring_size_updated(struct kvm *kvm); bool kvm_use_dirty_bitmap(struct kvm *kvm); bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm); u32 kvm_dirty_ring_get_rsvd_entries(struct kvm *kvm); diff --git a/virt/kvm/dirty_ring.c b/virt/kvm/dirty_ring.c index 572b854edf74..784f53c95b54 100644 --- a/virt/kvm/dirty_ring.c +++ b/virt/kvm/dirty_ring.c @@ -16,6 +16,10 @@ int __weak kvm_cpu_dirty_log_size(struct kvm *kvm) return 0; } +void __weak kvm_arch_dirty_ring_size_updated(struct kvm *kvm) +{ +} + u32 kvm_dirty_ring_get_rsvd_entries(struct kvm *kvm) { return KVM_DIRTY_RING_RSVD_ENTRIES + kvm_cpu_dirty_log_size(kvm); diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 65eb26a0520d..7d574fb29a8f 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -4988,6 +4988,7 @@ static int kvm_vm_ioctl_enable_dirty_log_ring(struct kvm *kvm, u32 size) r = -EINVAL; } else { kvm->dirty_ring_size = size; + kvm_arch_dirty_ring_size_updated(kvm); r = 0; } -- 2.33.0

Hardware dirty management of the stage-2 descriptors is currently enabled or disabled by two independent paths that pull VTCR_EL2 in opposite directions. Leonardo Bras' "Enable HAFDBS for guests not on migration" turns HD on outside of migration and off once any memslot starts logging, so the write-protect permission fault remains the dirty tracking signal. The HDBSS enablement turns HD|HA|HDBSS on when logging starts, so hardware promotes writable-clean pages and records the dirtied IPAs into the per-vCPU buffers instead. Both hooks run from kvm_arch_commit_memory_region(), so whichever runs second wins, and the two independent read-modify-write cycles also race against the vCPU setup path, which could leave HDBSS set with HD clear - an illegal VTCR_EL2 combination. Replace both with kvm_arch_update_hw_dirty_mode(), a single derived mode that is a pure function of the static capabilities and the number of logging memslots: - logging && HDBSS-capable -> HD|HA|HDBSS (hardware tracking) - logging, no HDBSS -> off (classic write-protect faults) - !logging && HAFDBS-cap. -> HD|HA (only written pages go dirty) Because the mode is recomputed rather than toggled, there is no lost-update window to lock against, and a vCPU created while the VM is migrating inherits the current mode instead of clobbering it. The HDBSS leg is gated on !kvm_vcpu_has_nv(), matching the HAFDBS leg: nested shadow stage-2 MMUs do not carry the HDBSS bits. Always set HA together with HD: FEAT_HDBSS requires VTCR_EL2.{HDBSS,HA,HD} to be all set, and neither the kernel's own stage-1 enablement (cpu_enable_hw_dbm()) nor the SMMUv3 driver ever enables dirty updates without access-flag updates. Hardware-managed AF also removes the access-flag exits on mmu-notifier aged pages. The mode switch issues a single KVM_REQ_RELOAD_STAGE2 followed by a VMID-wide TLB invalidation: the request only reloads VTCR_EL2, while cached translations created under the old mode survive until invalidated, mirroring cpu_enable_hw_dbm()'s pairing of the TCR_EL1.HD flip with local_flush_tlb_all(). In the logging-stop direction (HD back on) stale read-only translations of writable-clean pages would otherwise keep faulting until each page takes its next fault. kvm_s2_fault_compute_prot() decides whether a read-faulted page may stay writable-clean based on the live VTCR_EL2.HD state rather than the static capability: QEMU keeps KVM_MEM_LOG_DIRTY_PAGES on the VGA VRAM slot for the entire runtime of a desktop VM, so with HD off for the whole VM but the static check still true, every read fault on the non-logged RAM slots would install writable-clean - read-only under HD=0 - and pay one extra permission fault per page. kvm_arch_destroy_vm() forces every bit off via kvm_arm_disable_hdbss_global(), as userspace may destroy the VM without ever stopping dirty logging. This is a rework of Leonardo Bras' "Enable HAFDBS for guests not on migration", which introduced the VHE-only HAFDBS enablement, the vcpu-setup hook and kvm_set_hafdbs(). Link: https://lore.kernel.org/all/20260901171558.2674031-6-leo.bras@arm.com/ Signed-off-by: Tian Zheng <zhengtian10@huawei.com> --- arch/arm64/include/asm/kvm_dirty_bit.h | 1 + arch/arm64/include/asm/kvm_mmu.h | 31 +++++++++ arch/arm64/include/asm/kvm_nested.h | 9 ++- arch/arm64/kvm/arm.c | 17 +++++ arch/arm64/kvm/dirty_bit.c | 30 +++++++- arch/arm64/kvm/hyp/pgtable.c | 14 ++-- arch/arm64/kvm/mmu.c | 95 ++++++++++++++++++++++++-- 7 files changed, 181 insertions(+), 16 deletions(-) diff --git a/arch/arm64/include/asm/kvm_dirty_bit.h b/arch/arm64/include/asm/kvm_dirty_bit.h index 7319bae2d14e..e334b2c3657c 100644 --- a/arch/arm64/include/asm/kvm_dirty_bit.h +++ b/arch/arm64/include/asm/kvm_dirty_bit.h @@ -52,5 +52,6 @@ int kvm_arm_vcpu_alloc_hdbss(struct kvm_vcpu *vcpu); void kvm_arm_vcpu_free_hdbss(struct kvm_vcpu *vcpu); void kvm_flush_hdbss_buffer(struct kvm_vcpu *vcpu); int kvm_handle_hdbss_fault(struct kvm_vcpu *vcpu); +void kvm_arm_disable_hdbss_global(struct kvm *kvm); #endif /* __ARM64_KVM_DIRTY_BIT_H__ */ diff --git a/arch/arm64/include/asm/kvm_mmu.h b/arch/arm64/include/asm/kvm_mmu.h index 6eae7e7e2a68..c9bc38478f0a 100644 --- a/arch/arm64/include/asm/kvm_mmu.h +++ b/arch/arm64/include/asm/kvm_mmu.h @@ -390,6 +390,37 @@ static inline bool kvm_supports_cacheable_pfnmap(void) cpus_have_final_cap(ARM64_HAS_CACHE_DIC); } +static inline bool kvm_supports_hafdbs(struct kvm *kvm) +{ + return IS_ENABLED(CONFIG_ARM64_HW_AFDBM) && has_vhe() && + !kvm_vcpu_has_nv(kvm) && cpus_have_final_cap(ARM64_HW_DBM); +} + +/* + * Whether this VM can use FEAT_HDBSS for hardware dirty tracking: + * system support (VHE-only, the buffer registers are EL2-only and are + * programmed from host context) and no nested virtualization, whose + * shadow stage-2 MMUs do not carry the HDBSS bits. + */ +static inline bool kvm_supports_hdbss(struct kvm *kvm) +{ + return system_supports_hdbss() && !kvm_vcpu_has_nv(kvm); +} + +void kvm_arch_update_hw_dirty_mode(struct kvm *kvm); + +/* + * Live counterpart of kvm_supports_hafdbs(): reports whether hardware + * dirty management is actually enabled for this VM right now. The HD + * bit is flipped on/off with dirty logging (and HDBSS), so decisions + * that depend on it must observe the dynamic state, not the static + * capability. + */ +static inline bool kvm_hw_dirty_enabled(struct kvm *kvm) +{ + return kvm->arch.mmu.vtcr & VTCR_EL2_HD; +} + #ifdef CONFIG_PTDUMP_STAGE2_DEBUGFS void kvm_s2_ptdump_create_debugfs(struct kvm *kvm); void kvm_nested_s2_ptdump_create_debugfs(struct kvm_s2_mmu *mmu); diff --git a/arch/arm64/include/asm/kvm_nested.h b/arch/arm64/include/asm/kvm_nested.h index 1ed708335809..9242b5d665af 100644 --- a/arch/arm64/include/asm/kvm_nested.h +++ b/arch/arm64/include/asm/kvm_nested.h @@ -7,11 +7,16 @@ #include <asm/kvm_emulate.h> #include <asm/kvm_pgtable.h> -static inline bool vcpu_has_nv(const struct kvm_vcpu *vcpu) +static inline bool kvm_vcpu_has_nv(const struct kvm *kvm) { return (!__is_defined(__KVM_NVHE_HYPERVISOR__) && cpus_have_final_cap(ARM64_HAS_NESTED_VIRT) && - vcpu_has_feature(vcpu, KVM_ARM_VCPU_HAS_EL2)); + kvm_vcpu_has_feature(kvm, KVM_ARM_VCPU_HAS_EL2)); +} + +static inline bool vcpu_has_nv(const struct kvm_vcpu *vcpu) +{ + return kvm_vcpu_has_nv(vcpu->kvm); } /* Translation helpers from non-VHE EL2 to EL1 */ diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c index facc53991998..dadb1e3990f4 100644 --- a/arch/arm64/kvm/arm.c +++ b/arch/arm64/kvm/arm.c @@ -343,6 +343,15 @@ void kvm_arch_destroy_vm(struct kvm *kvm) if (is_protected_kvm_enabled()) pkvm_destroy_hyp_vm(kvm); + /* + * Userspace may destroy the VM without disabling dirty + * logging, so the auto-disable path is never reached. Force + * disable HDBSS before the stage-2 MMU and the vCPU buffers + * go away. + */ + if (kvm_hdbss_enabled(kvm)) + kvm_arm_disable_hdbss_global(kvm); + kvm_uninit_stage2_mmu(kvm); kvm_destroy_mpidr_data(kvm); @@ -1714,6 +1723,14 @@ static int kvm_setup_vcpu(struct kvm_vcpu *vcpu) if (!ret && vcpu_has_nv(vcpu)) ret = kvm_vcpu_init_nested(vcpu); + /* + * Derive the hardware dirty mode (HAFDBS while not logging, HDBSS + * or off during migration). Being a pure function of the logging + * state and the static capabilities, a vCPU created while the VM + * is migrating keeps the current mode instead of clobbering it. + */ + kvm_arch_update_hw_dirty_mode(kvm); + return ret; } diff --git a/arch/arm64/kvm/dirty_bit.c b/arch/arm64/kvm/dirty_bit.c index 74b8b4113bda..923f9301ca99 100644 --- a/arch/arm64/kvm/dirty_bit.c +++ b/arch/arm64/kvm/dirty_bit.c @@ -84,7 +84,15 @@ void kvm_flush_hdbss_buffer(struct kvm_vcpu *vcpu) entries = kvm_hdbss_buffer_size(kvm) / sizeof(u64); - /* kvm_vcpu_mark_page_dirty() resolves the memslot under SRCU. */ + /* + * kvm_vcpu_mark_page_dirty() resolves the memslot under SRCU. The + * host folio account is deliberately not touched here: with the + * speculative folio dirtying at fault-in time and the unmap / + * write-protect walkers harvesting the stage-2 dirty bit, every + * exit from the writable-dirty state is already covered, so a + * folio harvest in the drain would be redundant - and keeping + * this path free of mmu_lock preserves its SRCU-only design. + */ srcu_idx = srcu_read_lock(&kvm->srcu); for (idx = 0; idx < min_t(u32, curr_idx, entries); idx++) { u64 gpa; @@ -137,3 +145,23 @@ int kvm_handle_hdbss_fault(struct kvm_vcpu *vcpu) write_sysreg_s(prod & ~HDBSSPROD_EL2_FSC_MASK, SYS_HDBSSPROD_EL2); return -EFAULT; } + +/* + * VM teardown path: userspace may destroy the VM without ever + * stopping dirty logging, in which case kvm_arch_update_hw_dirty_mode() + * would keep deriving the logging-based mode. Force every hardware + * dirty bit off before the stage-2 MMU and the vCPU buffers go away. + */ +void kvm_arm_disable_hdbss_global(struct kvm *kvm) +{ + unsigned long dirty_bits = + VTCR_EL2_HD | VTCR_EL2_HDBSS | VTCR_EL2_HA; + + if (!(kvm->arch.mmu.vtcr & dirty_bits)) + return; + + kvm->arch.mmu.vtcr &= ~dirty_bits; + + kvm_make_all_cpus_request(kvm, KVM_REQ_RELOAD_STAGE2); + kvm_flush_remote_tlbs(kvm); +} diff --git a/arch/arm64/kvm/hyp/pgtable.c b/arch/arm64/kvm/hyp/pgtable.c index 1e7583c5abf9..08cfce90396c 100644 --- a/arch/arm64/kvm/hyp/pgtable.c +++ b/arch/arm64/kvm/hyp/pgtable.c @@ -1191,9 +1191,9 @@ static int stage2_unmap_walker(const struct kvm_pgtable_visit_ctx *ctx, * Harvest the dirty state into the host folio account * before the mapping goes away, mirroring * zap_present_folio_ptes() in the generic mm: S2AP[1] may - * have been set by hardware (FEAT_HAFDBS) without KVM ever - * observing a write fault, so this is the last chance to - * account it. Block mappings always map a folio-aligned + * have been set by hardware (HAFDBS/HDBSS) without KVM + * ever observing a write fault, so this is the last chance + * to account it. Block mappings always map a folio-aligned * head page, so dirtying the head covers the whole block. */ if ((ctx->old & KVM_PTE_LEAF_ATTR_LO_S2_S2AP_W) && @@ -1319,10 +1319,10 @@ static int stage2_wrprotect_walker(const struct kvm_pgtable_visit_ctx *ctx, /* * A writable-dirty page is about to lose its dirty state. If - * hardware promoted it, S2AP[1] is the only record of the write - * outside the PTE: harvest the folio account before the clear so - * the dirty information survives the transition regardless of - * what happens to the mapping afterwards. + * hardware promoted it (HAFDBS/HDBSS), the pending buffer entry + * has not been drained yet and the CLEAR ioctl can race with an + * unmap that follows; harvest the folio account now so the dirty + * information survives the transition regardless. */ if (kvm_pte_valid(ctx->old) && ctx->old != new && (ctx->old & KVM_PTE_LEAF_ATTR_LO_S2_S2AP_W) && diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c index 2b915468521c..42cc35dde736 100644 --- a/arch/arm64/kvm/mmu.c +++ b/arch/arm64/kvm/mmu.c @@ -893,7 +893,7 @@ static int get_user_mapping_size(struct kvm *kvm, u64 addr) * Harvest the stage-2 dirty state of a mapping into the host folio * account, wired into kvm_s2_mm_ops::mark_page_dirty for the unmap and * write-protect walkers. The dirty bit may have been set by hardware - * (FEAT_HAFDBS) without KVM ever observing a write fault, so this is + * (HAFDBS/HDBSS) without KVM ever observing a write fault, so this is * the exact accounting, unlike the speculative folio dirtying at * fault-in time. MMIO/PFNMAP ranges and reserved pages are outside the * page-dirty machinery (mirrors kvm_is_ad_tracked_page() in @@ -1712,10 +1712,17 @@ static int gmem_abort(const struct kvm_s2_fault_desc *s2fd) out_unlock: /* * Two distinct dirty ledgers with different precision requirements: - * the host folio account (SetPageDirty) must be speculative, as a - * writable-clean mapping can be hardware-promoted to writable-dirty - * without any VM exit once VTCR_EL2.HD is set; the dirty bitmap must - * remain exact, or pre-copy will ship clean pages. + * + * - the host folio account (SetPageDirty) must be *speculative*: + * a writable-clean mapping can be hardware-promoted to writable + * dirty without any VM exit once VTCR_EL2.HD is set, so any + * mapping that grants write permission must dirty the folio at + * fault-in time. Over-marking is safe, it only causes a spurious + * writeback. + * + * - the KVM dirty bitmap must remain *exact*: a read-faulted + * writable-clean page must not enter the bitmap or pre-copy will + * ship clean pages. */ kvm_release_faultin_page(kvm, page, !!ret, prot & KVM_PGTABLE_PROT_W); kvm_fault_unlock(kvm); @@ -2023,7 +2030,20 @@ static int kvm_s2_fault_compute_prot(const struct kvm_s2_fault_desc *s2fd, if (s2vi->map_writable) { *prot |= KVM_PGTABLE_PROT_W; - if (s2vi->device || !memslot_is_logging(s2fd->memslot) || + /* + * Check the *live* HD state, not the static capability: HD + * is turned off for the whole VM as soon as any single + * memslot starts logging, and QEMU keeps + * KVM_MEM_LOG_DIRTY_PAGES on the VGA VRAM slot for the + * entire runtime of a desktop VM. With HD off but the static + * check still true, every read fault on the non-logged RAM + * slots would install writable-clean - which is read-only + * under HD=0 - and pay an extra permission fault per page. + * A racing flip is benign: at worst one page is mapped + * writable-dirty one last time or takes one extra fault. + */ + if (s2vi->device || + !(memslot_is_logging(s2fd->memslot) || kvm_hw_dirty_enabled(kvm)) || kvm_is_write_fault(s2fd->vcpu)) *prot |= KVM_PGTABLE_PROT_DIRTY; } @@ -2615,6 +2635,66 @@ int __init kvm_mmu_init(u32 hyp_va_bits) return err; } +/* + * The VM's hardware dirty-management mode is a *derived* value, never + * an independently managed one: it depends only on the static + * capabilities and the number of logging memslots, so recomputing it + * on every event (vCPU setup, logging start/stop) cannot lose an + * update and needs no extra locking against racing writers: + * + * logging && HDBSS-capable -> HDBSS (HD|HA|HDBSS): hardware + * promotes writable-clean pages and + * records the dirtied IPAs into the + * per-vCPU buffers, which replace + * the write-fault as the tracking + * signal. + * logging, no HDBSS -> off: the write-protect fault is the + * tracking signal, so HD must be off + * or hardware would promote + * writable-clean pages silently. + * !logging, HAFDBS-capable -> HAFDBS (HD|HA): read faults install + * writable-clean pages, and only + * pages actually written to become + * dirty. + */ +void kvm_arch_update_hw_dirty_mode(struct kvm *kvm) +{ + unsigned long cur, target; + bool logging = atomic_read(&kvm->nr_memslots_dirty_logging) != 0; + + if (logging && kvm_supports_hdbss(kvm)) + target = VTCR_EL2_HD | VTCR_EL2_HA | VTCR_EL2_HDBSS; + else if (logging || !kvm_supports_hafdbs(kvm)) + target = 0; + else + target = VTCR_EL2_HD | VTCR_EL2_HA; + + cur = kvm->arch.mmu.vtcr & (VTCR_EL2_HD | VTCR_EL2_HA | VTCR_EL2_HDBSS); + if (cur == target) + return; + + kvm->arch.mmu.vtcr = (kvm->arch.mmu.vtcr & + ~(VTCR_EL2_HD | VTCR_EL2_HA | VTCR_EL2_HDBSS)) | + target; + + kvm_make_all_cpus_request(kvm, KVM_REQ_RELOAD_STAGE2); + + /* + * The request above only reloads VTCR_EL2; cached translations + * created under the old mode survive until invalidated. In the + * logging-start direction the subsequent write-protect + + * kvm_flush_remote_tlbs_memslot() happens to cover the logging + * memslot, but in the logging-stop direction (HD back on) stale + * read-only translations of writable-clean pages would keep + * faulting until each page takes its next fault. Mirror the + * kernel's own stage-1 enablement (cpu_enable_hw_dbm() pairs the + * TCR_EL1.HD flip with local_flush_tlb_all()) and flush the VMID + * once every vCPU has reloaded the new VTCR. __kvm_tlb_flush_vmid + * broadcasts inner-shareable, so one CPU executing it suffices. + */ + kvm_flush_remote_tlbs(kvm); +} + void kvm_arch_commit_memory_region(struct kvm *kvm, struct kvm_memory_slot *old, const struct kvm_memory_slot *new, @@ -2622,6 +2702,9 @@ void kvm_arch_commit_memory_region(struct kvm *kvm, { bool log_dirty_pages = new && new->flags & KVM_MEM_LOG_DIRTY_PAGES; + /* Derive the hardware dirty mode from the new logging state. */ + kvm_arch_update_hw_dirty_mode(kvm); + /* * At this point memslot has been committed and there is an * allocated dirty_bitmap[], dirty pages will be tracked while the -- 2.33.0

Document the KVM_CAP_ARM_HDBSS_BUFFER_SIZE capability, which allows userspace to configure the per-vCPU hardware dirty state tracking structure (HDBSS) buffer size used for hardware-assisted dirty page tracking during live migration. The capability applies to dirty-bitmap mode only: it is rejected once the dirty ring is enabled, and enabling the dirty ring after a size was configured resets it to the default, which is what the ring mode uses in any case. Signed-off-by: Tian Zheng <zhengtian10@huawei.com> --- Documentation/virt/kvm/api.rst | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst index e0430cc750c9..14588c5a480b 100644 --- a/Documentation/virt/kvm/api.rst +++ b/Documentation/virt/kvm/api.rst @@ -9056,6 +9056,36 @@ enabled, cmma can't be enabled anymore and pfmfi and the storage key interpretation are disabled. If cmma has already been enabled or the hpage_2g module parameter is not set to 1, -EINVAL is returned. +7.48 KVM_CAP_ARM_HDBSS_BUFFER_SIZE +----------------------------------- + +:Architectures: arm64 +:Target: VM +:Parameters: args[0] is the per-vCPU HDBSS buffer size in bytes +:Returns: 0 on success; -EINVAL if the size is invalid or vCPUs have already + been created; -EBUSY if the buffer size was already configured. + +This capability configures the hardware dirty state tracking structure +(HDBSS) buffer size used for hardware-assisted dirty page tracking during +live migration. + +When live migration is initiated, userspace can configure the per-vCPU HDBSS +buffer size through this capability; KVM will allocate per-vCPU HDBSS buffers +of the requested size. + +The size must be a power of two between the default (``PAGE_SIZE``) and the +maximum (2MB). This capability applies to dirty-bitmap mode only: it is +rejected with -EINVAL once the dirty ring (``KVM_CAP_DIRTY_LOG_RING``) is +enabled, and enabling the dirty ring after a size was configured resets it +to the default, which is what the ring mode uses in any case. + +This capability may only be set before any vCPUs are created. Setting the +size a second time is rejected with -EBUSY. + +KVM_CHECK_EXTENSION for this capability returns the maximum supported buffer +size when queried without a VM, or the currently configured per-VM buffer size +(defaulting to ``PAGE_SIZE``) when queried with a VM. + 8. Other capabilities. ====================== -- 2.33.0

--- arch/arm64/kvm/arm.c | 5 +++++ arch/arm64/kvm/dirty_bit.c | 15 ++++++++++++++- arch/arm64/kvm/mmu.c | 5 ++++- 3 files changed, 23 insertions(+), 2 deletions(-) diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c index 1737dbe13419..e053edf8387d 100644 --- a/arch/arm64/kvm/arm.c +++ b/arch/arm64/kvm/arm.c @@ -224,6 +224,8 @@ int kvm_vm_ioctl_enable_cap(struct kvm *kvm, r = -EBUSY; } else { kvm->arch.hdbss_buffer_size = size; + kvm_info("HDBSS buffer size set by userspace to %llu bytes\n", + size); r = 0; } mutex_unlock(&kvm->lock); @@ -252,6 +254,9 @@ void kvm_arch_dirty_ring_size_updated(struct kvm *kvm) return; kvm->arch.hdbss_buffer_size = KVM_ARM_HDBSS_DEFAULT_SIZE; + + kvm_info("HDBSS buffer size auto-configured to %u bytes for dirty-ring mode\n", + KVM_ARM_HDBSS_DEFAULT_SIZE); } /** diff --git a/arch/arm64/kvm/dirty_bit.c b/arch/arm64/kvm/dirty_bit.c index 205b5f7a2805..ae5acfc4fd5b 100644 --- a/arch/arm64/kvm/dirty_bit.c +++ b/arch/arm64/kvm/dirty_bit.c @@ -42,8 +42,11 @@ int kvm_arm_vcpu_alloc_hdbss(struct kvm_vcpu *vcpu) * pushing leftover page contents into the dirty ring as GFNs. */ hdbss_pg = alloc_pages(GFP_KERNEL_ACCOUNT | __GFP_ZERO, buddy_order); - if (!hdbss_pg) + if (!hdbss_pg) { + kvm_err("VCPU%u HDBSS buffer allocation failed (order=%u)\n", + vcpu->vcpu_id, buddy_order); return -ENOMEM; + } vcpu->arch.hdbss = (struct vcpu_hdbss_state) { .hdbss_pg = hdbss_pg, @@ -52,6 +55,9 @@ int kvm_arm_vcpu_alloc_hdbss(struct kvm_vcpu *vcpu) .buddy_order = buddy_order, }; + kvm_info("VCPU%u HDBSS buffer allocated (size=%u bytes, order=%u)\n", + vcpu->vcpu_id, size, buddy_order); + return 0; } @@ -60,6 +66,11 @@ void kvm_arm_vcpu_free_hdbss(struct kvm_vcpu *vcpu) if (!vcpu->arch.hdbss.hdbss_pg) return; + kvm_info("VCPU%u HDBSS buffer freed (size=%u bytes, order=%u)\n", + vcpu->vcpu_id, + PAGE_SIZE << vcpu->arch.hdbss.buddy_order, + vcpu->arch.hdbss.buddy_order); + __free_pages(vcpu->arch.hdbss.hdbss_pg, vcpu->arch.hdbss.buddy_order); vcpu->arch.hdbss.hdbss_pg = NULL; @@ -168,6 +179,8 @@ void kvm_arm_disable_hdbss_global(struct kvm *kvm) kvm->arch.mmu.vtcr &= ~dirty_bits; + kvm_info("HDBSS disabled\n"); + kvm_make_all_cpus_request(kvm, KVM_REQ_RELOAD_STAGE2); kvm_flush_remote_tlbs(kvm); } diff --git a/arch/arm64/kvm/mmu.c b/arch/arm64/kvm/mmu.c index 42cc35dde736..473de0f0b01b 100644 --- a/arch/arm64/kvm/mmu.c +++ b/arch/arm64/kvm/mmu.c @@ -2662,8 +2662,11 @@ void kvm_arch_update_hw_dirty_mode(struct kvm *kvm) unsigned long cur, target; bool logging = atomic_read(&kvm->nr_memslots_dirty_logging) != 0; - if (logging && kvm_supports_hdbss(kvm)) + if (logging && kvm_supports_hdbss(kvm)) { target = VTCR_EL2_HD | VTCR_EL2_HA | VTCR_EL2_HDBSS; + kvm_info("HDBSS enabled (buffer_size=%u bytes)\n", + kvm_hdbss_buffer_size(kvm)); + } else if (logging || !kvm_supports_hafdbs(kvm)) target = 0; else -- 2.33.0