dd5ac03e09
In the recent commit1515ab9321("powerpc/mm: Dump hash table") we added code to dump the hage page table. Currently this can be selected to build on any platform. However it breaks the build if we're building for a non-Book3S platform, because none of the hash page table related defines and so on exist. So restrict it to building only on Book3S. Similarly in commit8eb07b1870("powerpc/mm: Dump linux pagetables") we added code to dump the Linux page tables, which uses some constants which are only defined on Book3S - so guard those with an #ifdef. Fixes:1515ab9321("powerpc/mm: Dump hash table") Fixes:8eb07b1870("powerpc/mm: Dump linux pagetables") Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
443 lines
10 KiB
C
443 lines
10 KiB
C
/*
|
|
* Copyright 2016, Rashmica Gupta, IBM Corp.
|
|
*
|
|
* This traverses the kernel pagetables and dumps the
|
|
* information about the used sections of memory to
|
|
* /sys/kernel/debug/kernel_pagetables.
|
|
*
|
|
* Derived from the arm64 implementation:
|
|
* Copyright (c) 2014, The Linux Foundation, Laura Abbott.
|
|
* (C) Copyright 2008 Intel Corporation, Arjan van de Ven.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; version 2
|
|
* of the License.
|
|
*/
|
|
#include <linux/debugfs.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/io.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/seq_file.h>
|
|
#include <asm/fixmap.h>
|
|
#include <asm/pgtable.h>
|
|
#include <linux/const.h>
|
|
#include <asm/page.h>
|
|
#include <asm/pgalloc.h>
|
|
|
|
/*
|
|
* To visualise what is happening,
|
|
*
|
|
* - PTRS_PER_P** = how many entries there are in the corresponding P**
|
|
* - P**_SHIFT = how many bits of the address we use to index into the
|
|
* corresponding P**
|
|
* - P**_SIZE is how much memory we can access through the table - not the
|
|
* size of the table itself.
|
|
* P**={PGD, PUD, PMD, PTE}
|
|
*
|
|
*
|
|
* Each entry of the PGD points to a PUD. Each entry of a PUD points to a
|
|
* PMD. Each entry of a PMD points to a PTE. And every PTE entry points to
|
|
* a page.
|
|
*
|
|
* In the case where there are only 3 levels, the PUD is folded into the
|
|
* PGD: every PUD has only one entry which points to the PMD.
|
|
*
|
|
* The page dumper groups page table entries of the same type into a single
|
|
* description. It uses pg_state to track the range information while
|
|
* iterating over the PTE entries. When the continuity is broken it then
|
|
* dumps out a description of the range - ie PTEs that are virtually contiguous
|
|
* with the same PTE flags are chunked together. This is to make it clear how
|
|
* different areas of the kernel virtual memory are used.
|
|
*
|
|
*/
|
|
struct pg_state {
|
|
struct seq_file *seq;
|
|
const struct addr_marker *marker;
|
|
unsigned long start_address;
|
|
unsigned int level;
|
|
u64 current_flags;
|
|
};
|
|
|
|
struct addr_marker {
|
|
unsigned long start_address;
|
|
const char *name;
|
|
};
|
|
|
|
static struct addr_marker address_markers[] = {
|
|
{ 0, "Start of kernel VM" },
|
|
{ 0, "vmalloc() Area" },
|
|
{ 0, "vmalloc() End" },
|
|
{ 0, "isa I/O start" },
|
|
{ 0, "isa I/O end" },
|
|
{ 0, "phb I/O start" },
|
|
{ 0, "phb I/O end" },
|
|
{ 0, "I/O remap start" },
|
|
{ 0, "I/O remap end" },
|
|
{ 0, "vmemmap start" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct flag_info {
|
|
u64 mask;
|
|
u64 val;
|
|
const char *set;
|
|
const char *clear;
|
|
bool is_val;
|
|
int shift;
|
|
};
|
|
|
|
static const struct flag_info flag_array[] = {
|
|
{
|
|
#ifdef CONFIG_PPC_STD_MMU_64
|
|
.mask = _PAGE_PRIVILEGED,
|
|
.val = 0,
|
|
#else
|
|
.mask = _PAGE_USER,
|
|
.val = _PAGE_USER,
|
|
#endif
|
|
.set = "user",
|
|
.clear = " ",
|
|
}, {
|
|
.mask = _PAGE_RW,
|
|
.val = _PAGE_RW,
|
|
.set = "rw",
|
|
.clear = "ro",
|
|
}, {
|
|
.mask = _PAGE_EXEC,
|
|
.val = _PAGE_EXEC,
|
|
.set = " X ",
|
|
.clear = " ",
|
|
}, {
|
|
.mask = _PAGE_PTE,
|
|
.val = _PAGE_PTE,
|
|
.set = "pte",
|
|
.clear = " ",
|
|
}, {
|
|
.mask = _PAGE_PRESENT,
|
|
.val = _PAGE_PRESENT,
|
|
.set = "present",
|
|
.clear = " ",
|
|
}, {
|
|
#ifdef CONFIG_PPC_STD_MMU_64
|
|
.mask = H_PAGE_HASHPTE,
|
|
.val = H_PAGE_HASHPTE,
|
|
#else
|
|
.mask = _PAGE_HASHPTE,
|
|
.val = _PAGE_HASHPTE,
|
|
#endif
|
|
.set = "hpte",
|
|
.clear = " ",
|
|
}, {
|
|
#ifndef CONFIG_PPC_STD_MMU_64
|
|
.mask = _PAGE_GUARDED,
|
|
.val = _PAGE_GUARDED,
|
|
.set = "guarded",
|
|
.clear = " ",
|
|
}, {
|
|
#endif
|
|
.mask = _PAGE_DIRTY,
|
|
.val = _PAGE_DIRTY,
|
|
.set = "dirty",
|
|
.clear = " ",
|
|
}, {
|
|
.mask = _PAGE_ACCESSED,
|
|
.val = _PAGE_ACCESSED,
|
|
.set = "accessed",
|
|
.clear = " ",
|
|
}, {
|
|
#ifndef CONFIG_PPC_STD_MMU_64
|
|
.mask = _PAGE_WRITETHRU,
|
|
.val = _PAGE_WRITETHRU,
|
|
.set = "write through",
|
|
.clear = " ",
|
|
}, {
|
|
#endif
|
|
.mask = _PAGE_NO_CACHE,
|
|
.val = _PAGE_NO_CACHE,
|
|
.set = "no cache",
|
|
.clear = " ",
|
|
}, {
|
|
#ifdef CONFIG_PPC_BOOK3S_64
|
|
.mask = H_PAGE_BUSY,
|
|
.val = H_PAGE_BUSY,
|
|
.set = "busy",
|
|
}, {
|
|
#ifdef CONFIG_PPC_64K_PAGES
|
|
.mask = H_PAGE_COMBO,
|
|
.val = H_PAGE_COMBO,
|
|
.set = "combo",
|
|
}, {
|
|
.mask = H_PAGE_4K_PFN,
|
|
.val = H_PAGE_4K_PFN,
|
|
.set = "4K_pfn",
|
|
}, {
|
|
#endif
|
|
.mask = H_PAGE_F_GIX,
|
|
.val = H_PAGE_F_GIX,
|
|
.set = "f_gix",
|
|
.is_val = true,
|
|
.shift = H_PAGE_F_GIX_SHIFT,
|
|
}, {
|
|
.mask = H_PAGE_F_SECOND,
|
|
.val = H_PAGE_F_SECOND,
|
|
.set = "f_second",
|
|
}, {
|
|
#endif
|
|
.mask = _PAGE_SPECIAL,
|
|
.val = _PAGE_SPECIAL,
|
|
.set = "special",
|
|
}
|
|
};
|
|
|
|
struct pgtable_level {
|
|
const struct flag_info *flag;
|
|
size_t num;
|
|
u64 mask;
|
|
};
|
|
|
|
static struct pgtable_level pg_level[] = {
|
|
{
|
|
}, { /* pgd */
|
|
.flag = flag_array,
|
|
.num = ARRAY_SIZE(flag_array),
|
|
}, { /* pud */
|
|
.flag = flag_array,
|
|
.num = ARRAY_SIZE(flag_array),
|
|
}, { /* pmd */
|
|
.flag = flag_array,
|
|
.num = ARRAY_SIZE(flag_array),
|
|
}, { /* pte */
|
|
.flag = flag_array,
|
|
.num = ARRAY_SIZE(flag_array),
|
|
},
|
|
};
|
|
|
|
static void dump_flag_info(struct pg_state *st, const struct flag_info
|
|
*flag, u64 pte, int num)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < num; i++, flag++) {
|
|
const char *s = NULL;
|
|
u64 val;
|
|
|
|
/* flag not defined so don't check it */
|
|
if (flag->mask == 0)
|
|
continue;
|
|
/* Some 'flags' are actually values */
|
|
if (flag->is_val) {
|
|
val = pte & flag->val;
|
|
if (flag->shift)
|
|
val = val >> flag->shift;
|
|
seq_printf(st->seq, " %s:%llx", flag->set, val);
|
|
} else {
|
|
if ((pte & flag->mask) == flag->val)
|
|
s = flag->set;
|
|
else
|
|
s = flag->clear;
|
|
if (s)
|
|
seq_printf(st->seq, " %s", s);
|
|
}
|
|
st->current_flags &= ~flag->mask;
|
|
}
|
|
if (st->current_flags != 0)
|
|
seq_printf(st->seq, " unknown flags:%llx", st->current_flags);
|
|
}
|
|
|
|
static void dump_addr(struct pg_state *st, unsigned long addr)
|
|
{
|
|
static const char units[] = "KMGTPE";
|
|
const char *unit = units;
|
|
unsigned long delta;
|
|
|
|
seq_printf(st->seq, "0x%016lx-0x%016lx ", st->start_address, addr-1);
|
|
delta = (addr - st->start_address) >> 10;
|
|
/* Work out what appropriate unit to use */
|
|
while (!(delta & 1023) && unit[1]) {
|
|
delta >>= 10;
|
|
unit++;
|
|
}
|
|
seq_printf(st->seq, "%9lu%c", delta, *unit);
|
|
|
|
}
|
|
|
|
static void note_page(struct pg_state *st, unsigned long addr,
|
|
unsigned int level, u64 val)
|
|
{
|
|
u64 flag = val & pg_level[level].mask;
|
|
/* At first no level is set */
|
|
if (!st->level) {
|
|
st->level = level;
|
|
st->current_flags = flag;
|
|
st->start_address = addr;
|
|
seq_printf(st->seq, "---[ %s ]---\n", st->marker->name);
|
|
/*
|
|
* Dump the section of virtual memory when:
|
|
* - the PTE flags from one entry to the next differs.
|
|
* - we change levels in the tree.
|
|
* - the address is in a different section of memory and is thus
|
|
* used for a different purpose, regardless of the flags.
|
|
*/
|
|
} else if (flag != st->current_flags || level != st->level ||
|
|
addr >= st->marker[1].start_address) {
|
|
|
|
/* Check the PTE flags */
|
|
if (st->current_flags) {
|
|
dump_addr(st, addr);
|
|
|
|
/* Dump all the flags */
|
|
if (pg_level[st->level].flag)
|
|
dump_flag_info(st, pg_level[st->level].flag,
|
|
st->current_flags,
|
|
pg_level[st->level].num);
|
|
|
|
seq_puts(st->seq, "\n");
|
|
}
|
|
|
|
/*
|
|
* Address indicates we have passed the end of the
|
|
* current section of virtual memory
|
|
*/
|
|
while (addr >= st->marker[1].start_address) {
|
|
st->marker++;
|
|
seq_printf(st->seq, "---[ %s ]---\n", st->marker->name);
|
|
}
|
|
st->start_address = addr;
|
|
st->current_flags = flag;
|
|
st->level = level;
|
|
}
|
|
}
|
|
|
|
static void walk_pte(struct pg_state *st, pmd_t *pmd, unsigned long start)
|
|
{
|
|
pte_t *pte = pte_offset_kernel(pmd, 0);
|
|
unsigned long addr;
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < PTRS_PER_PTE; i++, pte++) {
|
|
addr = start + i * PAGE_SIZE;
|
|
note_page(st, addr, 4, pte_val(*pte));
|
|
|
|
}
|
|
}
|
|
|
|
static void walk_pmd(struct pg_state *st, pud_t *pud, unsigned long start)
|
|
{
|
|
pmd_t *pmd = pmd_offset(pud, 0);
|
|
unsigned long addr;
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < PTRS_PER_PMD; i++, pmd++) {
|
|
addr = start + i * PMD_SIZE;
|
|
if (!pmd_none(*pmd))
|
|
/* pmd exists */
|
|
walk_pte(st, pmd, addr);
|
|
else
|
|
note_page(st, addr, 3, pmd_val(*pmd));
|
|
}
|
|
}
|
|
|
|
static void walk_pud(struct pg_state *st, pgd_t *pgd, unsigned long start)
|
|
{
|
|
pud_t *pud = pud_offset(pgd, 0);
|
|
unsigned long addr;
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < PTRS_PER_PUD; i++, pud++) {
|
|
addr = start + i * PUD_SIZE;
|
|
if (!pud_none(*pud))
|
|
/* pud exists */
|
|
walk_pmd(st, pud, addr);
|
|
else
|
|
note_page(st, addr, 2, pud_val(*pud));
|
|
}
|
|
}
|
|
|
|
static void walk_pagetables(struct pg_state *st)
|
|
{
|
|
pgd_t *pgd = pgd_offset_k(0UL);
|
|
unsigned int i;
|
|
unsigned long addr;
|
|
|
|
/*
|
|
* Traverse the linux pagetable structure and dump pages that are in
|
|
* the hash pagetable.
|
|
*/
|
|
for (i = 0; i < PTRS_PER_PGD; i++, pgd++) {
|
|
addr = KERN_VIRT_START + i * PGDIR_SIZE;
|
|
if (!pgd_none(*pgd))
|
|
/* pgd exists */
|
|
walk_pud(st, pgd, addr);
|
|
else
|
|
note_page(st, addr, 1, pgd_val(*pgd));
|
|
}
|
|
}
|
|
|
|
static void populate_markers(void)
|
|
{
|
|
address_markers[0].start_address = PAGE_OFFSET;
|
|
address_markers[1].start_address = VMALLOC_START;
|
|
address_markers[2].start_address = VMALLOC_END;
|
|
address_markers[3].start_address = ISA_IO_BASE;
|
|
address_markers[4].start_address = ISA_IO_END;
|
|
address_markers[5].start_address = PHB_IO_BASE;
|
|
address_markers[6].start_address = PHB_IO_END;
|
|
address_markers[7].start_address = IOREMAP_BASE;
|
|
address_markers[8].start_address = IOREMAP_END;
|
|
#ifdef CONFIG_PPC_STD_MMU_64
|
|
address_markers[9].start_address = H_VMEMMAP_BASE;
|
|
#else
|
|
address_markers[9].start_address = VMEMMAP_BASE;
|
|
#endif
|
|
}
|
|
|
|
static int ptdump_show(struct seq_file *m, void *v)
|
|
{
|
|
struct pg_state st = {
|
|
.seq = m,
|
|
.start_address = KERN_VIRT_START,
|
|
.marker = address_markers,
|
|
};
|
|
/* Traverse kernel page tables */
|
|
walk_pagetables(&st);
|
|
note_page(&st, 0, 0, 0);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int ptdump_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, ptdump_show, NULL);
|
|
}
|
|
|
|
static const struct file_operations ptdump_fops = {
|
|
.open = ptdump_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static void build_pgtable_complete_mask(void)
|
|
{
|
|
unsigned int i, j;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(pg_level); i++)
|
|
if (pg_level[i].flag)
|
|
for (j = 0; j < pg_level[i].num; j++)
|
|
pg_level[i].mask |= pg_level[i].flag[j].mask;
|
|
}
|
|
|
|
static int ptdump_init(void)
|
|
{
|
|
struct dentry *debugfs_file;
|
|
|
|
populate_markers();
|
|
build_pgtable_complete_mask();
|
|
debugfs_file = debugfs_create_file("kernel_pagetables", 0400, NULL,
|
|
NULL, &ptdump_fops);
|
|
return debugfs_file ? 0 : -ENOMEM;
|
|
}
|
|
device_initcall(ptdump_init);
|