Merge branch 'locking-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...

[linux-2.6-microblaze.git] / arch / powerpc / mm / pgtable-radix.c

diff --git a/arch/powerpc/mm/pgtable-radix.c b/arch/powerpc/mm/pgtable-radix.c
index c28165d..8c13e42 100644 (file)
--- a/arch/powerpc/mm/pgtable-radix.c
+++ b/arch/powerpc/mm/pgtable-radix.c
@@ -11,6 +11,7 @@
 #include <linux/sched/mm.h>
 #include <linux/memblock.h>
 #include <linux/of_fdt.h>
+#include <linux/mm.h>
 
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
@@ -19,6 +20,8 @@
 #include <asm/mmu.h>
 #include <asm/firmware.h>
 #include <asm/powernv.h>
+#include <asm/sections.h>
+#include <asm/trace.h>
 
 #include <trace/events/thp.h>
 
@@ -108,6 +111,49 @@ set_the_pte:
        return 0;
 }
 
+#ifdef CONFIG_STRICT_KERNEL_RWX
+void radix__mark_rodata_ro(void)
+{
+       unsigned long start = (unsigned long)_stext;
+       unsigned long end = (unsigned long)__init_begin;
+       unsigned long idx;
+       pgd_t *pgdp;
+       pud_t *pudp;
+       pmd_t *pmdp;
+       pte_t *ptep;
+
+       start = ALIGN_DOWN(start, PAGE_SIZE);
+       end = PAGE_ALIGN(end); // aligns up
+
+       pr_devel("marking ro start %lx, end %lx\n", start, end);
+
+       for (idx = start; idx < end; idx += PAGE_SIZE) {
+               pgdp = pgd_offset_k(idx);
+               pudp = pud_alloc(&init_mm, pgdp, idx);
+               if (!pudp)
+                       continue;
+               if (pud_huge(*pudp)) {
+                       ptep = (pte_t *)pudp;
+                       goto update_the_pte;
+               }
+               pmdp = pmd_alloc(&init_mm, pudp, idx);
+               if (!pmdp)
+                       continue;
+               if (pmd_huge(*pmdp)) {
+                       ptep = pmdp_ptep(pmdp);
+                       goto update_the_pte;
+               }
+               ptep = pte_alloc_kernel(pmdp, idx);
+               if (!ptep)
+                       continue;
+update_the_pte:
+               radix__pte_update(&init_mm, idx, ptep, _PAGE_WRITE, 0, 0);
+       }
+
+       radix__flush_tlb_kernel_range(start, end);
+}
+#endif /* CONFIG_STRICT_KERNEL_RWX */
+
 static inline void __meminit print_mapping(unsigned long start,
                                           unsigned long end,
                                           unsigned long size)
@@ -121,7 +167,14 @@ static inline void __meminit print_mapping(unsigned long start,
 static int __meminit create_physical_mapping(unsigned long start,
                                             unsigned long end)
 {
-       unsigned long addr, mapping_size = 0;
+       unsigned long vaddr, addr, mapping_size = 0;
+       pgprot_t prot;
+       unsigned long max_mapping_size;
+#ifdef CONFIG_STRICT_KERNEL_RWX
+       int split_text_mapping = 1;
+#else
+       int split_text_mapping = 0;
+#endif
 
        start = _ALIGN_UP(start, PAGE_SIZE);
        for (addr = start; addr < end; addr += mapping_size) {
@@ -130,9 +183,12 @@ static int __meminit create_physical_mapping(unsigned long start,
 
                gap = end - addr;
                previous_size = mapping_size;
+               max_mapping_size = PUD_SIZE;
 
+retry:
                if (IS_ALIGNED(addr, PUD_SIZE) && gap >= PUD_SIZE &&
-                   mmu_psize_defs[MMU_PAGE_1G].shift)
+                   mmu_psize_defs[MMU_PAGE_1G].shift &&
+                   PUD_SIZE <= max_mapping_size)
                        mapping_size = PUD_SIZE;
                else if (IS_ALIGNED(addr, PMD_SIZE) && gap >= PMD_SIZE &&
                         mmu_psize_defs[MMU_PAGE_2M].shift)
@@ -140,13 +196,32 @@ static int __meminit create_physical_mapping(unsigned long start,
                else
                        mapping_size = PAGE_SIZE;
 
+               if (split_text_mapping && (mapping_size == PUD_SIZE) &&
+                       (addr <= __pa_symbol(__init_begin)) &&
+                       (addr + mapping_size) >= __pa_symbol(_stext)) {
+                       max_mapping_size = PMD_SIZE;
+                       goto retry;
+               }
+
+               if (split_text_mapping && (mapping_size == PMD_SIZE) &&
+                   (addr <= __pa_symbol(__init_begin)) &&
+                   (addr + mapping_size) >= __pa_symbol(_stext))
+                       mapping_size = PAGE_SIZE;
+
                if (mapping_size != previous_size) {
                        print_mapping(start, addr, previous_size);
                        start = addr;
                }
 
-               rc = radix__map_kernel_page((unsigned long)__va(addr), addr,
-                                           PAGE_KERNEL_X, mapping_size);
+               vaddr = (unsigned long)__va(addr);
+
+               if (overlaps_kernel_text(vaddr, vaddr + mapping_size) ||
+                   overlaps_interrupt_vector_text(vaddr, vaddr + mapping_size))
+                       prot = PAGE_KERNEL_X;
+               else
+                       prot = PAGE_KERNEL;
+
+               rc = radix__map_kernel_page(vaddr, addr, prot, mapping_size);
                if (rc)
                        return rc;
        }
@@ -190,6 +265,7 @@ static void __init radix_init_pgtable(void)
        asm volatile(PPC_TLBIE_5(%0,%1,2,1,1) : :
                     "r" (TLBIEL_INVAL_SET_LPID), "r" (0));
        asm volatile("eieio; tlbsync; ptesync" : : : "memory");
+       trace_tlbie(0, 0, TLBIEL_INVAL_SET_LPID, 0, 2, 1, 1);
 }
 
 static void __init radix_init_partition_table(void)
@@ -316,6 +392,9 @@ static void update_hid_for_radix(void)
        asm volatile(PPC_TLBIE_5(%0, %4, %3, %2, %1)
                     : : "r"(rb), "i"(1), "i"(1), "i"(2), "r"(0) : "memory");
        asm volatile("eieio; tlbsync; ptesync; isync; slbia": : :"memory");
+       trace_tlbie(0, 0, rb, 0, 2, 0, 1);
+       trace_tlbie(0, 0, rb, 0, 2, 1, 1);
+
        /*
         * now switch the HID
         */
@@ -683,7 +762,7 @@ unsigned long radix__pmd_hugepage_update(struct mm_struct *mm, unsigned long add
        unsigned long old;
 
 #ifdef CONFIG_DEBUG_VM
-       WARN_ON(!radix__pmd_trans_huge(*pmdp));
+       WARN_ON(!radix__pmd_trans_huge(*pmdp) && !pmd_devmap(*pmdp));
        assert_spin_locked(&mm->page_table_lock);
 #endif
 
@@ -701,6 +780,7 @@ pmd_t radix__pmdp_collapse_flush(struct vm_area_struct *vma, unsigned long addre
 
        VM_BUG_ON(address & ~HPAGE_PMD_MASK);
        VM_BUG_ON(radix__pmd_trans_huge(*pmdp));
+       VM_BUG_ON(pmd_devmap(*pmdp));
        /*
         * khugepaged calls this for normal pmd
         */