xref: /openbmc/linux/arch/arm/mm/dump.c (revision 275876e2)
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  * Derived from x86 implementation:
6  * (C) Copyright 2008 Intel Corporation
7  *
8  * Author: Arjan van de Ven <arjan@linux.intel.com>
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; version 2
13  * of the License.
14  */
15 #include <linux/debugfs.h>
16 #include <linux/fs.h>
17 #include <linux/mm.h>
18 #include <linux/seq_file.h>
19 
20 #include <asm/fixmap.h>
21 #include <asm/pgtable.h>
22 
23 struct addr_marker {
24 	unsigned long start_address;
25 	const char *name;
26 };
27 
28 static struct addr_marker address_markers[] = {
29 	{ MODULES_VADDR,	"Modules" },
30 	{ PAGE_OFFSET,		"Kernel Mapping" },
31 	{ 0,			"vmalloc() Area" },
32 	{ VMALLOC_END,		"vmalloc() End" },
33 	{ FIXADDR_START,	"Fixmap Area" },
34 	{ CONFIG_VECTORS_BASE,	"Vectors" },
35 	{ CONFIG_VECTORS_BASE + PAGE_SIZE * 2, "Vectors End" },
36 	{ -1,			NULL },
37 };
38 
39 struct pg_state {
40 	struct seq_file *seq;
41 	const struct addr_marker *marker;
42 	unsigned long start_address;
43 	unsigned level;
44 	u64 current_prot;
45 };
46 
47 struct prot_bits {
48 	u64		mask;
49 	u64		val;
50 	const char	*set;
51 	const char	*clear;
52 };
53 
54 static const struct prot_bits pte_bits[] = {
55 	{
56 		.mask	= L_PTE_USER,
57 		.val	= L_PTE_USER,
58 		.set	= "USR",
59 		.clear	= "   ",
60 	}, {
61 		.mask	= L_PTE_RDONLY,
62 		.val	= L_PTE_RDONLY,
63 		.set	= "ro",
64 		.clear	= "RW",
65 	}, {
66 		.mask	= L_PTE_XN,
67 		.val	= L_PTE_XN,
68 		.set	= "NX",
69 		.clear	= "x ",
70 	}, {
71 		.mask	= L_PTE_SHARED,
72 		.val	= L_PTE_SHARED,
73 		.set	= "SHD",
74 		.clear	= "   ",
75 	}, {
76 		.mask	= L_PTE_MT_MASK,
77 		.val	= L_PTE_MT_UNCACHED,
78 		.set	= "SO/UNCACHED",
79 	}, {
80 		.mask	= L_PTE_MT_MASK,
81 		.val	= L_PTE_MT_BUFFERABLE,
82 		.set	= "MEM/BUFFERABLE/WC",
83 	}, {
84 		.mask	= L_PTE_MT_MASK,
85 		.val	= L_PTE_MT_WRITETHROUGH,
86 		.set	= "MEM/CACHED/WT",
87 	}, {
88 		.mask	= L_PTE_MT_MASK,
89 		.val	= L_PTE_MT_WRITEBACK,
90 		.set	= "MEM/CACHED/WBRA",
91 #ifndef CONFIG_ARM_LPAE
92 	}, {
93 		.mask	= L_PTE_MT_MASK,
94 		.val	= L_PTE_MT_MINICACHE,
95 		.set	= "MEM/MINICACHE",
96 #endif
97 	}, {
98 		.mask	= L_PTE_MT_MASK,
99 		.val	= L_PTE_MT_WRITEALLOC,
100 		.set	= "MEM/CACHED/WBWA",
101 	}, {
102 		.mask	= L_PTE_MT_MASK,
103 		.val	= L_PTE_MT_DEV_SHARED,
104 		.set	= "DEV/SHARED",
105 #ifndef CONFIG_ARM_LPAE
106 	}, {
107 		.mask	= L_PTE_MT_MASK,
108 		.val	= L_PTE_MT_DEV_NONSHARED,
109 		.set	= "DEV/NONSHARED",
110 #endif
111 	}, {
112 		.mask	= L_PTE_MT_MASK,
113 		.val	= L_PTE_MT_DEV_WC,
114 		.set	= "DEV/WC",
115 	}, {
116 		.mask	= L_PTE_MT_MASK,
117 		.val	= L_PTE_MT_DEV_CACHED,
118 		.set	= "DEV/CACHED",
119 	},
120 };
121 
122 static const struct prot_bits section_bits[] = {
123 #ifdef CONFIG_ARM_LPAE
124 	{
125 		.mask	= PMD_SECT_USER,
126 		.val	= PMD_SECT_USER,
127 		.set	= "USR",
128 	}, {
129 		.mask	= L_PMD_SECT_RDONLY,
130 		.val	= L_PMD_SECT_RDONLY,
131 		.set	= "ro",
132 		.clear	= "RW",
133 #elif __LINUX_ARM_ARCH__ >= 6
134 	{
135 		.mask	= PMD_SECT_APX | PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
136 		.val	= PMD_SECT_APX | PMD_SECT_AP_WRITE,
137 		.set	= "    ro",
138 	}, {
139 		.mask	= PMD_SECT_APX | PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
140 		.val	= PMD_SECT_AP_WRITE,
141 		.set	= "    RW",
142 	}, {
143 		.mask	= PMD_SECT_APX | PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
144 		.val	= PMD_SECT_AP_READ,
145 		.set	= "USR ro",
146 	}, {
147 		.mask	= PMD_SECT_APX | PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
148 		.val	= PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
149 		.set	= "USR RW",
150 #else /* ARMv4/ARMv5  */
151 	/* These are approximate */
152 	{
153 		.mask   = PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
154 		.val    = 0,
155 		.set    = "    ro",
156 	}, {
157 		.mask   = PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
158 		.val    = PMD_SECT_AP_WRITE,
159 		.set    = "    RW",
160 	}, {
161 		.mask   = PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
162 		.val    = PMD_SECT_AP_READ,
163 		.set    = "USR ro",
164 	}, {
165 		.mask   = PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
166 		.val    = PMD_SECT_AP_READ | PMD_SECT_AP_WRITE,
167 		.set    = "USR RW",
168 #endif
169 	}, {
170 		.mask	= PMD_SECT_XN,
171 		.val	= PMD_SECT_XN,
172 		.set	= "NX",
173 		.clear	= "x ",
174 	}, {
175 		.mask	= PMD_SECT_S,
176 		.val	= PMD_SECT_S,
177 		.set	= "SHD",
178 		.clear	= "   ",
179 	},
180 };
181 
182 struct pg_level {
183 	const struct prot_bits *bits;
184 	size_t num;
185 	u64 mask;
186 };
187 
188 static struct pg_level pg_level[] = {
189 	{
190 	}, { /* pgd */
191 	}, { /* pud */
192 	}, { /* pmd */
193 		.bits	= section_bits,
194 		.num	= ARRAY_SIZE(section_bits),
195 	}, { /* pte */
196 		.bits	= pte_bits,
197 		.num	= ARRAY_SIZE(pte_bits),
198 	},
199 };
200 
201 static void dump_prot(struct pg_state *st, const struct prot_bits *bits, size_t num)
202 {
203 	unsigned i;
204 
205 	for (i = 0; i < num; i++, bits++) {
206 		const char *s;
207 
208 		if ((st->current_prot & bits->mask) == bits->val)
209 			s = bits->set;
210 		else
211 			s = bits->clear;
212 
213 		if (s)
214 			seq_printf(st->seq, " %s", s);
215 	}
216 }
217 
218 static void note_page(struct pg_state *st, unsigned long addr, unsigned level, u64 val)
219 {
220 	static const char units[] = "KMGTPE";
221 	u64 prot = val & pg_level[level].mask;
222 
223 	if (addr < USER_PGTABLES_CEILING)
224 		return;
225 
226 	if (!st->level) {
227 		st->level = level;
228 		st->current_prot = prot;
229 		seq_printf(st->seq, "---[ %s ]---\n", st->marker->name);
230 	} else if (prot != st->current_prot || level != st->level ||
231 		   addr >= st->marker[1].start_address) {
232 		const char *unit = units;
233 		unsigned long delta;
234 
235 		if (st->current_prot) {
236 			seq_printf(st->seq, "0x%08lx-0x%08lx   ",
237 				   st->start_address, addr);
238 
239 			delta = (addr - st->start_address) >> 10;
240 			while (!(delta & 1023) && unit[1]) {
241 				delta >>= 10;
242 				unit++;
243 			}
244 			seq_printf(st->seq, "%9lu%c", delta, *unit);
245 			if (pg_level[st->level].bits)
246 				dump_prot(st, pg_level[st->level].bits, pg_level[st->level].num);
247 			seq_printf(st->seq, "\n");
248 		}
249 
250 		if (addr >= st->marker[1].start_address) {
251 			st->marker++;
252 			seq_printf(st->seq, "---[ %s ]---\n", st->marker->name);
253 		}
254 		st->start_address = addr;
255 		st->current_prot = prot;
256 		st->level = level;
257 	}
258 }
259 
260 static void walk_pte(struct pg_state *st, pmd_t *pmd, unsigned long start)
261 {
262 	pte_t *pte = pte_offset_kernel(pmd, 0);
263 	unsigned long addr;
264 	unsigned i;
265 
266 	for (i = 0; i < PTRS_PER_PTE; i++, pte++) {
267 		addr = start + i * PAGE_SIZE;
268 		note_page(st, addr, 4, pte_val(*pte));
269 	}
270 }
271 
272 static void walk_pmd(struct pg_state *st, pud_t *pud, unsigned long start)
273 {
274 	pmd_t *pmd = pmd_offset(pud, 0);
275 	unsigned long addr;
276 	unsigned i;
277 
278 	for (i = 0; i < PTRS_PER_PMD; i++, pmd++) {
279 		addr = start + i * PMD_SIZE;
280 		if (pmd_none(*pmd) || pmd_large(*pmd) || !pmd_present(*pmd))
281 			note_page(st, addr, 3, pmd_val(*pmd));
282 		else
283 			walk_pte(st, pmd, addr);
284 
285 		if (SECTION_SIZE < PMD_SIZE && pmd_large(pmd[1]))
286 			note_page(st, addr + SECTION_SIZE, 3, pmd_val(pmd[1]));
287 	}
288 }
289 
290 static void walk_pud(struct pg_state *st, pgd_t *pgd, unsigned long start)
291 {
292 	pud_t *pud = pud_offset(pgd, 0);
293 	unsigned long addr;
294 	unsigned i;
295 
296 	for (i = 0; i < PTRS_PER_PUD; i++, pud++) {
297 		addr = start + i * PUD_SIZE;
298 		if (!pud_none(*pud)) {
299 			walk_pmd(st, pud, addr);
300 		} else {
301 			note_page(st, addr, 2, pud_val(*pud));
302 		}
303 	}
304 }
305 
306 static void walk_pgd(struct seq_file *m)
307 {
308 	pgd_t *pgd = swapper_pg_dir;
309 	struct pg_state st;
310 	unsigned long addr;
311 	unsigned i, pgdoff = USER_PGTABLES_CEILING / PGDIR_SIZE;
312 
313 	memset(&st, 0, sizeof(st));
314 	st.seq = m;
315 	st.marker = address_markers;
316 
317 	pgd += pgdoff;
318 
319 	for (i = pgdoff; i < PTRS_PER_PGD; i++, pgd++) {
320 		addr = i * PGDIR_SIZE;
321 		if (!pgd_none(*pgd)) {
322 			walk_pud(&st, pgd, addr);
323 		} else {
324 			note_page(&st, addr, 1, pgd_val(*pgd));
325 		}
326 	}
327 
328 	note_page(&st, 0, 0, 0);
329 }
330 
331 static int ptdump_show(struct seq_file *m, void *v)
332 {
333 	walk_pgd(m);
334 	return 0;
335 }
336 
337 static int ptdump_open(struct inode *inode, struct file *file)
338 {
339 	return single_open(file, ptdump_show, NULL);
340 }
341 
342 static const struct file_operations ptdump_fops = {
343 	.open		= ptdump_open,
344 	.read		= seq_read,
345 	.llseek		= seq_lseek,
346 	.release	= single_release,
347 };
348 
349 static int ptdump_init(void)
350 {
351 	struct dentry *pe;
352 	unsigned i, j;
353 
354 	for (i = 0; i < ARRAY_SIZE(pg_level); i++)
355 		if (pg_level[i].bits)
356 			for (j = 0; j < pg_level[i].num; j++)
357 				pg_level[i].mask |= pg_level[i].bits[j].mask;
358 
359 	address_markers[2].start_address = VMALLOC_START;
360 
361 	pe = debugfs_create_file("kernel_page_tables", 0400, NULL, NULL,
362 				 &ptdump_fops);
363 	return pe ? 0 : -ENOMEM;
364 }
365 __initcall(ptdump_init);
366