mm: convert p[te|md]_numa users to p[te|md]_protnone_numa

Convert existing users of pte_numa and friends to the new helper.  Note
that the kernel is broken after this patch is applied until the other page
table modifiers are also altered.  This patch layout is to make review
easier.

Signed-off-by: Mel Gorman <mgorman@suse.de>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Acked-by: Aneesh Kumar <aneesh.kumar@linux.vnet.ibm.com>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Tested-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Dave Jones <davej@redhat.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Kirill Shutemov <kirill.shutemov@linux.intel.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Rik van Riel <riel@redhat.com>
Cc: Sasha Levin <sasha.levin@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

5 files changed, 26 insertions, 44 deletions

diff --git a/mm/gup.c b/mm/gup.c
index c2da1163986a..51bf0b06ca7b 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -64,7 +64,7 @@ retry:
                 migration_entry_wait(mm, pmd, address);
                 goto retry;
         }
-        if ((flags & FOLL_NUMA) && pte_numa(pte))
+        if ((flags & FOLL_NUMA) && pte_protnone(pte))
                 goto no_page;
         if ((flags & FOLL_WRITE) && !pte_write(pte)) {
                 pte_unmap_unlock(ptep, ptl);
@@ -184,7 +184,7 @@ struct page *follow_page_mask(struct vm_area_struct *vma,
                         return page;
                 return no_page_table(vma, flags);
         }
-        if ((flags & FOLL_NUMA) && pmd_numa(*pmd))
+        if ((flags & FOLL_NUMA) && pmd_protnone(*pmd))
                 return no_page_table(vma, flags);
         if (pmd_trans_huge(*pmd)) {
                 if (flags & FOLL_SPLIT) {
@@ -906,10 +906,10 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
 
                 /*
                  * Similar to the PMD case below, NUMA hinting must take slow
-                 * path
+                 * path using the pte_protnone check.
                  */
                 if (!pte_present(pte) || pte_special(pte) ||
-                        pte_numa(pte) || (write && !pte_write(pte)))
+                        pte_protnone(pte) || (write && !pte_write(pte)))
                         goto pte_unmap;
 
                 VM_BUG_ON(!pfn_valid(pte_pfn(pte)));
@@ -1104,7 +1104,7 @@ static int gup_pmd_range(pud_t pud, unsigned long addr, unsigned long end,
                          * slowpath for accounting purposes and so that they
                          * can be serialised against THP migration.
                          */
-                        if (pmd_numa(pmd))
+                        if (pmd_protnone(pmd))
                                 return 0;
 
                         if (!gup_huge_pmd(pmd, pmdp, addr, next, write,
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index c6921362c5fc..915941c45169 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1211,7 +1211,7 @@ struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
                 return ERR_PTR(-EFAULT);
 
         /* Full NUMA hinting faults to serialise migration in fault paths */
-        if ((flags & FOLL_NUMA) && pmd_numa(*pmd))
+        if ((flags & FOLL_NUMA) && pmd_protnone(*pmd))
                 goto out;
 
         page = pmd_page(*pmd);
@@ -1342,7 +1342,7 @@ int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
 
         /*
          * Migrate the THP to the requested node, returns with page unlocked
-         * and pmd_numa cleared.
+         * and access rights restored.
          */
         spin_unlock(ptl);
         migrated = migrate_misplaced_transhuge_page(mm, vma,
@@ -1357,7 +1357,7 @@ clear_pmdnuma:
         BUG_ON(!PageLocked(page));
         pmd = pmd_mknonnuma(pmd);
         set_pmd_at(mm, haddr, pmdp, pmd);
-        VM_BUG_ON(pmd_numa(*pmdp));
+        VM_BUG_ON(pmd_protnone(*pmdp));
         update_mmu_cache_pmd(vma, addr, pmdp);
         unlock_page(page);
 out_unlock:
@@ -1483,7 +1483,7 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                 ret = 1;
                 if (!prot_numa) {
                         entry = pmdp_get_and_clear_notify(mm, addr, pmd);
-                        if (pmd_numa(entry))
+                        if (pmd_protnone(entry))
                                 entry = pmd_mknonnuma(entry);
                         entry = pmd_modify(entry, newprot);
                         ret = HPAGE_PMD_NR;
@@ -1499,7 +1499,7 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                          * local vs remote hits on the zero page.
                          */
                         if (!is_huge_zero_page(page) &&
-                            !pmd_numa(*pmd)) {
+                            !pmd_protnone(*pmd)) {
                                 pmdp_set_numa(mm, addr, pmd);
                                 ret = HPAGE_PMD_NR;
                         }
@@ -1767,9 +1767,9 @@ static int __split_huge_page_map(struct page *page,
                         pte_t *pte, entry;
                         BUG_ON(PageCompound(page+i));
                         /*
-                         * Note that pmd_numa is not transferred deliberately
-                         * to avoid any possibility that pte_numa leaks to
-                         * a PROT_NONE VMA by accident.
+                         * Note that NUMA hinting access restrictions are not
+                         * transferred to avoid any possibility of altering
+                         * permissions across VMAs.
                          */
                         entry = mk_pte(page + i, vma->vm_page_prot);
                         entry = maybe_mkwrite(pte_mkdirty(entry), vma);
diff --git a/mm/memory.c b/mm/memory.c
index bbe6a73a899d..92e6a6299e86 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -3124,7 +3124,7 @@ static int handle_pte_fault(struct mm_struct *mm,
                                         pte, pmd, flags, entry);
         }
 
-        if (pte_numa(entry))
+        if (pte_protnone(entry))
                 return do_numa_page(mm, vma, address, entry, pte, pmd);
 
         ptl = pte_lockptr(mm, pmd);
@@ -3202,7 +3202,7 @@ static int __handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                         if (pmd_trans_splitting(orig_pmd))
                                 return 0;
 
-                        if (pmd_numa(orig_pmd))
+                        if (pmd_protnone(orig_pmd))
                                 return do_huge_pmd_numa_page(mm, vma, address,
                                                              orig_pmd, pmd);
 
diff --git a/mm/mprotect.c b/mm/mprotect.c
index 33121662f08b..44ffa698484d 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -75,36 +75,18 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
                 oldpte = *pte;
                 if (pte_present(oldpte)) {
                         pte_t ptent;
-                        bool updated = false;
 
-                        if (!prot_numa) {
-                                ptent = ptep_modify_prot_start(mm, addr, pte);
-                                if (pte_numa(ptent))
-                                        ptent = pte_mknonnuma(ptent);
-                                ptent = pte_modify(ptent, newprot);
-                                /*
-                                 * Avoid taking write faults for pages we
-                                 * know to be dirty.
-                                 */
-                                if (dirty_accountable && pte_dirty(ptent) &&
-                                    (pte_soft_dirty(ptent) ||
-                                     !(vma->vm_flags & VM_SOFTDIRTY)))
-                                        ptent = pte_mkwrite(ptent);
-                                ptep_modify_prot_commit(mm, addr, pte, ptent);
-                                updated = true;
-                        } else {
-                                struct page *page;
-
-                                page = vm_normal_page(vma, addr, oldpte);
-                                if (page && !PageKsm(page)) {
-                                        if (!pte_numa(oldpte)) {
-                                                ptep_set_numa(mm, addr, pte);
-                                                updated = true;
-                                        }
-                                }
+                        ptent = ptep_modify_prot_start(mm, addr, pte);
+                        ptent = pte_modify(ptent, newprot);
+
+                        /* Avoid taking write faults for known dirty pages */
+                        if (dirty_accountable && pte_dirty(ptent) &&
+                                        (pte_soft_dirty(ptent) ||
+                                         !(vma->vm_flags & VM_SOFTDIRTY))) {
+                                ptent = pte_mkwrite(ptent);
                         }
-                        if (updated)
-                                pages++;
+                        ptep_modify_prot_commit(mm, addr, pte, ptent);
+                        pages++;
                 } else if (IS_ENABLED(CONFIG_MIGRATION)) {
                         swp_entry_t entry = pte_to_swp_entry(oldpte);
 
diff --git a/mm/pgtable-generic.c b/mm/pgtable-generic.c
index dfb79e028ecb..4b8ad760dde3 100644
--- a/mm/pgtable-generic.c
+++ b/mm/pgtable-generic.c
@@ -193,7 +193,7 @@ void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
                      pmd_t *pmdp)
 {
         pmd_t entry = *pmdp;
-        if (pmd_numa(entry))
+        if (pmd_protnone(entry))
                 entry = pmd_mknonnuma(entry);
         set_pmd_at(vma->vm_mm, address, pmdp, pmd_mknotpresent(entry));
         flush_tlb_range(vma, address, address + HPAGE_PMD_SIZE);