[PATCH 5.15.y 1/2] mm: provide mm_struct and address to huge_ptep_get()
From: Sasha Levin <sashal@kernel.org>
Date: 2026-09-04 18:35:09
Subsystem:
arm port, arm64 port (aarch64 architecture), filesystems (vfs and infrastructure), generic include/asm header files, hmm - heterogeneous memory management, hugetlb subsystem, hwpoison memory failure handling, memory management, memory management - gup (get user pages), memory management - memory policy and migration, memory management - rmap (reverse mapping), memory management - userfaultfd, memory mapping, proc filesystem, s390 architecture, the rest · Maintainers:
Russell King, Catalin Marinas, Will Deacon, Alexander Viro, Christian Brauner, Arnd Bergmann, Jason Gunthorpe, Leon Romanovsky, Muchun Song, Oscar Salvador, Miaohe Lin, Andrew Morton, David Hildenbrand, Lorenzo Stoakes, Mike Rapoport, Liam R. Howlett, Heiko Carstens, Vasily Gorbik, Alexander Gordeev, Linus Torvalds
From: Christophe Leroy <redacted> [ Upstream commit e6c0c03245b14d6c205814aee67128257d0bea84 ] On powerpc 8xx huge_ptep_get() will need to know whether the given ptep is a PTE entry or a PMD entry. This cannot be known with the PMD entry itself because there is no easy way to know it from the content of the entry. So huge_ptep_get() will need to know either the size of the page or get the pmd. In order to be consistent with huge_ptep_get_and_clear(), give mm and address to huge_ptep_get(). Link: https://lkml.kernel.org/r/cc00c70dd384298796a4e1b25d6c4eb306d3af85.1719928057.git.christophe.leroy@csgroup.eu Signed-off-by: Christophe Leroy <redacted> Reviewed-by: Oscar Salvador <osalvador@suse.de> Cc: Jason Gunthorpe <jgg@nvidia.com> Cc: Michael Ellerman <mpe@ellerman.id.au> Cc: Nicholas Piggin <npiggin@gmail.com> Cc: Peter Xu <peterx@redhat.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> [ sashal: Reduced backport -- upstream e6c0c03245b14 touches 21 file(s), this backport carries 15. Not backported here: arch/arm64/include/asm/hugetlb.h arch/riscv/include/asm/hugetlb.h arch/riscv/mm/hugetlbpage.c fs/hugetlbfs/inode.c include/linux/swapops.h mm/damon/vaddr.c mm/migrate.c This note is generated from the file lists only; see the resolution record for the reasoning. ] Stable-dep-of: e87df0d5d696 ("mm/page_vma_mapped: use huge_ptep_get() for hugetlb") Signed-off-by: Sasha Levin <sashal@kernel.org> --- arch/arm/include/asm/hugetlb-3level.h | 4 +-- arch/arm64/mm/hugetlbpage.c | 14 +++++---- arch/s390/include/asm/hugetlb.h | 4 +-- arch/s390/mm/hugetlbpage.c | 4 +-- fs/proc/task_mmu.c | 4 +-- fs/userfaultfd.c | 2 +- include/asm-generic/hugetlb.h | 2 +- mm/gup.c | 2 +- mm/hmm.c | 2 +- mm/hugetlb.c | 43 ++++++++++++++------------- mm/memory-failure.c | 2 +- mm/mempolicy.c | 2 +- mm/mincore.c | 3 +- mm/page_vma_mapped.c | 13 ++++---- mm/userfaultfd.c | 2 +- 15 files changed, 55 insertions(+), 48 deletions(-)
diff --git a/arch/arm/include/asm/hugetlb-3level.h b/arch/arm/include/asm/hugetlb-3level.h
index a30be55057939..87d48e2d90ad9 100644
--- a/arch/arm/include/asm/hugetlb-3level.h
+++ b/arch/arm/include/asm/hugetlb-3level.h@@ -13,12 +13,12 @@ /* * If our huge pte is non-zero then mark the valid bit. - * This allows pte_present(huge_ptep_get(ptep)) to return true for non-zero + * This allows pte_present(huge_ptep_get(mm,addr,ptep)) to return true for non-zero * ptes. * (The valid bit is automatically cleared by set_pte_at for PROT_NONE ptes). */ #define __HAVE_ARCH_HUGE_PTEP_GET -static inline pte_t huge_ptep_get(pte_t *ptep) +static inline pte_t huge_ptep_get(struct mm_struct *mm, unsigned long addr, pte_t *ptep) { pte_t retval = *ptep; if (pte_val(retval))
diff --git a/arch/arm64/mm/hugetlbpage.c b/arch/arm64/mm/hugetlbpage.c
index a8158c9489666..c468b7d29b0e2 100644
--- a/arch/arm64/mm/hugetlbpage.c
+++ b/arch/arm64/mm/hugetlbpage.c@@ -159,7 +159,7 @@ static pte_t get_clear_flush(struct mm_struct *mm, unsigned long pgsize, unsigned long ncontig) { - pte_t orig_pte = huge_ptep_get(ptep); + pte_t orig_pte = huge_ptep_get(mm, addr, ptep); bool valid = pte_valid(orig_pte); unsigned long i, saddr = addr;
@@ -371,7 +371,7 @@ pte_t huge_ptep_get_and_clear(struct mm_struct *mm, { int ncontig; size_t pgsize; - pte_t orig_pte = huge_ptep_get(ptep); + pte_t orig_pte = huge_ptep_get(mm, addr, ptep); if (!pte_cont(orig_pte)) return ptep_get_and_clear(mm, addr, ptep);
@@ -390,15 +390,16 @@ pte_t huge_ptep_get_and_clear(struct mm_struct *mm, * all the contiguous ptes we need to check whether or not there is a * discrepancy between dirty or young. */ -static int __cont_access_flags_changed(pte_t *ptep, pte_t pte, int ncontig) +static int __cont_access_flags_changed(struct mm_struct *mm, + unsigned long addr, pte_t *ptep, pte_t pte, int ncontig) { int i; - if (pte_write(pte) != pte_write(huge_ptep_get(ptep))) + if (pte_write(pte) != pte_write(huge_ptep_get(mm, addr, ptep))) return 1; for (i = 0; i < ncontig; i++) { - pte_t orig_pte = huge_ptep_get(ptep + i); + pte_t orig_pte = huge_ptep_get(mm, addr, ptep + i); if (pte_dirty(pte) != pte_dirty(orig_pte)) return 1;
@@ -426,7 +427,8 @@ int huge_ptep_set_access_flags(struct vm_area_struct *vma, ncontig = find_num_contig(vma->vm_mm, addr, ptep, &pgsize); dpfn = pgsize >> PAGE_SHIFT; - if (!__cont_access_flags_changed(ptep, pte, ncontig)) + if (!__cont_access_flags_changed(vma->vm_mm, addr, ptep, pte, + ncontig)) return 0; orig_pte = get_clear_flush(vma->vm_mm, addr, ptep, pgsize, ncontig);
diff --git a/arch/s390/include/asm/hugetlb.h b/arch/s390/include/asm/hugetlb.h
index d3642fb634bd9..ff0c51a633ef1 100644
--- a/arch/s390/include/asm/hugetlb.h
+++ b/arch/s390/include/asm/hugetlb.h@@ -17,7 +17,7 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, pte_t *ptep, pte_t pte); -pte_t huge_ptep_get(pte_t *ptep); +pte_t huge_ptep_get(struct mm_struct *mm, unsigned long addr, pte_t *ptep); pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep);
@@ -62,7 +62,7 @@ static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma, unsigned long addr, pte_t *ptep, pte_t pte, int dirty) { - int changed = !pte_same(huge_ptep_get(ptep), pte); + int changed = !pte_same(huge_ptep_get(vma->vm_mm, addr, ptep), pte); if (changed) { huge_ptep_get_and_clear(vma->vm_mm, addr, ptep); set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
diff --git a/arch/s390/mm/hugetlbpage.c b/arch/s390/mm/hugetlbpage.c
index 8631307d3defc..386e50952f5e9 100644
--- a/arch/s390/mm/hugetlbpage.c
+++ b/arch/s390/mm/hugetlbpage.c@@ -170,7 +170,7 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, pte_val(*ptep) = rste; } -pte_t huge_ptep_get(pte_t *ptep) +pte_t huge_ptep_get(struct mm_struct *mm, unsigned long addr, pte_t *ptep) { return __rste_to_pte(pte_val(*ptep)); }
@@ -178,7 +178,7 @@ pte_t huge_ptep_get(pte_t *ptep) pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep) { - pte_t pte = huge_ptep_get(ptep); + pte_t pte = huge_ptep_get(mm, addr, ptep); pmd_t *pmdp = (pmd_t *) ptep; pud_t *pudp = (pud_t *) ptep;
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index b255e3dfded14..e9c2cf0094aeb 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c@@ -1532,7 +1532,7 @@ static int pagemap_hugetlb_range(pte_t *ptep, unsigned long hmask, if (vma->vm_flags & VM_SOFTDIRTY) flags |= PM_SOFT_DIRTY; - pte = huge_ptep_get(ptep); + pte = huge_ptep_get(walk->mm, addr, ptep); if (pte_present(pte)) { struct page *page = pte_page(pte);
@@ -1851,7 +1851,7 @@ static int gather_pte_stats(pmd_t *pmd, unsigned long addr, static int gather_hugetlb_stats(pte_t *pte, unsigned long hmask, unsigned long addr, unsigned long end, struct mm_walk *walk) { - pte_t huge_pte = huge_ptep_get(pte); + pte_t huge_pte = huge_ptep_get(walk->mm, addr, pte); struct numa_maps *md; struct page *page;
diff --git a/fs/userfaultfd.c b/fs/userfaultfd.c
index 271ce399f6b6f..9df8808cdc004 100644
--- a/fs/userfaultfd.c
+++ b/fs/userfaultfd.c@@ -241,7 +241,7 @@ static inline bool userfaultfd_huge_must_wait(struct userfaultfd_ctx *ctx, goto out; ret = false; - pte = huge_ptep_get(ptep); + pte = huge_ptep_get(vma->vm_mm, address, ptep); /* * Lockless access: we're in a wait_event so it's ok if it
diff --git a/include/asm-generic/hugetlb.h b/include/asm-generic/hugetlb.h
index 8e1e6244a89da..158c03631a9a1 100644
--- a/include/asm-generic/hugetlb.h
+++ b/include/asm-generic/hugetlb.h@@ -120,7 +120,7 @@ static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma, #endif #ifndef __HAVE_ARCH_HUGE_PTEP_GET -static inline pte_t huge_ptep_get(pte_t *ptep) +static inline pte_t huge_ptep_get(struct mm_struct *mm, unsigned long addr, pte_t *ptep) { return ptep_get(ptep); }
diff --git a/mm/gup.c b/mm/gup.c
index 118c474471850..362c9e1c26c6e 100644
--- a/mm/gup.c
+++ b/mm/gup.c@@ -2516,7 +2516,7 @@ static int gup_hugepte(pte_t *ptep, unsigned long sz, unsigned long addr, if (pte_end < end) end = pte_end; - pte = huge_ptep_get(ptep); + pte = huge_ptep_get(current->mm, addr, ptep); if (!pte_access_permitted(pte, flags & FOLL_WRITE)) return 0;
diff --git a/mm/hmm.c b/mm/hmm.c
index 2a44bab2c9d17..e033c2bc850f2 100644
--- a/mm/hmm.c
+++ b/mm/hmm.c@@ -485,7 +485,7 @@ static int hmm_vma_walk_hugetlb_entry(pte_t *pte, unsigned long hmask, pte_t entry; ptl = huge_pte_lock(hstate_vma(vma), walk->mm, pte); - entry = huge_ptep_get(pte); + entry = huge_ptep_get(walk->mm, addr, pte); i = (start - range->start) >> PAGE_SHIFT; pfn_req_flags = range->hmm_pfns[i];
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index e0908e491065d..13a7ca474b20c 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c@@ -4258,7 +4258,8 @@ static void set_huge_ptep_writable(struct vm_area_struct *vma, { pte_t entry; - entry = huge_pte_mkwrite(huge_pte_mkdirty(huge_ptep_get(ptep))); + entry = huge_pte_mkwrite(huge_pte_mkdirty( + huge_ptep_get(vma->vm_mm, address, ptep))); if (huge_ptep_set_access_flags(vma, address, ptep, entry, 1)) update_mmu_cache(vma, address, ptep); }
@@ -4350,7 +4351,7 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src, dst_ptl = huge_pte_lock(h, dst, dst_pte); src_ptl = huge_pte_lockptr(h, src, src_pte); spin_lock_nested(src_ptl, SINGLE_DEPTH_NESTING); - entry = huge_ptep_get(src_pte); + entry = huge_ptep_get(src, addr, src_pte); again: if (huge_pte_none(entry)) { /*
@@ -4374,7 +4375,7 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src, } set_huge_swap_pte_at(dst, addr, dst_pte, entry, sz); } else { - entry = huge_ptep_get(src_pte); + entry = huge_ptep_get(src, addr, src_pte); ptepage = pte_page(entry); get_page(ptepage);
@@ -4408,7 +4409,7 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src, dst_ptl = huge_pte_lock(h, dst, dst_pte); src_ptl = huge_pte_lockptr(h, src, src_pte); spin_lock_nested(src_ptl, SINGLE_DEPTH_NESTING); - entry = huge_ptep_get(src_pte); + entry = huge_ptep_get(src, addr, src_pte); if (!pte_same(src_pte_old, entry)) { restore_reserve_on_error(h, vma, addr, new);
@@ -4494,7 +4495,7 @@ void __unmap_hugepage_range(struct mmu_gather *tlb, struct vm_area_struct *vma, continue; } - pte = huge_ptep_get(ptep); + pte = huge_ptep_get(mm, address, ptep); if (huge_pte_none(pte)) { spin_unlock(ptl); continue;
@@ -4654,7 +4655,7 @@ static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma, unsigned long haddr = address & huge_page_mask(h); struct mmu_notifier_range range; - pte = huge_ptep_get(ptep); + pte = huge_ptep_get(mm, haddr, ptep); old_page = pte_page(pte); retry_avoidcopy:
@@ -4724,7 +4725,7 @@ static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma, spin_lock(ptl); ptep = huge_pte_offset(mm, haddr, huge_page_size(h)); if (likely(ptep && - pte_same(huge_ptep_get(ptep), pte))) + pte_same(huge_ptep_get(mm, haddr, ptep), pte))) goto retry_avoidcopy; /* * race occurs while re-acquiring page table
@@ -4760,7 +4761,8 @@ static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma, */ spin_lock(ptl); ptep = huge_pte_offset(mm, haddr, huge_page_size(h)); - if (likely(ptep && pte_same(huge_ptep_get(ptep), pte))) { + if (likely(ptep && + pte_same(huge_ptep_get(mm, haddr, ptep), pte))) { ClearHPageRestoreReserve(new_page); /* Break COW */
@@ -4939,7 +4941,7 @@ static vm_fault_t hugetlb_no_page(struct mm_struct *mm, */ ptl = huge_pte_lock(h, mm, ptep); ret = 0; - if (huge_pte_none(huge_ptep_get(ptep))) + if (huge_pte_none(huge_ptep_get(mm, haddr, ptep))) ret = vmf_error(PTR_ERR(page)); spin_unlock(ptl); goto out;
@@ -5004,7 +5006,7 @@ static vm_fault_t hugetlb_no_page(struct mm_struct *mm, ptl = huge_pte_lock(h, mm, ptep); ret = 0; - if (!huge_pte_none(huge_ptep_get(ptep))) + if (!huge_pte_none(huge_ptep_get(mm, haddr, ptep))) goto backout; if (anon_rmap) {
@@ -5095,7 +5097,7 @@ vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma, * OK as we are only making decisions based on content and * not actually modifying content here. */ - entry = huge_ptep_get(ptep); + entry = huge_ptep_get(mm, haddr, ptep); if (unlikely(is_hugetlb_entry_migration(entry))) { migration_entry_wait_huge(vma, mm, ptep); return 0;
@@ -5132,7 +5134,7 @@ vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma, hash = hugetlb_fault_mutex_hash(mapping, idx); mutex_lock(&hugetlb_fault_mutex_table[hash]); - entry = huge_ptep_get(ptep); + entry = huge_ptep_get(mm, haddr, ptep); if (huge_pte_none(entry)) /* * hugetlb_no_page will drop vma lock and hugetlb fault
@@ -5176,7 +5178,7 @@ vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma, ptl = huge_pte_lock(h, mm, ptep); /* Check for a racing update before calling hugetlb_cow */ - if (unlikely(!pte_same(entry, huge_ptep_get(ptep)))) + if (unlikely(!pte_same(entry, huge_ptep_get(mm, haddr, ptep)))) goto out_ptl; /*
@@ -5376,7 +5378,7 @@ int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm, goto out_release_unlock; ret = -EEXIST; - if (!huge_pte_none(huge_ptep_get(dst_pte))) + if (!huge_pte_none(huge_ptep_get(dst_mm, dst_addr, dst_pte))) goto out_release_unlock; if (page_in_pagecache) {
@@ -5477,7 +5479,8 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma, huge_page_size(h)); if (pte) ptl = huge_pte_lock(h, mm, pte); - absent = !pte || huge_pte_none(huge_ptep_get(pte)); + absent = !pte || + huge_pte_none(huge_ptep_get(mm, vaddr, pte)); /* * When coredumping, it suits get_dump_page if we just return
@@ -5504,9 +5507,9 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma, * both cases, and because we can't follow correct pages * directly from any kind of swap entries. */ - if (absent || is_swap_pte(huge_ptep_get(pte)) || + if (absent || is_swap_pte(huge_ptep_get(mm, vaddr, pte)) || ((flags & FOLL_WRITE) && - !huge_pte_write(huge_ptep_get(pte)))) { + !huge_pte_write(huge_ptep_get(mm, vaddr, pte)))) { vm_fault_t ret; unsigned int fault_flags = 0;
@@ -5553,7 +5556,7 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma, } pfn_offset = (vaddr & ~huge_page_mask(h)) >> PAGE_SHIFT; - page = pte_page(huge_ptep_get(pte)); + page = pte_page(huge_ptep_get(mm, vaddr, pte)); /* * If subpage information not requested, update counters
@@ -5655,7 +5658,7 @@ unsigned long hugetlb_change_protection(struct vm_area_struct *vma, spin_unlock(ptl); continue; } - pte = huge_ptep_get(ptep); + pte = huge_ptep_get(mm, address, ptep); if (unlikely(is_hugetlb_entry_hwpoisoned(pte))) { spin_unlock(ptl); continue;
@@ -6243,7 +6246,7 @@ follow_huge_pmd_pte(struct vm_area_struct *vma, unsigned long address, int flags return NULL; ptl = huge_pte_lock(h, mm, ptep); - pte = huge_ptep_get(ptep); + pte = huge_ptep_get(mm, address, ptep); if (pte_present(pte)) { page = pte_page(pte) + ((address & ~huge_page_mask(h)) >> PAGE_SHIFT);
diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 66390688a62c0..17362b5db7d94 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c@@ -664,7 +664,7 @@ static int hwpoison_hugetlb_range(pte_t *ptep, unsigned long hmask, struct mm_walk *walk) { struct hwp_walk *hwp = (struct hwp_walk *)walk->private; - pte_t pte = huge_ptep_get(ptep); + pte_t pte = huge_ptep_get(walk->mm, addr, ptep); struct hstate *h = hstate_vma(walk->vma); return check_hwpoisoned_entry(pte, addr, huge_page_shift(h),
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index f089de8564cad..fd75021cc1943 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c@@ -574,7 +574,7 @@ static int queue_pages_hugetlb(pte_t *pte, unsigned long hmask, pte_t entry; ptl = huge_pte_lock(hstate_vma(walk->vma), walk->mm, pte); - entry = huge_ptep_get(pte); + entry = huge_ptep_get(walk->mm, addr, pte); if (!pte_present(entry)) goto unlock; page = pte_page(entry);
diff --git a/mm/mincore.c b/mm/mincore.c
index 889d84477a770..00d29997f0e16 100644
--- a/mm/mincore.c
+++ b/mm/mincore.c@@ -32,7 +32,8 @@ static int mincore_hugetlb(pte_t *pte, unsigned long hmask, unsigned long addr, * Hugepages under user process are always in RAM and never * swapped out, but theoretically it needs to be checked. */ - present = pte && !huge_pte_none(huge_ptep_get(pte)); + present = pte && + !huge_pte_none(huge_ptep_get(walk->mm, addr, pte)); for (; addr != end; vec++, addr += PAGE_SIZE) *vec = present; walk->private = vec;
diff --git a/mm/page_vma_mapped.c b/mm/page_vma_mapped.c
index f7b3310817910..3f003623eef45 100644
--- a/mm/page_vma_mapped.c
+++ b/mm/page_vma_mapped.c@@ -87,33 +87,34 @@ static inline bool pfn_is_match(struct page *page, unsigned long pfn) static bool check_pte(struct page_vma_mapped_walk *pvmw) { unsigned long pfn; + pte_t ptent = ptep_get(pvmw->pte); if (pvmw->flags & PVMW_MIGRATION) { swp_entry_t entry; - if (!is_swap_pte(*pvmw->pte)) + if (!is_swap_pte(ptent)) return false; - entry = pte_to_swp_entry(*pvmw->pte); + entry = pte_to_swp_entry(ptent); if (!is_migration_entry(entry) && !is_device_exclusive_entry(entry)) return false; pfn = swp_offset(entry); - } else if (is_swap_pte(*pvmw->pte)) { + } else if (is_swap_pte(ptent)) { swp_entry_t entry; /* Handle un-addressable ZONE_DEVICE memory */ - entry = pte_to_swp_entry(*pvmw->pte); + entry = pte_to_swp_entry(ptent); if (!is_device_private_entry(entry) && !is_device_exclusive_entry(entry)) return false; pfn = swp_offset(entry); } else { - if (!pte_present(*pvmw->pte)) + if (!pte_present(ptent)) return false; - pfn = pte_pfn(*pvmw->pte); + pfn = pte_pfn(ptent); } return pfn_is_match(pvmw->page, pfn);
diff --git a/mm/userfaultfd.c b/mm/userfaultfd.c
index 98a9d0ef2d917..812d6f50350ea 100644
--- a/mm/userfaultfd.c
+++ b/mm/userfaultfd.c@@ -378,7 +378,7 @@ static __always_inline ssize_t __mcopy_atomic_hugetlb(struct mm_struct *dst_mm, } if (mode != MCOPY_ATOMIC_CONTINUE && - !huge_pte_none(huge_ptep_get(dst_pte))) { + !huge_pte_none(huge_ptep_get(dst_mm, dst_addr, dst_pte))) { err = -EEXIST; mutex_unlock(&hugetlb_fault_mutex_table[hash]); i_mmap_unlock_read(mapping);
--
2.53.0