[deliverable/linux.git] / arch / i386 / kernel / machine_kexec.c

/*
 * machine_kexec.c - handle transition of Linux booting another kernel
 * Copyright (C) 2002-2005 Eric Biederman  <ebiederm@xmission.com>
 *
 * This source code is licensed under the GNU General Public License,
 * Version 2.  See the file COPYING for more details.
 */

#include <linux/mm.h>
#include <linux/kexec.h>
#include <linux/delay.h>
#include <asm/pgtable.h>
#include <asm/pgalloc.h>
#include <asm/tlbflush.h>
#include <asm/mmu_context.h>
#include <asm/io.h>
#include <asm/apic.h>
#include <asm/cpufeature.h>

static inline unsigned long read_cr3(void)
{
	unsigned long cr3;
	asm volatile("movl %%cr3,%0": "=r"(cr3));
	return cr3;
}

#define PAGE_ALIGNED __attribute__ ((__aligned__(PAGE_SIZE)))

#define L0_ATTR (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
#define L1_ATTR (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
#define L2_ATTR (_PAGE_PRESENT)

#define LEVEL0_SIZE (1UL << 12UL)

#ifndef CONFIG_X86_PAE
#define LEVEL1_SIZE (1UL << 22UL)
static u32 pgtable_level1[1024] PAGE_ALIGNED;

static void identity_map_page(unsigned long address)
{
	unsigned long level1_index, level2_index;
	u32 *pgtable_level2;

	/* Find the current page table */
	pgtable_level2 = __va(read_cr3());

	/* Find the indexes of the physical address to identity map */
	level1_index = (address % LEVEL1_SIZE)/LEVEL0_SIZE;
	level2_index = address / LEVEL1_SIZE;

	/* Identity map the page table entry */
	pgtable_level1[level1_index] = address | L0_ATTR;
	pgtable_level2[level2_index] = __pa(pgtable_level1) | L1_ATTR;

	/* Flush the tlb so the new mapping takes effect.
	 * Global tlb entries are not flushed but that is not an issue.
	 */
	load_cr3(pgtable_level2);
}

#else
#define LEVEL1_SIZE (1UL << 21UL)
#define LEVEL2_SIZE (1UL << 30UL)
static u64 pgtable_level1[512] PAGE_ALIGNED;
static u64 pgtable_level2[512] PAGE_ALIGNED;

static void identity_map_page(unsigned long address)
{
	unsigned long level1_index, level2_index, level3_index;
	u64 *pgtable_level3;

	/* Find the current page table */
	pgtable_level3 = __va(read_cr3());

	/* Find the indexes of the physical address to identity map */
	level1_index = (address % LEVEL1_SIZE)/LEVEL0_SIZE;
	level2_index = (address % LEVEL2_SIZE)/LEVEL1_SIZE;
	level3_index = address / LEVEL2_SIZE;

	/* Identity map the page table entry */
	pgtable_level1[level1_index] = address | L0_ATTR;
	pgtable_level2[level2_index] = __pa(pgtable_level1) | L1_ATTR;
	set_64bit(&pgtable_level3[level3_index],
					       __pa(pgtable_level2) | L2_ATTR);

	/* Flush the tlb so the new mapping takes effect.
	 * Global tlb entries are not flushed but that is not an issue.
	 */
	load_cr3(pgtable_level3);
}
#endif


static void set_idt(void *newidt, __u16 limit)
{
	unsigned char curidt[6];

	/* ia32 supports unaliged loads & stores */
	(*(__u16 *)(curidt)) = limit;
	(*(__u32 *)(curidt +2)) = (unsigned long)(newidt);

	__asm__ __volatile__ (
		"lidt %0\n"
		: "=m" (curidt)
		);
};


static void set_gdt(void *newgdt, __u16 limit)
{
	unsigned char curgdt[6];

	/* ia32 supports unaligned loads & stores */
	(*(__u16 *)(curgdt)) = limit;
	(*(__u32 *)(curgdt +2)) = (unsigned long)(newgdt);

	__asm__ __volatile__ (
		"lgdt %0\n"
		: "=m" (curgdt)
		);
};

static void load_segments(void)
{
#define __STR(X) #X
#define STR(X) __STR(X)

	__asm__ __volatile__ (
		"\tljmp $"STR(__KERNEL_CS)",$1f\n"
		"\t1:\n"
		"\tmovl $"STR(__KERNEL_DS)",%eax\n"
		"\tmovl %eax,%ds\n"
		"\tmovl %eax,%es\n"
		"\tmovl %eax,%fs\n"
		"\tmovl %eax,%gs\n"
		"\tmovl %eax,%ss\n"
		);
#undef STR
#undef __STR
}

typedef asmlinkage NORET_TYPE void (*relocate_new_kernel_t)(
					unsigned long indirection_page,
					unsigned long reboot_code_buffer,
					unsigned long start_address,
					unsigned int has_pae) ATTRIB_NORET;

const extern unsigned char relocate_new_kernel[];
extern void relocate_new_kernel_end(void);
const extern unsigned int relocate_new_kernel_size;

/*
 * A architecture hook called to validate the
 * proposed image and prepare the control pages
 * as needed.  The pages for KEXEC_CONTROL_CODE_SIZE
 * have been allocated, but the segments have yet
 * been copied into the kernel.
 *
 * Do what every setup is needed on image and the
 * reboot code buffer to allow us to avoid allocations
 * later.
 *
 * Currently nothing.
 */
int machine_kexec_prepare(struct kimage *image)
{
	return 0;
}

/*
 * Undo anything leftover by machine_kexec_prepare
 * when an image is freed.
 */
void machine_kexec_cleanup(struct kimage *image)
{
}

/*
 * Do not allocate memory (or fail in any way) in machine_kexec().
 * We are past the point of no return, committed to rebooting now.
 */
NORET_TYPE void machine_kexec(struct kimage *image)
{
	unsigned long page_list;
	unsigned long reboot_code_buffer;

	relocate_new_kernel_t rnk;

	/* Interrupts aren't acceptable while we reboot */
	local_irq_disable();

	/* Compute some offsets */
	reboot_code_buffer = page_to_pfn(image->control_code_page)
								<< PAGE_SHIFT;
	page_list = image->head;

	/* Set up an identity mapping for the reboot_code_buffer */
	identity_map_page(reboot_code_buffer);

	/* copy it out */
	memcpy((void *)reboot_code_buffer, relocate_new_kernel,
						relocate_new_kernel_size);

	/* The segment registers are funny things, they are
	 * automatically loaded from a table, in memory wherever you
	 * set them to a specific selector, but this table is never
	 * accessed again you set the segment to a different selector.
	 *
	 * The more common model is are caches where the behide
	 * the scenes work is done, but is also dropped at arbitrary
	 * times.
	 *
	 * I take advantage of this here by force loading the
	 * segments, before I zap the gdt with an invalid value.
	 */
	load_segments();
	/* The gdt & idt are now invalid.
	 * If you want to load them you must set up your own idt & gdt.
	 */
	set_gdt(phys_to_virt(0),0);
	set_idt(phys_to_virt(0),0);

	/* now call it */
	rnk = (relocate_new_kernel_t) reboot_code_buffer;
	(*rnk)(page_list, reboot_code_buffer, image->start, cpu_has_pae);
}
Commit	Line	Data
5033cba0 EB	1	/*
	2	* machine_kexec.c - handle transition of Linux booting another kernel
	3	* Copyright (C) 2002-2005 Eric Biederman <ebiederm@xmission.com>
	4	*
	5	* This source code is licensed under the GNU General Public License,
	6	* Version 2. See the file COPYING for more details.
	7	*/
	8
	9	#include <linux/mm.h>
	10	#include <linux/kexec.h>
	11	#include <linux/delay.h>
	12	#include <asm/pgtable.h>
	13	#include <asm/pgalloc.h>
	14	#include <asm/tlbflush.h>
	15	#include <asm/mmu_context.h>
	16	#include <asm/io.h>
	17	#include <asm/apic.h>
	18	#include <asm/cpufeature.h>
	19
	20	static inline unsigned long read_cr3(void)
	21	{
	22	unsigned long cr3;
	23	asm volatile("movl %%cr3,%0": "=r"(cr3));
	24	return cr3;
	25	}
	26
	27	#define PAGE_ALIGNED __attribute__ ((__aligned__(PAGE_SIZE)))
	28
	29	#define L0_ATTR (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_ACCESSED \| _PAGE_DIRTY)
	30	#define L1_ATTR (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_ACCESSED \| _PAGE_DIRTY)
	31	#define L2_ATTR (_PAGE_PRESENT)
	32
	33	#define LEVEL0_SIZE (1UL << 12UL)
	34
	35	#ifndef CONFIG_X86_PAE
	36	#define LEVEL1_SIZE (1UL << 22UL)
	37	static u32 pgtable_level1[1024] PAGE_ALIGNED;
	38
	39	static void identity_map_page(unsigned long address)
	40	{
	41	unsigned long level1_index, level2_index;
	42	u32 *pgtable_level2;
	43
	44	/* Find the current page table */
	45	pgtable_level2 = __va(read_cr3());
	46
	47	/* Find the indexes of the physical address to identity map */
	48	level1_index = (address % LEVEL1_SIZE)/LEVEL0_SIZE;
	49	level2_index = address / LEVEL1_SIZE;
	50
	51	/* Identity map the page table entry */
	52	pgtable_level1[level1_index] = address \| L0_ATTR;
	53	pgtable_level2[level2_index] = __pa(pgtable_level1) \| L1_ATTR;
	54
	55	/* Flush the tlb so the new mapping takes effect.
	56	* Global tlb entries are not flushed but that is not an issue.
	57	*/
	58	load_cr3(pgtable_level2);
	59	}
	60
	61	#else
	62	#define LEVEL1_SIZE (1UL << 21UL)
	63	#define LEVEL2_SIZE (1UL << 30UL)
	64	static u64 pgtable_level1[512] PAGE_ALIGNED;
65	static u64 pgtable_level2[512] PAGE_ALIGNED;
66
67	static void identity_map_page(unsigned long address)
68	{
69	unsigned long level1_index, level2_index, level3_index;
70	u64 *pgtable_level3;
71
72	/* Find the current page table */
73	pgtable_level3 = __va(read_cr3());
74
75	/* Find the indexes of the physical address to identity map */
76	level1_index = (address % LEVEL1_SIZE)/LEVEL0_SIZE;
77	level2_index = (address % LEVEL2_SIZE)/LEVEL1_SIZE;
78	level3_index = address / LEVEL2_SIZE;
79
80	/* Identity map the page table entry */
81	pgtable_level1[level1_index] = address \| L0_ATTR;
82	pgtable_level2[level2_index] = __pa(pgtable_level1) \| L1_ATTR;
72414d3f MS	83	set_64bit(&pgtable_level3[level3_index],
72414d3f MS	84	__pa(pgtable_level2) \| L2_ATTR);
5033cba0 EB	85
	86	/* Flush the tlb so the new mapping takes effect.
	87	* Global tlb entries are not flushed but that is not an issue.
	88	*/
	89	load_cr3(pgtable_level3);
	90	}
	91	#endif
	92
	93
	94	static void set_idt(void *newidt, __u16 limit)
	95	{
	96	unsigned char curidt[6];
	97
	98	/* ia32 supports unaliged loads & stores */
	99	((__u16 )(curidt)) = limit;
	100	((__u32 )(curidt +2)) = (unsigned long)(newidt);
	101
	102	__asm__ __volatile__ (
	103	"lidt %0\n"
	104	: "=m" (curidt)
	105	);
	106	};
	107
	108
	109	static void set_gdt(void *newgdt, __u16 limit)
	110	{
	111	unsigned char curgdt[6];
	112
	113	/* ia32 supports unaligned loads & stores */
	114	((__u16 )(curgdt)) = limit;
	115	((__u32 )(curgdt +2)) = (unsigned long)(newgdt);
	116
	117	__asm__ __volatile__ (
	118	"lgdt %0\n"
	119	: "=m" (curgdt)
	120	);
	121	};
	122
	123	static void load_segments(void)
	124	{
	125	#define __STR(X) #X
	126	#define STR(X) __STR(X)
	127
	128	__asm__ __volatile__ (
	129	"\tljmp $"STR(__KERNEL_CS)",$1f\n"
	130	"\t1:\n"
	131	"\tmovl $"STR(__KERNEL_DS)",%eax\n"
	132	"\tmovl %eax,%ds\n"
	133	"\tmovl %eax,%es\n"
	134	"\tmovl %eax,%fs\n"
	135	"\tmovl %eax,%gs\n"
	136	"\tmovl %eax,%ss\n"
	137	);
	138	#undef STR
	139	#undef __STR
	140	}
	141
	142	typedef asmlinkage NORET_TYPE void (*relocate_new_kernel_t)(
72414d3f MS	143	unsigned long indirection_page,
	144	unsigned long reboot_code_buffer,
	145	unsigned long start_address,
	146	unsigned int has_pae) ATTRIB_NORET;
5033cba0 EB	147
	148	const extern unsigned char relocate_new_kernel[];
	149	extern void relocate_new_kernel_end(void);
	150	const extern unsigned int relocate_new_kernel_size;
	151
	152	/*
	153	* A architecture hook called to validate the
	154	* proposed image and prepare the control pages
	155	* as needed. The pages for KEXEC_CONTROL_CODE_SIZE
	156	* have been allocated, but the segments have yet
	157	* been copied into the kernel.
	158	*
	159	* Do what every setup is needed on image and the
	160	* reboot code buffer to allow us to avoid allocations
	161	* later.
	162	*
	163	* Currently nothing.
	164	*/
	165	int machine_kexec_prepare(struct kimage *image)
	166	{
	167	return 0;
	168	}
	169
	170	/*
	171	* Undo anything leftover by machine_kexec_prepare
	172	* when an image is freed.
	173	*/
	174	void machine_kexec_cleanup(struct kimage *image)
	175	{
	176	}
	177
	178	/*
	179	* Do not allocate memory (or fail in any way) in machine_kexec().
	180	* We are past the point of no return, committed to rebooting now.
	181	*/
	182	NORET_TYPE void machine_kexec(struct kimage *image)
	183	{
	184	unsigned long page_list;
	185	unsigned long reboot_code_buffer;
72414d3f	186
5033cba0 EB	187	relocate_new_kernel_t rnk;
	188
	189	/* Interrupts aren't acceptable while we reboot */
	190	local_irq_disable();
	191
	192	/* Compute some offsets */
72414d3f MS	193	reboot_code_buffer = page_to_pfn(image->control_code_page)
72414d3f MS	194	<< PAGE_SHIFT;
5033cba0 EB	195	page_list = image->head;
	196
	197	/* Set up an identity mapping for the reboot_code_buffer */
	198	identity_map_page(reboot_code_buffer);
	199
	200	/* copy it out */
72414d3f MS	201	memcpy((void *)reboot_code_buffer, relocate_new_kernel,
72414d3f MS	202	relocate_new_kernel_size);
5033cba0 EB	203
	204	/* The segment registers are funny things, they are
	205	* automatically loaded from a table, in memory wherever you
	206	* set them to a specific selector, but this table is never
	207	* accessed again you set the segment to a different selector.
	208	*
	209	* The more common model is are caches where the behide
	210	* the scenes work is done, but is also dropped at arbitrary
	211	* times.
	212	*
	213	* I take advantage of this here by force loading the
	214	* segments, before I zap the gdt with an invalid value.
	215	*/
	216	load_segments();
	217	/* The gdt & idt are now invalid.
	218	* If you want to load them you must set up your own idt & gdt.
	219	*/
	220	set_gdt(phys_to_virt(0),0);
	221	set_idt(phys_to_virt(0),0);
	222
	223	/* now call it */
	224	rnk = (relocate_new_kernel_t) reboot_code_buffer;
	225	(*rnk)(page_list, reboot_code_buffer, image->start, cpu_has_pae);
	226	}