arch/powerpc/mm/pgtable_64.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  This file contains pgtable related functions for 64-bit machines.
   4  *
   5  *  Derived from arch/ppc64/mm/init.c
   6  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
   7  *
   8  *  Modifications by Paul Mackerras (PowerMac) (paulus@samba.org)
   9  *  and Cort Dougan (PReP) (cort@cs.nmt.edu)
  10  *    Copyright (C) 1996 Paul Mackerras
  11  *
  12  *  Derived from "arch/i386/mm/init.c"
  13  *    Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
  14  *
  15  *  Dave Engebretsen <engebret@us.ibm.com>
  16  *      Rework for PPC64 port.
  17  */
  18
  19 #include <linux/signal.h>
  20 #include <linux/sched.h>
  21 #include <linux/kernel.h>
  22 #include <linux/errno.h>
  23 #include <linux/string.h>
  24 #include <linux/export.h>
  25 #include <linux/types.h>
  26 #include <linux/mman.h>
  27 #include <linux/mm.h>
  28 #include <linux/swap.h>
  29 #include <linux/stddef.h>
  30 #include <linux/vmalloc.h>
  31 #include <linux/slab.h>
  32 #include <linux/hugetlb.h>
  33
  34 #include <asm/pgalloc.h>
  35 #include <asm/page.h>
  36 #include <asm/prom.h>
  37 #include <asm/mmu_context.h>
  38 #include <asm/mmu.h>
  39 #include <asm/smp.h>
  40 #include <asm/machdep.h>
  41 #include <asm/tlb.h>
  42 #include <asm/processor.h>
  43 #include <asm/cputable.h>
  44 #include <asm/sections.h>
  45 #include <asm/firmware.h>
  46 #include <asm/dma.h>
  47
  48 #include <mm/mmu_decl.h>
  49
  50
  51 #ifdef CONFIG_PPC_BOOK3S_64
  52 /*
  53  * partition table and process table for ISA 3.0
  54  */
  55 struct prtb_entry *process_tb;
  56 struct patb_entry *partition_tb;
  57 /*
  58  * page table size
  59  */
  60 unsigned long __pte_index_size;
  61 EXPORT_SYMBOL(__pte_index_size);
  62 unsigned long __pmd_index_size;
  63 EXPORT_SYMBOL(__pmd_index_size);
  64 unsigned long __pud_index_size;
  65 EXPORT_SYMBOL(__pud_index_size);
  66 unsigned long __pgd_index_size;
  67 EXPORT_SYMBOL(__pgd_index_size);
  68 unsigned long __pud_cache_index;
  69 EXPORT_SYMBOL(__pud_cache_index);
  70 unsigned long __pte_table_size;
  71 EXPORT_SYMBOL(__pte_table_size);
  72 unsigned long __pmd_table_size;
  73 EXPORT_SYMBOL(__pmd_table_size);
  74 unsigned long __pud_table_size;
  75 EXPORT_SYMBOL(__pud_table_size);
  76 unsigned long __pgd_table_size;
  77 EXPORT_SYMBOL(__pgd_table_size);
  78 unsigned long __pmd_val_bits;
  79 EXPORT_SYMBOL(__pmd_val_bits);
  80 unsigned long __pud_val_bits;
  81 EXPORT_SYMBOL(__pud_val_bits);
  82 unsigned long __pgd_val_bits;
  83 EXPORT_SYMBOL(__pgd_val_bits);
  84 unsigned long __kernel_virt_start;
  85 EXPORT_SYMBOL(__kernel_virt_start);
  86 unsigned long __vmalloc_start;
  87 EXPORT_SYMBOL(__vmalloc_start);
  88 unsigned long __vmalloc_end;
  89 EXPORT_SYMBOL(__vmalloc_end);
  90 unsigned long __kernel_io_start;
  91 EXPORT_SYMBOL(__kernel_io_start);
  92 unsigned long __kernel_io_end;
  93 struct page *vmemmap;
  94 EXPORT_SYMBOL(vmemmap);
  95 unsigned long __pte_frag_nr;
  96 EXPORT_SYMBOL(__pte_frag_nr);
  97 unsigned long __pte_frag_size_shift;
  98 EXPORT_SYMBOL(__pte_frag_size_shift);
  99 #endif
 100
 101 #ifndef __PAGETABLE_PUD_FOLDED
 102 /* 4 level page table */
 103 struct page *p4d_page(p4d_t p4d)
 104 {
 105         if (p4d_is_leaf(p4d)) {
 106                 VM_WARN_ON(!p4d_huge(p4d));
 107                 return pte_page(p4d_pte(p4d));
 108         }
 109         return virt_to_page(p4d_page_vaddr(p4d));
 110 }
 111 #endif
 112
 113 struct page *pud_page(pud_t pud)
 114 {
 115         if (pud_is_leaf(pud)) {
 116                 VM_WARN_ON(!pud_huge(pud));
 117                 return pte_page(pud_pte(pud));
 118         }
 119         return virt_to_page(pud_page_vaddr(pud));
 120 }
 121
 122 /*
 123  * For hugepage we have pfn in the pmd, we use PTE_RPN_SHIFT bits for flags
 124  * For PTE page, we have a PTE_FRAG_SIZE (4K) aligned virtual address.
 125  */
 126 struct page *pmd_page(pmd_t pmd)
 127 {
 128         if (pmd_is_leaf(pmd)) {
 129                 VM_WARN_ON(!(pmd_large(pmd) || pmd_huge(pmd)));
 130                 return pte_page(pmd_pte(pmd));
 131         }
 132         return virt_to_page(pmd_page_vaddr(pmd));
 133 }
 134
 135 #ifdef CONFIG_STRICT_KERNEL_RWX
 136 void mark_rodata_ro(void)
 137 {
 138         if (!mmu_has_feature(MMU_FTR_KERNEL_RO)) {
 139                 pr_warn("Warning: Unable to mark rodata read only on this CPU.\n");
 140                 return;
 141         }
 142
 143         if (radix_enabled())
 144                 radix__mark_rodata_ro();
 145         else
 146                 hash__mark_rodata_ro();
 147
 148         // mark_initmem_nx() should have already run by now
 149         ptdump_check_wx();
 150 }
 151
 152 void mark_initmem_nx(void)
 153 {
 154         if (radix_enabled())
 155                 radix__mark_initmem_nx();
 156         else
 157                 hash__mark_initmem_nx();
 158 }
 159 #endif