arch/s390/mm/dump_pagetables.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/seq_file.h>
   3 #include <linux/debugfs.h>
   4 #include <linux/sched.h>
   5 #include <linux/mm.h>
   6 #include <linux/kasan.h>
   7 #include <asm/kasan.h>
   8 #include <asm/sections.h>
   9
  10 static unsigned long max_addr;
  11
  12 struct addr_marker {
  13         unsigned long start_address;
  14         const char *name;
  15 };
  16
  17 enum address_markers_idx {
  18         IDENTITY_NR = 0,
  19         KERNEL_START_NR,
  20         KERNEL_END_NR,
  21 #ifdef CONFIG_KASAN
  22         KASAN_SHADOW_START_NR,
  23         KASAN_SHADOW_END_NR,
  24 #endif
  25         VMEMMAP_NR,
  26         VMALLOC_NR,
  27         MODULES_NR,
  28 };
  29
  30 static struct addr_marker address_markers[] = {
  31         [IDENTITY_NR]           = {0, "Identity Mapping"},
  32         [KERNEL_START_NR]       = {(unsigned long)_stext, "Kernel Image Start"},
  33         [KERNEL_END_NR]         = {(unsigned long)_end, "Kernel Image End"},
  34 #ifdef CONFIG_KASAN
  35         [KASAN_SHADOW_START_NR] = {KASAN_SHADOW_START, "Kasan Shadow Start"},
  36         [KASAN_SHADOW_END_NR]   = {KASAN_SHADOW_END, "Kasan Shadow End"},
  37 #endif
  38         [VMEMMAP_NR]            = {0, "vmemmap Area"},
  39         [VMALLOC_NR]            = {0, "vmalloc Area"},
  40         [MODULES_NR]            = {0, "Modules Area"},
  41         { -1, NULL }
  42 };
  43
  44 struct pg_state {
  45         int level;
  46         unsigned int current_prot;
  47         unsigned long start_address;
  48         unsigned long current_address;
  49         const struct addr_marker *marker;
  50 };
  51
  52 static void print_prot(struct seq_file *m, unsigned int pr, int level)
  53 {
  54         static const char * const level_name[] =
  55                 { "ASCE", "PGD", "PUD", "PMD", "PTE" };
  56
  57         seq_printf(m, "%s ", level_name[level]);
  58         if (pr & _PAGE_INVALID) {
  59                 seq_printf(m, "I\n");
  60                 return;
  61         }
  62         seq_puts(m, (pr & _PAGE_PROTECT) ? "RO " : "RW ");
  63         seq_puts(m, (pr & _PAGE_NOEXEC) ? "NX\n" : "X\n");
  64 }
  65
  66 static void note_page(struct seq_file *m, struct pg_state *st,
  67                      unsigned int new_prot, int level)
  68 {
  69         static const char units[] = "KMGTPE";
  70         int width = sizeof(unsigned long) * 2;
  71         const char *unit = units;
  72         unsigned int prot, cur;
  73         unsigned long delta;
  74
  75         /*
  76          * If we have a "break" in the series, we need to flush the state
  77          * that we have now. "break" is either changing perms, levels or
  78          * address space marker.
  79          */
  80         prot = new_prot;
  81         cur = st->current_prot;
  82
  83         if (!st->level) {
  84                 /* First entry */
  85                 st->current_prot = new_prot;
  86                 st->level = level;
  87                 st->marker = address_markers;
  88                 seq_printf(m, "---[ %s ]---\n", st->marker->name);
  89         } else if (prot != cur || level != st->level ||
  90                    st->current_address >= st->marker[1].start_address) {
  91                 /* Print the actual finished series */
  92                 seq_printf(m, "0x%0*lx-0x%0*lx ",
  93                            width, st->start_address,
  94                            width, st->current_address);
  95                 delta = (st->current_address - st->start_address) >> 10;
  96                 while (!(delta & 0x3ff) && unit[1]) {
  97                         delta >>= 10;
  98                         unit++;
  99                 }
 100                 seq_printf(m, "%9lu%c ", delta, *unit);
 101                 print_prot(m, st->current_prot, st->level);
 102                 while (st->current_address >= st->marker[1].start_address) {
 103                         st->marker++;
 104                         seq_printf(m, "---[ %s ]---\n", st->marker->name);
 105                 }
 106                 st->start_address = st->current_address;
 107                 st->current_prot = new_prot;
 108                 st->level = level;
 109         }
 110 }
 111
 112 #ifdef CONFIG_KASAN
 113 static void note_kasan_early_shadow_page(struct seq_file *m,
 114                                                 struct pg_state *st)
 115 {
 116         unsigned int prot;
 117
 118         prot = pte_val(*kasan_early_shadow_pte) &
 119                 (_PAGE_PROTECT | _PAGE_INVALID | _PAGE_NOEXEC);
 120         note_page(m, st, prot, 4);
 121 }
 122 #endif
 123
 124 /*
 125  * The actual page table walker functions. In order to keep the
 126  * implementation of print_prot() short, we only check and pass
 127  * _PAGE_INVALID and _PAGE_PROTECT flags to note_page() if a region,
 128  * segment or page table entry is invalid or read-only.
 129  * After all it's just a hint that the current level being walked
 130  * contains an invalid or read-only entry.
 131  */
 132 static void walk_pte_level(struct seq_file *m, struct pg_state *st,
 133                            pmd_t *pmd, unsigned long addr)
 134 {
 135         unsigned int prot;
 136         pte_t *pte;
 137         int i;
 138
 139         for (i = 0; i < PTRS_PER_PTE && addr < max_addr; i++) {
 140                 st->current_address = addr;
 141                 pte = pte_offset_kernel(pmd, addr);
 142                 prot = pte_val(*pte) &
 143                         (_PAGE_PROTECT | _PAGE_INVALID | _PAGE_NOEXEC);
 144                 note_page(m, st, prot, 4);
 145                 addr += PAGE_SIZE;
 146         }
 147 }
 148
 149 static void walk_pmd_level(struct seq_file *m, struct pg_state *st,
 150                            pud_t *pud, unsigned long addr)
 151 {
 152         unsigned int prot;
 153         pmd_t *pmd;
 154         int i;
 155
 156 #ifdef CONFIG_KASAN
 157         if ((pud_val(*pud) & PAGE_MASK) == __pa(kasan_early_shadow_pmd)) {
 158                 note_kasan_early_shadow_page(m, st);
 159                 return;
 160         }
 161 #endif
 162
 163         pmd = pmd_offset(pud, addr);
 164         for (i = 0; i < PTRS_PER_PMD && addr < max_addr; i++, pmd++) {
 165                 st->current_address = addr;
 166                 if (!pmd_none(*pmd)) {
 167                         if (pmd_large(*pmd)) {
 168                                 prot = pmd_val(*pmd) &
 169                                         (_SEGMENT_ENTRY_PROTECT |
 170                                          _SEGMENT_ENTRY_NOEXEC);
 171                                 note_page(m, st, prot, 3);
 172                         } else
 173                                 walk_pte_level(m, st, pmd, addr);
 174                 } else
 175                         note_page(m, st, _PAGE_INVALID, 3);
 176                 addr += PMD_SIZE;
 177         }
 178 }
 179
 180 static void walk_pud_level(struct seq_file *m, struct pg_state *st,
 181                            p4d_t *p4d, unsigned long addr)
 182 {
 183         unsigned int prot;
 184         pud_t *pud;
 185         int i;
 186
 187 #ifdef CONFIG_KASAN
 188         if ((p4d_val(*p4d) & PAGE_MASK) == __pa(kasan_early_shadow_pud)) {
 189                 note_kasan_early_shadow_page(m, st);
 190                 return;
 191         }
 192 #endif
 193
 194         pud = pud_offset(p4d, addr);
 195         for (i = 0; i < PTRS_PER_PUD && addr < max_addr; i++, pud++) {
 196                 st->current_address = addr;
 197                 if (!pud_none(*pud))
 198                         if (pud_large(*pud)) {
 199                                 prot = pud_val(*pud) &
 200                                         (_REGION_ENTRY_PROTECT |
 201                                          _REGION_ENTRY_NOEXEC);
 202                                 note_page(m, st, prot, 2);
 203                         } else
 204                                 walk_pmd_level(m, st, pud, addr);
 205                 else
 206                         note_page(m, st, _PAGE_INVALID, 2);
 207                 addr += PUD_SIZE;
 208         }
 209 }
 210
 211 static void walk_p4d_level(struct seq_file *m, struct pg_state *st,
 212                            pgd_t *pgd, unsigned long addr)
 213 {
 214         p4d_t *p4d;
 215         int i;
 216
 217 #ifdef CONFIG_KASAN
 218         if ((pgd_val(*pgd) & PAGE_MASK) == __pa(kasan_early_shadow_p4d)) {
 219                 note_kasan_early_shadow_page(m, st);
 220                 return;
 221         }
 222 #endif
 223
 224         p4d = p4d_offset(pgd, addr);
 225         for (i = 0; i < PTRS_PER_P4D && addr < max_addr; i++, p4d++) {
 226                 st->current_address = addr;
 227                 if (!p4d_none(*p4d))
 228                         walk_pud_level(m, st, p4d, addr);
 229                 else
 230                         note_page(m, st, _PAGE_INVALID, 2);
 231                 addr += P4D_SIZE;
 232         }
 233 }
 234
 235 static void walk_pgd_level(struct seq_file *m)
 236 {
 237         unsigned long addr = 0;
 238         struct pg_state st;
 239         pgd_t *pgd;
 240         int i;
 241
 242         memset(&st, 0, sizeof(st));
 243         for (i = 0; i < PTRS_PER_PGD && addr < max_addr; i++) {
 244                 st.current_address = addr;
 245                 pgd = pgd_offset_k(addr);
 246                 if (!pgd_none(*pgd))
 247                         walk_p4d_level(m, &st, pgd, addr);
 248                 else
 249                         note_page(m, &st, _PAGE_INVALID, 1);
 250                 addr += PGDIR_SIZE;
 251                 cond_resched();
 252         }
 253         /* Flush out the last page */
 254         st.current_address = max_addr;
 255         note_page(m, &st, 0, 0);
 256 }
 257
 258 static int ptdump_show(struct seq_file *m, void *v)
 259 {
 260         walk_pgd_level(m);
 261         return 0;
 262 }
 263
 264 static int ptdump_open(struct inode *inode, struct file *filp)
 265 {
 266         return single_open(filp, ptdump_show, NULL);
 267 }
 268
 269 static const struct file_operations ptdump_fops = {
 270         .open           = ptdump_open,
 271         .read           = seq_read,
 272         .llseek         = seq_lseek,
 273         .release        = single_release,
 274 };
 275
 276 static int pt_dump_init(void)
 277 {
 278         /*
 279          * Figure out the maximum virtual address being accessible with the
 280          * kernel ASCE. We need this to keep the page table walker functions
 281          * from accessing non-existent entries.
 282          */
 283         max_addr = (S390_lowcore.kernel_asce & _REGION_ENTRY_TYPE_MASK) >> 2;
 284         max_addr = 1UL << (max_addr * 11 + 31);
 285         address_markers[MODULES_NR].start_address = MODULES_VADDR;
 286         address_markers[VMEMMAP_NR].start_address = (unsigned long) vmemmap;
 287         address_markers[VMALLOC_NR].start_address = VMALLOC_START;
 288         debugfs_create_file("kernel_page_tables", 0400, NULL, NULL, &ptdump_fops);
 289         return 0;
 290 }
 291 device_initcall(pt_dump_init);