arch/powerpc/include/asm/book3s/64/radix.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _ASM_POWERPC_PGTABLE_RADIX_H
   3 #define _ASM_POWERPC_PGTABLE_RADIX_H
   4
   5 #ifndef __ASSEMBLY__
   6 #include <asm/cmpxchg.h>
   7 #endif
   8
   9 #ifdef CONFIG_PPC_64K_PAGES
  10 #include <asm/book3s/64/radix-64k.h>
  11 #else
  12 #include <asm/book3s/64/radix-4k.h>
  13 #endif
  14
  15 #ifndef __ASSEMBLY__
  16 #include <asm/book3s/64/tlbflush-radix.h>
  17 #include <asm/cpu_has_feature.h>
  18 #endif
  19
  20 /* An empty PTE can still have a R or C writeback */
  21 #define RADIX_PTE_NONE_MASK             (_PAGE_DIRTY | _PAGE_ACCESSED)
  22
  23 /* Bits to set in a RPMD/RPUD/RPGD */
  24 #define RADIX_PMD_VAL_BITS              (0x8000000000000000UL | RADIX_PTE_INDEX_SIZE)
  25 #define RADIX_PUD_VAL_BITS              (0x8000000000000000UL | RADIX_PMD_INDEX_SIZE)
  26 #define RADIX_PGD_VAL_BITS              (0x8000000000000000UL | RADIX_PUD_INDEX_SIZE)
  27
  28 /* Don't have anything in the reserved bits and leaf bits */
  29 #define RADIX_PMD_BAD_BITS              0x60000000000000e0UL
  30 #define RADIX_PUD_BAD_BITS              0x60000000000000e0UL
  31 #define RADIX_PGD_BAD_BITS              0x60000000000000e0UL
  32
  33 /*
  34  * Size of EA range mapped by our pagetables.
  35  */
  36 #define RADIX_PGTABLE_EADDR_SIZE (RADIX_PTE_INDEX_SIZE + RADIX_PMD_INDEX_SIZE + \
  37                               RADIX_PUD_INDEX_SIZE + RADIX_PGD_INDEX_SIZE + PAGE_SHIFT)
  38 #define RADIX_PGTABLE_RANGE (ASM_CONST(1) << RADIX_PGTABLE_EADDR_SIZE)
  39
  40 /*
  41  * We support 52 bit address space, Use top bit for kernel
  42  * virtual mapping. Also make sure kernel fit in the top
  43  * quadrant.
  44  *
  45  *           +------------------+
  46  *           +------------------+  Kernel virtual map (0xc008000000000000)
  47  *           |                  |
  48  *           |                  |
  49  *           |                  |
  50  * 0b11......+------------------+  Kernel linear map (0xc....)
  51  *           |                  |
  52  *           |     2 quadrant   |
  53  *           |                  |
  54  * 0b10......+------------------+
  55  *           |                  |
  56  *           |    1 quadrant    |
  57  *           |                  |
  58  * 0b01......+------------------+
  59  *           |                  |
  60  *           |    0 quadrant    |
  61  *           |                  |
  62  * 0b00......+------------------+
  63  *
  64  *
  65  * 3rd quadrant expanded:
  66  * +------------------------------+
  67  * |                              |
  68  * |                              |
  69  * |                              |
  70  * +------------------------------+  Kernel IO map end (0xc010000000000000)
  71  * |                              |
  72  * |                              |
  73  * |      1/2 of virtual map      |
  74  * |                              |
  75  * |                              |
  76  * +------------------------------+  Kernel IO map start
  77  * |                              |
  78  * |      1/4 of virtual map      |
  79  * |                              |
  80  * +------------------------------+  Kernel vmemap start
  81  * |                              |
  82  * |     1/4 of virtual map       |
  83  * |                              |
  84  * +------------------------------+  Kernel virt start (0xc008000000000000)
  85  * |                              |
  86  * |                              |
  87  * |                              |
  88  * +------------------------------+  Kernel linear (0xc.....)
  89  */
  90
  91 #define RADIX_KERN_VIRT_START ASM_CONST(0xc008000000000000)
  92 #define RADIX_KERN_VIRT_SIZE  ASM_CONST(0x0008000000000000)
  93
  94 /*
  95  * The vmalloc space starts at the beginning of that region, and
  96  * occupies a quarter of it on radix config.
  97  * (we keep a quarter for the virtual memmap)
  98  */
  99 #define RADIX_VMALLOC_START     RADIX_KERN_VIRT_START
 100 #define RADIX_VMALLOC_SIZE      (RADIX_KERN_VIRT_SIZE >> 2)
 101 #define RADIX_VMALLOC_END       (RADIX_VMALLOC_START + RADIX_VMALLOC_SIZE)
 102 /*
 103  * Defines the address of the vmemap area, in its own region on
 104  * hash table CPUs.
 105  */
 106 #define RADIX_VMEMMAP_BASE              (RADIX_VMALLOC_END)
 107
 108 #define RADIX_KERN_IO_START     (RADIX_KERN_VIRT_START + (RADIX_KERN_VIRT_SIZE >> 1))
 109
 110 #ifndef __ASSEMBLY__
 111 #define RADIX_PTE_TABLE_SIZE    (sizeof(pte_t) << RADIX_PTE_INDEX_SIZE)
 112 #define RADIX_PMD_TABLE_SIZE    (sizeof(pmd_t) << RADIX_PMD_INDEX_SIZE)
 113 #define RADIX_PUD_TABLE_SIZE    (sizeof(pud_t) << RADIX_PUD_INDEX_SIZE)
 114 #define RADIX_PGD_TABLE_SIZE    (sizeof(pgd_t) << RADIX_PGD_INDEX_SIZE)
 115
 116 #ifdef CONFIG_STRICT_KERNEL_RWX
 117 extern void radix__mark_rodata_ro(void);
 118 extern void radix__mark_initmem_nx(void);
 119 #endif
 120
 121 extern void radix__ptep_set_access_flags(struct vm_area_struct *vma, pte_t *ptep,
 122                                          pte_t entry, unsigned long address,
 123                                          int psize);
 124
 125 static inline unsigned long __radix_pte_update(pte_t *ptep, unsigned long clr,
 126                                                unsigned long set)
 127 {
 128         __be64 old_be, tmp_be;
 129
 130         __asm__ __volatile__(
 131         "1:     ldarx   %0,0,%3         # pte_update\n"
 132         "       andc    %1,%0,%5        \n"
 133         "       or      %1,%1,%4        \n"
 134         "       stdcx.  %1,0,%3         \n"
 135         "       bne-    1b"
 136         : "=&r" (old_be), "=&r" (tmp_be), "=m" (*ptep)
 137         : "r" (ptep), "r" (cpu_to_be64(set)), "r" (cpu_to_be64(clr))
 138         : "cc" );
 139
 140         return be64_to_cpu(old_be);
 141 }
 142
 143 static inline unsigned long radix__pte_update(struct mm_struct *mm,
 144                                         unsigned long addr,
 145                                         pte_t *ptep, unsigned long clr,
 146                                         unsigned long set,
 147                                         int huge)
 148 {
 149         unsigned long old_pte;
 150
 151         old_pte = __radix_pte_update(ptep, clr, set);
 152         if (!huge)
 153                 assert_pte_locked(mm, addr);
 154
 155         return old_pte;
 156 }
 157
 158 static inline pte_t radix__ptep_get_and_clear_full(struct mm_struct *mm,
 159                                                    unsigned long addr,
 160                                                    pte_t *ptep, int full)
 161 {
 162         unsigned long old_pte;
 163
 164         if (full) {
 165                 old_pte = pte_val(*ptep);
 166                 *ptep = __pte(0);
 167         } else
 168                 old_pte = radix__pte_update(mm, addr, ptep, ~0ul, 0, 0);
 169
 170         return __pte(old_pte);
 171 }
 172
 173 static inline int radix__pte_same(pte_t pte_a, pte_t pte_b)
 174 {
 175         return ((pte_raw(pte_a) ^ pte_raw(pte_b)) == 0);
 176 }
 177
 178 static inline int radix__pte_none(pte_t pte)
 179 {
 180         return (pte_val(pte) & ~RADIX_PTE_NONE_MASK) == 0;
 181 }
 182
 183 static inline void radix__set_pte_at(struct mm_struct *mm, unsigned long addr,
 184                                  pte_t *ptep, pte_t pte, int percpu)
 185 {
 186         *ptep = pte;
 187
 188         /*
 189          * The architecture suggests a ptesync after setting the pte, which
 190          * orders the store that updates the pte with subsequent page table
 191          * walk accesses which may load the pte. Without this it may be
 192          * possible for a subsequent access to result in spurious fault.
 193          *
 194          * This is not necessary for correctness, because a spurious fault
 195          * is tolerated by the page fault handler, and this store will
 196          * eventually be seen. In testing, there was no noticable increase
 197          * in user faults on POWER9. Avoiding ptesync here is a significant
 198          * win for things like fork. If a future microarchitecture benefits
 199          * from ptesync, it should probably go into update_mmu_cache, rather
 200          * than set_pte_at (which is used to set ptes unrelated to faults).
 201          *
 202          * Spurious faults to vmalloc region are not tolerated, so there is
 203          * a ptesync in flush_cache_vmap.
 204          */
 205 }
 206
 207 static inline int radix__pmd_bad(pmd_t pmd)
 208 {
 209         return !!(pmd_val(pmd) & RADIX_PMD_BAD_BITS);
 210 }
 211
 212 static inline int radix__pmd_same(pmd_t pmd_a, pmd_t pmd_b)
 213 {
 214         return ((pmd_raw(pmd_a) ^ pmd_raw(pmd_b)) == 0);
 215 }
 216
 217 static inline int radix__pud_bad(pud_t pud)
 218 {
 219         return !!(pud_val(pud) & RADIX_PUD_BAD_BITS);
 220 }
 221
 222
 223 static inline int radix__pgd_bad(pgd_t pgd)
 224 {
 225         return !!(pgd_val(pgd) & RADIX_PGD_BAD_BITS);
 226 }
 227
 228 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 229
 230 static inline int radix__pmd_trans_huge(pmd_t pmd)
 231 {
 232         return (pmd_val(pmd) & (_PAGE_PTE | _PAGE_DEVMAP)) == _PAGE_PTE;
 233 }
 234
 235 static inline pmd_t radix__pmd_mkhuge(pmd_t pmd)
 236 {
 237         return __pmd(pmd_val(pmd) | _PAGE_PTE);
 238 }
 239
 240 extern unsigned long radix__pmd_hugepage_update(struct mm_struct *mm, unsigned long addr,
 241                                           pmd_t *pmdp, unsigned long clr,
 242                                           unsigned long set);
 243 extern pmd_t radix__pmdp_collapse_flush(struct vm_area_struct *vma,
 244                                   unsigned long address, pmd_t *pmdp);
 245 extern void radix__pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
 246                                         pgtable_t pgtable);
 247 extern pgtable_t radix__pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp);
 248 extern pmd_t radix__pmdp_huge_get_and_clear(struct mm_struct *mm,
 249                                       unsigned long addr, pmd_t *pmdp);
 250 extern int radix__has_transparent_hugepage(void);
 251 #endif
 252
 253 extern int __meminit radix__vmemmap_create_mapping(unsigned long start,
 254                                              unsigned long page_size,
 255                                              unsigned long phys);
 256 extern void radix__vmemmap_remove_mapping(unsigned long start,
 257                                     unsigned long page_size);
 258
 259 extern int radix__map_kernel_page(unsigned long ea, unsigned long pa,
 260                                  pgprot_t flags, unsigned int psz);
 261
 262 static inline unsigned long radix__get_tree_size(void)
 263 {
 264         unsigned long rts_field;
 265         /*
 266          * We support 52 bits, hence:
 267          * bits 52 - 31 = 21, 0b10101
 268          * RTS encoding details
 269          * bits 0 - 3 of rts -> bits 6 - 8 unsigned long
 270          * bits 4 - 5 of rts -> bits 62 - 63 of unsigned long
 271          */
 272         rts_field = (0x5UL << 5); /* 6 - 8 bits */
 273         rts_field |= (0x2UL << 61);
 274
 275         return rts_field;
 276 }
 277
 278 #ifdef CONFIG_MEMORY_HOTPLUG
 279 int radix__create_section_mapping(unsigned long start, unsigned long end, int nid);
 280 int radix__remove_section_mapping(unsigned long start, unsigned long end);
 281 #endif /* CONFIG_MEMORY_HOTPLUG */
 282 #endif /* __ASSEMBLY__ */
 283 #endif