[net-next-2.6.git] / arch / x86 / kernel / vmlinux.lds.S

/*
 * ld script for the x86 kernel
 *
 * Historic 32-bit version written by Martin Mares <mj@atrey.karlin.mff.cuni.cz>
 *
 * Modernisation, unification and other changes and fixes:
 *   Copyright (C) 2007-2009  Sam Ravnborg <sam@ravnborg.org>
 *
 *
 * Don't define absolute symbols until and unless you know that symbol
 * value is should remain constant even if kernel image is relocated
 * at run time. Absolute symbols are not relocated. If symbol value should
 * change if kernel is relocated, make the symbol section relative and
 * put it inside the section definition.
 */

#ifdef CONFIG_X86_32
#define LOAD_OFFSET __PAGE_OFFSET
#else
#define LOAD_OFFSET __START_KERNEL_map
#endif

#include <asm-generic/vmlinux.lds.h>
#include <asm/asm-offsets.h>
#include <asm/thread_info.h>
#include <asm/page_types.h>
#include <asm/cache.h>
#include <asm/boot.h>

#undef i386     /* in case the preprocessor is a 32bit one */

OUTPUT_FORMAT(CONFIG_OUTPUT_FORMAT, CONFIG_OUTPUT_FORMAT, CONFIG_OUTPUT_FORMAT)

#ifdef CONFIG_X86_32
OUTPUT_ARCH(i386)
ENTRY(phys_startup_32)
jiffies = jiffies_64;
#else
OUTPUT_ARCH(i386:x86-64)
ENTRY(phys_startup_64)
jiffies_64 = jiffies;
#endif

#if defined(CONFIG_X86_64) && defined(CONFIG_DEBUG_RODATA)
/*
 * On 64-bit, align RODATA to 2MB so that even with CONFIG_DEBUG_RODATA
 * we retain large page mappings for boundaries spanning kernel text, rodata
 * and data sections.
 *
 * However, kernel identity mappings will have different RWX permissions
 * to the pages mapping to text and to the pages padding (which are freed) the
 * text section. Hence kernel identity mappings will be broken to smaller
 * pages. For 64-bit, kernel text and kernel identity mappings are different,
 * so we can enable protection checks that come with CONFIG_DEBUG_RODATA,
 * as well as retain 2MB large page mappings for kernel text.
 */
#define X64_ALIGN_DEBUG_RODATA_BEGIN	. = ALIGN(HPAGE_SIZE);

#define X64_ALIGN_DEBUG_RODATA_END				\
		. = ALIGN(HPAGE_SIZE);				\
		__end_rodata_hpage_align = .;

#else

#define X64_ALIGN_DEBUG_RODATA_BEGIN
#define X64_ALIGN_DEBUG_RODATA_END

#endif

PHDRS {
	text PT_LOAD FLAGS(5);          /* R_E */
	data PT_LOAD FLAGS(7);          /* RWE */
#ifdef CONFIG_X86_64
	user PT_LOAD FLAGS(5);          /* R_E */
#ifdef CONFIG_SMP
	percpu PT_LOAD FLAGS(6);        /* RW_ */
#endif
	init PT_LOAD FLAGS(7);          /* RWE */
#endif
	note PT_NOTE FLAGS(0);          /* ___ */
}

SECTIONS
{
#ifdef CONFIG_X86_32
        . = LOAD_OFFSET + LOAD_PHYSICAL_ADDR;
        phys_startup_32 = startup_32 - LOAD_OFFSET;
#else
        . = __START_KERNEL;
        phys_startup_64 = startup_64 - LOAD_OFFSET;
#endif

	/* Text and read-only data */
	.text :  AT(ADDR(.text) - LOAD_OFFSET) {
		_text = .;
		/* bootstrapping code */
		HEAD_TEXT
#ifdef CONFIG_X86_32
		. = ALIGN(PAGE_SIZE);
		*(.text.page_aligned)
#endif
		. = ALIGN(8);
		_stext = .;
		TEXT_TEXT
		SCHED_TEXT
		LOCK_TEXT
		KPROBES_TEXT
		IRQENTRY_TEXT
		*(.fixup)
		*(.gnu.warning)
		/* End of text section */
		_etext = .;
	} :text = 0x9090

	NOTES :text :note

	EXCEPTION_TABLE(16) :text = 0x9090

	X64_ALIGN_DEBUG_RODATA_BEGIN
	RO_DATA(PAGE_SIZE)
	X64_ALIGN_DEBUG_RODATA_END

	/* Data */
	.data : AT(ADDR(.data) - LOAD_OFFSET) {
		/* Start of data section */
		_sdata = .;

		/* init_task */
		INIT_TASK_DATA(THREAD_SIZE)

#ifdef CONFIG_X86_32
		/* 32 bit has nosave before _edata */
		NOSAVE_DATA
#endif

		PAGE_ALIGNED_DATA(PAGE_SIZE)

		CACHELINE_ALIGNED_DATA(L1_CACHE_BYTES)

		DATA_DATA
		CONSTRUCTORS

		/* rarely changed data like cpu maps */
		READ_MOSTLY_DATA(INTERNODE_CACHE_BYTES)

		/* End of data section */
		_edata = .;
	} :data

#ifdef CONFIG_X86_64

#define VSYSCALL_ADDR (-10*1024*1024)

#define VLOAD_OFFSET (VSYSCALL_ADDR - __vsyscall_0 + LOAD_OFFSET)
#define VLOAD(x) (ADDR(x) - VLOAD_OFFSET)

#define VVIRT_OFFSET (VSYSCALL_ADDR - __vsyscall_0)
#define VVIRT(x) (ADDR(x) - VVIRT_OFFSET)

	. = ALIGN(4096);
	__vsyscall_0 = .;

	. = VSYSCALL_ADDR;
	.vsyscall_0 : AT(VLOAD(.vsyscall_0)) {
		*(.vsyscall_0)
	} :user

	. = ALIGN(L1_CACHE_BYTES);
	.vsyscall_fn : AT(VLOAD(.vsyscall_fn)) {
		*(.vsyscall_fn)
	}

	. = ALIGN(L1_CACHE_BYTES);
	.vsyscall_gtod_data : AT(VLOAD(.vsyscall_gtod_data)) {
		*(.vsyscall_gtod_data)
	}

	vsyscall_gtod_data = VVIRT(.vsyscall_gtod_data);
	.vsyscall_clock : AT(VLOAD(.vsyscall_clock)) {
		*(.vsyscall_clock)
	}
	vsyscall_clock = VVIRT(.vsyscall_clock);


	.vsyscall_1 ADDR(.vsyscall_0) + 1024: AT(VLOAD(.vsyscall_1)) {
		*(.vsyscall_1)
	}
	.vsyscall_2 ADDR(.vsyscall_0) + 2048: AT(VLOAD(.vsyscall_2)) {
		*(.vsyscall_2)
	}

	.vgetcpu_mode : AT(VLOAD(.vgetcpu_mode)) {
		*(.vgetcpu_mode)
	}
	vgetcpu_mode = VVIRT(.vgetcpu_mode);

	. = ALIGN(L1_CACHE_BYTES);
	.jiffies : AT(VLOAD(.jiffies)) {
		*(.jiffies)
	}
	jiffies = VVIRT(.jiffies);

	.vsyscall_3 ADDR(.vsyscall_0) + 3072: AT(VLOAD(.vsyscall_3)) {
		*(.vsyscall_3)
	}

	. = __vsyscall_0 + PAGE_SIZE;

#undef VSYSCALL_ADDR
#undef VLOAD_OFFSET
#undef VLOAD
#undef VVIRT_OFFSET
#undef VVIRT

#endif /* CONFIG_X86_64 */

	/* Init code and data - will be freed after init */
	. = ALIGN(PAGE_SIZE);
	.init.begin : AT(ADDR(.init.begin) - LOAD_OFFSET) {
		__init_begin = .; /* paired with __init_end */
	}

#if defined(CONFIG_X86_64) && defined(CONFIG_SMP)
	/*
	 * percpu offsets are zero-based on SMP.  PERCPU_VADDR() changes the
	 * output PHDR, so the next output section - .init.text - should
	 * start another segment - init.
	 */
	PERCPU_VADDR(0, :percpu)
#endif

	INIT_TEXT_SECTION(PAGE_SIZE)
#ifdef CONFIG_X86_64
	:init
#endif

	INIT_DATA_SECTION(16)

	.x86_cpu_dev.init : AT(ADDR(.x86_cpu_dev.init) - LOAD_OFFSET) {
		__x86_cpu_dev_start = .;
		*(.x86_cpu_dev.init)
		__x86_cpu_dev_end = .;
	}

	. = ALIGN(8);
	.parainstructions : AT(ADDR(.parainstructions) - LOAD_OFFSET) {
		__parainstructions = .;
		*(.parainstructions)
		__parainstructions_end = .;
	}

	. = ALIGN(8);
	.altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) {
		__alt_instructions = .;
		*(.altinstructions)
		__alt_instructions_end = .;
	}

	.altinstr_replacement : AT(ADDR(.altinstr_replacement) - LOAD_OFFSET) {
		*(.altinstr_replacement)
	}

	/*
	 * .exit.text is discard at runtime, not link time, to deal with
	 *  references from .altinstructions and .eh_frame
	 */
	.exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
		EXIT_TEXT
	}

	.exit.data : AT(ADDR(.exit.data) - LOAD_OFFSET) {
		EXIT_DATA
	}

#if !defined(CONFIG_X86_64) || !defined(CONFIG_SMP)
	PERCPU(PAGE_SIZE)
#endif

	. = ALIGN(PAGE_SIZE);

	/* freed after init ends here */
	.init.end : AT(ADDR(.init.end) - LOAD_OFFSET) {
		__init_end = .;
	}

	/*
	 * smp_locks might be freed after init
	 * start/end must be page aligned
	 */
	. = ALIGN(PAGE_SIZE);
	.smp_locks : AT(ADDR(.smp_locks) - LOAD_OFFSET) {
		__smp_locks = .;
		*(.smp_locks)
		. = ALIGN(PAGE_SIZE);
		__smp_locks_end = .;
	}

#ifdef CONFIG_X86_64
	.data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
		NOSAVE_DATA
	}
#endif

	/* BSS */
	. = ALIGN(PAGE_SIZE);
	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {
		__bss_start = .;
		*(.bss.page_aligned)
		*(.bss)
		. = ALIGN(4);
		__bss_stop = .;
	}

	. = ALIGN(PAGE_SIZE);
	.brk : AT(ADDR(.brk) - LOAD_OFFSET) {
		__brk_base = .;
		. += 64 * 1024;		/* 64k alignment slop space */
		*(.brk_reservation)	/* areas brk users have reserved */
		__brk_limit = .;
	}

	_end = .;

        STABS_DEBUG
        DWARF_DEBUG

	/* Sections to be discarded */
	DISCARDS
	/DISCARD/ : { *(.eh_frame) }
}


#ifdef CONFIG_X86_32
/*
 * The ASSERT() sink to . is intentional, for binutils 2.14 compatibility:
 */
. = ASSERT((_end - LOAD_OFFSET <= KERNEL_IMAGE_SIZE),
	   "kernel image bigger than KERNEL_IMAGE_SIZE");
#else
/*
 * Per-cpu symbols which need to be offset from __per_cpu_load
 * for the boot processor.
 */
#define INIT_PER_CPU(x) init_per_cpu__##x = x + __per_cpu_load
INIT_PER_CPU(gdt_page);
INIT_PER_CPU(irq_stack_union);

/*
 * Build-time check on the image size:
 */
. = ASSERT((_end - _text <= KERNEL_IMAGE_SIZE),
	   "kernel image bigger than KERNEL_IMAGE_SIZE");

#ifdef CONFIG_SMP
. = ASSERT((irq_stack_union == 0),
           "irq_stack_union is not at start of per-cpu area");
#endif

#endif /* CONFIG_X86_32 */

#ifdef CONFIG_KEXEC
#include <asm/kexec.h>

. = ASSERT(kexec_control_code_size <= KEXEC_CONTROL_CODE_MAX_SIZE,
           "kexec control code size is too big");
#endif
Commit	Line	Data
17ce265d SR	1	/*
	2	* ld script for the x86 kernel
	3	*
	4	* Historic 32-bit version written by Martin Mares <mj@atrey.karlin.mff.cuni.cz>
	5	*
91fd7fe8 IM	6	* Modernisation, unification and other changes and fixes:
91fd7fe8 IM	7	* Copyright (C) 2007-2009 Sam Ravnborg <sam@ravnborg.org>
17ce265d SR	8	*
	9	*
	10	* Don't define absolute symbols until and unless you know that symbol
	11	* value is should remain constant even if kernel image is relocated
	12	* at run time. Absolute symbols are not relocated. If symbol value should
	13	* change if kernel is relocated, make the symbol section relative and
	14	* put it inside the section definition.
	15	*/
	16
	17	#ifdef CONFIG_X86_32
	18	#define LOAD_OFFSET __PAGE_OFFSET
	19	#else
	20	#define LOAD_OFFSET __START_KERNEL_map
	21	#endif
	22
	23	#include <asm-generic/vmlinux.lds.h>
	24	#include <asm/asm-offsets.h>
	25	#include <asm/thread_info.h>
	26	#include <asm/page_types.h>
	27	#include <asm/cache.h>
	28	#include <asm/boot.h>
	29
	30	#undef i386 /* in case the preprocessor is a 32bit one */
	31
	32	OUTPUT_FORMAT(CONFIG_OUTPUT_FORMAT, CONFIG_OUTPUT_FORMAT, CONFIG_OUTPUT_FORMAT)
	33
	34	#ifdef CONFIG_X86_32
	35	OUTPUT_ARCH(i386)
	36	ENTRY(phys_startup_32)
	37	jiffies = jiffies_64;
	38	#else
	39	OUTPUT_ARCH(i386:x86-64)
	40	ENTRY(phys_startup_64)
	41	jiffies_64 = jiffies;
	42	#endif
	43
74e08179	44	#if defined(CONFIG_X86_64) && defined(CONFIG_DEBUG_RODATA)
d6cc1c3a SS	45	/*
	46	* On 64-bit, align RODATA to 2MB so that even with CONFIG_DEBUG_RODATA
	47	* we retain large page mappings for boundaries spanning kernel text, rodata
	48	* and data sections.
	49	*
	50	* However, kernel identity mappings will have different RWX permissions
	51	* to the pages mapping to text and to the pages padding (which are freed) the
	52	* text section. Hence kernel identity mappings will be broken to smaller
	53	* pages. For 64-bit, kernel text and kernel identity mappings are different,
	54	* so we can enable protection checks that come with CONFIG_DEBUG_RODATA,
	55	* as well as retain 2MB large page mappings for kernel text.
	56	*/
74e08179 SS	57	#define X64_ALIGN_DEBUG_RODATA_BEGIN . = ALIGN(HPAGE_SIZE);
	58
	59	#define X64_ALIGN_DEBUG_RODATA_END \
	60	. = ALIGN(HPAGE_SIZE); \
	61	__end_rodata_hpage_align = .;
	62
	63	#else
	64
	65	#define X64_ALIGN_DEBUG_RODATA_BEGIN
	66	#define X64_ALIGN_DEBUG_RODATA_END
	67
	68	#endif
	69
afb8095a SR	70	PHDRS {
	71	text PT_LOAD FLAGS(5); /* R_E */
	72	data PT_LOAD FLAGS(7); /* RWE */
	73	#ifdef CONFIG_X86_64
8d0cc631	74	user PT_LOAD FLAGS(5); /* R_E */
afb8095a	75	#ifdef CONFIG_SMP
8d0cc631	76	percpu PT_LOAD FLAGS(6); /* RW_ */
afb8095a	77	#endif
c62e4320	78	init PT_LOAD FLAGS(7); /* RWE */
afb8095a SR	79	#endif
	80	note PT_NOTE FLAGS(0); /* ___ */
	81	}
17ce265d	82
444e0ae4 SR	83	SECTIONS
	84	{
	85	#ifdef CONFIG_X86_32
	86	. = LOAD_OFFSET + LOAD_PHYSICAL_ADDR;
	87	phys_startup_32 = startup_32 - LOAD_OFFSET;
	88	#else
	89	. = __START_KERNEL;
	90	phys_startup_64 = startup_64 - LOAD_OFFSET;
	91	#endif
	92
dfc20895	93	/* Text and read-only data */
dfc20895	94	.text : AT(ADDR(.text) - LOAD_OFFSET) {
4ae59b91 TA	95	_text = .;
	96	/* bootstrapping code */
	97	HEAD_TEXT
dfc20895	98	#ifdef CONFIG_X86_32
dfc20895 SR	99	. = ALIGN(PAGE_SIZE);
	100	*(.text.page_aligned)
	101	#endif
	102	. = ALIGN(8);
	103	_stext = .;
	104	TEXT_TEXT
	105	SCHED_TEXT
	106	LOCK_TEXT
	107	KPROBES_TEXT
	108	IRQENTRY_TEXT
	109	*(.fixup)
	110	*(.gnu.warning)
	111	/* End of text section */
	112	_etext = .;
	113	} :text = 0x9090
	114
	115	NOTES :text :note
	116
123f3e1d	117	EXCEPTION_TABLE(16) :text = 0x9090
448bc3ab	118
74e08179	119	X64_ALIGN_DEBUG_RODATA_BEGIN
c62e4320	120	RO_DATA(PAGE_SIZE)
74e08179	121	X64_ALIGN_DEBUG_RODATA_END
448bc3ab	122
1f6397ba	123	/* Data */
1f6397ba	124	.data : AT(ADDR(.data) - LOAD_OFFSET) {
1260866a CM	125	/* Start of data section */
1260866a CM	126	_sdata = .;
c62e4320 JB	127
	128	/* init_task */
	129	INIT_TASK_DATA(THREAD_SIZE)
1f6397ba SR	130
1f6397ba SR	131	#ifdef CONFIG_X86_32
c62e4320 JB	132	/* 32 bit has nosave before _edata */
c62e4320 JB	133	NOSAVE_DATA
1f6397ba SR	134	#endif
1f6397ba SR	135
c62e4320	136	PAGE_ALIGNED_DATA(PAGE_SIZE)
1f6397ba	137
350f8f56	138	CACHELINE_ALIGNED_DATA(L1_CACHE_BYTES)
1f6397ba	139
c62e4320 JB	140	DATA_DATA
	141	CONSTRUCTORS
	142
	143	/* rarely changed data like cpu maps */
350f8f56	144	READ_MOSTLY_DATA(INTERNODE_CACHE_BYTES)
1f6397ba	145
1f6397ba SR	146	/* End of data section */
1f6397ba SR	147	_edata = .;
c62e4320	148	} :data
1f6397ba	149
ff6f87e1 SR	150	#ifdef CONFIG_X86_64
	151
	152	#define VSYSCALL_ADDR (-1010241024)
ff6f87e1	153
d223246e	154	#define VLOAD_OFFSET (VSYSCALL_ADDR - __vsyscall_0 + LOAD_OFFSET)
ff6f87e1 SR	155	#define VLOAD(x) (ADDR(x) - VLOAD_OFFSET)
ff6f87e1 SR	156
d223246e	157	#define VVIRT_OFFSET (VSYSCALL_ADDR - __vsyscall_0)
ff6f87e1 SR	158	#define VVIRT(x) (ADDR(x) - VVIRT_OFFSET)
ff6f87e1 SR	159
d223246e AK	160	. = ALIGN(4096);
	161	__vsyscall_0 = .;
	162
ff6f87e1	163	. = VSYSCALL_ADDR;
d223246e	164	.vsyscall_0 : AT(VLOAD(.vsyscall_0)) {
ff6f87e1 SR	165	*(.vsyscall_0)
	166	} :user
	167
350f8f56	168	. = ALIGN(L1_CACHE_BYTES);
ff6f87e1 SR	169	.vsyscall_fn : AT(VLOAD(.vsyscall_fn)) {
	170	*(.vsyscall_fn)
	171	}
	172
350f8f56	173	. = ALIGN(L1_CACHE_BYTES);
ff6f87e1 SR	174	.vsyscall_gtod_data : AT(VLOAD(.vsyscall_gtod_data)) {
	175	*(.vsyscall_gtod_data)
	176	}
	177
	178	vsyscall_gtod_data = VVIRT(.vsyscall_gtod_data);
	179	.vsyscall_clock : AT(VLOAD(.vsyscall_clock)) {
	180	*(.vsyscall_clock)
	181	}
	182	vsyscall_clock = VVIRT(.vsyscall_clock);
	183
	184
	185	.vsyscall_1 ADDR(.vsyscall_0) + 1024: AT(VLOAD(.vsyscall_1)) {
	186	*(.vsyscall_1)
	187	}
	188	.vsyscall_2 ADDR(.vsyscall_0) + 2048: AT(VLOAD(.vsyscall_2)) {
	189	*(.vsyscall_2)
	190	}
	191
	192	.vgetcpu_mode : AT(VLOAD(.vgetcpu_mode)) {
	193	*(.vgetcpu_mode)
	194	}
	195	vgetcpu_mode = VVIRT(.vgetcpu_mode);
	196
350f8f56	197	. = ALIGN(L1_CACHE_BYTES);
ff6f87e1 SR	198	.jiffies : AT(VLOAD(.jiffies)) {
	199	*(.jiffies)
	200	}
	201	jiffies = VVIRT(.jiffies);
	202
	203	.vsyscall_3 ADDR(.vsyscall_0) + 3072: AT(VLOAD(.vsyscall_3)) {
	204	*(.vsyscall_3)
	205	}
	206
d223246e	207	. = __vsyscall_0 + PAGE_SIZE;
ff6f87e1 SR	208
ff6f87e1 SR	209	#undef VSYSCALL_ADDR
ff6f87e1 SR	210	#undef VLOAD_OFFSET
	211	#undef VLOAD
	212	#undef VVIRT_OFFSET
	213	#undef VVIRT
	214
	215	#endif /* CONFIG_X86_64 */
dfc20895	216
c62e4320 JB	217	/* Init code and data - will be freed after init */
	218	. = ALIGN(PAGE_SIZE);
	219	.init.begin : AT(ADDR(.init.begin) - LOAD_OFFSET) {
	220	__init_begin = .; /* paired with __init_end */
e58bdaa8	221	}
e58bdaa8	222
c62e4320	223	#if defined(CONFIG_X86_64) && defined(CONFIG_SMP)
e58bdaa8	224	/*
c62e4320 JB	225	* percpu offsets are zero-based on SMP. PERCPU_VADDR() changes the
	226	* output PHDR, so the next output section - .init.text - should
	227	* start another segment - init.
e58bdaa8	228	*/
c62e4320 JB	229	PERCPU_VADDR(0, :percpu)
c62e4320 JB	230	#endif
e58bdaa8	231
123f3e1d	232	INIT_TEXT_SECTION(PAGE_SIZE)
c62e4320 JB	233	#ifdef CONFIG_X86_64
	234	:init
	235	#endif
e58bdaa8	236
123f3e1d	237	INIT_DATA_SECTION(16)
e58bdaa8 SR	238
	239	.x86_cpu_dev.init : AT(ADDR(.x86_cpu_dev.init) - LOAD_OFFSET) {
	240	__x86_cpu_dev_start = .;
	241	*(.x86_cpu_dev.init)
	242	__x86_cpu_dev_end = .;
	243	}
	244
ae618362 SR	245	. = ALIGN(8);
	246	.parainstructions : AT(ADDR(.parainstructions) - LOAD_OFFSET) {
	247	__parainstructions = .;
	248	*(.parainstructions)
	249	__parainstructions_end = .;
	250	}
	251
	252	. = ALIGN(8);
	253	.altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) {
	254	__alt_instructions = .;
	255	*(.altinstructions)
	256	__alt_instructions_end = .;
	257	}
	258
	259	.altinstr_replacement : AT(ADDR(.altinstr_replacement) - LOAD_OFFSET) {
	260	*(.altinstr_replacement)
	261	}
	262
bf6a5741 SR	263	/*
	264	* .exit.text is discard at runtime, not link time, to deal with
	265	* references from .altinstructions and .eh_frame
	266	*/
	267	.exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) {
	268	EXIT_TEXT
	269	}
	270
	271	.exit.data : AT(ADDR(.exit.data) - LOAD_OFFSET) {
	272	EXIT_DATA
	273	}
	274
c62e4320	275	#if !defined(CONFIG_X86_64) \|\| !defined(CONFIG_SMP)
9d16e783 SR	276	PERCPU(PAGE_SIZE)
	277	#endif
	278
	279	. = ALIGN(PAGE_SIZE);
fd073194	280
9d16e783	281	/* freed after init ends here */
fd073194 IM	282	.init.end : AT(ADDR(.init.end) - LOAD_OFFSET) {
	283	__init_end = .;
	284	}
9d16e783	285
c62e4320 JB	286	/*
	287	* smp_locks might be freed after init
	288	* start/end must be page aligned
	289	*/
	290	. = ALIGN(PAGE_SIZE);
	291	.smp_locks : AT(ADDR(.smp_locks) - LOAD_OFFSET) {
	292	__smp_locks = .;
	293	*(.smp_locks)
c62e4320	294	. = ALIGN(PAGE_SIZE);
596b711e	295	__smp_locks_end = .;
c62e4320 JB	296	}
c62e4320 JB	297
9d16e783 SR	298	#ifdef CONFIG_X86_64
9d16e783 SR	299	.data_nosave : AT(ADDR(.data_nosave) - LOAD_OFFSET) {
c62e4320 JB	300	NOSAVE_DATA
c62e4320 JB	301	}
9d16e783 SR	302	#endif
9d16e783 SR	303
091e52c3 SR	304	/* BSS */
	305	. = ALIGN(PAGE_SIZE);
	306	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {
	307	__bss_start = .;
	308	*(.bss.page_aligned)
	309	*(.bss)
	310	. = ALIGN(4);
	311	__bss_stop = .;
	312	}
9d16e783	313
091e52c3 SR	314	. = ALIGN(PAGE_SIZE);
	315	.brk : AT(ADDR(.brk) - LOAD_OFFSET) {
	316	__brk_base = .;
	317	. += 64 * 1024; /* 64k alignment slop space */
	318	(.brk_reservation) / areas brk users have reserved */
	319	__brk_limit = .;
	320	}
	321
873b5271	322	_end = .;
091e52c3	323
444e0ae4 SR	324	STABS_DEBUG
444e0ae4 SR	325	DWARF_DEBUG
023bf6f1 TH	326
	327	/* Sections to be discarded */
	328	DISCARDS
	329	/DISCARD/ : { *(.eh_frame) }
444e0ae4 SR	330	}
444e0ae4 SR	331
17ce265d SR	332
17ce265d SR	333	#ifdef CONFIG_X86_32
a5912f6b IM	334	/*
	335	* The ASSERT() sink to . is intentional, for binutils 2.14 compatibility:
	336	*/
d2ba8b21 PA	337	. = ASSERT((_end - LOAD_OFFSET <= KERNEL_IMAGE_SIZE),
d2ba8b21 PA	338	"kernel image bigger than KERNEL_IMAGE_SIZE");
17ce265d SR	339	#else
	340	/*
	341	* Per-cpu symbols which need to be offset from __per_cpu_load
	342	* for the boot processor.
	343	*/
dd17c8f7	344	#define INIT_PER_CPU(x) init_per_cpu__##x = x + __per_cpu_load
17ce265d SR	345	INIT_PER_CPU(gdt_page);
	346	INIT_PER_CPU(irq_stack_union);
	347
	348	/*
	349	* Build-time check on the image size:
	350	*/
d2ba8b21 PA	351	. = ASSERT((_end - _text <= KERNEL_IMAGE_SIZE),
d2ba8b21 PA	352	"kernel image bigger than KERNEL_IMAGE_SIZE");
17ce265d SR	353
17ce265d SR	354	#ifdef CONFIG_SMP
dd17c8f7	355	. = ASSERT((irq_stack_union == 0),
d2ba8b21	356	"irq_stack_union is not at start of per-cpu area");
17ce265d SR	357	#endif
	358
	359	#endif /* CONFIG_X86_32 */
	360
	361	#ifdef CONFIG_KEXEC
	362	#include <asm/kexec.h>
	363
d2ba8b21 PA	364	. = ASSERT(kexec_control_code_size <= KEXEC_CONTROL_CODE_MAX_SIZE,
d2ba8b21 PA	365	"kexec control code size is too big");
17ce265d SR	366	#endif
17ce265d SR	367