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