[linux-2.6-block.git] / arch / x86 / power / hibernate_32.c

/*
 * Hibernation support specific for i386 - temporary page tables
 *
 * Distribute under GPLv2
 *
 * Copyright (c) 2006 Rafael J. Wysocki <rjw@sisk.pl>
 */

#include <linux/gfp.h>
#include <linux/suspend.h>
#include <linux/memblock.h>

#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/mmzone.h>
#include <asm/sections.h>
#include <asm/suspend.h>

/* Pointer to the temporary resume page tables */
pgd_t *resume_pg_dir;

/* The following three functions are based on the analogous code in
 * arch/x86/mm/init_32.c
 */

/*
 * Create a middle page table on a resume-safe page and put a pointer to it in
 * the given global directory entry.  This only returns the gd entry
 * in non-PAE compilation mode, since the middle layer is folded.
 */
static pmd_t *resume_one_md_table_init(pgd_t *pgd)
{
	p4d_t *p4d;
	pud_t *pud;
	pmd_t *pmd_table;

#ifdef CONFIG_X86_PAE
	pmd_table = (pmd_t *)get_safe_page(GFP_ATOMIC);
	if (!pmd_table)
		return NULL;

	set_pgd(pgd, __pgd(__pa(pmd_table) | _PAGE_PRESENT));
	p4d = p4d_offset(pgd, 0);
	pud = pud_offset(p4d, 0);

	BUG_ON(pmd_table != pmd_offset(pud, 0));
#else
	p4d = p4d_offset(pgd, 0);
	pud = pud_offset(p4d, 0);
	pmd_table = pmd_offset(pud, 0);
#endif

	return pmd_table;
}

/*
 * Create a page table on a resume-safe page and place a pointer to it in
 * a middle page directory entry.
 */
static pte_t *resume_one_page_table_init(pmd_t *pmd)
{
	if (pmd_none(*pmd)) {
		pte_t *page_table = (pte_t *)get_safe_page(GFP_ATOMIC);
		if (!page_table)
			return NULL;

		set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE));

		BUG_ON(page_table != pte_offset_kernel(pmd, 0));

		return page_table;
	}

	return pte_offset_kernel(pmd, 0);
}

/*
 * This maps the physical memory to kernel virtual address space, a total
 * of max_low_pfn pages, by creating page tables starting from address
 * PAGE_OFFSET.  The page tables are allocated out of resume-safe pages.
 */
static int resume_physical_mapping_init(pgd_t *pgd_base)
{
	unsigned long pfn;
	pgd_t *pgd;
	pmd_t *pmd;
	pte_t *pte;
	int pgd_idx, pmd_idx;

	pgd_idx = pgd_index(PAGE_OFFSET);
	pgd = pgd_base + pgd_idx;
	pfn = 0;

	for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
		pmd = resume_one_md_table_init(pgd);
		if (!pmd)
			return -ENOMEM;

		if (pfn >= max_low_pfn)
			continue;

		for (pmd_idx = 0; pmd_idx < PTRS_PER_PMD; pmd++, pmd_idx++) {
			if (pfn >= max_low_pfn)
				break;

			/* Map with big pages if possible, otherwise create
			 * normal page tables.
			 * NOTE: We can mark everything as executable here
			 */
			if (boot_cpu_has(X86_FEATURE_PSE)) {
				set_pmd(pmd, pfn_pmd(pfn, PAGE_KERNEL_LARGE_EXEC));
				pfn += PTRS_PER_PTE;
			} else {
				pte_t *max_pte;

				pte = resume_one_page_table_init(pmd);
				if (!pte)
					return -ENOMEM;

				max_pte = pte + PTRS_PER_PTE;
				for (; pte < max_pte; pte++, pfn++) {
					if (pfn >= max_low_pfn)
						break;

					set_pte(pte, pfn_pte(pfn, PAGE_KERNEL_EXEC));
				}
			}
		}
	}

	return 0;
}

static inline void resume_init_first_level_page_table(pgd_t *pg_dir)
{
#ifdef CONFIG_X86_PAE
	int i;

	/* Init entries of the first-level page table to the zero page */
	for (i = 0; i < PTRS_PER_PGD; i++)
		set_pgd(pg_dir + i,
			__pgd(__pa(empty_zero_page) | _PAGE_PRESENT));
#endif
}

static int set_up_temporary_text_mapping(pgd_t *pgd_base)
{
	pgd_t *pgd;
	pmd_t *pmd;
	pte_t *pte;

	pgd = pgd_base + pgd_index(restore_jump_address);

	pmd = resume_one_md_table_init(pgd);
	if (!pmd)
		return -ENOMEM;

	if (boot_cpu_has(X86_FEATURE_PSE)) {
		set_pmd(pmd + pmd_index(restore_jump_address),
		__pmd((jump_address_phys & PMD_MASK) | pgprot_val(PAGE_KERNEL_LARGE_EXEC)));
	} else {
		pte = resume_one_page_table_init(pmd);
		if (!pte)
			return -ENOMEM;
		set_pte(pte + pte_index(restore_jump_address),
		__pte((jump_address_phys & PAGE_MASK) | pgprot_val(PAGE_KERNEL_EXEC)));
	}

	return 0;
}

asmlinkage int swsusp_arch_resume(void)
{
	int error;

	resume_pg_dir = (pgd_t *)get_safe_page(GFP_ATOMIC);
	if (!resume_pg_dir)
		return -ENOMEM;

	resume_init_first_level_page_table(resume_pg_dir);

	error = set_up_temporary_text_mapping(resume_pg_dir);
	if (error)
		return error;

	error = resume_physical_mapping_init(resume_pg_dir);
	if (error)
		return error;

	temp_pgt = __pa(resume_pg_dir);

	error = relocate_restore_code();
	if (error)
		return error;

	/* We have got enough memory and from now on we cannot recover */
	restore_image();
	return 0;
}
Commit	Line	Data
2d4a34c9	1	/*
c5759124	2	* Hibernation support specific for i386 - temporary page tables
2d4a34c9 RW	3	*
	4	* Distribute under GPLv2
	5	*
	6	* Copyright (c) 2006 Rafael J. Wysocki <rjw@sisk.pl>
	7	*/
	8
5a0e3ad6	9	#include <linux/gfp.h>
2d4a34c9	10	#include <linux/suspend.h>
57c8a661	11	#include <linux/memblock.h>
2d4a34c9	12
2d4a34c9 RW	13	#include <asm/page.h>
2d4a34c9 RW	14	#include <asm/pgtable.h>
97a70e54	15	#include <asm/mmzone.h>
7f8998c7	16	#include <asm/sections.h>
25862a04	17	#include <asm/suspend.h>
2d4a34c9 RW	18
	19	/* Pointer to the temporary resume page tables */
	20	pgd_t *resume_pg_dir;
	21
	22	/* The following three functions are based on the analogous code in
261f0ce5	23	* arch/x86/mm/init_32.c
2d4a34c9 RW	24	*/
	25
	26	/*
	27	* Create a middle page table on a resume-safe page and put a pointer to it in
	28	* the given global directory entry. This only returns the gd entry
	29	* in non-PAE compilation mode, since the middle layer is folded.
	30	*/
	31	static pmd_t resume_one_md_table_init(pgd_t pgd)
	32	{
e0c4f675	33	p4d_t *p4d;
2d4a34c9 RW	34	pud_t *pud;
	35	pmd_t *pmd_table;
	36
	37	#ifdef CONFIG_X86_PAE
	38	pmd_table = (pmd_t *)get_safe_page(GFP_ATOMIC);
	39	if (!pmd_table)
	40	return NULL;
	41
	42	set_pgd(pgd, __pgd(__pa(pmd_table) \| _PAGE_PRESENT));
e0c4f675 KS	43	p4d = p4d_offset(pgd, 0);
e0c4f675 KS	44	pud = pud_offset(p4d, 0);
2d4a34c9 RW	45
	46	BUG_ON(pmd_table != pmd_offset(pud, 0));
	47	#else
e0c4f675 KS	48	p4d = p4d_offset(pgd, 0);
e0c4f675 KS	49	pud = pud_offset(p4d, 0);
2d4a34c9 RW	50	pmd_table = pmd_offset(pud, 0);
	51	#endif
	52
	53	return pmd_table;
	54	}
	55
	56	/*
	57	* Create a page table on a resume-safe page and place a pointer to it in
	58	* a middle page directory entry.
	59	*/
	60	static pte_t resume_one_page_table_init(pmd_t pmd)
	61	{
	62	if (pmd_none(*pmd)) {
	63	pte_t page_table = (pte_t )get_safe_page(GFP_ATOMIC);
	64	if (!page_table)
	65	return NULL;
	66
	67	set_pmd(pmd, __pmd(__pa(page_table) \| _PAGE_TABLE));
	68
	69	BUG_ON(page_table != pte_offset_kernel(pmd, 0));
	70
	71	return page_table;
	72	}
	73
	74	return pte_offset_kernel(pmd, 0);
	75	}
	76
	77	/*
	78	* This maps the physical memory to kernel virtual address space, a total
	79	* of max_low_pfn pages, by creating page tables starting from address
	80	* PAGE_OFFSET. The page tables are allocated out of resume-safe pages.
	81	*/
	82	static int resume_physical_mapping_init(pgd_t *pgd_base)
	83	{
	84	unsigned long pfn;
	85	pgd_t *pgd;
	86	pmd_t *pmd;
	87	pte_t *pte;
	88	int pgd_idx, pmd_idx;
	89
	90	pgd_idx = pgd_index(PAGE_OFFSET);
	91	pgd = pgd_base + pgd_idx;
	92	pfn = 0;
	93
	94	for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
	95	pmd = resume_one_md_table_init(pgd);
	96	if (!pmd)
	97	return -ENOMEM;
	98
	99	if (pfn >= max_low_pfn)
	100	continue;
	101
	102	for (pmd_idx = 0; pmd_idx < PTRS_PER_PMD; pmd++, pmd_idx++) {
	103	if (pfn >= max_low_pfn)
	104	break;
	105
	106	/* Map with big pages if possible, otherwise create
	107	* normal page tables.
	108	* NOTE: We can mark everything as executable here
	109	*/
16bf9226	110	if (boot_cpu_has(X86_FEATURE_PSE)) {
2d4a34c9 RW	111	set_pmd(pmd, pfn_pmd(pfn, PAGE_KERNEL_LARGE_EXEC));
	112	pfn += PTRS_PER_PTE;
	113	} else {
	114	pte_t *max_pte;
	115
	116	pte = resume_one_page_table_init(pmd);
	117	if (!pte)
	118	return -ENOMEM;
	119
	120	max_pte = pte + PTRS_PER_PTE;
	121	for (; pte < max_pte; pte++, pfn++) {
	122	if (pfn >= max_low_pfn)
	123	break;
	124
	125	set_pte(pte, pfn_pte(pfn, PAGE_KERNEL_EXEC));
	126	}
	127	}
	128	}
	129	}
97a70e54	130
2d4a34c9 RW	131	return 0;
	132	}
	133
	134	static inline void resume_init_first_level_page_table(pgd_t *pg_dir)
	135	{
	136	#ifdef CONFIG_X86_PAE
	137	int i;
	138
	139	/* Init entries of the first-level page table to the zero page */
	140	for (i = 0; i < PTRS_PER_PGD; i++)
	141	set_pgd(pg_dir + i,
	142	__pgd(__pa(empty_zero_page) \| _PAGE_PRESENT));
	143	#endif
	144	}
	145
5331d2c7 ZG	146	static int set_up_temporary_text_mapping(pgd_t *pgd_base)
	147	{
	148	pgd_t *pgd;
	149	pmd_t *pmd;
	150	pte_t *pte;
	151
	152	pgd = pgd_base + pgd_index(restore_jump_address);
	153
	154	pmd = resume_one_md_table_init(pgd);
	155	if (!pmd)
	156	return -ENOMEM;
	157
	158	if (boot_cpu_has(X86_FEATURE_PSE)) {
	159	set_pmd(pmd + pmd_index(restore_jump_address),
	160	__pmd((jump_address_phys & PMD_MASK) \| pgprot_val(PAGE_KERNEL_LARGE_EXEC)));
	161	} else {
	162	pte = resume_one_page_table_init(pmd);
	163	if (!pte)
	164	return -ENOMEM;
	165	set_pte(pte + pte_index(restore_jump_address),
	166	__pte((jump_address_phys & PAGE_MASK) \| pgprot_val(PAGE_KERNEL_EXEC)));
	167	}
	168
	169	return 0;
	170	}
	171
328008a7	172	asmlinkage int swsusp_arch_resume(void)
2d4a34c9 RW	173	{
	174	int error;
	175
	176	resume_pg_dir = (pgd_t *)get_safe_page(GFP_ATOMIC);
	177	if (!resume_pg_dir)
	178	return -ENOMEM;
	179
	180	resume_init_first_level_page_table(resume_pg_dir);
5331d2c7 ZG	181
	182	error = set_up_temporary_text_mapping(resume_pg_dir);
	183	if (error)
	184	return error;
	185
2d4a34c9 RW	186	error = resume_physical_mapping_init(resume_pg_dir);
	187	if (error)
	188	return error;
	189
7c0a9827 ZG	190	temp_pgt = __pa(resume_pg_dir);
7c0a9827 ZG	191
6bae499a ZG	192	error = relocate_restore_code();
	193	if (error)
	194	return error;
	195
2d4a34c9 RW	196	/* We have got enough memory and from now on we cannot recover */
	197	restore_image();
	198	return 0;
	199	}