1 /*
2 * Debug helper to dump the current kernel pagetables of the system
3 * so that we can see what the various memory ranges are set to.
4 *
5 * (C) Copyright 2008 Intel Corporation
6 *
7 * Author: Arjan van de Ven <arjan@linux.intel.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; version 2
12 * of the License.
13 */
14
15 #include <linux/debugfs.h>
16 #include <linux/mm.h>
17 #include <linux/module.h>
18 #include <linux/seq_file.h>
19
20 #include <asm/pgtable.h>
21
22 /*
23 * The dumper groups pagetable entries of the same type into one, and for
24 * that it needs to keep some state when walking, and flush this state
25 * when a "break" in the continuity is found.
26 */
27 struct pg_state {
28 int level;
29 pgprot_t current_prot;
30 unsigned long start_address;
31 unsigned long current_address;
32 const struct addr_marker *marker;
33 };
34
35 struct addr_marker {
36 unsigned long start_address;
37 const char *name;
38 };
39
40 /* Address space markers hints */
41 static struct addr_marker address_markers[] = {
42 { 0, "User Space" },
43 #ifdef CONFIG_X86_64
44 { 0x8000000000000000UL, "Kernel Space" },
45 { PAGE_OFFSET, "Low Kernel Mapping" },
46 { VMALLOC_START, "vmalloc() Area" },
47 { VMEMMAP_START, "Vmemmap" },
48 { __START_KERNEL_map, "High Kernel Mapping" },
49 { MODULES_VADDR, "Modules" },
50 { MODULES_END, "End Modules" },
51 #else
52 { PAGE_OFFSET, "Kernel Mapping" },
53 { 0/* VMALLOC_START */, "vmalloc() Area" },
54 { 0/*VMALLOC_END*/, "vmalloc() End" },
55 # ifdef CONFIG_HIGHMEM
56 { 0/*PKMAP_BASE*/, "Persisent kmap() Area" },
57 # endif
58 { 0/*FIXADDR_START*/, "Fixmap Area" },
59 #endif
60 { -1, NULL } /* End of list */
61 };
62
63 /* Multipliers for offsets within the PTEs */
64 #define PTE_LEVEL_MULT (PAGE_SIZE)
65 #define PMD_LEVEL_MULT (PTRS_PER_PTE * PTE_LEVEL_MULT)
66 #define PUD_LEVEL_MULT (PTRS_PER_PMD * PMD_LEVEL_MULT)
67 #define PGD_LEVEL_MULT (PTRS_PER_PUD * PUD_LEVEL_MULT)
68
69 /*
70 * Print a readable form of a pgprot_t to the seq_file
71 */
printk_prot(struct seq_file * m,pgprot_t prot,int level)72 static void printk_prot(struct seq_file *m, pgprot_t prot, int level)
73 {
74 pgprotval_t pr = pgprot_val(prot);
75 static const char * const level_name[] =
76 { "cr3", "pgd", "pud", "pmd", "pte" };
77
78 if (!pgprot_val(prot)) {
79 /* Not present */
80 seq_printf(m, " ");
81 } else {
82 if (pr & _PAGE_USER)
83 seq_printf(m, "USR ");
84 else
85 seq_printf(m, " ");
86 if (pr & _PAGE_RW)
87 seq_printf(m, "RW ");
88 else
89 seq_printf(m, "ro ");
90 if (pr & _PAGE_PWT)
91 seq_printf(m, "PWT ");
92 else
93 seq_printf(m, " ");
94 if (pr & _PAGE_PCD)
95 seq_printf(m, "PCD ");
96 else
97 seq_printf(m, " ");
98
99 /* Bit 9 has a different meaning on level 3 vs 4 */
100 if (level <= 3) {
101 if (pr & _PAGE_PSE)
102 seq_printf(m, "PSE ");
103 else
104 seq_printf(m, " ");
105 } else {
106 if (pr & _PAGE_PAT)
107 seq_printf(m, "pat ");
108 else
109 seq_printf(m, " ");
110 }
111 if (pr & _PAGE_GLOBAL)
112 seq_printf(m, "GLB ");
113 else
114 seq_printf(m, " ");
115 if (pr & _PAGE_NX)
116 seq_printf(m, "NX ");
117 else
118 seq_printf(m, "x ");
119 }
120 seq_printf(m, "%s\n", level_name[level]);
121 }
122
123 /*
124 * On 64 bits, sign-extend the 48 bit address to 64 bit
125 */
normalize_addr(unsigned long u)126 static unsigned long normalize_addr(unsigned long u)
127 {
128 #ifdef CONFIG_X86_64
129 return (signed long)(u << 16) >> 16;
130 #else
131 return u;
132 #endif
133 }
134
135 /*
136 * This function gets called on a break in a continuous series
137 * of PTE entries; the next one is different so we need to
138 * print what we collected so far.
139 */
note_page(struct seq_file * m,struct pg_state * st,pgprot_t new_prot,int level)140 static void note_page(struct seq_file *m, struct pg_state *st,
141 pgprot_t new_prot, int level)
142 {
143 pgprotval_t prot, cur;
144 static const char units[] = "KMGTPE";
145
146 /*
147 * If we have a "break" in the series, we need to flush the state that
148 * we have now. "break" is either changing perms, levels or
149 * address space marker.
150 */
151 prot = pgprot_val(new_prot) & PTE_FLAGS_MASK;
152 cur = pgprot_val(st->current_prot) & PTE_FLAGS_MASK;
153
154 if (!st->level) {
155 /* First entry */
156 st->current_prot = new_prot;
157 st->level = level;
158 st->marker = address_markers;
159 seq_printf(m, "---[ %s ]---\n", st->marker->name);
160 } else if (prot != cur || level != st->level ||
161 st->current_address >= st->marker[1].start_address) {
162 const char *unit = units;
163 unsigned long delta;
164
165 /*
166 * Now print the actual finished series
167 */
168 seq_printf(m, "0x%p-0x%p ",
169 (void *)st->start_address,
170 (void *)st->current_address);
171
172 delta = (st->current_address - st->start_address) >> 10;
173 while (!(delta & 1023) && unit[1]) {
174 delta >>= 10;
175 unit++;
176 }
177 seq_printf(m, "%9lu%c ", delta, *unit);
178 printk_prot(m, st->current_prot, st->level);
179
180 /*
181 * We print markers for special areas of address space,
182 * such as the start of vmalloc space etc.
183 * This helps in the interpretation.
184 */
185 if (st->current_address >= st->marker[1].start_address) {
186 st->marker++;
187 seq_printf(m, "---[ %s ]---\n", st->marker->name);
188 }
189
190 st->start_address = st->current_address;
191 st->current_prot = new_prot;
192 st->level = level;
193 }
194 }
195
walk_pte_level(struct seq_file * m,struct pg_state * st,pmd_t addr,unsigned long P)196 static void walk_pte_level(struct seq_file *m, struct pg_state *st, pmd_t addr,
197 unsigned long P)
198 {
199 int i;
200 pte_t *start;
201
202 start = (pte_t *) pmd_page_vaddr(addr);
203 for (i = 0; i < PTRS_PER_PTE; i++) {
204 pgprot_t prot = pte_pgprot(*start);
205
206 st->current_address = normalize_addr(P + i * PTE_LEVEL_MULT);
207 note_page(m, st, prot, 4);
208 start++;
209 }
210 }
211
212 #if PTRS_PER_PMD > 1
213
walk_pmd_level(struct seq_file * m,struct pg_state * st,pud_t addr,unsigned long P)214 static void walk_pmd_level(struct seq_file *m, struct pg_state *st, pud_t addr,
215 unsigned long P)
216 {
217 int i;
218 pmd_t *start;
219
220 start = (pmd_t *) pud_page_vaddr(addr);
221 for (i = 0; i < PTRS_PER_PMD; i++) {
222 st->current_address = normalize_addr(P + i * PMD_LEVEL_MULT);
223 if (!pmd_none(*start)) {
224 pgprotval_t prot = pmd_val(*start) & PTE_FLAGS_MASK;
225
226 if (pmd_large(*start) || !pmd_present(*start))
227 note_page(m, st, __pgprot(prot), 3);
228 else
229 walk_pte_level(m, st, *start,
230 P + i * PMD_LEVEL_MULT);
231 } else
232 note_page(m, st, __pgprot(0), 3);
233 start++;
234 }
235 }
236
237 #else
238 #define walk_pmd_level(m,s,a,p) walk_pte_level(m,s,__pmd(pud_val(a)),p)
239 #define pud_large(a) pmd_large(__pmd(pud_val(a)))
240 #define pud_none(a) pmd_none(__pmd(pud_val(a)))
241 #endif
242
243 #if PTRS_PER_PUD > 1
244
walk_pud_level(struct seq_file * m,struct pg_state * st,pgd_t addr,unsigned long P)245 static void walk_pud_level(struct seq_file *m, struct pg_state *st, pgd_t addr,
246 unsigned long P)
247 {
248 int i;
249 pud_t *start;
250
251 start = (pud_t *) pgd_page_vaddr(addr);
252
253 for (i = 0; i < PTRS_PER_PUD; i++) {
254 st->current_address = normalize_addr(P + i * PUD_LEVEL_MULT);
255 if (!pud_none(*start)) {
256 pgprotval_t prot = pud_val(*start) & PTE_FLAGS_MASK;
257
258 if (pud_large(*start) || !pud_present(*start))
259 note_page(m, st, __pgprot(prot), 2);
260 else
261 walk_pmd_level(m, st, *start,
262 P + i * PUD_LEVEL_MULT);
263 } else
264 note_page(m, st, __pgprot(0), 2);
265
266 start++;
267 }
268 }
269
270 #else
271 #define walk_pud_level(m,s,a,p) walk_pmd_level(m,s,__pud(pgd_val(a)),p)
272 #define pgd_large(a) pud_large(__pud(pgd_val(a)))
273 #define pgd_none(a) pud_none(__pud(pgd_val(a)))
274 #endif
275
walk_pgd_level(struct seq_file * m)276 static void walk_pgd_level(struct seq_file *m)
277 {
278 #ifdef CONFIG_X86_64
279 pgd_t *start = (pgd_t *) &init_level4_pgt;
280 #else
281 pgd_t *start = swapper_pg_dir;
282 #endif
283 int i;
284 struct pg_state st;
285
286 memset(&st, 0, sizeof(st));
287
288 for (i = 0; i < PTRS_PER_PGD; i++) {
289 st.current_address = normalize_addr(i * PGD_LEVEL_MULT);
290 if (!pgd_none(*start)) {
291 pgprotval_t prot = pgd_val(*start) & PTE_FLAGS_MASK;
292
293 if (pgd_large(*start) || !pgd_present(*start))
294 note_page(m, &st, __pgprot(prot), 1);
295 else
296 walk_pud_level(m, &st, *start,
297 i * PGD_LEVEL_MULT);
298 } else
299 note_page(m, &st, __pgprot(0), 1);
300
301 start++;
302 }
303
304 /* Flush out the last page */
305 st.current_address = normalize_addr(PTRS_PER_PGD*PGD_LEVEL_MULT);
306 note_page(m, &st, __pgprot(0), 0);
307 }
308
ptdump_show(struct seq_file * m,void * v)309 static int ptdump_show(struct seq_file *m, void *v)
310 {
311 walk_pgd_level(m);
312 return 0;
313 }
314
ptdump_open(struct inode * inode,struct file * filp)315 static int ptdump_open(struct inode *inode, struct file *filp)
316 {
317 return single_open(filp, ptdump_show, NULL);
318 }
319
320 static const struct file_operations ptdump_fops = {
321 .open = ptdump_open,
322 .read = seq_read,
323 .llseek = seq_lseek,
324 .release = single_release,
325 };
326
pt_dump_init(void)327 static int pt_dump_init(void)
328 {
329 struct dentry *pe;
330
331 #ifdef CONFIG_X86_32
332 /* Not a compile-time constant on x86-32 */
333 address_markers[2].start_address = VMALLOC_START;
334 address_markers[3].start_address = VMALLOC_END;
335 # ifdef CONFIG_HIGHMEM
336 address_markers[4].start_address = PKMAP_BASE;
337 address_markers[5].start_address = FIXADDR_START;
338 # else
339 address_markers[4].start_address = FIXADDR_START;
340 # endif
341 #endif
342
343 pe = debugfs_create_file("kernel_page_tables", 0600, NULL, NULL,
344 &ptdump_fops);
345 if (!pe)
346 return -ENOMEM;
347
348 return 0;
349 }
350
351 __initcall(pt_dump_init);
352 MODULE_LICENSE("GPL");
353 MODULE_AUTHOR("Arjan van de Ven <arjan@linux.intel.com>");
354 MODULE_DESCRIPTION("Kernel debugging helper that dumps pagetables");
355