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
 10static unsigned long max_addr;
 11
 12struct addr_marker {
 13	unsigned long start_address;
 14	const char *name;
 15};
 16
 17enum 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
 30static 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
 44struct 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
 52static 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
 66static 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
113static 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 */
132static 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
149static 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
180static 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
211static 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
235static 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
258static int ptdump_show(struct seq_file *m, void *v)
259{
260	walk_pgd_level(m);
261	return 0;
262}
263
264static int ptdump_open(struct inode *inode, struct file *filp)
265{
266	return single_open(filp, ptdump_show, NULL);
267}
268
269static const struct file_operations ptdump_fops = {
270	.open		= ptdump_open,
271	.read		= seq_read,
272	.llseek		= seq_lseek,
273	.release	= single_release,
274};
275
276static 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}
291device_initcall(pt_dump_init);