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); 292