1 #include <linux/seq_file.h>
2 #include <linux/debugfs.h>
3 #include <linux/module.h>
4 #include <linux/mm.h>
5 #include <asm/sections.h>
6 #include <asm/pgtable.h>
7
8 static unsigned long max_addr;
9
10 struct addr_marker {
11 unsigned long start_address;
12 const char *name;
13 };
14
15 enum address_markers_idx {
16 IDENTITY_NR = 0,
17 KERNEL_START_NR,
18 KERNEL_END_NR,
19 VMEMMAP_NR,
20 VMALLOC_NR,
21 #ifdef CONFIG_64BIT
22 MODULES_NR,
23 #endif
24 };
25
26 static struct addr_marker address_markers[] = {
27 [IDENTITY_NR] = {0, "Identity Mapping"},
28 [KERNEL_START_NR] = {(unsigned long)&_stext, "Kernel Image Start"},
29 [KERNEL_END_NR] = {(unsigned long)&_end, "Kernel Image End"},
30 [VMEMMAP_NR] = {0, "vmemmap Area"},
31 [VMALLOC_NR] = {0, "vmalloc Area"},
32 #ifdef CONFIG_64BIT
33 [MODULES_NR] = {0, "Modules Area"},
34 #endif
35 { -1, NULL }
36 };
37
38 struct pg_state {
39 int level;
40 unsigned int current_prot;
41 unsigned long start_address;
42 unsigned long current_address;
43 const struct addr_marker *marker;
44 };
45
print_prot(struct seq_file * m,unsigned int pr,int level)46 static void print_prot(struct seq_file *m, unsigned int pr, int level)
47 {
48 static const char * const level_name[] =
49 { "ASCE", "PGD", "PUD", "PMD", "PTE" };
50
51 seq_printf(m, "%s ", level_name[level]);
52 if (pr & _PAGE_INVALID) {
53 seq_printf(m, "I\n");
54 return;
55 }
56 seq_printf(m, "%s", pr & _PAGE_PROTECT ? "RO " : "RW ");
57 seq_putc(m, '\n');
58 }
59
note_page(struct seq_file * m,struct pg_state * st,unsigned int new_prot,int level)60 static void note_page(struct seq_file *m, struct pg_state *st,
61 unsigned int new_prot, int level)
62 {
63 static const char units[] = "KMGTPE";
64 int width = sizeof(unsigned long) * 2;
65 const char *unit = units;
66 unsigned int prot, cur;
67 unsigned long delta;
68
69 /*
70 * If we have a "break" in the series, we need to flush the state
71 * that we have now. "break" is either changing perms, levels or
72 * address space marker.
73 */
74 prot = new_prot;
75 cur = st->current_prot;
76
77 if (!st->level) {
78 /* First entry */
79 st->current_prot = new_prot;
80 st->level = level;
81 st->marker = address_markers;
82 seq_printf(m, "---[ %s ]---\n", st->marker->name);
83 } else if (prot != cur || level != st->level ||
84 st->current_address >= st->marker[1].start_address) {
85 /* Print the actual finished series */
86 seq_printf(m, "0x%0*lx-0x%0*lx",
87 width, st->start_address,
88 width, st->current_address);
89 delta = (st->current_address - st->start_address) >> 10;
90 while (!(delta & 0x3ff) && unit[1]) {
91 delta >>= 10;
92 unit++;
93 }
94 seq_printf(m, "%9lu%c ", delta, *unit);
95 print_prot(m, st->current_prot, st->level);
96 if (st->current_address >= st->marker[1].start_address) {
97 st->marker++;
98 seq_printf(m, "---[ %s ]---\n", st->marker->name);
99 }
100 st->start_address = st->current_address;
101 st->current_prot = new_prot;
102 st->level = level;
103 }
104 }
105
106 /*
107 * The actual page table walker functions. In order to keep the
108 * implementation of print_prot() short, we only check and pass
109 * _PAGE_INVALID and _PAGE_PROTECT flags to note_page() if a region,
110 * segment or page table entry is invalid or read-only.
111 * After all it's just a hint that the current level being walked
112 * contains an invalid or read-only entry.
113 */
walk_pte_level(struct seq_file * m,struct pg_state * st,pmd_t * pmd,unsigned long addr)114 static void walk_pte_level(struct seq_file *m, struct pg_state *st,
115 pmd_t *pmd, unsigned long addr)
116 {
117 unsigned int prot;
118 pte_t *pte;
119 int i;
120
121 for (i = 0; i < PTRS_PER_PTE && addr < max_addr; i++) {
122 st->current_address = addr;
123 pte = pte_offset_kernel(pmd, addr);
124 prot = pte_val(*pte) & (_PAGE_PROTECT | _PAGE_INVALID);
125 note_page(m, st, prot, 4);
126 addr += PAGE_SIZE;
127 }
128 }
129
130 #ifdef CONFIG_64BIT
131 #define _PMD_PROT_MASK _SEGMENT_ENTRY_PROTECT
132 #else
133 #define _PMD_PROT_MASK 0
134 #endif
135
walk_pmd_level(struct seq_file * m,struct pg_state * st,pud_t * pud,unsigned long addr)136 static void walk_pmd_level(struct seq_file *m, struct pg_state *st,
137 pud_t *pud, unsigned long addr)
138 {
139 unsigned int prot;
140 pmd_t *pmd;
141 int i;
142
143 for (i = 0; i < PTRS_PER_PMD && addr < max_addr; i++) {
144 st->current_address = addr;
145 pmd = pmd_offset(pud, addr);
146 if (!pmd_none(*pmd)) {
147 if (pmd_large(*pmd)) {
148 prot = pmd_val(*pmd) & _PMD_PROT_MASK;
149 note_page(m, st, prot, 3);
150 } else
151 walk_pte_level(m, st, pmd, addr);
152 } else
153 note_page(m, st, _PAGE_INVALID, 3);
154 addr += PMD_SIZE;
155 }
156 }
157
158 #ifdef CONFIG_64BIT
159 #define _PUD_PROT_MASK _REGION3_ENTRY_RO
160 #else
161 #define _PUD_PROT_MASK 0
162 #endif
163
walk_pud_level(struct seq_file * m,struct pg_state * st,pgd_t * pgd,unsigned long addr)164 static void walk_pud_level(struct seq_file *m, struct pg_state *st,
165 pgd_t *pgd, unsigned long addr)
166 {
167 unsigned int prot;
168 pud_t *pud;
169 int i;
170
171 for (i = 0; i < PTRS_PER_PUD && addr < max_addr; i++) {
172 st->current_address = addr;
173 pud = pud_offset(pgd, addr);
174 if (!pud_none(*pud))
175 if (pud_large(*pud)) {
176 prot = pud_val(*pud) & _PUD_PROT_MASK;
177 note_page(m, st, prot, 2);
178 } else
179 walk_pmd_level(m, st, pud, addr);
180 else
181 note_page(m, st, _PAGE_INVALID, 2);
182 addr += PUD_SIZE;
183 }
184 }
185
walk_pgd_level(struct seq_file * m)186 static void walk_pgd_level(struct seq_file *m)
187 {
188 unsigned long addr = 0;
189 struct pg_state st;
190 pgd_t *pgd;
191 int i;
192
193 memset(&st, 0, sizeof(st));
194 for (i = 0; i < PTRS_PER_PGD && addr < max_addr; i++) {
195 st.current_address = addr;
196 pgd = pgd_offset_k(addr);
197 if (!pgd_none(*pgd))
198 walk_pud_level(m, &st, pgd, addr);
199 else
200 note_page(m, &st, _PAGE_INVALID, 1);
201 addr += PGDIR_SIZE;
202 }
203 /* Flush out the last page */
204 st.current_address = max_addr;
205 note_page(m, &st, 0, 0);
206 }
207
ptdump_show(struct seq_file * m,void * v)208 static int ptdump_show(struct seq_file *m, void *v)
209 {
210 walk_pgd_level(m);
211 return 0;
212 }
213
ptdump_open(struct inode * inode,struct file * filp)214 static int ptdump_open(struct inode *inode, struct file *filp)
215 {
216 return single_open(filp, ptdump_show, NULL);
217 }
218
219 static const struct file_operations ptdump_fops = {
220 .open = ptdump_open,
221 .read = seq_read,
222 .llseek = seq_lseek,
223 .release = single_release,
224 };
225
pt_dump_init(void)226 static int pt_dump_init(void)
227 {
228 /*
229 * Figure out the maximum virtual address being accessible with the
230 * kernel ASCE. We need this to keep the page table walker functions
231 * from accessing non-existent entries.
232 */
233 #ifdef CONFIG_32BIT
234 max_addr = 1UL << 31;
235 #else
236 max_addr = (S390_lowcore.kernel_asce & _REGION_ENTRY_TYPE_MASK) >> 2;
237 max_addr = 1UL << (max_addr * 11 + 31);
238 address_markers[MODULES_NR].start_address = MODULES_VADDR;
239 #endif
240 address_markers[VMEMMAP_NR].start_address = (unsigned long) vmemmap;
241 address_markers[VMALLOC_NR].start_address = VMALLOC_START;
242 debugfs_create_file("kernel_page_tables", 0400, NULL, NULL, &ptdump_fops);
243 return 0;
244 }
245 device_initcall(pt_dump_init);
246