suspend_64.c 7.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * Suspend support specific for i386.
 *
 * Distribute under GPLv2
 *
 * Copyright (c) 2002 Pavel Machek <pavel@suse.cz>
 * Copyright (c) 2001 Patrick Mochel <mochel@osdl.org>
 */

10
#include <linux/smp.h>
L
Linus Torvalds 已提交
11 12
#include <linux/suspend.h>
#include <asm/proto.h>
13 14
#include <asm/page.h>
#include <asm/pgtable.h>
15
#include <asm/mtrr.h>
L
Linus Torvalds 已提交
16

17 18 19
/* References to section boundaries */
extern const void __nosave_begin, __nosave_end;

L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
struct saved_context saved_context;

unsigned long saved_context_eax, saved_context_ebx, saved_context_ecx, saved_context_edx;
unsigned long saved_context_esp, saved_context_ebp, saved_context_esi, saved_context_edi;
unsigned long saved_context_r08, saved_context_r09, saved_context_r10, saved_context_r11;
unsigned long saved_context_r12, saved_context_r13, saved_context_r14, saved_context_r15;
unsigned long saved_context_eflags;

void __save_processor_state(struct saved_context *ctxt)
{
	kernel_fpu_begin();

	/*
	 * descriptor tables
	 */
	asm volatile ("sgdt %0" : "=m" (ctxt->gdt_limit));
	asm volatile ("sidt %0" : "=m" (ctxt->idt_limit));
	asm volatile ("str %0"  : "=m" (ctxt->tr));

	/* XMM0..XMM15 should be handled by kernel_fpu_begin(). */
	/*
	 * segment registers
	 */
	asm volatile ("movw %%ds, %0" : "=m" (ctxt->ds));
	asm volatile ("movw %%es, %0" : "=m" (ctxt->es));
	asm volatile ("movw %%fs, %0" : "=m" (ctxt->fs));
	asm volatile ("movw %%gs, %0" : "=m" (ctxt->gs));
	asm volatile ("movw %%ss, %0" : "=m" (ctxt->ss));

	rdmsrl(MSR_FS_BASE, ctxt->fs_base);
	rdmsrl(MSR_GS_BASE, ctxt->gs_base);
	rdmsrl(MSR_KERNEL_GS_BASE, ctxt->gs_kernel_base);
52
	mtrr_save_fixed_ranges(NULL);
L
Linus Torvalds 已提交
53 54 55 56

	/*
	 * control registers 
	 */
57
	rdmsrl(MSR_EFER, ctxt->efer);
58 59 60 61 62
	ctxt->cr0 = read_cr0();
	ctxt->cr2 = read_cr2();
	ctxt->cr3 = read_cr3();
	ctxt->cr4 = read_cr4();
	ctxt->cr8 = read_cr8();
L
Linus Torvalds 已提交
63 64 65 66 67 68 69
}

void save_processor_state(void)
{
	__save_processor_state(&saved_context);
}

70
static void do_fpu_end(void)
L
Linus Torvalds 已提交
71
{
72 73 74 75
	/*
	 * Restore FPU regs if necessary
	 */
	kernel_fpu_end();
L
Linus Torvalds 已提交
76 77 78 79 80 81 82
}

void __restore_processor_state(struct saved_context *ctxt)
{
	/*
	 * control registers
	 */
83
	wrmsrl(MSR_EFER, ctxt->efer);
84 85 86 87 88
	write_cr8(ctxt->cr8);
	write_cr4(ctxt->cr4);
	write_cr3(ctxt->cr3);
	write_cr2(ctxt->cr2);
	write_cr0(ctxt->cr0);
L
Linus Torvalds 已提交
89

90 91 92 93 94 95 96
	/*
	 * now restore the descriptor tables to their proper values
	 * ltr is done i fix_processor_context().
	 */
	asm volatile ("lgdt %0" :: "m" (ctxt->gdt_limit));
	asm volatile ("lidt %0" :: "m" (ctxt->idt_limit));

L
Linus Torvalds 已提交
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
	/*
	 * segment registers
	 */
	asm volatile ("movw %0, %%ds" :: "r" (ctxt->ds));
	asm volatile ("movw %0, %%es" :: "r" (ctxt->es));
	asm volatile ("movw %0, %%fs" :: "r" (ctxt->fs));
	load_gs_index(ctxt->gs);
	asm volatile ("movw %0, %%ss" :: "r" (ctxt->ss));

	wrmsrl(MSR_FS_BASE, ctxt->fs_base);
	wrmsrl(MSR_GS_BASE, ctxt->gs_base);
	wrmsrl(MSR_KERNEL_GS_BASE, ctxt->gs_kernel_base);

	fix_processor_context();

	do_fpu_end();
S
Shaohua Li 已提交
113
	mtrr_ap_init();
L
Linus Torvalds 已提交
114 115 116 117 118 119 120 121 122 123 124 125 126 127
}

void restore_processor_state(void)
{
	__restore_processor_state(&saved_context);
}

void fix_processor_context(void)
{
	int cpu = smp_processor_id();
	struct tss_struct *t = &per_cpu(init_tss, cpu);

	set_tss_desc(cpu,t);	/* This just modifies memory; should not be neccessary. But... This is neccessary, because 386 hardware has concept of busy TSS or some similar stupidity. */

128
	cpu_gdt(cpu)[GDT_ENTRY_TSS].type = 9;
L
Linus Torvalds 已提交
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148

	syscall_init();                         /* This sets MSR_*STAR and related */
	load_TR_desc();				/* This does ltr */
	load_LDT(&current->active_mm->context);	/* This does lldt */

	/*
	 * Now maybe reload the debug registers
	 */
	if (current->thread.debugreg7){
                loaddebug(&current->thread, 0);
                loaddebug(&current->thread, 1);
                loaddebug(&current->thread, 2);
                loaddebug(&current->thread, 3);
                /* no 4 and 5 */
                loaddebug(&current->thread, 6);
                loaddebug(&current->thread, 7);
	}

}

149
#ifdef CONFIG_HIBERNATION
150 151
/* Defined in arch/x86_64/kernel/suspend_asm.S */
extern int restore_image(void);
L
Linus Torvalds 已提交
152

153 154 155 156 157 158
/*
 * Address to jump to in the last phase of restore in order to get to the image
 * kernel's text (this value is passed in the image header).
 */
unsigned long restore_jump_address;

159 160 161 162 163 164
/*
 * Value of the cr3 register from before the hibernation (this value is passed
 * in the image header).
 */
unsigned long restore_cr3;

165 166
pgd_t *temp_level4_pgt;

167 168
void *relocated_restore_code;

169
static int res_phys_pud_init(pud_t *pud, unsigned long address, unsigned long end)
170 171 172 173 174 175 176 177 178 179 180 181 182
{
	long i, j;

	i = pud_index(address);
	pud = pud + i;
	for (; i < PTRS_PER_PUD; pud++, i++) {
		unsigned long paddr;
		pmd_t *pmd;

		paddr = address + i*PUD_SIZE;
		if (paddr >= end)
			break;

183 184 185
		pmd = (pmd_t *)get_safe_page(GFP_ATOMIC);
		if (!pmd)
			return -ENOMEM;
186 187 188 189 190 191
		set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE));
		for (j = 0; j < PTRS_PER_PMD; pmd++, j++, paddr += PMD_SIZE) {
			unsigned long pe;

			if (paddr >= end)
				break;
192
			pe = __PAGE_KERNEL_LARGE_EXEC | paddr;
193 194 195 196
			pe &= __supported_pte_mask;
			set_pmd(pmd, __pmd(pe));
		}
	}
197
	return 0;
198 199
}

200
static int set_up_temporary_mappings(void)
201 202
{
	unsigned long start, end, next;
203
	int error;
204

205 206 207
	temp_level4_pgt = (pgd_t *)get_safe_page(GFP_ATOMIC);
	if (!temp_level4_pgt)
		return -ENOMEM;
208 209 210 211 212 213 214 215 216 217

	/* It is safe to reuse the original kernel mapping */
	set_pgd(temp_level4_pgt + pgd_index(__START_KERNEL_map),
		init_level4_pgt[pgd_index(__START_KERNEL_map)]);

	/* Set up the direct mapping from scratch */
	start = (unsigned long)pfn_to_kaddr(0);
	end = (unsigned long)pfn_to_kaddr(end_pfn);

	for (; start < end; start = next) {
218 219 220
		pud_t *pud = (pud_t *)get_safe_page(GFP_ATOMIC);
		if (!pud)
			return -ENOMEM;
221 222 223
		next = start + PGDIR_SIZE;
		if (next > end)
			next = end;
224 225
		if ((error = res_phys_pud_init(pud, __pa(start), __pa(next))))
			return error;
226 227 228
		set_pgd(temp_level4_pgt + pgd_index(start),
			mk_kernel_pgd(__pa(pud)));
	}
229
	return 0;
230 231 232 233
}

int swsusp_arch_resume(void)
{
234
	int error;
235 236

	/* We have got enough memory and from now on we cannot recover */
237 238
	if ((error = set_up_temporary_mappings()))
		return error;
239 240 241 242 243 244 245

	relocated_restore_code = (void *)get_safe_page(GFP_ATOMIC);
	if (!relocated_restore_code)
		return -ENOMEM;
	memcpy(relocated_restore_code, &core_restore_code,
	       &restore_registers - &core_restore_code);

246 247 248
	restore_image();
	return 0;
}
249 250 251 252 253 254 255 256 257 258 259

/*
 *	pfn_is_nosave - check if given pfn is in the 'nosave' section
 */

int pfn_is_nosave(unsigned long pfn)
{
	unsigned long nosave_begin_pfn = __pa_symbol(&__nosave_begin) >> PAGE_SHIFT;
	unsigned long nosave_end_pfn = PAGE_ALIGN(__pa_symbol(&__nosave_end)) >> PAGE_SHIFT;
	return (pfn >= nosave_begin_pfn) && (pfn < nosave_end_pfn);
}
260 261 262

struct restore_data_record {
	unsigned long jump_address;
263 264
	unsigned long cr3;
	unsigned long magic;
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
};

#define RESTORE_MAGIC	0x0123456789ABCDEFUL

/**
 *	arch_hibernation_header_save - populate the architecture specific part
 *		of a hibernation image header
 *	@addr: address to save the data at
 */
int arch_hibernation_header_save(void *addr, unsigned int max_size)
{
	struct restore_data_record *rdr = addr;

	if (max_size < sizeof(struct restore_data_record))
		return -EOVERFLOW;
	rdr->jump_address = restore_jump_address;
281 282
	rdr->cr3 = restore_cr3;
	rdr->magic = RESTORE_MAGIC;
283 284 285 286 287 288 289 290 291 292 293 294 295
	return 0;
}

/**
 *	arch_hibernation_header_restore - read the architecture specific data
 *		from the hibernation image header
 *	@addr: address to read the data from
 */
int arch_hibernation_header_restore(void *addr)
{
	struct restore_data_record *rdr = addr;

	restore_jump_address = rdr->jump_address;
296 297
	restore_cr3 = rdr->cr3;
	return (rdr->magic == RESTORE_MAGIC) ? 0 : -EINVAL;
298
}
299
#endif /* CONFIG_HIBERNATION */