arch/s390/mm/pageattr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright IBM Corp. 2011
   4  * Author(s): Jan Glauber <jang@linux.vnet.ibm.com>
   5  */
   6 #include <linux/hugetlb.h>
   7 #include <linux/mm.h>
   8 #include <asm/cacheflush.h>
   9 #include <asm/facility.h>
  10 #include <asm/pgalloc.h>
  11 #include <asm/page.h>
  12 #include <asm/set_memory.h>
  13
  14 static inline unsigned long sske_frame(unsigned long addr, unsigned char skey)
  15 {
  16         asm volatile(".insn rrf,0xb22b0000,%[skey],%[addr],1,0"
  17                      : [addr] "+a" (addr) : [skey] "d" (skey));
  18         return addr;
  19 }
  20
  21 void __storage_key_init_range(unsigned long start, unsigned long end)
  22 {
  23         unsigned long boundary, size;
  24
  25         while (start < end) {
  26                 if (MACHINE_HAS_EDAT1) {
  27                         /* set storage keys for a 1MB frame */
  28                         size = 1UL << 20;
  29                         boundary = (start + size) & ~(size - 1);
  30                         if (boundary <= end) {
  31                                 do {
  32                                         start = sske_frame(start, PAGE_DEFAULT_KEY);
  33                                 } while (start < boundary);
  34                                 continue;
  35                         }
  36                 }
  37                 page_set_storage_key(start, PAGE_DEFAULT_KEY, 1);
  38                 start += PAGE_SIZE;
  39         }
  40 }
  41
  42 #ifdef CONFIG_PROC_FS
  43 atomic_long_t direct_pages_count[PG_DIRECT_MAP_MAX];
  44
  45 void arch_report_meminfo(struct seq_file *m)
  46 {
  47         seq_printf(m, "DirectMap4k:    %8lu kB\n",
  48                    atomic_long_read(&direct_pages_count[PG_DIRECT_MAP_4K]) << 2);
  49         seq_printf(m, "DirectMap1M:    %8lu kB\n",
  50                    atomic_long_read(&direct_pages_count[PG_DIRECT_MAP_1M]) << 10);
  51         seq_printf(m, "DirectMap2G:    %8lu kB\n",
  52                    atomic_long_read(&direct_pages_count[PG_DIRECT_MAP_2G]) << 21);
  53 }
  54 #endif /* CONFIG_PROC_FS */
  55
  56 static void pgt_set(unsigned long *old, unsigned long new, unsigned long addr,
  57                     unsigned long dtt)
  58 {
  59         unsigned long table, mask;
  60
  61         mask = 0;
  62         if (MACHINE_HAS_EDAT2) {
  63                 switch (dtt) {
  64                 case CRDTE_DTT_REGION3:
  65                         mask = ~(PTRS_PER_PUD * sizeof(pud_t) - 1);
  66                         break;
  67                 case CRDTE_DTT_SEGMENT:
  68                         mask = ~(PTRS_PER_PMD * sizeof(pmd_t) - 1);
  69                         break;
  70                 case CRDTE_DTT_PAGE:
  71                         mask = ~(PTRS_PER_PTE * sizeof(pte_t) - 1);
  72                         break;
  73                 }
  74                 table = (unsigned long)old & mask;
  75                 crdte(*old, new, table, dtt, addr, S390_lowcore.kernel_asce);
  76         } else if (MACHINE_HAS_IDTE) {
  77                 cspg(old, *old, new);
  78         } else {
  79                 csp((unsigned int *)old + 1, *old, new);
  80         }
  81 }
  82
  83 static int walk_pte_level(pmd_t *pmdp, unsigned long addr, unsigned long end,
  84                           unsigned long flags)
  85 {
  86         pte_t *ptep, new;
  87
  88         ptep = pte_offset_kernel(pmdp, addr);
  89         do {
  90                 new = *ptep;
  91                 if (pte_none(new))
  92                         return -EINVAL;
  93                 if (flags & SET_MEMORY_RO)
  94                         new = pte_wrprotect(new);
  95                 else if (flags & SET_MEMORY_RW)
  96                         new = pte_mkwrite(pte_mkdirty(new));
  97                 if (flags & SET_MEMORY_NX)
  98                         pte_val(new) |= _PAGE_NOEXEC;
  99                 else if (flags & SET_MEMORY_X)
 100                         pte_val(new) &= ~_PAGE_NOEXEC;
 101                 pgt_set((unsigned long *)ptep, pte_val(new), addr, CRDTE_DTT_PAGE);
 102                 ptep++;
 103                 addr += PAGE_SIZE;
 104                 cond_resched();
 105         } while (addr < end);
 106         return 0;
 107 }
 108
 109 static int split_pmd_page(pmd_t *pmdp, unsigned long addr)
 110 {
 111         unsigned long pte_addr, prot;
 112         pte_t *pt_dir, *ptep;
 113         pmd_t new;
 114         int i, ro, nx;
 115
 116         pt_dir = vmem_pte_alloc();
 117         if (!pt_dir)
 118                 return -ENOMEM;
 119         pte_addr = pmd_pfn(*pmdp) << PAGE_SHIFT;
 120         ro = !!(pmd_val(*pmdp) & _SEGMENT_ENTRY_PROTECT);
 121         nx = !!(pmd_val(*pmdp) & _SEGMENT_ENTRY_NOEXEC);
 122         prot = pgprot_val(ro ? PAGE_KERNEL_RO : PAGE_KERNEL);
 123         if (!nx)
 124                 prot &= ~_PAGE_NOEXEC;
 125         ptep = pt_dir;
 126         for (i = 0; i < PTRS_PER_PTE; i++) {
 127                 pte_val(*ptep) = pte_addr | prot;
 128                 pte_addr += PAGE_SIZE;
 129                 ptep++;
 130         }
 131         pmd_val(new) = __pa(pt_dir) | _SEGMENT_ENTRY;
 132         pgt_set((unsigned long *)pmdp, pmd_val(new), addr, CRDTE_DTT_SEGMENT);
 133         update_page_count(PG_DIRECT_MAP_4K, PTRS_PER_PTE);
 134         update_page_count(PG_DIRECT_MAP_1M, -1);
 135         return 0;
 136 }
 137
 138 static void modify_pmd_page(pmd_t *pmdp, unsigned long addr,
 139                             unsigned long flags)
 140 {
 141         pmd_t new = *pmdp;
 142
 143         if (flags & SET_MEMORY_RO)
 144                 new = pmd_wrprotect(new);
 145         else if (flags & SET_MEMORY_RW)
 146                 new = pmd_mkwrite(pmd_mkdirty(new));
 147         if (flags & SET_MEMORY_NX)
 148                 pmd_val(new) |= _SEGMENT_ENTRY_NOEXEC;
 149         else if (flags & SET_MEMORY_X)
 150                 pmd_val(new) &= ~_SEGMENT_ENTRY_NOEXEC;
 151         pgt_set((unsigned long *)pmdp, pmd_val(new), addr, CRDTE_DTT_SEGMENT);
 152 }
 153
 154 static int walk_pmd_level(pud_t *pudp, unsigned long addr, unsigned long end,
 155                           unsigned long flags)
 156 {
 157         unsigned long next;
 158         pmd_t *pmdp;
 159         int rc = 0;
 160
 161         pmdp = pmd_offset(pudp, addr);
 162         do {
 163                 if (pmd_none(*pmdp))
 164                         return -EINVAL;
 165                 next = pmd_addr_end(addr, end);
 166                 if (pmd_large(*pmdp)) {
 167                         if (addr & ~PMD_MASK || addr + PMD_SIZE > next) {
 168                                 rc = split_pmd_page(pmdp, addr);
 169                                 if (rc)
 170                                         return rc;
 171                                 continue;
 172                         }
 173                         modify_pmd_page(pmdp, addr, flags);
 174                 } else {
 175                         rc = walk_pte_level(pmdp, addr, next, flags);
 176                         if (rc)
 177                                 return rc;
 178                 }
 179                 pmdp++;
 180                 addr = next;
 181                 cond_resched();
 182         } while (addr < end);
 183         return rc;
 184 }
 185
 186 static int split_pud_page(pud_t *pudp, unsigned long addr)
 187 {
 188         unsigned long pmd_addr, prot;
 189         pmd_t *pm_dir, *pmdp;
 190         pud_t new;
 191         int i, ro, nx;
 192
 193         pm_dir = vmem_crst_alloc(_SEGMENT_ENTRY_EMPTY);
 194         if (!pm_dir)
 195                 return -ENOMEM;
 196         pmd_addr = pud_pfn(*pudp) << PAGE_SHIFT;
 197         ro = !!(pud_val(*pudp) & _REGION_ENTRY_PROTECT);
 198         nx = !!(pud_val(*pudp) & _REGION_ENTRY_NOEXEC);
 199         prot = pgprot_val(ro ? SEGMENT_KERNEL_RO : SEGMENT_KERNEL);
 200         if (!nx)
 201                 prot &= ~_SEGMENT_ENTRY_NOEXEC;
 202         pmdp = pm_dir;
 203         for (i = 0; i < PTRS_PER_PMD; i++) {
 204                 pmd_val(*pmdp) = pmd_addr | prot;
 205                 pmd_addr += PMD_SIZE;
 206                 pmdp++;
 207         }
 208         pud_val(new) = __pa(pm_dir) | _REGION3_ENTRY;
 209         pgt_set((unsigned long *)pudp, pud_val(new), addr, CRDTE_DTT_REGION3);
 210         update_page_count(PG_DIRECT_MAP_1M, PTRS_PER_PMD);
 211         update_page_count(PG_DIRECT_MAP_2G, -1);
 212         return 0;
 213 }
 214
 215 static void modify_pud_page(pud_t *pudp, unsigned long addr,
 216                             unsigned long flags)
 217 {
 218         pud_t new = *pudp;
 219
 220         if (flags & SET_MEMORY_RO)
 221                 new = pud_wrprotect(new);
 222         else if (flags & SET_MEMORY_RW)
 223                 new = pud_mkwrite(pud_mkdirty(new));
 224         if (flags & SET_MEMORY_NX)
 225                 pud_val(new) |= _REGION_ENTRY_NOEXEC;
 226         else if (flags & SET_MEMORY_X)
 227                 pud_val(new) &= ~_REGION_ENTRY_NOEXEC;
 228         pgt_set((unsigned long *)pudp, pud_val(new), addr, CRDTE_DTT_REGION3);
 229 }
 230
 231 static int walk_pud_level(p4d_t *p4d, unsigned long addr, unsigned long end,
 232                           unsigned long flags)
 233 {
 234         unsigned long next;
 235         pud_t *pudp;
 236         int rc = 0;
 237
 238         pudp = pud_offset(p4d, addr);
 239         do {
 240                 if (pud_none(*pudp))
 241                         return -EINVAL;
 242                 next = pud_addr_end(addr, end);
 243                 if (pud_large(*pudp)) {
 244                         if (addr & ~PUD_MASK || addr + PUD_SIZE > next) {
 245                                 rc = split_pud_page(pudp, addr);
 246                                 if (rc)
 247                                         break;
 248                                 continue;
 249                         }
 250                         modify_pud_page(pudp, addr, flags);
 251                 } else {
 252                         rc = walk_pmd_level(pudp, addr, next, flags);
 253                 }
 254                 pudp++;
 255                 addr = next;
 256                 cond_resched();
 257         } while (addr < end && !rc);
 258         return rc;
 259 }
 260
 261 static int walk_p4d_level(pgd_t *pgd, unsigned long addr, unsigned long end,
 262                           unsigned long flags)
 263 {
 264         unsigned long next;
 265         p4d_t *p4dp;
 266         int rc = 0;
 267
 268         p4dp = p4d_offset(pgd, addr);
 269         do {
 270                 if (p4d_none(*p4dp))
 271                         return -EINVAL;
 272                 next = p4d_addr_end(addr, end);
 273                 rc = walk_pud_level(p4dp, addr, next, flags);
 274                 p4dp++;
 275                 addr = next;
 276                 cond_resched();
 277         } while (addr < end && !rc);
 278         return rc;
 279 }
 280
 281 DEFINE_MUTEX(cpa_mutex);
 282
 283 static int change_page_attr(unsigned long addr, unsigned long end,
 284                             unsigned long flags)
 285 {
 286         unsigned long next;
 287         int rc = -EINVAL;
 288         pgd_t *pgdp;
 289
 290         if (addr == end)
 291                 return 0;
 292         if (end >= MODULES_END)
 293                 return -EINVAL;
 294         mutex_lock(&cpa_mutex);
 295         pgdp = pgd_offset_k(addr);
 296         do {
 297                 if (pgd_none(*pgdp))
 298                         break;
 299                 next = pgd_addr_end(addr, end);
 300                 rc = walk_p4d_level(pgdp, addr, next, flags);
 301                 if (rc)
 302                         break;
 303                 cond_resched();
 304         } while (pgdp++, addr = next, addr < end && !rc);
 305         mutex_unlock(&cpa_mutex);
 306         return rc;
 307 }
 308
 309 int __set_memory(unsigned long addr, int numpages, unsigned long flags)
 310 {
 311         if (!MACHINE_HAS_NX)
 312                 flags &= ~(SET_MEMORY_NX | SET_MEMORY_X);
 313         if (!flags)
 314                 return 0;
 315         addr &= PAGE_MASK;
 316         return change_page_attr(addr, addr + numpages * PAGE_SIZE, flags);
 317 }
 318
 319 #ifdef CONFIG_DEBUG_PAGEALLOC
 320
 321 static void ipte_range(pte_t *pte, unsigned long address, int nr)
 322 {
 323         int i;
 324
 325         if (test_facility(13)) {
 326                 __ptep_ipte_range(address, nr - 1, pte, IPTE_GLOBAL);
 327                 return;
 328         }
 329         for (i = 0; i < nr; i++) {
 330                 __ptep_ipte(address, pte, 0, 0, IPTE_GLOBAL);
 331                 address += PAGE_SIZE;
 332                 pte++;
 333         }
 334 }
 335
 336 void __kernel_map_pages(struct page *page, int numpages, int enable)
 337 {
 338         unsigned long address;
 339         int nr, i, j;
 340         pte_t *pte;
 341
 342         for (i = 0; i < numpages;) {
 343                 address = page_to_phys(page + i);
 344                 pte = virt_to_kpte(address);
 345                 nr = (unsigned long)pte >> ilog2(sizeof(long));
 346                 nr = PTRS_PER_PTE - (nr & (PTRS_PER_PTE - 1));
 347                 nr = min(numpages - i, nr);
 348                 if (enable) {
 349                         for (j = 0; j < nr; j++) {
 350                                 pte_val(*pte) &= ~_PAGE_INVALID;
 351                                 address += PAGE_SIZE;
 352                                 pte++;
 353                         }
 354                 } else {
 355                         ipte_range(pte, address, nr);
 356                 }
 357                 i += nr;
 358         }
 359 }
 360
 361 #endif /* CONFIG_DEBUG_PAGEALLOC */