KVM: s390: More gmap and vsie fixes
Claudio Imbrenda
maintainerv3 cover KVM: s390: More gmap and vsie fixes
Another batch of fixups for gmap and vsie. Some minor fixes, some not-so-minor fixes that could have caused guest corruption under particular circumstances.
v2->v3:
* Improve patch 8 to avoid a possible race and minor issue when the given limit is smaller than a page
* Fix possible reference leak in fault-in code
* Fix possible warning if gmap_helper_zap_one_page() is called on a migration entry
v1->v2:
* Reordered the patches
* _gmap_crstep_xchg_atomic() will now attempt to clear the vsie_notif bit when failing due to unshadowing; this prevents potential loops
* try_get_locked_pte() will now return -EAGAIN instead of NULL if the pte was reached but the lock was contended; this prevents potential loops
* _kvm_s390_pv_make_secure() will now attempt mmap_read_trylock(); this prevents try_get_locked_pte() from potentially racing
* Take kvm->slots_lock instead of kvm->slots_arch_lock in kvm_s390_set_mem_control() when handling KVM_S390_VM_MEM_LIMIT_SIZE, and also take kvm->lock.
* Minor cosmetic / style fixes.
Claudio Imbrenda (10):
KVM: s390: Fix _gmap_unmap_crste()
KVM: s390: Fix _gmap_crstep_xchg_atomic()
KVM: s390: Avoid potentially sleeping while atomic when zapping pages
KVM: s390: Fix guest / virtual address confusion in _essa_clear_cbrl()
KVM: s390: vsie: Fix rmap handling in _do_shadow_crste()
KVM: s390: Fix fault-in code
KVM: s390: Lock pte when making page secure
KVM: s390: Prevent memslots outside the ASCE range
KVM: s390: Fix possible reference leak in fault-in code
KVM: s390: Remove ptep_zap_softleaf_entry()
arch/s390/include/asm/gmap_helpers.h | 1 + arch/s390/kvm/faultin.c | 30 +++---- arch/s390/kvm/gaccess.c | 11 +-- arch/s390/kvm/gmap.c | 19 +++- arch/s390/kvm/gmap.h | 3 + arch/s390/kvm/kvm-s390.c | 33 +++++-- arch/s390/kvm/priv.c | 8 +- arch/s390/kvm/pv.c | 21 ++++- arch/s390/mm/gmap_helpers.c | 128 +++++++++++++++------------ 9 files changed, 165 insertions(+), 89 deletions(-)
Signature · 1 line
2.54.0
Claudio Imbrenda
maintainerPATCH v3 1/10 KVM: s390: Fix _gmap_unmap_crste()
In _gmap_unmap_crste(), the crste to be unmapped is zapped calling gmap_crstep_xchg_atomic() exactly once, and expecting it to succeed. This is a reasonable sanity check, since kvm->mmu_lock is being held in write mode, and thus no races should be possible.
An upcoming patch will change the behaviour of gmap_crstep_xchg_atomic() to return false and clear the vsie_notif bit if the operation triggers an unshadow operation. With the new behaviour, an unmap operation that triggers an unshadow would cause the VM to be killed.
Prepare for the change by checking if the vsie_notif bit was set in the old crste if gmap_crstep_xchg_atomic() fails the first time, and try a second time. The second time no failures are allowed.
--- arch/s390/kvm/gmap.c | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-)
arch/s390/kvm/gmap.c +16 -3
@@ -395,15 +395,28 @@ static long _gmap_unmap_crste(union crste *crstep, gfn_t gfn, gfn_t next, structstruct gmap_unmap_priv *priv = walk->priv;struct folio *folio =NULL ;union crste old = *crstep; +bool ok;if (!old.h.fc)return 0 ;if (old.s.fc1.pr &&test_bit (GMAP_FLAG_EXPORT_ON_UNMAP , &priv->gmap->flags)) folio =phys_to_folio (crste_origin_large (old)); -/* No races should happen because kvm->mmu_lock is held in write mode */ -KVM_BUG_ON (!gmap_crstep_xchg_atomic (priv->gmap, crstep, old,_CRSTE_EMPTY (old.h.tt), gfn), - priv->gmap->kvm); +/* +* No races should happen because kvm->mmu_lock is held in write mode, +* but the unmap operation could have triggered an unshadow, which +* causes gmap_crstep_xchg_atomic() to return false and clear the +* vsie_notif bit. Allow the operation to fail once, if the old crste +* had the vsie_notif bit set. A second failure is not allowed, for +* the reasons above. +*/ + ok =gmap_crstep_xchg_atomic (priv->gmap, crstep, old,_CRSTE_EMPTY (old.h.tt), gfn); +if (!ok) { +KVM_BUG_ON (!old.s.fc1.vsie_notif, priv->gmap->kvm); + old.s.fc1.vsie_notif =0 ; + ok =gmap_crstep_xchg_atomic (priv->gmap, crstep, old,_CRSTE_EMPTY (old.h.tt), gfn); +KVM_BUG_ON (!ok, priv->gmap->kvm); + }if (folio)uv_convert_from_secure_folio (folio);
Signature · 1 line
2.54.0
Claudio Imbrenda
maintainerPATCH v3 2/10 KVM: s390: Fix _gmap_crstep_xchg_atomic()
In reply to Claudio ImbrendaThe previous incorrect behaviour cleared the vsie_notif bit without returning false, which allowed shadow crstes to be installed without the vsie_notif bit.
Return false and do not perform the operation if an unshadow event has been triggered, but still attempt to clear the vsie_notif bit from the existing crste.
This will prevent the installation of shadow crstes without vsie_notif bit and will also prevent the caller from looping forever if it was not checking for the sg->invalidated flag.
--- arch/s390/kvm/gmap.h | 3 +++ 1 file changed, 3 insertions(+)
arch/s390/kvm/gmap.h +3 -0
@@ -273,11 +273,14 @@ static inline bool __must_check _gmap_crstep_xchg_atomic(struct gmap *gmap, uniogmap_unmap_prefix (gmap, gfn, gfn + align); }if (crste_leaf (oldcrste) &&crste_needs_unshadow (oldcrste, newcrste)) { + newcrste = oldcrste; newcrste.s.fc1.vsie_notif =0 ;if (needs_lock)gmap_handle_vsie_unshadow_event (gmap, gfn);else _gmap_handle_vsie_unshadow_event (gmap, gfn); +dat_crstep_xchg_atomic (crstep, oldcrste, newcrste, gfn, gmap->asce); +return false; }if (!oldcrste.s.fc1.d && newcrste.s.fc1.d && !newcrste.s.fc1.s)SetPageDirty (phys_to_page (crste_origin_large (newcrste)));
Signature · 1 line
2.54.0
Claudio Imbrenda
maintainerPATCH v3 3/10 KVM: s390: Avoid potentially sleeping while atomic when zapping pages
In reply to Claudio ImbrendaFactor out try_get_locked_pte(), which behaves similarly to get_locked_pte(), but does not attempt to allocate missing tables and performs a spin_trylock() instead of blocking.
The new function is also exported, since it will be used in other patches.
If intermediate entries are missing, there can be no pte swap entry to free, so it's safe to ignore them.
This avoids potentially sleeping while atomic.
--- arch/s390/include/asm/gmap_helpers.h | 1 + arch/s390/mm/gmap_helpers.c | 117 ++++++++++++++++----------- 2 files changed, 73 insertions(+), 45 deletions(-)
arch/s390/include/asm/gmap_helpers.h +1 -0
@@ -12,5 +12,6 @@ void gmap_helper_zap_one_page(struct mm_struct *mm, unsigned long vmaddr);void gmap_helper_discard (struct mm_struct *mm,unsigned long vmaddr,unsigned long end);int gmap_helper_disable_cow_sharing (void );void gmap_helper_try_set_pte_unused (struct mm_struct *mm,unsigned long vmaddr); +pte_t *try_get_locked_pte (struct mm_struct *mm,unsigned long addr,spinlock_t **ptl);#endif /* _ASM_S390_GMAP_HELPERS_H */
arch/s390/mm/gmap_helpers.c +72 -45
151 lines not on this page · raw message
Signature · 1 line
2.54.0
Claudio Imbrenda
maintainerPATCH v3 4/10 KVM: s390: Fix guest / virtual address confusion in _essa_clear_cbrl()
In reply to Claudio ImbrendaUntil now, gmap_helper_zap_one_page() was being called with the guest absolute address, but it expects a userspace virtual address.
This meant that in the best case the requested pages were not being discarded, and in the worst case that the wrong pages were being discarded.
Fix this by converting the guest absolute address to host virtual before passing it to gmap_helper_zap_one_page().
--- arch/s390/kvm/priv.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
arch/s390/kvm/priv.c +6 -2
@@ -1188,6 +1188,7 @@ static void _essa_clear_cbrl(struct kvm_vcpu *vcpu, unsigned long *cbrl, int lenunion crste *crstep;union pgste pgste;union pte *ptep; +hva_t hva;int i;lockdep_assert_held (&vcpu->kvm->mmu_lock);
@@ -1199,8 +1200,11 @@ static void _essa_clear_cbrl(struct kvm_vcpu *vcpu, unsigned long *cbrl, int lenif (!ptep || ptep->s.pr)continue ; pgste =pgste_get_lock (ptep); -if (pgste.usage ==PGSTE_GPS_USAGE_UNUSED || pgste.zero) -gmap_helper_zap_one_page (vcpu->kvm->mm, cbrl[i]); +if (pgste.usage ==PGSTE_GPS_USAGE_UNUSED || pgste.zero) { + hva =gpa_to_hva (vcpu->kvm, cbrl[i]); +if (!kvm_is_error_hva (hva)) +gmap_helper_zap_one_page (vcpu->kvm->mm, hva); + }pgste_set_unlock (ptep, pgste); } }
Signature · 1 line
2.54.0
Claudio Imbrenda
maintainerPATCH v3 5/10 KVM: s390: vsie: Fix rmap handling in _do_shadow_crste()
In reply to Claudio ImbrendaFix _do_shadow_crste() to also apply a mask on the reverse address, to prevent spurious entries from being created, like already done in gmap_protect_rmap().
--- arch/s390/kvm/gaccess.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
arch/s390/kvm/gaccess.c +6 -5
@@ -1466,15 +1466,17 @@ static int _do_shadow_crste(struct gmap *sg, gpa_t raddr, union crste *host, uni struct guest_fault *f, bool p) {union crste newcrste, oldcrste; -gfn_t gfn; +unsigned long mask; +gfn_t r_gfn;int rc;lockdep_assert_held (&sg->kvm->mmu_lock);lockdep_assert_held (&sg->parent->children_lock); - gfn = f->gfn & (is_pmd (*table) ? _SEGMENT_FR_MASK : _REGION3_FR_MASK); + mask =is_pmd (*table) ? _SEGMENT_FR_MASK : _REGION3_FR_MASK; + r_gfn =gpa_to_gfn (raddr) & mask;scoped_guard (spinlock, &sg->host_to_rmap_lock) - rc = gmap_insert_rmap(sg, gfn, gpa_to_gfn(raddr), host->h.tt); + rc = gmap_insert_rmap(sg, f->gfn & mask, r_gfn, host->h.tt);if (rc)return rc;
@@ -1497,8 +1499,7 @@ static int _do_shadow_crste(struct gmap *sg, gpa_t raddr, union crste *host, unireturn -EAGAIN ; newcrste =_crste_fc1 (f->pfn, oldcrste.h.tt,0 , !p); - gfn =gpa_to_gfn (raddr); -while (!dat_crstep_xchg_atomic (table,READ_ONCE (*table), newcrste, gfn, sg->asce)) +while (!dat_crstep_xchg_atomic (table,READ_ONCE (*table), newcrste, r_gfn, sg->asce)) ;return 0 ; }
Signature · 1 line
2.54.0
Claudio Imbrenda
maintainerPATCH v3 6/10 KVM: s390: Fix fault-in code
In reply to Claudio ImbrendaFix the fault-in code so that it does not return success if a concurrent unmap event invalidated the fault-in process between the best-effort lockless check and the proper check with lock.
The new behaviour is to retry, like the best-effort lockless check already did.
This prevents the fault-in handler from returning success without having actually faulted in the requested page.
--- arch/s390/kvm/faultin.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
arch/s390/kvm/faultin.c +7 -7
@@ -36,7 +36,8 @@ int kvm_s390_faultin_gfn(struct kvm_vcpu *vcpu, struct kvm *kvm, struct guest_fastruct kvm_s390_mmu_cache *mc =NULL ;struct kvm_memory_slot *slot;unsigned long inv_seq; -int foll, rc =0 ; +int rc = -EAGAIN ; +int foll; foll = f->write_attempt ?FOLL_WRITE :0 ; foll |= f->attempt_pfault ?FOLL_NOWAIT :0 ;
@@ -53,7 +54,7 @@ int kvm_s390_faultin_gfn(struct kvm_vcpu *vcpu, struct kvm *kvm, struct guest_fareturn 0 ; } -while (1 ) { +while (rc == -EAGAIN ) { f->valid = false; inv_seq = kvm->mmu_invalidate_seq;/* Pairs with the smp_wmb() in kvm_mmu_invalidate_end(). */
@@ -110,20 +111,19 @@ int kvm_s390_faultin_gfn(struct kvm_vcpu *vcpu, struct kvm *kvm, struct guest_faif (!mmu_invalidate_retry_gfn (kvm, inv_seq, f->gfn)) { f->valid = true; rc =gmap_link (mc, kvm->arch.gmap, f, slot); -kvm_release_faultin_page (kvm, f->page, !!rc, f->write_attempt); - f->page =NULL ; } +kvm_release_faultin_page (kvm, f->page, !!rc, f->write_attempt); } -kvm_release_faultin_page (kvm, f->page, true, false);if (rc == -ENOMEM ) { rc =kvm_s390_mmu_cache_topup (mc);if (rc)return rc; - }else if (rc != -EAGAIN ) { -return rc; + rc = -EAGAIN ; } } + +return rc; }int kvm_s390_get_guest_page (struct kvm *kvm,struct guest_fault *f,gfn_t gfn,bool w)
Signature · 1 line
2.54.0
Claudio Imbrenda
maintainerPATCH v3 7/10 KVM: s390: Lock pte when making page secure
In reply to Claudio ImbrendaMake sure _kvm_s390_pv_make_secure() takes the pte lock for the given address when attempting to make the page secure.
One of the steps in making the page secure is freezing the folio using folio_ref_freeze(), which temporarily sets the reference count to 0. Any attempt to get such a folio while frozen will fail and cause a warning to be printed.
Other users of folio_ref_freeze() make sure that the page is not mapped while it's being frozen, thus preventing gup functions from being able to access it. For _kvm_s390_pv_make_secure(), this is not possible, because the page needs to be mapped in order for the import to succeed.
By taking the pte lock, gup functions will be blocked until the import operation is done, thus avoiding the race.
In theory this does not completely solve the issue: if a page is mapped through multiple mappings, locking one pte does not protect from calling gup on it through the other mapping. In practice this does not happen and it is a decent stopgap solution until a more correct solution is available.
--- arch/s390/kvm/pv.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-)
arch/s390/kvm/pv.c +20 -1
@@ -17,6 +17,7 @@#include <linux/pagewalk.h> #include <linux/sched/mm.h> #include <linux/mmu_notifier.h> +#include <asm/gmap_helpers.h> #include "kvm-s390.h" #include "dat.h" #include "gaccess.h"
@@ -73,6 +74,7 @@ static bool should_export_before_import(struct uv_cb_header *uvcb, struct mm_strstruct pv_make_secure {void *uvcb;struct folio *folio; +struct kvm *kvm;int rc;bool needs_export; };
@@ -103,9 +105,21 @@ static void _kvm_s390_pv_make_secure(struct guest_fault *f) {struct pv_make_secure *priv = f->priv;struct folio *folio; +spinlock_t *ptl;/* pte lock from try_get_locked_pte() */ +pte_t *ptep; folio =pfn_folio (f->pfn); priv->rc = -EAGAIN ; + +if (!mmap_read_trylock (priv->kvm->mm)) +return ; + + ptep =try_get_locked_pte (priv->kvm->mm,gfn_to_hva (priv->kvm, f->gfn), &ptl); +if (IS_ERR_VALUE (ptep)) { + priv->rc =PTR_ERR (ptep); + goto out; + } +if (folio_trylock (folio)) { priv->rc =__kvm_s390_pv_make_secure (f, folio);if (priv->rc == -E2BIG || priv->rc == -EBUSY ) {
@@ -114,6 +128,11 @@ static void _kvm_s390_pv_make_secure(struct guest_fault *f) }folio_unlock (folio); } + +if (ptep) +pte_unmap_unlock (ptep, ptl); +out: +mmap_read_unlock (priv->kvm->mm); }/**
@@ -127,7 +146,7 @@ static void _kvm_s390_pv_make_secure(struct guest_fault *f)*/ int kvm_s390_pv_make_secure (struct kvm *kvm,unsigned long gaddr,void *uvcb) { -struct pv_make_secure priv = { .uvcb = uvcb }; +struct pv_make_secure priv = { .uvcb = uvcb, .kvm = kvm, };struct guest_fault f = { .write_attempt = true, .gfn =gpa_to_gfn (gaddr),
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v3 07/10] KVM: s390: Lock pte when making page secure
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
New issues:
- [High] If try_get_locked_pte returns NULL for a THP, the host PTE lock is bypassed. A concurrent split of the THP allows freezing the folio without the PTE lock, reintroducing the GUP race the patch intended to fix.
Pre-existing issues:
- [High] Host kernel panic when a PV guest attempts to secure memory backed by raw PFNs (e.g., PFNMAP/VFIO without a struct page). --
commit aa4d37eba4327b04312028eb0cda26ab49b2e88f
Author: Claudio Imbrenda <[email protected]>
KVM: s390: Lock pte when making page secure
This commit attempts to fix a race with GUP when freezing folios during the secure page import process by temporarily locking the PTE.
Quoted 4 lines
arch/s390/kvm/pv.c +0
-0
[ ... ]
arch/s390/kvm/pv.c static void _kvm_s390_pv_make_secure(struct guest_fault *f) · line 111
Quoted 8 lines
arch/s390/kvm/pv.c +2
-0@@ -103,9 +105,21 @@ static void _kvm_s390_pv_make_secure(struct guest_fault *f) {struct pv_make_secure *priv = f->priv;struct folio *folio; +spinlock_t *ptl;/* pte lock from try_get_locked_pte() */ +pte_t *ptep; folio =pfn_folio (f->pfn);
[Severity: High]
This is a pre-existing issue, but can this cause a host kernel panic if the guest attempts to secure memory backed by raw PFNs (e.g., PFNMAP/VFIO) that lack a struct page?
If kvm_s390_faultin_gfn() resolves the GFN to a raw PFN but leaves f->page = NULL, blindly converting it via pfn_folio() accesses memory outside the bounds of the vmemmap array, returning a garbage pointer.
Later in __kvm_s390_pv_make_secure(), the code does:
if (!f->page)
folio_get(folio);Would this try to increment the reference count of that garbage pointer?
arch/s390/kvm/pv.c static void _kvm_s390_pv_make_secure(struct guest_fault *f) · line 118
Quoted 7 lines
arch/s390/kvm/pv.c +6
-0priv->rc = -EAGAIN ; + +if (!mmap_read_trylock (priv->kvm->mm)) +return ; + + ptep =try_get_locked_pte (priv->kvm->mm,gfn_to_hva (priv->kvm, f->gfn), &ptl); +if (IS_ERR_VALUE (ptep)) {
[Severity: High]
Since try_get_locked_pte() returns NULL for large PMDs (THPs) or unmapped entries, and IS_ERR_VALUE(NULL) evaluates to false, does this proceed with ptep == NULL and no PTE lock?
If the memory is a THP and a concurrent operation triggers a THP split immediately after try_get_locked_pte() returns NULL, the THP becomes order-0 folios. The KVM thread then successfully locks the newly-split order-0 folio and freezes it since it bypassed the PTE lock entirely.
Could a concurrent slow GUP on the same address then acquire the PTE lock, read the PTE, and call try_grab_folio(), triggering a WARN_ON_ONCE because the folio refcount is 0?
Quoted 6 lines
arch/s390/kvm/pv.c +4
-0+ priv->rc =PTR_ERR (ptep); + goto out; + } +if (folio_trylock (folio)) { priv->rc =__kvm_s390_pv_make_secure (f, folio);
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
Claudio Imbrenda
maintainerPATCH v3 8/10 KVM: s390: Prevent memslots outside the ASCE range
In reply to Claudio ImbrendaWith KVM_S390_VM_MEM_LIMIT_SIZE, userspace can set the highest address allowed for the VM. Creating a memslot that lies over the maximum address does not make sense and is only a potential source of bugs.
Prevent creation of memslots over the maximum address, and prevent the maximum address from being reduced below the end of existing memslots.
--- arch/s390/kvm/kvm-s390.c | 33 ++++++++++++++++++++++++++++----- 1 file changed, 28 insertions(+), 5 deletions(-)
arch/s390/kvm/kvm-s390.c +28 -5
@@ -999,7 +999,10 @@ static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attbreak ; }case KVM_S390_VM_MEM_LIMIT_SIZE : { +struct kvm_memslots *slots; +struct kvm_memory_slot *ms;unsigned long new_limit; +int bkt;if (kvm_is_ucontrol (kvm))return -EINVAL ;
@@ -1007,6 +1010,9 @@ static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attif (get_user (new_limit, (u64 __user *)attr->addr))return -EFAULT ; +guard (mutex)(&kvm->lock); + + new_limit =ALIGN (new_limit,HPAGE_SIZE );if (kvm->arch.mem_limit !=KVM_S390_NO_MEM_LIMIT && new_limit > kvm->arch.mem_limit)return -E2BIG ;
@@ -1014,12 +1020,27 @@ static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attif (!new_limit)return -EINVAL ; - ret = -EBUSY ; -if (!kvm->created_vcpus) - ret =gmap_set_limit (kvm->arch.gmap,gpa_to_gfn (new_limit)); +if (kvm->created_vcpus) +return -EBUSY ; + + ret =0 ; + scoped_guard(mutex, &kvm->slots_lock) { + slots =kvm_memslots (kvm); +if (slots && !kvm_memslots_empty (slots)) { +kvm_for_each_memslot (ms, bkt, slots) { +if (gpa_to_gfn (new_limit) < ms->base_gfn + ms->npages) { + ret = -EBUSY ; +break ; + } + } + } +if (!ret) + ret =gmap_set_limit (kvm->arch.gmap,gpa_to_gfn (new_limit)); + } +if (ret) +break ;VM_EVENT (kvm,3 ,"SET: max guest address: %lu" , new_limit); -VM_EVENT (kvm,3 ,"New guest asce: 0x%p" , - (void *)kvm->arch.gmap->asce.val); +VM_EVENT (kvm,3 ,"New guest asce: 0x%p" , (void *)kvm->arch.gmap->asce.val);break ; }default :
@@ -5672,6 +5693,8 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,return -EINVAL ;if ((new->base_gfn + new->npages) *PAGE_SIZE > kvm->arch.mem_limit)return -EINVAL ; +if (!asce_contains_gfn (kvm->arch.gmap->asce, new->base_gfn + new->npages -1 )) +return -EINVAL ; }if (!kvm->arch.migration_mode)
Signature · 1 line
2.54.0
[email protected]
AI reviewRe: [PATCH v3 08/10] KVM: s390: Prevent memslots outside the ASCE range
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Asymmetric and Order-Dependent Limit Validation --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Asymmetric and Order-Dependent Limit Validation
--
commit 7a66168c52b7a30030450cbbdcd5db0e9145bbfe
Author: Claudio Imbrenda <[email protected]>
KVM: s390: Prevent memslots outside the ASCE range
This patch aims to prevent userspace from creating memslots above the maximum allowed VM address, and prevents reducing the maximum address below existing memslots.
Quoted 12 lines
arch/s390/kvm/kvm-s390.c +3
-0@@ -999,7 +999,10 @@ static int kvm_s390_set_mem_control(struct kvm *kvm, struct kvm_device_attr *attbreak ; }case KVM_S390_VM_MEM_LIMIT_SIZE : { +struct kvm_memslots *slots; +struct kvm_memory_slot *ms;unsigned long new_limit; +int bkt;
[ ... ]
Quoted 14 lines
arch/s390/kvm/kvm-s390.c +14
-0+ ret =0 ; + scoped_guard(mutex, &kvm->slots_lock) { + slots =kvm_memslots (kvm); +if (slots && !kvm_memslots_empty (slots)) { +kvm_for_each_memslot (ms, bkt, slots) { +if (gpa_to_gfn (new_limit) < ms->base_gfn + ms->npages) { + ret = -EBUSY ; +break ; + } + } + } +if (!ret) + ret =gmap_set_limit (kvm->arch.gmap,gpa_to_gfn (new_limit)); + }
[ ... ]
arch/s390/kvm/kvm-s390.c int kvm_arch_prepare_memory_region(struct kvm *kvm, · line 5698
Quoted 7 lines
arch/s390/kvm/kvm-s390.c +2
-0@@ -5672,6 +5693,8 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,return -EINVAL ;if ((new->base_gfn + new->npages) *PAGE_SIZE > kvm->arch.mem_limit)return -EINVAL ; +if (!asce_contains_gfn (kvm->arch.gmap->asce, new->base_gfn + new->npages -1 )) +return -EINVAL ; }
[Severity: Medium]
Is this creating an asymmetric and order-dependent limit validation?
When KVM_S390_VM_MEM_LIMIT_SIZE is called, the exact new_limit is strictly checked against existing memslots (e.g., rejecting a 4GB limit if a 3TB memslot exists). However, new_limit is never saved back to kvm->arch.mem_limit.
When a new memslot is added later, it is only validated against the old kvm->arch.mem_limit and the rounded-up ASCE capacity here in asce_contains_gfn().
For example, setting a 4GB limit configures a TABLE_TYPE_REGION3 ASCE with a 4TB capacity. Because the exact 4GB limit was not saved, userspace can successfully add a 3TB memslot later since 3TB < 4TB.
Should kvm->arch.mem_limit be updated during KVM_S390_VM_MEM_LIMIT_SIZE to enforce the exact limit symmetrically?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Claudio Imbrenda
maintainerPATCH v3 9/10 KVM: s390: Fix possible reference leak in fault-in code
In reply to Claudio ImbrendaIf kvm_s390_new_mmu_cache() fails, kvm_s390_faultin_gfn() returns without releasing the faulted page.
Fix this by moving the allocation of the memory cache outside of the loop. There is no reason to check at every iteration.
Opportunistically fix a comment.
--- arch/s390/kvm/faultin.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
arch/s390/kvm/faultin.c +8 -8
@@ -54,6 +54,13 @@ int kvm_s390_faultin_gfn(struct kvm_vcpu *vcpu, struct kvm *kvm, struct guest_fareturn 0 ; } +if (!mc) { + local_mc =kvm_s390_new_mmu_cache (); +if (!local_mc) +return -ENOMEM ; + mc = local_mc; + } +while (rc == -EAGAIN ) { f->valid = false; inv_seq = kvm->mmu_invalidate_seq;
@@ -94,14 +101,7 @@ int kvm_s390_faultin_gfn(struct kvm_vcpu *vcpu, struct kvm *kvm, struct guest_faif (is_error_pfn (f->pfn))return -EFAULT ; -if (!mc) { - local_mc =kvm_s390_new_mmu_cache (); -if (!local_mc) -return -ENOMEM ; - mc = local_mc; - } - -/* Loop, will automatically release the faulted page. */ +/* Loop, release the faulted page. */ if (mmu_invalidate_retry_gfn_unsafe (kvm, inv_seq, f->gfn)) {kvm_release_faultin_page (kvm, f->page, true, false);continue ;
Signature · 1 line
2.54.0
Claudio Imbrenda
maintainerPATCH v3 10/10 KVM: s390: Remove ptep_zap_softleaf_entry()
In reply to Claudio ImbrendaMigration entries do not need to be removed.
The swap subsystem has been (and still is being) heavily reworked. The current implementation of ptep_zap_softleaf_entry() has been slowly modified and is now wrong, since it unconditionally calls swap_put_entries_direct() for both swap and migration entries.
Remove ptep_zap_softleaf_entry() altogether, merge the path for proper swap entries directly in the only caller, and ignore migration entries.
--- arch/s390/mm/gmap_helpers.c | 25 +++++-------------------- 1 file changed, 5 insertions(+), 20 deletions(-)
arch/s390/mm/gmap_helpers.c +5 -20
@@ -16,24 +16,6 @@#include <linux/ksm.h> #include <asm/gmap_helpers.h> -/** -* ptep_zap_softleaf_entry() - discard a software leaf entry. -* @mm: the mm -* @entry: the software leaf entry that needs to be zapped -* -* Discards the given software leaf entry. If the leaf entry was an actual -* swap entry (and not a migration entry, for example), the actual swapped -* page is also discarded from swap. -*/ -static void ptep_zap_softleaf_entry (struct mm_struct *mm,softleaf_t entry) -{ -if (softleaf_is_swap (entry)) -dec_mm_counter (mm,MM_SWAPENTS ); -else if (softleaf_is_migration (entry)) -dec_mm_counter (mm,mm_counter (softleaf_to_folio (entry))); -swap_put_entries_direct (entry,1 ); -} -/** * try_get_locked_pte() - like get_locked_pte(), but atomic and with trylock * @mm: the mm
@@ -111,6 +93,7 @@ void gmap_helper_zap_one_page(struct mm_struct *mm, unsigned long vmaddr) {struct vm_area_struct *vma;spinlock_t *ptl;/* Lock for the host (userspace) page table */ +softleaf_t sl;pte_t *ptep;mmap_assert_locked (mm);
@@ -124,8 +107,10 @@ void gmap_helper_zap_one_page(struct mm_struct *mm, unsigned long vmaddr) ptep =try_get_locked_pte (mm, vmaddr, &ptl);if (IS_ERR_OR_NULL (ptep))return ; -if (pte_swap (*ptep)) { -ptep_zap_softleaf_entry (mm,softleaf_from_pte (*ptep)); + sl =softleaf_from_pte (*ptep); +if (pte_swap (*ptep) &&softleaf_is_swap (sl)) { +dec_mm_counter (mm,MM_SWAPENTS ); +swap_put_entries_direct (sl,1 );pte_clear (mm, vmaddr, ptep); }pte_unmap_unlock (ptep, ptl);
Signature · 1 line
2.54.0