On Mon, Aug 03, 2026, Xiaoyao Li wrote: > On 8/1/2026 12:26 AM, Sean Christopherson wrote: > > On Fri, Jul 31, 2026, Xiaoyao Li wrote: > > > On 7/31/2026 4:42 AM, Ackerley Tng wrote: > > > If kvm_range_is_private() is useful/required by huge page support, then > > > let > > > the huge page series to introduce it. It has nothing to do with the > > > in-place > > > conversion series. > > > > If it weren't for the fact that the range-based search is used later in this > > series, I would 100% agree with Xiaoyao. > > But since the core logic is used and needed elsewhere, > > I don't see it a problem. Without introducing kvm_range_is_private() in this > patch, the core logic of range-based search on gmem can still be introduced > as kvm_gmem_range_has_attributes() directly in patch 10 or in a separate > patch. > > > and because kvm_range_has_vm_memory_attributes() takes a range, my vote is > > to provide the plumbing now, even though a small portion of it isn't > > strictly necessary. > > So my initial feedback was "we can just use kvm_mem_is_private(kvm, gfn)". > It makes code simpler.
My apologies, I hadn't actually applied v9 to look at the full context. I agree, providing kvm_range_is_private() is completely unnecessary. It's not even really a problem with this patch, it's a pre-existing issue that can and should be addressed with a prep patch. > And as a bonus, the logic to choose between gmem-based attribute query and > vm-based attribute query is hidden from the static call. I don't follow. What do you mean by "hidden from the static call?" The whole point of using a static call is to select between gmem-based and vm-based private memory. Or are you saying the populate() flow doesn't need to manually check gmem_in_place_conversion? > The second bonus of dropping kvm_range_is_private() is that we can eliminate > one more chunk in patch 20. Ya. Untested, but unless I'm missing something, patches 6 and 7 of this series can be replaced with the attached patches (6 and 7 should be squashed together no matter what).
>From 77bd0524535d65d7c6beb4a0cc70a65fbacc9f81 Mon Sep 17 00:00:00 2001 From: Sean Christopherson <[email protected]> Date: Mon, 3 Aug 2026 08:10:09 -0700 Subject: [PATCH 1/2] KVM: guest_memfd: Use kvm_mem_is_private() when populating guest_memfd memory Using kvm_mem_is_private() when populating guest_memfd instead of using an open coded equivalent. In addition to simplifying the populate code *now*, this avoids the need to provide a range-based gmem lookup API in the future as well. No functional change intended. Suggested-by: Xiaoyao Li <[email protected]> Signed-off-by: Sean Christopherson <[email protected]> --- virt/kvm/guest_memfd.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c index 8c7709a352cc..48c13d18af15 100644 --- a/virt/kvm/guest_memfd.c +++ b/virt/kvm/guest_memfd.c @@ -881,9 +881,7 @@ static long __kvm_gmem_populate(struct kvm *kvm, struct kvm_memory_slot *slot, folio_unlock(folio); - if (!kvm_range_has_vm_memory_attributes(kvm, gfn, gfn + 1, - KVM_MEMORY_ATTRIBUTE_PRIVATE, - KVM_MEMORY_ATTRIBUTE_PRIVATE)) { + if (!kvm_mem_is_private(kvm, gfn)) { ret = -EINVAL; goto out_put_folio; } base-commit: 17548ee538ef4f476e16fb5dd3ca8adfd8a852ed -- 2.55.0.508.g3f0d502094-goog
>From 02db86dc193d969085bbc0c98c6117e59d469cb5 Mon Sep 17 00:00:00 2001 From: Sean Christopherson <[email protected]> Date: Mon, 3 Aug 2026 08:17:34 -0700 Subject: [PATCH 2/2] KVM: guest_memfd: Stub in ability to enable in-place shared<=>private conversion Stub in global variable to enable in-place guest_memfd private<=>shared memory conversion, which will eventually be exposed to userspace via a module param, and wire up the __kvm_mem_is_private() static call to the guest_memfd version when in-place conversion is enabled, i.e. when gmem is the sole authority on private vs. shared memory. Cc: Fuad Tabba <[email protected]> Cc: Xiaoyao Li <[email protected]> Co-developed-by: Ackerley Tng <[email protected]> Signed-off-by: Ackerley Tng <[email protected]> Signed-off-by: Sean Christopherson <[email protected]> --- include/linux/kvm_host.h | 6 ++++++ virt/kvm/guest_memfd.c | 26 ++++++++++++++++++++++++++ virt/kvm/kvm_main.c | 12 +++++++++++- 3 files changed, 43 insertions(+), 1 deletion(-) diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index 65fbce46b63f..9477ecebbbce 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h @@ -2580,6 +2580,8 @@ static inline bool kvm_vm_mem_is_private(struct kvm *kvm, gfn_t gfn) #endif /* CONFIG_KVM_VM_MEMORY_ATTRIBUTES */ #ifdef kvm_arch_has_private_mem +extern bool gmem_in_place_conversion; + typedef bool (kvm_mem_is_private_t)(struct kvm *kvm, gfn_t gfn); DECLARE_STATIC_CALL(__kvm_mem_is_private, kvm_mem_is_private_t); @@ -2588,6 +2590,8 @@ static inline bool kvm_mem_is_private(struct kvm *kvm, gfn_t gfn) return static_call(__kvm_mem_is_private)(kvm, gfn); } #else +#define gmem_in_place_conversion false + static inline bool kvm_mem_is_private(struct kvm *kvm, gfn_t gfn) { return false; @@ -2595,6 +2599,8 @@ static inline bool kvm_mem_is_private(struct kvm *kvm, gfn_t gfn) #endif /* kvm_arch_has_private_mem */ #ifdef CONFIG_KVM_GUEST_MEMFD +bool kvm_gmem_is_private(struct kvm *kvm, gfn_t gfn); + int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory_slot *slot, gfn_t gfn, kvm_pfn_t *pfn, struct page **page, int *max_order); diff --git a/virt/kvm/guest_memfd.c b/virt/kvm/guest_memfd.c index 48c13d18af15..e21c7122539a 100644 --- a/virt/kvm/guest_memfd.c +++ b/virt/kvm/guest_memfd.c @@ -474,6 +474,32 @@ static int kvm_gmem_mmap(struct file *file, struct vm_area_struct *vma) return 0; } +bool kvm_gmem_is_private(struct kvm *kvm, gfn_t gfn) +{ + struct kvm_memory_slot *slot = gfn_to_memslot(kvm, gfn); + struct inode *inode; + + if (!slot) + return 0; + + CLASS(gmem_get_file, file)(slot); + if (!file) + return 0; + + inode = file_inode(file); + + /* + * Rely on the maple tree's internal RCU lock to ensure a stable result. + * This result can become stale as soon as the lock is dropped, so the + * caller _must_ protect consumption of private vs. shared either by + * holding guest_memfd's invalidate lock for the entire duration, or by + * checking mmu_invalidate_retry_gfn() under mmu_lock to serialize + * against concurrent attribute updates. + */ + return kvm_gmem_is_private_mem(inode, kvm_gmem_get_index(slot, gfn)); +} +EXPORT_SYMBOL_FOR_KVM_INTERNAL(kvm_gmem_is_private); + static struct file_operations kvm_gmem_fops = { .mmap = kvm_gmem_mmap, .open = generic_file_open, diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 081e3309359d..e5654baa8895 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -101,6 +101,10 @@ EXPORT_SYMBOL_FOR_KVM_INTERNAL(halt_poll_ns_shrink); static bool __ro_after_init allow_unsafe_mappings; module_param(allow_unsafe_mappings, bool, 0444); +#ifdef kvm_arch_has_private_mem +bool __ro_after_init gmem_in_place_conversion = false; +#endif + /* * Ordering of locks: * @@ -2422,6 +2426,9 @@ static int kvm_vm_ioctl_clear_dirty_log(struct kvm *kvm, static u64 kvm_supported_vm_mem_attributes(struct kvm *kvm) { #ifdef kvm_arch_has_private_mem + if (gmem_in_place_conversion) + return 0; + if (!kvm || kvm_arch_has_private_mem(kvm)) return KVM_MEMORY_ATTRIBUTE_PRIVATE; #endif @@ -2633,8 +2640,11 @@ EXPORT_STATIC_CALL_GPL(__kvm_mem_is_private); static void kvm_init_memory_attributes(void) { + if (gmem_in_place_conversion) + static_call_update(__kvm_mem_is_private, kvm_gmem_is_private); #ifdef CONFIG_KVM_VM_MEMORY_ATTRIBUTES - static_call_update(__kvm_mem_is_private, kvm_vm_mem_is_private); + else + static_call_update(__kvm_mem_is_private, kvm_vm_mem_is_private); #endif } #else -- 2.55.0.508.g3f0d502094-goog
