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 (!st->level) { 224 st->level = level; 225 st->current_prot = prot; 226 seq_printf(st->seq, "---[ %s ]---\n", st->marker->name); 227 } else if (prot != st->current_prot || level != st->level || 228 addr >= st->marker[1].start_address) { 229 const char *unit = units; 230 unsigned long delta; 231 232 if (st->current_prot) { 233 seq_printf(st->seq, "0x%08lx-0x%08lx ", 234 st->start_address, addr); 235 236 delta = (addr - st->start_address) >> 10; 237 while (!(delta & 1023) && unit[1]) { 238 delta >>= 10; 239 unit++; 240 } 241 seq_printf(st->seq, "%9lu%c", delta, *unit); 242 if (pg_level[st->level].bits) 243 dump_prot(st, pg_level[st->level].bits, pg_level[st->level].num); 244 seq_printf(st->seq, "\n"); 245 } 246 247 if (addr >= st->marker[1].start_address) { 248 st->marker++; 249 seq_printf(st->seq, "---[ %s ]---\n", st->marker->name); 250 } 251 st->start_address = addr; 252 st->current_prot = prot; 253 st->level = level; 254 } 255 } 256 257 static void walk_pte(struct pg_state *st, pmd_t *pmd, unsigned long start) 258 { 259 pte_t *pte = pte_offset_kernel(pmd, 0); 260 unsigned long addr; 261 unsigned i; 262 263 for (i = 0; i < PTRS_PER_PTE; i++, pte++) { 264 addr = start + i * PAGE_SIZE; 265 note_page(st, addr, 4, pte_val(*pte)); 266 } 267 } 268 269 static void walk_pmd(struct pg_state *st, pud_t *pud, unsigned long start) 270 { 271 pmd_t *pmd = pmd_offset(pud, 0); 272 unsigned long addr; 273 unsigned i; 274 275 for (i = 0; i < PTRS_PER_PMD; i++, pmd++) { 276 addr = start + i * PMD_SIZE; 277 if (pmd_none(*pmd) || pmd_large(*pmd) || !pmd_present(*pmd)) 278 note_page(st, addr, 3, pmd_val(*pmd)); 279 else 280 walk_pte(st, pmd, addr); 281 282 if (SECTION_SIZE < PMD_SIZE && pmd_large(pmd[1])) 283 note_page(st, addr + SECTION_SIZE, 3, pmd_val(pmd[1])); 284 } 285 } 286 287 static void walk_pud(struct pg_state *st, pgd_t *pgd, unsigned long start) 288 { 289 pud_t *pud = pud_offset(pgd, 0); 290 unsigned long addr; 291 unsigned i; 292 293 for (i = 0; i < PTRS_PER_PUD; i++, pud++) { 294 addr = start + i * PUD_SIZE; 295 if (!pud_none(*pud)) { 296 walk_pmd(st, pud, addr); 297 } else { 298 note_page(st, addr, 2, pud_val(*pud)); 299 } 300 } 301 } 302 303 static void walk_pgd(struct seq_file *m) 304 { 305 pgd_t *pgd = swapper_pg_dir; 306 struct pg_state st; 307 unsigned long addr; 308 unsigned i; 309 310 memset(&st, 0, sizeof(st)); 311 st.seq = m; 312 st.marker = address_markers; 313 314 for (i = 0; i < PTRS_PER_PGD; i++, pgd++) { 315 addr = i * PGDIR_SIZE; 316 if (!pgd_none(*pgd)) { 317 walk_pud(&st, pgd, addr); 318 } else { 319 note_page(&st, addr, 1, pgd_val(*pgd)); 320 } 321 } 322 323 note_page(&st, 0, 0, 0); 324 } 325 326 static int ptdump_show(struct seq_file *m, void *v) 327 { 328 walk_pgd(m); 329 return 0; 330 } 331 332 static int ptdump_open(struct inode *inode, struct file *file) 333 { 334 return single_open(file, ptdump_show, NULL); 335 } 336 337 static const struct file_operations ptdump_fops = { 338 .open = ptdump_open, 339 .read = seq_read, 340 .llseek = seq_lseek, 341 .release = single_release, 342 }; 343 344 static int ptdump_init(void) 345 { 346 struct dentry *pe; 347 unsigned i, j; 348 349 for (i = 0; i < ARRAY_SIZE(pg_level); i++) 350 if (pg_level[i].bits) 351 for (j = 0; j < pg_level[i].num; j++) 352 pg_level[i].mask |= pg_level[i].bits[j].mask; 353 354 address_markers[2].start_address = VMALLOC_START; 355 356 pe = debugfs_create_file("kernel_page_tables", 0400, NULL, NULL, 357 &ptdump_fops); 358 return pe ? 0 : -ENOMEM; 359 } 360 __initcall(ptdump_init); 361