1 // SPDX-License-Identifier: GPL-2.0-only
3 * Debug helper to dump the current kernel pagetables of the system
4 * so that we can see what the various memory ranges are set to.
6 * (C) Copyright 2008 Intel Corporation
8 * Author: Arjan van de Ven <arjan@linux.intel.com>
11 #include <linux/debugfs.h>
12 #include <linux/kasan.h>
14 #include <linux/init.h>
15 #include <linux/sched.h>
16 #include <linux/seq_file.h>
17 #include <linux/highmem.h>
18 #include <linux/pci.h>
19 #include <linux/ptdump.h>
21 #include <asm/e820/types.h>
22 #include <asm/pgtable.h>
25 * The dumper groups pagetable entries of the same type into one, and for
26 * that it needs to keep some state when walking, and flush this state
27 * when a "break" in the continuity is found.
30 struct ptdump_state ptdump;
32 pgprotval_t current_prot;
33 pgprotval_t effective_prot;
34 pgprotval_t prot_levels[5];
35 unsigned long start_address;
36 const struct addr_marker *marker;
40 unsigned long wx_pages;
45 unsigned long start_address;
47 unsigned long max_lines;
50 /* Address space markers hints */
54 enum address_markers_idx {
57 #ifdef CONFIG_MODIFY_LDT_SYSCALL
64 KASAN_SHADOW_START_NR,
68 #ifdef CONFIG_X86_ESPFIX64
81 static struct addr_marker address_markers[] = {
82 [USER_SPACE_NR] = { 0, "User Space" },
83 [KERNEL_SPACE_NR] = { (1UL << 63), "Kernel Space" },
84 [LOW_KERNEL_NR] = { 0UL, "Low Kernel Mapping" },
85 [VMALLOC_START_NR] = { 0UL, "vmalloc() Area" },
86 [VMEMMAP_START_NR] = { 0UL, "Vmemmap" },
89 * These fields get initialized with the (dynamic)
90 * KASAN_SHADOW_{START,END} values in pt_dump_init().
92 [KASAN_SHADOW_START_NR] = { 0UL, "KASAN shadow" },
93 [KASAN_SHADOW_END_NR] = { 0UL, "KASAN shadow end" },
95 #ifdef CONFIG_MODIFY_LDT_SYSCALL
96 [LDT_NR] = { 0UL, "LDT remap" },
98 [CPU_ENTRY_AREA_NR] = { CPU_ENTRY_AREA_BASE,"CPU entry Area" },
99 #ifdef CONFIG_X86_ESPFIX64
100 [ESPFIX_START_NR] = { ESPFIX_BASE_ADDR, "ESPfix Area", 16 },
103 [EFI_END_NR] = { EFI_VA_END, "EFI Runtime Services" },
105 [HIGH_KERNEL_NR] = { __START_KERNEL_map, "High Kernel Mapping" },
106 [MODULES_VADDR_NR] = { MODULES_VADDR, "Modules" },
107 [MODULES_END_NR] = { MODULES_END, "End Modules" },
108 [FIXADDR_START_NR] = { FIXADDR_START, "Fixmap Area" },
109 [END_OF_SPACE_NR] = { -1, NULL }
112 #define INIT_PGD ((pgd_t *) &init_top_pgt)
114 #else /* CONFIG_X86_64 */
116 enum address_markers_idx {
121 #ifdef CONFIG_HIGHMEM
124 #ifdef CONFIG_MODIFY_LDT_SYSCALL
132 static struct addr_marker address_markers[] = {
133 [USER_SPACE_NR] = { 0, "User Space" },
134 [KERNEL_SPACE_NR] = { PAGE_OFFSET, "Kernel Mapping" },
135 [VMALLOC_START_NR] = { 0UL, "vmalloc() Area" },
136 [VMALLOC_END_NR] = { 0UL, "vmalloc() End" },
137 #ifdef CONFIG_HIGHMEM
138 [PKMAP_BASE_NR] = { 0UL, "Persistent kmap() Area" },
140 #ifdef CONFIG_MODIFY_LDT_SYSCALL
141 [LDT_NR] = { 0UL, "LDT remap" },
143 [CPU_ENTRY_AREA_NR] = { 0UL, "CPU entry area" },
144 [FIXADDR_START_NR] = { 0UL, "Fixmap area" },
145 [END_OF_SPACE_NR] = { -1, NULL }
148 #define INIT_PGD (swapper_pg_dir)
150 #endif /* !CONFIG_X86_64 */
152 /* Multipliers for offsets within the PTEs */
153 #define PTE_LEVEL_MULT (PAGE_SIZE)
154 #define PMD_LEVEL_MULT (PTRS_PER_PTE * PTE_LEVEL_MULT)
155 #define PUD_LEVEL_MULT (PTRS_PER_PMD * PMD_LEVEL_MULT)
156 #define P4D_LEVEL_MULT (PTRS_PER_PUD * PUD_LEVEL_MULT)
157 #define PGD_LEVEL_MULT (PTRS_PER_P4D * P4D_LEVEL_MULT)
159 #define pt_dump_seq_printf(m, to_dmesg, fmt, args...) \
162 printk(KERN_INFO fmt, ##args); \
165 seq_printf(m, fmt, ##args); \
168 #define pt_dump_cont_printf(m, to_dmesg, fmt, args...) \
171 printk(KERN_CONT fmt, ##args); \
174 seq_printf(m, fmt, ##args); \
178 * Print a readable form of a pgprot_t to the seq_file
180 static void printk_prot(struct seq_file *m, pgprotval_t pr, int level, bool dmsg)
182 static const char * const level_name[] =
183 { "cr3", "pgd", "p4d", "pud", "pmd", "pte" };
185 if (!(pr & _PAGE_PRESENT)) {
187 pt_dump_cont_printf(m, dmsg, " ");
190 pt_dump_cont_printf(m, dmsg, "USR ");
192 pt_dump_cont_printf(m, dmsg, " ");
194 pt_dump_cont_printf(m, dmsg, "RW ");
196 pt_dump_cont_printf(m, dmsg, "ro ");
198 pt_dump_cont_printf(m, dmsg, "PWT ");
200 pt_dump_cont_printf(m, dmsg, " ");
202 pt_dump_cont_printf(m, dmsg, "PCD ");
204 pt_dump_cont_printf(m, dmsg, " ");
206 /* Bit 7 has a different meaning on level 3 vs 4 */
207 if (level <= 4 && pr & _PAGE_PSE)
208 pt_dump_cont_printf(m, dmsg, "PSE ");
210 pt_dump_cont_printf(m, dmsg, " ");
211 if ((level == 5 && pr & _PAGE_PAT) ||
212 ((level == 4 || level == 3) && pr & _PAGE_PAT_LARGE))
213 pt_dump_cont_printf(m, dmsg, "PAT ");
215 pt_dump_cont_printf(m, dmsg, " ");
216 if (pr & _PAGE_GLOBAL)
217 pt_dump_cont_printf(m, dmsg, "GLB ");
219 pt_dump_cont_printf(m, dmsg, " ");
221 pt_dump_cont_printf(m, dmsg, "NX ");
223 pt_dump_cont_printf(m, dmsg, "x ");
225 pt_dump_cont_printf(m, dmsg, "%s\n", level_name[level]);
228 static void note_wx(struct pg_state *st, unsigned long addr)
230 unsigned long npages;
232 npages = (addr - st->start_address) / PAGE_SIZE;
234 #ifdef CONFIG_PCI_BIOS
236 * If PCI BIOS is enabled, the PCI BIOS area is forced to WX.
237 * Inform about it, but avoid the warning.
239 if (pcibios_enabled && st->start_address >= PAGE_OFFSET + BIOS_BEGIN &&
240 addr <= PAGE_OFFSET + BIOS_END) {
241 pr_warn_once("x86/mm: PCI BIOS W+X mapping %lu pages\n", npages);
245 /* Account the WX pages */
246 st->wx_pages += npages;
247 WARN_ONCE(__supported_pte_mask & _PAGE_NX,
248 "x86/mm: Found insecure W+X mapping at address %pS\n",
249 (void *)st->start_address);
252 static inline pgprotval_t effective_prot(pgprotval_t prot1, pgprotval_t prot2)
254 return (prot1 & prot2 & (_PAGE_USER | _PAGE_RW)) |
255 ((prot1 | prot2) & _PAGE_NX);
259 * This function gets called on a break in a continuous series
260 * of PTE entries; the next one is different so we need to
261 * print what we collected so far.
263 static void note_page(struct ptdump_state *pt_st, unsigned long addr, int level,
266 struct pg_state *st = container_of(pt_st, struct pg_state, ptdump);
267 pgprotval_t new_prot, new_eff;
268 pgprotval_t cur, eff;
269 static const char units[] = "BKMGTPE";
270 struct seq_file *m = st->seq;
272 new_prot = val & PTE_FLAGS_MASK;
275 new_eff = effective_prot(st->prot_levels[level - 2],
282 st->prot_levels[level - 1] = new_eff;
285 * If we have a "break" in the series, we need to flush the state that
286 * we have now. "break" is either changing perms, levels or
287 * address space marker.
289 cur = st->current_prot;
290 eff = st->effective_prot;
294 st->current_prot = new_prot;
295 st->effective_prot = new_eff;
297 st->marker = address_markers;
299 pt_dump_seq_printf(m, st->to_dmesg, "---[ %s ]---\n",
301 } else if (new_prot != cur || new_eff != eff || level != st->level ||
302 addr >= st->marker[1].start_address) {
303 const char *unit = units;
305 int width = sizeof(unsigned long) * 2;
307 if (st->check_wx && (eff & _PAGE_RW) && !(eff & _PAGE_NX))
311 * Now print the actual finished series
313 if (!st->marker->max_lines ||
314 st->lines < st->marker->max_lines) {
315 pt_dump_seq_printf(m, st->to_dmesg,
317 width, st->start_address,
320 delta = addr - st->start_address;
321 while (!(delta & 1023) && unit[1]) {
325 pt_dump_cont_printf(m, st->to_dmesg, "%9lu%c ",
327 printk_prot(m, st->current_prot, st->level,
333 * We print markers for special areas of address space,
334 * such as the start of vmalloc space etc.
335 * This helps in the interpretation.
337 if (addr >= st->marker[1].start_address) {
338 if (st->marker->max_lines &&
339 st->lines > st->marker->max_lines) {
340 unsigned long nskip =
341 st->lines - st->marker->max_lines;
342 pt_dump_seq_printf(m, st->to_dmesg,
343 "... %lu entr%s skipped ... \n",
345 nskip == 1 ? "y" : "ies");
349 pt_dump_seq_printf(m, st->to_dmesg, "---[ %s ]---\n",
353 st->start_address = addr;
354 st->current_prot = new_prot;
355 st->effective_prot = new_eff;
360 static void ptdump_walk_pgd_level_core(struct seq_file *m, pgd_t *pgd,
361 bool checkwx, bool dmesg)
363 const struct ptdump_range ptdump_ranges[] = {
366 #define normalize_addr_shift (64 - (__VIRTUAL_MASK_SHIFT + 1))
367 #define normalize_addr(u) ((signed long)((u) << normalize_addr_shift) >> \
368 normalize_addr_shift)
370 {0, PTRS_PER_PGD * PGD_LEVEL_MULT / 2},
371 {normalize_addr(PTRS_PER_PGD * PGD_LEVEL_MULT / 2), ~0UL},
378 struct pg_state st = {
380 .note_page = note_page,
381 .range = ptdump_ranges
388 struct mm_struct fake_mm = {
391 init_rwsem(&fake_mm.mmap_sem);
393 ptdump_walk_pgd(&st.ptdump, &fake_mm);
398 pr_info("x86/mm: Checked W+X mappings: FAILED, %lu W+X pages found.\n",
401 pr_info("x86/mm: Checked W+X mappings: passed, no W+X pages found.\n");
404 void ptdump_walk_pgd_level(struct seq_file *m, struct mm_struct *mm)
406 ptdump_walk_pgd_level_core(m, mm->pgd, false, true);
409 void ptdump_walk_pgd_level_debugfs(struct seq_file *m, struct mm_struct *mm,
412 pgd_t *pgd = mm->pgd;
413 #ifdef CONFIG_PAGE_TABLE_ISOLATION
414 if (user && boot_cpu_has(X86_FEATURE_PTI))
415 pgd = kernel_to_user_pgdp(pgd);
417 ptdump_walk_pgd_level_core(m, pgd, false, false);
419 EXPORT_SYMBOL_GPL(ptdump_walk_pgd_level_debugfs);
421 void ptdump_walk_user_pgd_level_checkwx(void)
423 #ifdef CONFIG_PAGE_TABLE_ISOLATION
424 pgd_t *pgd = INIT_PGD;
426 if (!(__supported_pte_mask & _PAGE_NX) ||
427 !boot_cpu_has(X86_FEATURE_PTI))
430 pr_info("x86/mm: Checking user space page tables\n");
431 pgd = kernel_to_user_pgdp(pgd);
432 ptdump_walk_pgd_level_core(NULL, pgd, true, false);
436 void ptdump_walk_pgd_level_checkwx(void)
438 ptdump_walk_pgd_level_core(NULL, INIT_PGD, true, false);
441 static int __init pt_dump_init(void)
444 * Various markers are not compile-time constants, so assign them
448 address_markers[LOW_KERNEL_NR].start_address = PAGE_OFFSET;
449 address_markers[VMALLOC_START_NR].start_address = VMALLOC_START;
450 address_markers[VMEMMAP_START_NR].start_address = VMEMMAP_START;
451 #ifdef CONFIG_MODIFY_LDT_SYSCALL
452 address_markers[LDT_NR].start_address = LDT_BASE_ADDR;
455 address_markers[KASAN_SHADOW_START_NR].start_address = KASAN_SHADOW_START;
456 address_markers[KASAN_SHADOW_END_NR].start_address = KASAN_SHADOW_END;
460 address_markers[VMALLOC_START_NR].start_address = VMALLOC_START;
461 address_markers[VMALLOC_END_NR].start_address = VMALLOC_END;
462 # ifdef CONFIG_HIGHMEM
463 address_markers[PKMAP_BASE_NR].start_address = PKMAP_BASE;
465 address_markers[FIXADDR_START_NR].start_address = FIXADDR_START;
466 address_markers[CPU_ENTRY_AREA_NR].start_address = CPU_ENTRY_AREA_BASE;
467 # ifdef CONFIG_MODIFY_LDT_SYSCALL
468 address_markers[LDT_NR].start_address = LDT_BASE_ADDR;
473 __initcall(pt_dump_init);