Lines Matching refs:pte
102 * Return true if the original pte was a uffd-wp pte marker (so the pte was
425 void pmd_install(struct mm_struct *mm, pmd_t *pmd, pgtable_t *pte)
432 * Ensure all pte setup (eg. pte page lock and page clearing) are
433 * visible before the pte is made visible to other CPUs by being
445 pmd_populate(mm, pmd, *pte);
446 *pte = NULL;
577 * PFN-mapped pte in a region that doesn't allow it.
630 #define print_bad_pte(vma, addr, pte, page) \
631 print_bad_page_map(vma, addr, pte_val(pte), page, PGTABLE_LEVEL_PTE)
757 * @vma: The VMA mapping the @pte.
758 * @addr: The address where the @pte is mapped.
759 * @pte: The PTE.
768 pte_t pte)
770 return __vm_normal_page(vma, addr, pte_pfn(pte), pte_special(pte),
771 pte_val(pte), PGTABLE_LEVEL_PTE);
776 * @vma: The VMA mapping the @pte.
777 * @addr: The address where the @pte is mapped.
778 * @pte: The PTE.
787 pte_t pte)
789 struct page *page = vm_normal_page(vma, addr, pte);
864 * @ptep: pte pointer into the locked page table mapping the folio page
865 * @orig_pte: pte value at @ptep
867 * Restore a device-exclusive non-swap entry to an ordinary present pte.
872 * Locking the folio makes sure that anybody who just converted the pte to
888 pte_t pte;
892 pte = pte_mkold(mk_pte(page, READ_ONCE(vma->vm_page_prot)));
894 pte = pte_mksoft_dirty(pte);
897 pte = pte_mkuffd(pte);
901 pte = pte_modify(pte, PAGE_NONE);
904 can_change_pte_writable(vma, address, pte)) {
906 pte = pte_mkdirty(pte);
907 pte = pte_mkwrite(pte, vma);
909 set_pte_at(vma->vm_mm, address, ptep, pte);
919 * Tries to restore an exclusive pte if the page lock can be acquired without
952 pte_t pte = orig_pte;
963 pte = pte_swp_clear_exclusive(orig_pte);
964 set_pte_at(src_mm, addr, src_pte, pte);
981 pte = softleaf_to_pte(entry);
983 pte = pte_swp_mksoft_dirty(pte);
985 pte = pte_swp_mkuffd(pte);
986 set_pte_at(src_mm, addr, src_pte, pte);
1017 pte = swp_entry_to_pte(entry);
1019 pte = pte_swp_mkuffd(pte);
1020 set_pte_at(src_mm, addr, src_pte, pte);
1025 * original entry then copying as for a present pte. Device
1042 pte = pte_swp_clear_uffd(pte);
1043 set_pte_at(dst_mm, addr, dst_pte, pte);
1052 * and re-use the pte the traditional way.
1065 pte_t pte;
1086 pte = folio_mk_pte(new_folio, dst_vma->vm_page_prot);
1087 pte = maybe_mkwrite(pte_mkdirty(pte), dst_vma);
1089 /* The uffd bit needs to be delivered to the dest pte as well */
1090 pte = pte_mkuffd(pte);
1093 pte = pte_modify(pte, PAGE_NONE);
1095 set_pte_at(dst_vma->vm_mm, addr, dst_pte, pte);
1101 pte_t pte, unsigned long addr, int nr)
1108 * child is not RWP-armed, pte_modify(pte, dst_vma->vm_page_prot) can
1110 * so a later pte_write(pte) check would skip the COW wrprotect and
1113 writable = pte_write(pte);
1118 * pte_uffd(pte) so unrelated PAGE_NONE markers (e.g. NUMA balancing)
1122 if (userfaultfd_rwp(src_vma) && pte_uffd(pte))
1123 pte = pte_modify(pte, dst_vma->vm_page_prot);
1124 pte = pte_clear_uffd(pte);
1130 pte = pte_wrprotect(pte);
1135 pte = pte_mkclean(pte);
1136 pte = pte_mkold(pte);
1138 set_ptes(dst_vma->vm_mm, addr, dst_pte, pte, nr);
1150 pte_t *dst_pte, pte_t *src_pte, pte_t pte, unsigned long addr,
1158 page = vm_normal_page(src_vma, addr, pte);
1175 nr = folio_pte_batch_flags(folio, src_vma, src_pte, &pte, max_nr, flags);
1189 __copy_present_ptes(dst_vma, src_vma, dst_pte, src_pte, pte,
1217 __copy_present_ptes(dst_vma, src_vma, dst_pte, src_pte, pte, addr, 1);
1334 * the now present pte.
1343 * If we need a pre-allocated page for this pte, drop the
1354 * could only happen if one pinned pte changed.
1627 * @pte: Old value of the entry pointed to by @ptep.
1644 unsigned long addr, pte_t *ptep, pte_t pte,
1652 /* The current status of the pte should be "cleared" before calling */
1658 * page, or in TTU where the present pte will be quickly replaced
1659 * with a swap pte. There's no way of leaking the bit.
1664 /* A uffd-wp wr-protected normal pte */
1665 if (unlikely(pte_present(pte) && pte_uffd(pte)))
1669 * A uffd-wp wr-protected swap pte. Note: this should even cover an
1670 * existing pte marker with uffd-wp bit set.
1672 if (unlikely(pte_swp_uffd_any(pte)))
1691 * This function makes sure that we'll replace the none pte with an uffd-wp
1692 * swap special pte marker when necessary. Must be with the pgtable lock held.
1698 unsigned long addr, pte_t *pte, int nr,
1704 return cond_install_uffd_wp_ptes(vma, addr, pte, pteval, nr);
1709 struct page *page, pte_t *pte, pte_t ptent, unsigned int nr,
1717 ptent = get_and_clear_full_ptes(mm, addr, pte, nr, tlb->fullmm);
1730 clear_full_ptes(mm, addr, pte, nr, tlb->fullmm);
1735 tlb_remove_tlb_entries(tlb, pte, nr, addr);
1737 *any_skipped = zap_install_uffd_wp_if_needed(vma, addr, pte,
1759 struct vm_area_struct *vma, pte_t *pte, pte_t ptent,
1772 ptep_get_and_clear_full(mm, addr, pte, tlb->fullmm);
1774 tlb_remove_tlb_entry(tlb, pte, addr);
1777 pte, 1, details, ptent);
1793 nr = folio_pte_batch(folio, pte, ptent, max_nr);
1794 zap_present_folio_ptes(tlb, vma, folio, page, pte, ptent, nr,
1799 zap_present_folio_ptes(tlb, vma, folio, page, pte, ptent, 1, addr,
1805 struct vm_area_struct *vma, pte_t *pte, pte_t ptent,
1836 nr = swap_pte_batch(pte, max_nr, ptent);
1869 clear_nonpresent_ptes(vma->vm_mm, addr, pte, nr);
1870 *any_skipped = zap_install_uffd_wp_if_needed(vma, addr, pte, nr, details, ptent);
1876 struct vm_area_struct *vma, pte_t *pte,
1882 pte_t ptent = ptep_get(pte);
1889 ptent = ptep_get(pte + nr);
1896 pte += nr;
1901 nr += zap_present_ptes(tlb, vma, pte, ptent, max_nr, addr,
1905 nr += zap_nonpresent_ptes(tlb, vma, pte, ptent, max_nr, addr,
1939 pte_t *start_pte, *pte;
1949 for (i = 0, pte = start_pte; i < PTRS_PER_PTE; i++, pte++) {
1950 if (!pte_none(ptep_get(pte)))
1980 pte_t *pte;
1989 start_pte = pte = pte_offset_map_lock(mm, pmd, addr, &ptl);
1990 if (!pte)
2003 nr = do_zap_pte_range(tlb, vma, pte, addr, end, details, rss,
2012 } while (pte += nr, addr += PAGE_SIZE * nr, addr != end);
2017 * If the pte lock was released midway (retry case), or if the attempt
2018 * to hold the pmd lock failed, then we need to recheck all pte entries
2019 * to ensure they are still none, thereby preventing the pte entries
2420 static int insert_page_into_pte_locked(struct vm_area_struct *vma, pte_t *pte,
2425 pte_t pteval = ptep_get(pte);
2438 if (ptep_set_access_flags(vma, addr, pte, pteval, 1))
2439 update_mmu_cache(vma, addr, pte);
2457 set_pte_at(vma->vm_mm, addr, pte, pteval);
2465 pte_t *pte;
2472 pte = get_locked_pte(vma->vm_mm, addr, &ptl);
2473 if (!pte)
2475 retval = insert_page_into_pte_locked(vma, pte, addr, page, prot,
2477 pte_unmap_unlock(pte, ptl);
2482 static int insert_page_in_batch_locked(struct vm_area_struct *vma, pte_t *pte,
2490 return insert_page_into_pte_locked(vma, pte, addr, page, prot, false);
2500 pte_t *start_pte, *pte;
2530 for (pte = start_pte; pte_idx < batch_size; ++pte, ++pte_idx) {
2531 int err = insert_page_in_batch_locked(vma, pte,
2743 pte_t *pte, entry;
2746 pte = get_locked_pte(mm, addr, &ptl);
2747 if (!pte)
2749 entry = ptep_get(pte);
2768 if (ptep_set_access_flags(vma, addr, pte, entry, 1))
2769 update_mmu_cache(vma, addr, pte);
2782 set_pte_at(mm, addr, pte, entry);
2783 update_mmu_cache(vma, addr, pte); /* XXX: why not for insert_page? */
2786 pte_unmap_unlock(pte, ptl);
2909 * If we don't have pte special, then we have to use the pfn_valid()
2913 * without pte special, it would there be refcounted as a normal page.
2984 pte_t *pte, *mapped_pte;
2988 mapped_pte = pte = pte_alloc_map_lock(mm, pmd, addr, &ptl);
2989 if (!pte)
2993 BUG_ON(!pte_none(ptep_get(pte)));
2998 set_pte_at(mm, addr, pte, pte_mkspecial(pfn_pte(pfn, prot)));
3000 } while (pte++, addr += PAGE_SIZE, addr != end);
3385 pte_t *pte, *mapped_pte;
3390 mapped_pte = pte = (mm == &init_mm) ?
3393 if (!pte)
3396 mapped_pte = pte = (mm == &init_mm) ?
3399 if (!pte)
3407 if (create || !pte_none(ptep_get(pte))) {
3408 err = fn(pte, addr, data);
3412 } while (pte++, addr += PAGE_SIZE, addr != end);
3600 * parts, do_swap_page must check under lock before unmapping the pte and
3610 same = pte_same(ptep_get(vmf->pte), vmf->orig_pte);
3614 pte_unmap(vmf->pte);
3615 vmf->pte = NULL;
3655 vmf->pte = NULL;
3659 vmf->pte = pte_offset_map_lock(mm, vmf->pmd, addr, &vmf->ptl);
3660 if (unlikely(!vmf->pte || !pte_same(ptep_get(vmf->pte), vmf->orig_pte))) {
3665 if (vmf->pte)
3666 update_mmu_tlb(vma, addr, vmf->pte);
3672 if (ptep_set_access_flags(vma, addr, vmf->pte, entry, 0))
3673 update_mmu_cache_range(vmf, vma, addr, vmf->pte, 1);
3683 if (vmf->pte)
3687 vmf->pte = pte_offset_map_lock(mm, vmf->pmd, addr, &vmf->ptl);
3688 if (unlikely(!vmf->pte || !pte_same(ptep_get(vmf->pte), vmf->orig_pte))) {
3690 if (vmf->pte)
3691 update_mmu_tlb(vma, addr, vmf->pte);
3714 if (vmf->pte)
3715 pte_unmap_unlock(vmf->pte, vmf->ptl);
3852 if (ptep_set_access_flags(vma, vmf->address, vmf->pte, entry, 1))
3853 update_mmu_cache_range(vmf, vma, vmf->address, vmf->pte, 1);
3854 pte_unmap_unlock(vmf->pte, vmf->ptl);
3917 * - Take the PTL. If the pte changed, bail out and release the allocated page
3918 * - If the pte is still the way we remember it, update the page table and all
3979 * Re-check the pte - we dropped the lock
3981 vmf->pte = pte_offset_map_lock(mm, vmf->pmd, vmf->address, &vmf->ptl);
3982 if (likely(vmf->pte && pte_same(ptep_get(vmf->pte), vmf->orig_pte))) {
4005 * Clear the pte entry and flush it first, before updating the
4006 * pte with the new entry, to keep TLBs on different CPUs in
4011 ptep_clear_flush(vma, vmf->address, vmf->pte);
4015 set_pte_at(mm, vmf->address, vmf->pte, entry);
4016 update_mmu_cache_range(vmf, vma, vmf->address, vmf->pte, 1);
4019 * Only after switching the pte to the new page may
4022 * before the pte is switched to the new page, and
4023 * "reuse" the old page writing into it while our pte
4046 pte_unmap_unlock(vmf->pte, vmf->ptl);
4047 } else if (vmf->pte) {
4048 update_mmu_tlb(vma, vmf->address, vmf->pte);
4049 pte_unmap_unlock(vmf->pte, vmf->ptl);
4094 vmf->pte = pte_offset_map_lock(vmf->vma->vm_mm, vmf->pmd, vmf->address,
4096 if (!vmf->pte)
4102 if (!pte_same(ptep_get(vmf->pte), vmf->orig_pte)) {
4103 update_mmu_tlb(vmf->vma, vmf->address, vmf->pte);
4104 pte_unmap_unlock(vmf->pte, vmf->ptl);
4122 pte_unmap_unlock(vmf->pte, vmf->ptl);
4148 pte_unmap_unlock(vmf->pte, vmf->ptl);
4315 * FAULT_FLAG_VMA_LOCK) and pte both mapped and locked. We return with
4316 * the same lock still held, but pte unmapped and unlocked.
4324 pte_t pte;
4327 if (userfaultfd_pte_wp(vma, ptep_get(vmf->pte))) {
4329 pte_unmap_unlock(vmf->pte, vmf->ptl);
4338 pte = pte_clear_uffd(ptep_get(vmf->pte));
4340 set_pte_at(vma->vm_mm, vmf->address, vmf->pte, pte);
4345 vmf->orig_pte = pte;
4393 pte_unmap_unlock(vmf->pte, vmf->ptl);
4405 pte_unmap_unlock(vmf->pte, vmf->ptl);
4536 * Restore a potential device exclusive pte to a working pte entry
4566 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address,
4568 if (likely(vmf->pte && pte_same(ptep_get(vmf->pte), vmf->orig_pte)))
4570 vmf->pte, vmf->orig_pte);
4572 if (vmf->pte)
4573 pte_unmap_unlock(vmf->pte, vmf->ptl);
4615 vmf->pte = pte_offset_map_lock(vmf->vma->vm_mm, vmf->pmd,
4617 if (!vmf->pte)
4620 * Be careful so that we will only recover a special uffd-wp pte into a
4621 * none pte. Otherwise it means the pte could have changed, so retry.
4623 * This should also cover the case where e.g. the pte changed
4625 * So pte_is_marker() check is not enough to safely drop the pte.
4627 if (pte_same(vmf->orig_pte, ptep_get(vmf->pte)))
4628 pte_clear(vmf->vma->vm_mm, vmf->address, vmf->pte);
4629 pte_unmap_unlock(vmf->pte, vmf->ptl);
4642 * This is actually a page-missing access, but with uffd-wp special pte
4643 * installed. It means this pte was wr-protected before being unmapped.
4680 /* This is an unknown pte marker */
4692 pte_t pte;
4696 pte = ptep_get(ptep);
4698 if (!pte_same(pte, pte_move_swp_offset(vmf->orig_pte, -idx)))
4705 if (swap_pte_batch(ptep, nr_pages, pte) != nr_pages)
4740 pte_t *pte;
4772 pte = pte_offset_map_lock(vmf->vma->vm_mm, vmf->pmd,
4774 if (unlikely(!pte))
4784 if (can_swapin_thp(vmf, pte + pte_index(addr), 1 << order))
4789 pte_unmap_unlock(pte, ptl);
4813 * FAULT_FLAG_VMA_LOCK), and pte mapped but not yet locked.
4814 * We return with pte unmapped and unlocked.
4829 pte_t pte;
4859 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
4861 if (unlikely(!vmf->pte ||
4862 !pte_same(ptep_get(vmf->pte),
4874 pte_unmap_unlock(vmf->pte, vmf->ptl);
4880 pte_unmap(vmf->pte);
4913 * Back out if somebody else faulted in this pte
4914 * while we released the pte lock.
4916 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
4918 if (likely(vmf->pte &&
4919 pte_same(ptep_get(vmf->pte), vmf->orig_pte)))
4976 * Back out if somebody else already faulted in this pte.
4978 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address,
4980 if (unlikely(!vmf->pte || !pte_same(ptep_get(vmf->pte), vmf->orig_pte)))
4991 ptep = vmf->pte;
5005 folio_ptep = vmf->pte - idx;
5021 * PG_anon_exclusive reuses PG_mappedtodisk for anon pages. A swap pte
5101 pte = mk_pte(page, vma->vm_page_prot);
5103 pte = pte_mksoft_dirty(pte);
5105 pte = pte_mkuffd(pte);
5113 pte = pte_modify(pte, PAGE_NONE);
5121 * Skip the write upgrade for an RWP-restored pte: it must stay
5127 (vma->vm_flags & VM_WRITE) && !userfaultfd_pte_wp(vma, pte) &&
5128 !pte_needs_soft_dirty_wp(vma, pte)) {
5129 pte = pte_mkwrite(pte, vma);
5131 pte = pte_mkdirty(pte);
5137 vmf->orig_pte = pte_advance_pfn(pte, page_idx);
5161 (pte_write(pte) && !PageAnonExclusive(page)));
5162 set_ptes(vma->vm_mm, address, ptep, pte, nr_pages);
5164 pte, pte, nr_pages);
5189 * For an RWP-restored pte, leave it PROT_NONE and let the write
5193 if ((vmf->flags & FAULT_FLAG_WRITE) && !pte_write(pte) && !rwp_restore) {
5203 if (vmf->pte)
5204 pte_unmap_unlock(vmf->pte, vmf->ptl);
5210 if (vmf->pte)
5211 pte_unmap_unlock(vmf->pte, vmf->ptl);
5227 static bool pte_range_none(pte_t *pte, int nr_pages)
5232 if (!pte_none(ptep_get_lockless(pte + i)))
5246 pte_t *pte;
5269 pte = pte_offset_map(vmf->pmd, vmf->address & PMD_MASK);
5270 if (!pte)
5281 if (pte_range_none(pte + pte_index(addr), 1 << order))
5286 pte_unmap(pte);
5328 void map_anon_folio_pte_nopf(struct folio *folio, pte_t *pte,
5345 set_ptes(vma->vm_mm, addr, pte, entry, nr_pages);
5346 update_mmu_cache_range(NULL, vma, addr, pte, nr_pages);
5349 static void map_anon_folio_pte_pf(struct folio *folio, pte_t *pte,
5354 map_anon_folio_pte_nopf(folio, pte, vma, addr, uffd_wp);
5361 * FAULT_FLAG_VMA_LOCK), and pte unmapped and unlocked.
5362 * We return with the lock still held, but pte unmapped and unlocked.
5390 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
5392 if (!vmf->pte)
5395 update_mmu_tlb(vma, vmf->address, vmf->pte);
5403 pte_unmap_unlock(vmf->pte, vmf->ptl);
5408 set_pte_at(vma->vm_mm, addr, vmf->pte, entry);
5411 update_mmu_cache(vma, addr, vmf->pte);
5436 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, addr, &vmf->ptl);
5437 if (!vmf->pte)
5440 update_mmu_tlb(vma, addr, vmf->pte);
5442 } else if (nr_pages > 1 && !pte_range_none(vmf->pte, nr_pages)) {
5443 update_mmu_tlb_range(vma, addr, vmf->pte, nr_pages);
5453 pte_unmap_unlock(vmf->pte, vmf->ptl);
5457 map_anon_folio_pte_pf(folio, vmf->pte, vma, addr,
5460 if (vmf->pte)
5461 pte_unmap_unlock(vmf->pte, vmf->ptl);
5483 * Preallocate pte before we take folio lock because this might lead to
5583 * related to pte entry. Use the preallocated table for that.
5666 set_ptes(vma->vm_mm, addr, vmf->pte, entry, nr);
5669 update_mmu_cache_range(vmf, vma, addr, vmf->pte, nr);
5675 return !pte_same(ptep_get(vmf->pte), vmf->orig_pte);
5677 return !pte_none(ptep_get(vmf->pte));
5785 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
5787 if (!vmf->pte)
5792 update_mmu_tlb(vma, addr, vmf->pte);
5795 } else if (nr_pages > 1 && !pte_range_none(vmf->pte, nr_pages)) {
5797 pte_unmap_unlock(vmf->pte, vmf->ptl);
5808 pte_unmap_unlock(vmf->pte, vmf->ptl);
6052 vmf->pte = pte_offset_map_lock(vmf->vma->vm_mm, vmf->pmd,
6054 if (unlikely(!vmf->pte))
6058 * Make sure this is not a temporary clearing of pte
6060 * of pte involves: take ptl, clearing the pte so that
6064 if (unlikely(pte_none(ptep_get(vmf->pte))))
6069 pte_unmap_unlock(vmf->pte, vmf->ptl);
6137 pte_t pte, old_pte;
6140 pte = pte_modify(old_pte, vma->vm_page_prot);
6141 pte = pte_mkyoung(pte);
6143 pte = pte_mkwrite(pte, vma);
6144 ptep_modify_prot_commit(vma, fault_addr, fault_pte, old_pte, pte);
6162 start_ptep = vmf->pte - ((addr - start) >> PAGE_SHIFT);
6199 pte_t pte;
6203 pte_unmap(vmf->pte);
6208 if (unlikely(!pte_same(ptep_get(vmf->pte), vmf->orig_pte))) {
6209 pte_unmap_unlock(vmf->pte, vmf->ptl);
6212 pte = pte_modify(vmf->orig_pte, vmf->vma->vm_page_prot);
6214 pte = pte_clear_uffd(pte);
6215 pte = pte_mkyoung(pte);
6216 if (!pte_write(pte) &&
6218 can_change_pte_writable(vmf->vma, vmf->address, pte))
6219 pte = pte_mkwrite(pte, vmf->vma);
6220 set_pte_at(vmf->vma->vm_mm, vmf->address, vmf->pte, pte);
6221 update_mmu_cache(vmf->vma, vmf->address, vmf->pte);
6222 pte_unmap_unlock(vmf->pte, vmf->ptl);
6235 pte_t pte, old_pte;
6239 * The pte cannot be used safely until we verify, while holding the page
6244 old_pte = ptep_get(vmf->pte);
6247 pte_unmap_unlock(vmf->pte, vmf->ptl);
6251 pte = pte_modify(old_pte, vma->vm_page_prot);
6257 writable = pte_write(pte);
6259 can_change_pte_writable(vma, vmf->address, pte))
6262 folio = vm_normal_folio(vma, vmf->address, pte);
6278 pte_unmap_unlock(vmf->pte, vmf->ptl);
6291 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
6293 if (unlikely(!vmf->pte))
6295 if (unlikely(!pte_same(ptep_get(vmf->pte), vmf->orig_pte))) {
6296 pte_unmap_unlock(vmf->pte, vmf->ptl);
6305 numa_rebuild_large_mapping(vmf, vma, folio, pte, ignore_writable,
6308 numa_rebuild_single_mapping(vmf, vma, vmf->address, vmf->pte,
6310 pte_unmap_unlock(vmf->pte, vmf->ptl);
6353 /* COW or write-notify handled on pte level: split pmd. */
6430 vmf->pte);
6463 vmf->pte = NULL;
6474 * Use the maywrite version to indicate that vmf->pte may be
6481 vmf->pte = pte_offset_map_rw_nolock(vmf->vma->vm_mm, vmf->pmd,
6484 if (unlikely(!vmf->pte))
6486 vmf->orig_pte = ptep_get_lockless(vmf->pte);
6490 pte_unmap(vmf->pte);
6491 vmf->pte = NULL;
6495 if (!vmf->pte)
6514 if (unlikely(!pte_same(ptep_get(vmf->pte), entry))) {
6515 update_mmu_tlb(vmf->vma, vmf->address, vmf->pte);
6525 if (ptep_set_access_flags(vmf->vma, vmf->address, vmf->pte, entry,
6528 vmf->pte, 1);
6532 pte_unmap_unlock(vmf->pte, vmf->ptl);
6987 pte_t *ptep, pte;
7051 pte = ptep_get(ptep);
7052 if (!pte_present(pte))
7054 pfnmap_args_setup(args, lock, ptep, pte_pgprot(pte),
7055 pte_pfn(pte), PAGE_MASK, pte_write(pte),
7056 pte_special(pte));