~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/mm/dump_pagetables.c

Version: ~ [ linux-5.8-rc5 ] ~ [ linux-5.7.8 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.51 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.132 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.188 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.230 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.230 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  * (C) Copyright 2008 Intel Corporation
  6  *
  7  * Author: Arjan van de Ven <arjan@linux.intel.com>
  8  *
  9  * This program is free software; you can redistribute it and/or
 10  * modify it under the terms of the GNU General Public License
 11  * as published by the Free Software Foundation; version 2
 12  * of the License.
 13  */
 14 
 15 #include <linux/debugfs.h>
 16 #include <linux/mm.h>
 17 #include <linux/module.h>
 18 #include <linux/seq_file.h>
 19 
 20 #include <asm/pgtable.h>
 21 
 22 /*
 23  * The dumper groups pagetable entries of the same type into one, and for
 24  * that it needs to keep some state when walking, and flush this state
 25  * when a "break" in the continuity is found.
 26  */
 27 struct pg_state {
 28         int level;
 29         pgprot_t current_prot;
 30         unsigned long start_address;
 31         unsigned long current_address;
 32         const struct addr_marker *marker;
 33         unsigned long lines;
 34         bool to_dmesg;
 35 };
 36 
 37 struct addr_marker {
 38         unsigned long start_address;
 39         const char *name;
 40         unsigned long max_lines;
 41 };
 42 
 43 /* indices for address_markers; keep sync'd w/ address_markers below */
 44 enum address_markers_idx {
 45         USER_SPACE_NR = 0,
 46 #ifdef CONFIG_X86_64
 47         KERNEL_SPACE_NR,
 48         LOW_KERNEL_NR,
 49         VMALLOC_START_NR,
 50         VMEMMAP_START_NR,
 51 # ifdef CONFIG_X86_ESPFIX64
 52         ESPFIX_START_NR,
 53 # endif
 54         HIGH_KERNEL_NR,
 55         MODULES_VADDR_NR,
 56         MODULES_END_NR,
 57 #else
 58         KERNEL_SPACE_NR,
 59         VMALLOC_START_NR,
 60         VMALLOC_END_NR,
 61 # ifdef CONFIG_HIGHMEM
 62         PKMAP_BASE_NR,
 63 # endif
 64         FIXADDR_START_NR,
 65 #endif
 66 };
 67 
 68 /* Address space markers hints */
 69 static struct addr_marker address_markers[] = {
 70         { 0, "User Space" },
 71 #ifdef CONFIG_X86_64
 72         { 0x8000000000000000UL, "Kernel Space" },
 73         { PAGE_OFFSET,          "Low Kernel Mapping" },
 74         { VMALLOC_START,        "vmalloc() Area" },
 75         { VMEMMAP_START,        "Vmemmap" },
 76 # ifdef CONFIG_X86_ESPFIX64
 77         { ESPFIX_BASE_ADDR,     "ESPfix Area", 16 },
 78 # endif
 79 # ifdef CONFIG_EFI
 80         { EFI_VA_END,           "EFI Runtime Services" },
 81 # endif
 82         { __START_KERNEL_map,   "High Kernel Mapping" },
 83         { MODULES_VADDR,        "Modules" },
 84         { MODULES_END,          "End Modules" },
 85 #else
 86         { PAGE_OFFSET,          "Kernel Mapping" },
 87         { 0/* VMALLOC_START */, "vmalloc() Area" },
 88         { 0/*VMALLOC_END*/,     "vmalloc() End" },
 89 # ifdef CONFIG_HIGHMEM
 90         { 0/*PKMAP_BASE*/,      "Persisent kmap() Area" },
 91 # endif
 92         { 0/*FIXADDR_START*/,   "Fixmap Area" },
 93 #endif
 94         { -1, NULL }            /* End of list */
 95 };
 96 
 97 /* Multipliers for offsets within the PTEs */
 98 #define PTE_LEVEL_MULT (PAGE_SIZE)
 99 #define PMD_LEVEL_MULT (PTRS_PER_PTE * PTE_LEVEL_MULT)
100 #define PUD_LEVEL_MULT (PTRS_PER_PMD * PMD_LEVEL_MULT)
101 #define PGD_LEVEL_MULT (PTRS_PER_PUD * PUD_LEVEL_MULT)
102 
103 #define pt_dump_seq_printf(m, to_dmesg, fmt, args...)           \
104 ({                                                              \
105         if (to_dmesg)                                   \
106                 printk(KERN_INFO fmt, ##args);                  \
107         else                                                    \
108                 if (m)                                          \
109                         seq_printf(m, fmt, ##args);             \
110 })
111 
112 #define pt_dump_cont_printf(m, to_dmesg, fmt, args...)          \
113 ({                                                              \
114         if (to_dmesg)                                   \
115                 printk(KERN_CONT fmt, ##args);                  \
116         else                                                    \
117                 if (m)                                          \
118                         seq_printf(m, fmt, ##args);             \
119 })
120 
121 /*
122  * Print a readable form of a pgprot_t to the seq_file
123  */
124 static void printk_prot(struct seq_file *m, pgprot_t prot, int level, bool dmsg)
125 {
126         pgprotval_t pr = pgprot_val(prot);
127         static const char * const level_name[] =
128                 { "cr3", "pgd", "pud", "pmd", "pte" };
129 
130         if (!pgprot_val(prot)) {
131                 /* Not present */
132                 pt_dump_cont_printf(m, dmsg, "                              ");
133         } else {
134                 if (pr & _PAGE_USER)
135                         pt_dump_cont_printf(m, dmsg, "USR ");
136                 else
137                         pt_dump_cont_printf(m, dmsg, "    ");
138                 if (pr & _PAGE_RW)
139                         pt_dump_cont_printf(m, dmsg, "RW ");
140                 else
141                         pt_dump_cont_printf(m, dmsg, "ro ");
142                 if (pr & _PAGE_PWT)
143                         pt_dump_cont_printf(m, dmsg, "PWT ");
144                 else
145                         pt_dump_cont_printf(m, dmsg, "    ");
146                 if (pr & _PAGE_PCD)
147                         pt_dump_cont_printf(m, dmsg, "PCD ");
148                 else
149                         pt_dump_cont_printf(m, dmsg, "    ");
150 
151                 /* Bit 7 has a different meaning on level 3 vs 4 */
152                 if (level <= 3 && pr & _PAGE_PSE)
153                         pt_dump_cont_printf(m, dmsg, "PSE ");
154                 else
155                         pt_dump_cont_printf(m, dmsg, "    ");
156                 if ((level == 4 && pr & _PAGE_PAT) ||
157                     ((level == 3 || level == 2) && pr & _PAGE_PAT_LARGE))
158                         pt_dump_cont_printf(m, dmsg, "pat ");
159                 else
160                         pt_dump_cont_printf(m, dmsg, "    ");
161                 if (pr & _PAGE_GLOBAL)
162                         pt_dump_cont_printf(m, dmsg, "GLB ");
163                 else
164                         pt_dump_cont_printf(m, dmsg, "    ");
165                 if (pr & _PAGE_NX)
166                         pt_dump_cont_printf(m, dmsg, "NX ");
167                 else
168                         pt_dump_cont_printf(m, dmsg, "x  ");
169         }
170         pt_dump_cont_printf(m, dmsg, "%s\n", level_name[level]);
171 }
172 
173 /*
174  * On 64 bits, sign-extend the 48 bit address to 64 bit
175  */
176 static unsigned long normalize_addr(unsigned long u)
177 {
178 #ifdef CONFIG_X86_64
179         return (signed long)(u << 16) >> 16;
180 #else
181         return u;
182 #endif
183 }
184 
185 /*
186  * This function gets called on a break in a continuous series
187  * of PTE entries; the next one is different so we need to
188  * print what we collected so far.
189  */
190 static void note_page(struct seq_file *m, struct pg_state *st,
191                       pgprot_t new_prot, int level)
192 {
193         pgprotval_t prot, cur;
194         static const char units[] = "BKMGTPE";
195 
196         /*
197          * If we have a "break" in the series, we need to flush the state that
198          * we have now. "break" is either changing perms, levels or
199          * address space marker.
200          */
201         prot = pgprot_val(new_prot) & PTE_FLAGS_MASK;
202         cur = pgprot_val(st->current_prot) & PTE_FLAGS_MASK;
203 
204         if (!st->level) {
205                 /* First entry */
206                 st->current_prot = new_prot;
207                 st->level = level;
208                 st->marker = address_markers;
209                 st->lines = 0;
210                 pt_dump_seq_printf(m, st->to_dmesg, "---[ %s ]---\n",
211                                    st->marker->name);
212         } else if (prot != cur || level != st->level ||
213                    st->current_address >= st->marker[1].start_address) {
214                 const char *unit = units;
215                 unsigned long delta;
216                 int width = sizeof(unsigned long) * 2;
217 
218                 /*
219                  * Now print the actual finished series
220                  */
221                 if (!st->marker->max_lines ||
222                     st->lines < st->marker->max_lines) {
223                         pt_dump_seq_printf(m, st->to_dmesg,
224                                            "0x%0*lx-0x%0*lx   ",
225                                            width, st->start_address,
226                                            width, st->current_address);
227 
228                         delta = st->current_address - st->start_address;
229                         while (!(delta & 1023) && unit[1]) {
230                                 delta >>= 10;
231                                 unit++;
232                         }
233                         pt_dump_cont_printf(m, st->to_dmesg, "%9lu%c ",
234                                             delta, *unit);
235                         printk_prot(m, st->current_prot, st->level,
236                                     st->to_dmesg);
237                 }
238                 st->lines++;
239 
240                 /*
241                  * We print markers for special areas of address space,
242                  * such as the start of vmalloc space etc.
243                  * This helps in the interpretation.
244                  */
245                 if (st->current_address >= st->marker[1].start_address) {
246                         if (st->marker->max_lines &&
247                             st->lines > st->marker->max_lines) {
248                                 unsigned long nskip =
249                                         st->lines - st->marker->max_lines;
250                                 pt_dump_seq_printf(m, st->to_dmesg,
251                                                    "... %lu entr%s skipped ... \n",
252                                                    nskip,
253                                                    nskip == 1 ? "y" : "ies");
254                         }
255                         st->marker++;
256                         st->lines = 0;
257                         pt_dump_seq_printf(m, st->to_dmesg, "---[ %s ]---\n",
258                                            st->marker->name);
259                 }
260 
261                 st->start_address = st->current_address;
262                 st->current_prot = new_prot;
263                 st->level = level;
264         }
265 }
266 
267 static void walk_pte_level(struct seq_file *m, struct pg_state *st, pmd_t addr,
268                                                         unsigned long P)
269 {
270         int i;
271         pte_t *start;
272 
273         start = (pte_t *) pmd_page_vaddr(addr);
274         for (i = 0; i < PTRS_PER_PTE; i++) {
275                 pgprot_t prot = pte_pgprot(*start);
276 
277                 st->current_address = normalize_addr(P + i * PTE_LEVEL_MULT);
278                 note_page(m, st, prot, 4);
279                 start++;
280         }
281 }
282 
283 #if PTRS_PER_PMD > 1
284 
285 static void walk_pmd_level(struct seq_file *m, struct pg_state *st, pud_t addr,
286                                                         unsigned long P)
287 {
288         int i;
289         pmd_t *start;
290 
291         start = (pmd_t *) pud_page_vaddr(addr);
292         for (i = 0; i < PTRS_PER_PMD; i++) {
293                 st->current_address = normalize_addr(P + i * PMD_LEVEL_MULT);
294                 if (!pmd_none(*start)) {
295                         pgprotval_t prot = pmd_val(*start) & PTE_FLAGS_MASK;
296 
297                         if (pmd_large(*start) || !pmd_present(*start))
298                                 note_page(m, st, __pgprot(prot), 3);
299                         else
300                                 walk_pte_level(m, st, *start,
301                                                P + i * PMD_LEVEL_MULT);
302                 } else
303                         note_page(m, st, __pgprot(0), 3);
304                 start++;
305         }
306 }
307 
308 #else
309 #define walk_pmd_level(m,s,a,p) walk_pte_level(m,s,__pmd(pud_val(a)),p)
310 #define pud_large(a) pmd_large(__pmd(pud_val(a)))
311 #define pud_none(a)  pmd_none(__pmd(pud_val(a)))
312 #endif
313 
314 #if PTRS_PER_PUD > 1
315 
316 static void walk_pud_level(struct seq_file *m, struct pg_state *st, pgd_t addr,
317                                                         unsigned long P)
318 {
319         int i;
320         pud_t *start;
321 
322         start = (pud_t *) pgd_page_vaddr(addr);
323 
324         for (i = 0; i < PTRS_PER_PUD; i++) {
325                 st->current_address = normalize_addr(P + i * PUD_LEVEL_MULT);
326                 if (!pud_none(*start)) {
327                         pgprotval_t prot = pud_val(*start) & PTE_FLAGS_MASK;
328 
329                         if (pud_large(*start) || !pud_present(*start))
330                                 note_page(m, st, __pgprot(prot), 2);
331                         else
332                                 walk_pmd_level(m, st, *start,
333                                                P + i * PUD_LEVEL_MULT);
334                 } else
335                         note_page(m, st, __pgprot(0), 2);
336 
337                 start++;
338         }
339 }
340 
341 #else
342 #define walk_pud_level(m,s,a,p) walk_pmd_level(m,s,__pud(pgd_val(a)),p)
343 #define pgd_large(a) pud_large(__pud(pgd_val(a)))
344 #define pgd_none(a)  pud_none(__pud(pgd_val(a)))
345 #endif
346 
347 void ptdump_walk_pgd_level(struct seq_file *m, pgd_t *pgd)
348 {
349 #ifdef CONFIG_X86_64
350         pgd_t *start = (pgd_t *) &init_level4_pgt;
351 #else
352         pgd_t *start = swapper_pg_dir;
353 #endif
354         int i;
355         struct pg_state st = {};
356 
357         if (pgd) {
358                 start = pgd;
359                 st.to_dmesg = true;
360         }
361 
362         for (i = 0; i < PTRS_PER_PGD; i++) {
363                 st.current_address = normalize_addr(i * PGD_LEVEL_MULT);
364                 if (!pgd_none(*start)) {
365                         pgprotval_t prot = pgd_val(*start) & PTE_FLAGS_MASK;
366 
367                         if (pgd_large(*start) || !pgd_present(*start))
368                                 note_page(m, &st, __pgprot(prot), 1);
369                         else
370                                 walk_pud_level(m, &st, *start,
371                                                i * PGD_LEVEL_MULT);
372                 } else
373                         note_page(m, &st, __pgprot(0), 1);
374 
375                 start++;
376         }
377 
378         /* Flush out the last page */
379         st.current_address = normalize_addr(PTRS_PER_PGD*PGD_LEVEL_MULT);
380         note_page(m, &st, __pgprot(0), 0);
381 }
382 
383 static int ptdump_show(struct seq_file *m, void *v)
384 {
385         ptdump_walk_pgd_level(m, NULL);
386         return 0;
387 }
388 
389 static int ptdump_open(struct inode *inode, struct file *filp)
390 {
391         return single_open(filp, ptdump_show, NULL);
392 }
393 
394 static const struct file_operations ptdump_fops = {
395         .open           = ptdump_open,
396         .read           = seq_read,
397         .llseek         = seq_lseek,
398         .release        = single_release,
399 };
400 
401 static int pt_dump_init(void)
402 {
403         struct dentry *pe;
404 
405 #ifdef CONFIG_X86_32
406         /* Not a compile-time constant on x86-32 */
407         address_markers[VMALLOC_START_NR].start_address = VMALLOC_START;
408         address_markers[VMALLOC_END_NR].start_address = VMALLOC_END;
409 # ifdef CONFIG_HIGHMEM
410         address_markers[PKMAP_BASE_NR].start_address = PKMAP_BASE;
411 # endif
412         address_markers[FIXADDR_START_NR].start_address = FIXADDR_START;
413 #endif
414 
415         pe = debugfs_create_file("kernel_page_tables", 0600, NULL, NULL,
416                                  &ptdump_fops);
417         if (!pe)
418                 return -ENOMEM;
419 
420         return 0;
421 }
422 
423 __initcall(pt_dump_init);
424 MODULE_LICENSE("GPL");
425 MODULE_AUTHOR("Arjan van de Ven <arjan@linux.intel.com>");
426 MODULE_DESCRIPTION("Kernel debugging helper that dumps pagetables");
427 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp