Subject: linux-next: manual merge of the kvms390 tree with the origin tree

From: Mark Brown <[email-masked]>
Date: Wed, 8 Apr 2026 16:31:46 +0100

Hi all,

Today's linux-next merge of the kvms390 tree got a conflict in:

  arch/s390/kvm/gmap.c

between commit:

  45921d0212d4a ("KVM: s390: Fix gmap_link()")

from the origin tree and commit:

  4204067f99820 ("KVM: s390: Add alignment checks for hugepages")

from the kvms390 tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

diff --cc arch/s390/kvm/gmap.c
index 57802cb8af8e4,e3c1b070a11dc..0000000000000
--- a/arch/s390/kvm/gmap.c
+++ b/arch/s390/kvm/gmap.c
@@@ -623,78 -619,48 +624,97 @@@ static inline bool gmap_2g_allowed(stru
  	return false;
  }
  
- static inline bool gmap_1m_allowed(struct gmap *gmap, gfn_t gfn)
+ /**
+  * gmap_1m_allowed() - Check whether a 1M hugepage is allowed.
+  * @gmap: The gmap of the guest.
+  * @f: Describes the fault that is being resolved.
+  * @slot: The memslot the faulting address belongs to.
+  *
+  * The function checks whether the GMAP_FLAG_ALLOW_HPAGE_1M flag is set for
+  * @gmap, whether the offset of the address in the 1M virtual frame is the
+  * same as the offset in the physical 1M frame, and finally whether the whole
+  * 1M page would fit in the given memslot.
+  *
+  * Return: true if a 1M hugepage is allowed to back the faulting address, false
+  *         otherwise.
+  */
+ static inline bool gmap_1m_allowed(struct gmap *gmap, struct guest_fault *f,
+ 				   struct kvm_memory_slot *slot)
  {
- 	return test_bit(GMAP_FLAG_ALLOW_HPAGE_1M, &gmap->flags);
+ 	return test_bit(GMAP_FLAG_ALLOW_HPAGE_1M, &gmap->flags) &&
+ 	       !((f->gfn ^ f->pfn) & ~_SEGMENT_FR_MASK) &&
+ 	       slot->base_gfn <= ALIGN_DOWN(f->gfn, _PAGES_PER_SEGMENT) &&
+ 	       slot->base_gfn + slot->npages >= ALIGN(f->gfn + 1, _PAGES_PER_SEGMENT);
  }
  
 +static int _gmap_link(struct kvm_s390_mmu_cache *mc, struct gmap *gmap, int level,
 +		      struct guest_fault *f)
 +{
 +	union crste oldval, newval;
 +	union pte newpte, oldpte;
 +	union pgste pgste;
 +	int rc = 0;
 +
 +	rc = dat_entry_walk(mc, f->gfn, gmap->asce, DAT_WALK_ALLOC_CONTINUE, level,
 +			    &f->crstep, &f->ptep);
 +	if (rc == -ENOMEM)
 +		return rc;
 +	if (KVM_BUG_ON(rc == -EINVAL, gmap->kvm))
 +		return rc;
 +	if (rc)
 +		return -EAGAIN;
 +	if (KVM_BUG_ON(get_level(f->crstep, f->ptep) > level, gmap->kvm))
 +		return -EINVAL;
 +
 +	if (f->ptep) {
 +		pgste = pgste_get_lock(f->ptep);
 +		oldpte = *f->ptep;
 +		newpte = _pte(f->pfn, f->writable, f->write_attempt | oldpte.s.d, !f->page);
 +		newpte.s.sd = oldpte.s.sd;
 +		oldpte.s.sd = 0;
 +		if (oldpte.val == _PTE_EMPTY.val || oldpte.h.pfra == f->pfn) {
 +			pgste = gmap_ptep_xchg(gmap, f->ptep, newpte, pgste, f->gfn);
 +			if (f->callback)
 +				f->callback(f);
 +		} else {
 +			rc = -EAGAIN;
 +		}
 +		pgste_set_unlock(f->ptep, pgste);
 +	} else {
 +		do {
 +			oldval = READ_ONCE(*f->crstep);
 +			newval = _crste_fc1(f->pfn, oldval.h.tt, f->writable,
 +					    f->write_attempt | oldval.s.fc1.d);
 +			newval.s.fc1.s = !f->page;
 +			newval.s.fc1.sd = oldval.s.fc1.sd;
 +			if (oldval.val != _CRSTE_EMPTY(oldval.h.tt).val &&
 +			    crste_origin_large(oldval) != crste_origin_large(newval))
 +				return -EAGAIN;
 +		} while (!gmap_crstep_xchg_atomic(gmap, f->crstep, oldval, newval, f->gfn));
 +		if (f->callback)
 +			f->callback(f);
 +	}
 +
 +	return rc;
 +}
 +
- int gmap_link(struct kvm_s390_mmu_cache *mc, struct gmap *gmap, struct guest_fault *f)
+ int gmap_link(struct kvm_s390_mmu_cache *mc, struct gmap *gmap, struct guest_fault *f,
+ 	      struct kvm_memory_slot *slot)
  {
  	unsigned int order;
 -	int rc, level;
 +	int level;
  
  	lockdep_assert_held(&gmap->kvm->mmu_lock);
  
  	level = TABLE_TYPE_PAGE_TABLE;
  	if (f->page) {
  		order = folio_order(page_folio(f->page));
- 		if (order >= get_order(_REGION3_SIZE) && gmap_2g_allowed(gmap, f->gfn))
+ 		if (order >= get_order(_REGION3_SIZE) && gmap_2g_allowed(gmap, f, slot))
  			level = TABLE_TYPE_REGION3;
- 		else if (order >= get_order(_SEGMENT_SIZE) && gmap_1m_allowed(gmap, f->gfn))
+ 		else if (order >= get_order(_SEGMENT_SIZE) && gmap_1m_allowed(gmap, f, slot))
  			level = TABLE_TYPE_SEGMENT;
  	}
 -	rc = dat_link(mc, gmap->asce, level, uses_skeys(gmap), f);
 -	KVM_BUG_ON(rc == -EINVAL, gmap->kvm);
 -	return rc;
 +	return _gmap_link(mc, gmap, level, f);
  }
  
  static int gmap_ucas_map_one(struct kvm_s390_mmu_cache *mc, struct gmap *gmap,