With hot-plugged memory getting mapped with 2M mappings always,
there will be no need to split any mappings during unplug.

Hence remove split_kernel_mapping() and associated code. This
essentially is a revert of
commit 4dd5f8a99e791 ("powerpc/mm/radix: Split linear mapping on hot-unplug")

Signed-off-by: Bharata B Rao <[email protected]>
---
 arch/powerpc/mm/book3s64/radix_pgtable.c | 93 +++++-------------------
 1 file changed, 19 insertions(+), 74 deletions(-)

diff --git a/arch/powerpc/mm/book3s64/radix_pgtable.c 
b/arch/powerpc/mm/book3s64/radix_pgtable.c
index 0d9ef3277579..56f2c698deac 100644
--- a/arch/powerpc/mm/book3s64/radix_pgtable.c
+++ b/arch/powerpc/mm/book3s64/radix_pgtable.c
@@ -15,7 +15,6 @@
 #include <linux/mm.h>
 #include <linux/hugetlb.h>
 #include <linux/string_helpers.h>
-#include <linux/stop_machine.h>
 #include <linux/memory.h>
 
 #include <asm/pgtable.h>
@@ -782,30 +781,6 @@ static void free_pud_table(pud_t *pud_start, pgd_t *pgd)
        pgd_clear(pgd);
 }
 
-struct change_mapping_params {
-       pte_t *pte;
-       unsigned long start;
-       unsigned long end;
-       unsigned long aligned_start;
-       unsigned long aligned_end;
-};
-
-static int __meminit stop_machine_change_mapping(void *data)
-{
-       struct change_mapping_params *params =
-                       (struct change_mapping_params *)data;
-
-       if (!data)
-               return -1;
-
-       spin_unlock(&init_mm.page_table_lock);
-       pte_clear(&init_mm, params->aligned_start, params->pte);
-       create_physical_mapping(__pa(params->aligned_start), 
__pa(params->start), -1);
-       create_physical_mapping(__pa(params->end), __pa(params->aligned_end), 
-1);
-       spin_lock(&init_mm.page_table_lock);
-       return 0;
-}
-
 static void remove_pte_table(pte_t *pte_start, unsigned long addr,
                             unsigned long end)
 {
@@ -834,52 +809,6 @@ static void remove_pte_table(pte_t *pte_start, unsigned 
long addr,
        }
 }
 
-/*
- * clear the pte and potentially split the mapping helper
- */
-static void __meminit split_kernel_mapping(unsigned long addr, unsigned long 
end,
-                               unsigned long size, pte_t *pte)
-{
-       unsigned long mask = ~(size - 1);
-       unsigned long aligned_start = addr & mask;
-       unsigned long aligned_end = addr + size;
-       struct change_mapping_params params;
-       bool split_region = false;
-
-       if ((end - addr) < size) {
-               /*
-                * We're going to clear the PTE, but not flushed
-                * the mapping, time to remap and flush. The
-                * effects if visible outside the processor or
-                * if we are running in code close to the
-                * mapping we cleared, we are in trouble.
-                */
-               if (overlaps_kernel_text(aligned_start, addr) ||
-                       overlaps_kernel_text(end, aligned_end)) {
-                       /*
-                        * Hack, just return, don't pte_clear
-                        */
-                       WARN_ONCE(1, "Linear mapping %lx->%lx overlaps kernel "
-                                 "text, not splitting\n", addr, end);
-                       return;
-               }
-               split_region = true;
-       }
-
-       if (split_region) {
-               params.pte = pte;
-               params.start = addr;
-               params.end = end;
-               params.aligned_start = addr & ~(size - 1);
-               params.aligned_end = min_t(unsigned long, aligned_end,
-                               (unsigned long)__va(memblock_end_of_DRAM()));
-               stop_machine(stop_machine_change_mapping, &params, NULL);
-               return;
-       }
-
-       pte_clear(&init_mm, addr, pte);
-}
-
 static void remove_pmd_table(pmd_t *pmd_start, unsigned long addr,
                             unsigned long end)
 {
@@ -895,7 +824,12 @@ static void remove_pmd_table(pmd_t *pmd_start, unsigned 
long addr,
                        continue;
 
                if (pmd_is_leaf(*pmd)) {
-                       split_kernel_mapping(addr, end, PMD_SIZE, (pte_t *)pmd);
+                       if (!IS_ALIGNED(addr, PMD_SIZE) ||
+                           !IS_ALIGNED(next, PMD_SIZE)) {
+                               WARN_ONCE(1, "%s: unaligned range\n", __func__);
+                               continue;
+                       }
+                       pte_clear(&init_mm, addr, (pte_t *)pmd);
                        continue;
                }
 
@@ -920,7 +854,12 @@ static void remove_pud_table(pud_t *pud_start, unsigned 
long addr,
                        continue;
 
                if (pud_is_leaf(*pud)) {
-                       split_kernel_mapping(addr, end, PUD_SIZE, (pte_t *)pud);
+                       if (!IS_ALIGNED(addr, PUD_SIZE) ||
+                           !IS_ALIGNED(next, PUD_SIZE)) {
+                               WARN_ONCE(1, "%s: unaligned range\n", __func__);
+                               continue;
+                       }
+                       pte_clear(&init_mm, addr, (pte_t *)pud);
                        continue;
                }
 
@@ -946,7 +885,13 @@ static void __meminit remove_pagetable(unsigned long 
start, unsigned long end)
                        continue;
 
                if (pgd_is_leaf(*pgd)) {
-                       split_kernel_mapping(addr, end, PGDIR_SIZE, (pte_t 
*)pgd);
+                       if (!IS_ALIGNED(addr, PGDIR_SIZE) ||
+                           !IS_ALIGNED(next, PGDIR_SIZE)) {
+                               WARN_ONCE(1, "%s: unaligned range\n", __func__);
+                               continue;
+                       }
+
+                       pte_clear(&init_mm, addr, (pte_t *)pgd);
                        continue;
                }
 
-- 
2.21.0

Reply via email to