[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / s390 / mm / dump_pagetables.c

#include <linux/seq_file.h>
#include <linux/debugfs.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <asm/sections.h>
#include <asm/pgtable.h>

static unsigned long max_addr;

struct addr_marker {
	unsigned long start_address;
	const char *name;
};

enum address_markers_idx {
	IDENTITY_NR = 0,
	KERNEL_START_NR,
	KERNEL_END_NR,
	VMEMMAP_NR,
	VMALLOC_NR,
#ifdef CONFIG_64BIT
	MODULES_NR,
#endif
};

static struct addr_marker address_markers[] = {
	[IDENTITY_NR]	  = {0, "Identity Mapping"},
	[KERNEL_START_NR] = {(unsigned long)&_stext, "Kernel Image Start"},
	[KERNEL_END_NR]	  = {(unsigned long)&_end, "Kernel Image End"},
	[VMEMMAP_NR]	  = {0, "vmemmap Area"},
	[VMALLOC_NR]	  = {0, "vmalloc Area"},
#ifdef CONFIG_64BIT
	[MODULES_NR]	  = {0, "Modules Area"},
#endif
	{ -1, NULL }
};

struct pg_state {
	int level;
	unsigned int current_prot;
	unsigned long start_address;
	unsigned long current_address;
	const struct addr_marker *marker;
};

static void print_prot(struct seq_file *m, unsigned int pr, int level)
{
	static const char * const level_name[] =
		{ "ASCE", "PGD", "PUD", "PMD", "PTE" };

	seq_printf(m, "%s ", level_name[level]);
	if (pr & _PAGE_INVALID) {
		seq_printf(m, "I\n");
		return;
	}
	seq_printf(m, "%s", pr & _PAGE_RO ? "RO " : "RW ");
	seq_printf(m, "%s", pr & _PAGE_CO ? "CO " : "   ");
	seq_putc(m, '\n');
}

static void note_page(struct seq_file *m, struct pg_state *st,
		     unsigned int new_prot, int level)
{
	static const char units[] = "KMGTPE";
	int width = sizeof(unsigned long) * 2;
	const char *unit = units;
	unsigned int prot, cur;
	unsigned long delta;

	/*
	 * If we have a "break" in the series, we need to flush the state
	 * that we have now. "break" is either changing perms, levels or
	 * address space marker.
	 */
	prot = new_prot;
	cur = st->current_prot;

	if (!st->level) {
		/* First entry */
		st->current_prot = new_prot;
		st->level = level;
		st->marker = address_markers;
		seq_printf(m, "---[ %s ]---\n", st->marker->name);
	} else if (prot != cur || level != st->level ||
		   st->current_address >= st->marker[1].start_address) {
		/* Print the actual finished series */
		seq_printf(m, "0x%0*lx-0x%0*lx",
			   width, st->start_address,
			   width, st->current_address);
		delta = (st->current_address - st->start_address) >> 10;
		while (!(delta & 0x3ff) && unit[1]) {
			delta >>= 10;
			unit++;
		}
		seq_printf(m, "%9lu%c ", delta, *unit);
		print_prot(m, st->current_prot, st->level);
		if (st->current_address >= st->marker[1].start_address) {
			st->marker++;
			seq_printf(m, "---[ %s ]---\n", st->marker->name);
		}
		st->start_address = st->current_address;
		st->current_prot = new_prot;
		st->level = level;
	}
}

/*
 * The actual page table walker functions. In order to keep the implementation
 * of print_prot() short, we only check and pass _PAGE_INVALID and _PAGE_RO
 * flags to note_page() if a region, segment or page table entry is invalid or
 * read-only.
 * After all it's just a hint that the current level being walked contains an
 * invalid or read-only entry.
 */
static void walk_pte_level(struct seq_file *m, struct pg_state *st,
			   pmd_t *pmd, unsigned long addr)
{
	unsigned int prot;
	pte_t *pte;
	int i;

	for (i = 0; i < PTRS_PER_PTE && addr < max_addr; i++) {
		st->current_address = addr;
		pte = pte_offset_kernel(pmd, addr);
		prot = pte_val(*pte) & (_PAGE_RO | _PAGE_INVALID);
		note_page(m, st, prot, 4);
		addr += PAGE_SIZE;
	}
}

#ifdef CONFIG_64BIT
#define _PMD_PROT_MASK (_SEGMENT_ENTRY_RO | _SEGMENT_ENTRY_CO)
#else
#define _PMD_PROT_MASK 0
#endif

static void walk_pmd_level(struct seq_file *m, struct pg_state *st,
			   pud_t *pud, unsigned long addr)
{
	unsigned int prot;
	pmd_t *pmd;
	int i;

	for (i = 0; i < PTRS_PER_PMD && addr < max_addr; i++) {
		st->current_address = addr;
		pmd = pmd_offset(pud, addr);
		if (!pmd_none(*pmd)) {
			if (pmd_large(*pmd)) {
				prot = pmd_val(*pmd) & _PMD_PROT_MASK;
				note_page(m, st, prot, 3);
			} else
				walk_pte_level(m, st, pmd, addr);
		} else
			note_page(m, st, _PAGE_INVALID, 3);
		addr += PMD_SIZE;
	}
}

#ifdef CONFIG_64BIT
#define _PUD_PROT_MASK (_REGION3_ENTRY_RO | _REGION3_ENTRY_CO)
#else
#define _PUD_PROT_MASK 0
#endif

static void walk_pud_level(struct seq_file *m, struct pg_state *st,
			   pgd_t *pgd, unsigned long addr)
{
	unsigned int prot;
	pud_t *pud;
	int i;

	for (i = 0; i < PTRS_PER_PUD && addr < max_addr; i++) {
		st->current_address = addr;
		pud = pud_offset(pgd, addr);
		if (!pud_none(*pud))
			if (pud_large(*pud)) {
				prot = pud_val(*pud) & _PUD_PROT_MASK;
				note_page(m, st, prot, 2);
			} else
				walk_pmd_level(m, st, pud, addr);
		else
			note_page(m, st, _PAGE_INVALID, 2);
		addr += PUD_SIZE;
	}
}

static void walk_pgd_level(struct seq_file *m)
{
	unsigned long addr = 0;
	struct pg_state st;
	pgd_t *pgd;
	int i;

	memset(&st, 0, sizeof(st));
	for (i = 0; i < PTRS_PER_PGD && addr < max_addr; i++) {
		st.current_address = addr;
		pgd = pgd_offset_k(addr);
		if (!pgd_none(*pgd))
			walk_pud_level(m, &st, pgd, addr);
		else
			note_page(m, &st, _PAGE_INVALID, 1);
		addr += PGDIR_SIZE;
	}
	/* Flush out the last page */
	st.current_address = max_addr;
	note_page(m, &st, 0, 0);
}

static int ptdump_show(struct seq_file *m, void *v)
{
	walk_pgd_level(m);
	return 0;
}

static int ptdump_open(struct inode *inode, struct file *filp)
{
	return single_open(filp, ptdump_show, NULL);
}

static const struct file_operations ptdump_fops = {
	.open		= ptdump_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int pt_dump_init(void)
{
	/*
	 * Figure out the maximum virtual address being accessible with the
	 * kernel ASCE. We need this to keep the page table walker functions
	 * from accessing non-existent entries.
	 */
#ifdef CONFIG_32BIT
	max_addr = 1UL << 31;
#else
	max_addr = (S390_lowcore.kernel_asce & _REGION_ENTRY_TYPE_MASK) >> 2;
	max_addr = 1UL << (max_addr * 11 + 31);
	address_markers[MODULES_NR].start_address = MODULES_VADDR;
#endif
	address_markers[VMEMMAP_NR].start_address = (unsigned long) vmemmap;
	address_markers[VMALLOC_NR].start_address = VMALLOC_START;
	debugfs_create_file("kernel_page_tables", 0400, NULL, NULL, &ptdump_fops);
	return 0;
}
device_initcall(pt_dump_init);
Commit	Line	Data
e76e82d7 HC	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,
c972cc60 HC	21	#ifdef CONFIG_64BIT
	22	MODULES_NR,
	23	#endif
e76e82d7 HC	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"},
c972cc60 HC	32	#ifdef CONFIG_64BIT
	33	[MODULES_NR] = {0, "Modules Area"},
	34	#endif
e76e82d7 HC	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]);
1819ed1f	52	if (pr & _PAGE_INVALID) {
e76e82d7	53	seq_printf(m, "I\n");
1819ed1f HC	54	return;
	55	}
	56	seq_printf(m, "%s", pr & _PAGE_RO ? "RO " : "RW ");
	57	seq_printf(m, "%s", pr & _PAGE_CO ? "CO " : " ");
	58	seq_putc(m, '\n');
e76e82d7 HC	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%0lx-0x%0lx",
	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 implementation
	109	* of print_prot() short, we only check and pass _PAGE_INVALID and _PAGE_RO
	110	* flags to note_page() if a region, segment or page table entry is invalid or
	111	* read-only.
	112	* After all it's just a hint that the current level being walked contains an
	113	* 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_RO \| _PAGE_INVALID);
126	note_page(m, st, prot, 4);
127	addr += PAGE_SIZE;
128	}
129	}
130
1819ed1f HC	131	#ifdef CONFIG_64BIT
	132	#define _PMD_PROT_MASK (_SEGMENT_ENTRY_RO \| _SEGMENT_ENTRY_CO)
	133	#else
	134	#define _PMD_PROT_MASK 0
	135	#endif
	136
e76e82d7 HC	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)) {
1819ed1f	149	prot = pmd_val(*pmd) & _PMD_PROT_MASK;
e76e82d7 HC	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
1819ed1f HC	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
e76e82d7 HC	165	static void walk_pud_level(struct seq_file m, struct pg_state st,
	166	pgd_t *pgd, unsigned long addr)
	167	{
18da2369	168	unsigned int prot;
e76e82d7 HC	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))
18da2369	176	if (pud_large(*pud)) {
1819ed1f	177	prot = pud_val(*pud) & _PUD_PROT_MASK;
18da2369 HC	178	note_page(m, st, prot, 2);
	179	} else
	180	walk_pmd_level(m, st, pud, addr);
e76e82d7 HC	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	*/
c972cc60 HC	234	#ifdef CONFIG_32BIT
	235	max_addr = 1UL << 31;
	236	#else
e76e82d7 HC	237	max_addr = (S390_lowcore.kernel_asce & _REGION_ENTRY_TYPE_MASK) >> 2;
e76e82d7 HC	238	max_addr = 1UL << (max_addr * 11 + 31);
c972cc60	239	address_markers[MODULES_NR].start_address = MODULES_VADDR;
e76e82d7 HC	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);