nohash/64/pgtable.h

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #ifndef _ASM_POWERPC_NOHASH_64_PGTABLE_H
0003 #define _ASM_POWERPC_NOHASH_64_PGTABLE_H
0004 /*
0005  * This file contains the functions and defines necessary to modify and use
0006  * the ppc64 non-hashed page table.
0007  */
0008
0009 #include <linux/sizes.h>
0010
0011 #include <asm/nohash/64/pgtable-4k.h>
0012 #include <asm/barrier.h>
0013 #include <asm/asm-const.h>
0014
0015 /*
0016  * Size of EA range mapped by our pagetables.
0017  */
0018 #define PGTABLE_EADDR_SIZE (PTE_INDEX_SIZE + PMD_INDEX_SIZE + \
0019                 PUD_INDEX_SIZE + PGD_INDEX_SIZE + PAGE_SHIFT)
0020 #define PGTABLE_RANGE (ASM_CONST(1) << PGTABLE_EADDR_SIZE)
0021
0022 #define PMD_CACHE_INDEX PMD_INDEX_SIZE
0023 #define PUD_CACHE_INDEX PUD_INDEX_SIZE
0024
0025 /*
0026  * Define the address range of the kernel non-linear virtual area
0027  */
0028 #define KERN_VIRT_START ASM_CONST(0xc000100000000000)
0029 #define KERN_VIRT_SIZE  ASM_CONST(0x0000100000000000)
0030
0031 /*
0032  * The vmalloc space starts at the beginning of that region, and
0033  * occupies a quarter of it on Book3E
0034  * (we keep a quarter for the virtual memmap)
0035  */
0036 #define VMALLOC_START   KERN_VIRT_START
0037 #define VMALLOC_SIZE    (KERN_VIRT_SIZE >> 2)
0038 #define VMALLOC_END (VMALLOC_START + VMALLOC_SIZE)
0039
0040 /*
0041  * The third quarter of the kernel virtual space is used for IO mappings,
0042  * it's itself carved into the PIO region (ISA and PHB IO space) and
0043  * the ioremap space
0044  *
0045  *  ISA_IO_BASE = KERN_IO_START, 64K reserved area
0046  *  PHB_IO_BASE = ISA_IO_BASE + 64K to ISA_IO_BASE + 2G, PHB IO spaces
0047  * IOREMAP_BASE = ISA_IO_BASE + 2G to KERN_IO_START + KERN_IO_SIZE
0048  */
0049 #define KERN_IO_START   (KERN_VIRT_START + (KERN_VIRT_SIZE >> 1))
0050 #define KERN_IO_SIZE    (KERN_VIRT_SIZE >> 2)
0051 #define FULL_IO_SIZE    0x80000000ul
0052 #define  ISA_IO_BASE    (KERN_IO_START)
0053 #define  ISA_IO_END (KERN_IO_START + 0x10000ul)
0054 #define  PHB_IO_BASE    (ISA_IO_END)
0055 #define  PHB_IO_END (KERN_IO_START + FULL_IO_SIZE)
0056 #define IOREMAP_BASE    (PHB_IO_END)
0057 #define IOREMAP_START   (ioremap_bot)
0058 #define IOREMAP_END (KERN_IO_START + KERN_IO_SIZE - FIXADDR_SIZE)
0059 #define FIXADDR_SIZE    SZ_32M
0060
0061 /*
0062  * Defines the address of the vmemap area, in its own region on
0063  * after the vmalloc space on Book3E
0064  */
0065 #define VMEMMAP_BASE        VMALLOC_END
0066 #define VMEMMAP_END     KERN_IO_START
0067 #define vmemmap         ((struct page *)VMEMMAP_BASE)
0068
0069
0070 /*
0071  * Include the PTE bits definitions
0072  */
0073 #include <asm/nohash/pte-book3e.h>
0074
0075 #define PTE_RPN_MASK    (~((1UL << PTE_RPN_SHIFT) - 1))
0076
0077 /*
0078  * _PAGE_CHG_MASK masks of bits that are to be preserved across
0079  * pgprot changes.
0080  */
0081 #define _PAGE_CHG_MASK  (PTE_RPN_MASK | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_SPECIAL)
0082
0083 #define H_PAGE_4K_PFN 0
0084
0085 #ifndef __ASSEMBLY__
0086 /* pte_clear moved to later in this file */
0087
0088 static inline pte_t pte_mkwrite(pte_t pte)
0089 {
0090     return __pte(pte_val(pte) | _PAGE_RW);
0091 }
0092
0093 static inline pte_t pte_mkdirty(pte_t pte)
0094 {
0095     return __pte(pte_val(pte) | _PAGE_DIRTY);
0096 }
0097
0098 static inline pte_t pte_mkyoung(pte_t pte)
0099 {
0100     return __pte(pte_val(pte) | _PAGE_ACCESSED);
0101 }
0102
0103 static inline pte_t pte_wrprotect(pte_t pte)
0104 {
0105     return __pte(pte_val(pte) & ~_PAGE_RW);
0106 }
0107
0108 #define PMD_BAD_BITS        (PTE_TABLE_SIZE-1)
0109 #define PUD_BAD_BITS        (PMD_TABLE_SIZE-1)
0110
0111 static inline void pmd_set(pmd_t *pmdp, unsigned long val)
0112 {
0113     *pmdp = __pmd(val);
0114 }
0115
0116 static inline void pmd_clear(pmd_t *pmdp)
0117 {
0118     *pmdp = __pmd(0);
0119 }
0120
0121 static inline pte_t pmd_pte(pmd_t pmd)
0122 {
0123     return __pte(pmd_val(pmd));
0124 }
0125
0126 #define pmd_none(pmd)       (!pmd_val(pmd))
0127 #define pmd_bad(pmd)        (!is_kernel_addr(pmd_val(pmd)) \
0128                  || (pmd_val(pmd) & PMD_BAD_BITS))
0129 #define pmd_present(pmd)    (!pmd_none(pmd))
0130 #define pmd_page_vaddr(pmd) (pmd_val(pmd) & ~PMD_MASKED_BITS)
0131 extern struct page *pmd_page(pmd_t pmd);
0132 #define pmd_pfn(pmd)        (page_to_pfn(pmd_page(pmd)))
0133
0134 static inline void pud_set(pud_t *pudp, unsigned long val)
0135 {
0136     *pudp = __pud(val);
0137 }
0138
0139 static inline void pud_clear(pud_t *pudp)
0140 {
0141     *pudp = __pud(0);
0142 }
0143
0144 #define pud_none(pud)       (!pud_val(pud))
0145 #define pud_bad(pud)        (!is_kernel_addr(pud_val(pud)) \
0146                  || (pud_val(pud) & PUD_BAD_BITS))
0147 #define pud_present(pud)    (pud_val(pud) != 0)
0148
0149 static inline pmd_t *pud_pgtable(pud_t pud)
0150 {
0151     return (pmd_t *)(pud_val(pud) & ~PUD_MASKED_BITS);
0152 }
0153
0154 extern struct page *pud_page(pud_t pud);
0155
0156 static inline pte_t pud_pte(pud_t pud)
0157 {
0158     return __pte(pud_val(pud));
0159 }
0160
0161 static inline pud_t pte_pud(pte_t pte)
0162 {
0163     return __pud(pte_val(pte));
0164 }
0165 #define pud_write(pud)      pte_write(pud_pte(pud))
0166 #define p4d_write(pgd)      pte_write(p4d_pte(p4d))
0167
0168 static inline void p4d_set(p4d_t *p4dp, unsigned long val)
0169 {
0170     *p4dp = __p4d(val);
0171 }
0172
0173 /* Atomic PTE updates */
0174 static inline unsigned long pte_update(struct mm_struct *mm,
0175                        unsigned long addr,
0176                        pte_t *ptep, unsigned long clr,
0177                        unsigned long set,
0178                        int huge)
0179 {
0180     unsigned long old = pte_val(*ptep);
0181     *ptep = __pte((old & ~clr) | set);
0182
0183     /* huge pages use the old page table lock */
0184     if (!huge)
0185         assert_pte_locked(mm, addr);
0186
0187     return old;
0188 }
0189
0190 static inline int pte_young(pte_t pte)
0191 {
0192     return pte_val(pte) & _PAGE_ACCESSED;
0193 }
0194
0195 static inline int __ptep_test_and_clear_young(struct mm_struct *mm,
0196                           unsigned long addr, pte_t *ptep)
0197 {
0198     unsigned long old;
0199
0200     if (pte_young(*ptep))
0201         return 0;
0202     old = pte_update(mm, addr, ptep, _PAGE_ACCESSED, 0, 0);
0203     return (old & _PAGE_ACCESSED) != 0;
0204 }
0205 #define __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
0206 #define ptep_test_and_clear_young(__vma, __addr, __ptep)           \
0207 ({                                     \
0208     int __r;                               \
0209     __r = __ptep_test_and_clear_young((__vma)->vm_mm, __addr, __ptep); \
0210     __r;                                   \
0211 })
0212
0213 #define __HAVE_ARCH_PTEP_SET_WRPROTECT
0214 static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addr,
0215                       pte_t *ptep)
0216 {
0217
0218     if ((pte_val(*ptep) & _PAGE_RW) == 0)
0219         return;
0220
0221     pte_update(mm, addr, ptep, _PAGE_RW, 0, 0);
0222 }
0223
0224 #define __HAVE_ARCH_HUGE_PTEP_SET_WRPROTECT
0225 static inline void huge_ptep_set_wrprotect(struct mm_struct *mm,
0226                        unsigned long addr, pte_t *ptep)
0227 {
0228     if ((pte_val(*ptep) & _PAGE_RW) == 0)
0229         return;
0230
0231     pte_update(mm, addr, ptep, _PAGE_RW, 0, 1);
0232 }
0233
0234 #define __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH
0235 #define ptep_clear_flush_young(__vma, __address, __ptep)        \
0236 ({                                  \
0237     int __young = __ptep_test_and_clear_young((__vma)->vm_mm, __address, \
0238                           __ptep);      \
0239     __young;                            \
0240 })
0241
0242 #define __HAVE_ARCH_PTEP_GET_AND_CLEAR
0243 static inline pte_t ptep_get_and_clear(struct mm_struct *mm,
0244                        unsigned long addr, pte_t *ptep)
0245 {
0246     unsigned long old = pte_update(mm, addr, ptep, ~0UL, 0, 0);
0247     return __pte(old);
0248 }
0249
0250 static inline void pte_clear(struct mm_struct *mm, unsigned long addr,
0251                  pte_t * ptep)
0252 {
0253     pte_update(mm, addr, ptep, ~0UL, 0, 0);
0254 }
0255
0256
0257 /* Set the dirty and/or accessed bits atomically in a linux PTE */
0258 static inline void __ptep_set_access_flags(struct vm_area_struct *vma,
0259                        pte_t *ptep, pte_t entry,
0260                        unsigned long address,
0261                        int psize)
0262 {
0263     unsigned long bits = pte_val(entry) &
0264         (_PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_RW | _PAGE_EXEC);
0265
0266     unsigned long old = pte_val(*ptep);
0267     *ptep = __pte(old | bits);
0268
0269     flush_tlb_page(vma, address);
0270 }
0271
0272 #define pte_ERROR(e) \
0273     pr_err("%s:%d: bad pte %08lx.\n", __FILE__, __LINE__, pte_val(e))
0274 #define pmd_ERROR(e) \
0275     pr_err("%s:%d: bad pmd %08lx.\n", __FILE__, __LINE__, pmd_val(e))
0276 #define pgd_ERROR(e) \
0277     pr_err("%s:%d: bad pgd %08lx.\n", __FILE__, __LINE__, pgd_val(e))
0278
0279 /* Encode and de-code a swap entry */
0280 #define MAX_SWAPFILES_CHECK() do { \
0281     BUILD_BUG_ON(MAX_SWAPFILES_SHIFT > SWP_TYPE_BITS); \
0282     } while (0)
0283
0284 #define SWP_TYPE_BITS 5
0285 #define __swp_type(x)       (((x).val >> _PAGE_BIT_SWAP_TYPE) \
0286                 & ((1UL << SWP_TYPE_BITS) - 1))
0287 #define __swp_offset(x)     ((x).val >> PTE_RPN_SHIFT)
0288 #define __swp_entry(type, offset)   ((swp_entry_t) { \
0289                     ((type) << _PAGE_BIT_SWAP_TYPE) \
0290                     | ((offset) << PTE_RPN_SHIFT) })
0291
0292 #define __pte_to_swp_entry(pte)     ((swp_entry_t) { pte_val((pte)) })
0293 #define __swp_entry_to_pte(x)       __pte((x).val)
0294
0295 int map_kernel_page(unsigned long ea, unsigned long pa, pgprot_t prot);
0296 void unmap_kernel_page(unsigned long va);
0297 extern int __meminit vmemmap_create_mapping(unsigned long start,
0298                         unsigned long page_size,
0299                         unsigned long phys);
0300 extern void vmemmap_remove_mapping(unsigned long start,
0301                    unsigned long page_size);
0302 void __patch_exception(int exc, unsigned long addr);
0303 #define patch_exception(exc, name) do { \
0304     extern unsigned int name; \
0305     __patch_exception((exc), (unsigned long)&name); \
0306 } while (0)
0307
0308 #endif /* __ASSEMBLY__ */
0309
0310 #endif /* _ASM_POWERPC_NOHASH_64_PGTABLE_H */