1 files changed, 92 insertions, 102 deletions
diff --git a/arch/x86/boot/compressed/head_32.S b/arch/x86/boot/compressed/head_32.S
index 3a8a866fb2e2..75e4f001e706 100644
--- a/arch/x86/boot/compressed/head_32.S
+++ b/arch/x86/boot/compressed/head_32.S
@@ -12,16 +12,16 @@
 * the page directory. [According to comments etc elsewhere on a compressed
 * kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC]
 *
- * Page 0 is deliberately kept safe, since System Management Mode code in 
+ * Page 0 is deliberately kept safe, since System Management Mode code in
 * laptops may need to access the BIOS data stored there.  This is also
- * useful for future device drivers that either access the BIOS via VM86 
+ * useful for future device drivers that either access the BIOS via VM86
 * mode.
 */
 /*
 * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
 */
-.text
+        .text
 #include <linux/linkage.h>
 #include <asm/segment.h>
@@ -29,161 +29,151 @@
 #include <asm/boot.h>
 #include <asm/asm-offsets.h>
-.section ".text.head","ax",@progbits
+        .section ".text.head","ax",@progbits
 ENTRY(startup_32)
        cld
-        /* test KEEP_SEGMENTS flag to see if the bootloader is asking
+        /*
-         * us to not reload segments */
+         * Test KEEP_SEGMENTS flag to see if the bootloader is asking
-        testb $(1<<6), BP_loadflags(%esi)
+         * us to not reload segments
-        jnz 1f
+         */
+        testb   $(1<<6), BP_loadflags(%esi)
+        jnz     1f
        cli
-        movl $(__BOOT_DS),%eax
+        movl    $__BOOT_DS, %eax
-        movl %eax,%ds
+        movl    %eax, %ds
-        movl %eax,%es
+        movl    %eax, %es
-        movl %eax,%fs
+        movl    %eax, %fs
-        movl %eax,%gs
+        movl    %eax, %gs
-        movl %eax,%ss
+        movl    %eax, %ss
 1:
-/* Calculate the delta between where we were compiled to run
+/*
+ * Calculate the delta between where we were compiled to run
 * at and where we were actually loaded at.  This can only be done
 * with a short local call on x86.  Nothing  else will tell us what
 * address we are running at.  The reserved chunk of the real-mode
 * data at 0x1e4 (defined as a scratch field) are used as the stack
 * for this calculation. Only 4 bytes are needed.
 */
-        leal (0x1e4+4)(%esi), %esp
+        leal    (BP_scratch+4)(%esi), %esp
-        call 1f
+        call    1f
-1:      popl %ebp
+1:      popl    %ebp
-        subl $1b, %ebp
+        subl    $1b, %ebp
-/* %ebp contains the address we are loaded at by the boot loader and %ebx
+/*
+ * %ebp contains the address we are loaded at by the boot loader and %ebx
 * contains the address where we should move the kernel image temporarily
 * for safe in-place decompression.
 */
 #ifdef CONFIG_RELOCATABLE
-        movl    %ebp, %ebx
+        movl    %ebp, %ebx
-        addl    $(CONFIG_PHYSICAL_ALIGN - 1), %ebx
+        movl    BP_kernel_alignment(%esi), %eax
-        andl    $(~(CONFIG_PHYSICAL_ALIGN - 1)), %ebx
+        decl    %eax
+        addl    %eax, %ebx
+        notl    %eax
+        andl    %eax, %ebx
 #else
-        movl $LOAD_PHYSICAL_ADDR, %ebx
+        movl    $LOAD_PHYSICAL_ADDR, %ebx
 #endif
-        /* Replace the compressed data size with the uncompressed size */
+        /* Target address to relocate to for decompression */
-        subl input_len(%ebp), %ebx
+        addl    $z_extract_offset, %ebx
-        movl output_len(%ebp), %eax
-        addl %eax, %ebx
+        /* Set up the stack */
-        /* Add 8 bytes for every 32K input block */
+        leal    boot_stack_end(%ebx), %esp
-        shrl $12, %eax
-        addl %eax, %ebx
+        /* Zero EFLAGS */
-        /* Add 32K + 18 bytes of extra slack */
+        pushl   $0
-        addl $(32768 + 18), %ebx
+        popfl
-        /* Align on a 4K boundary */
-        addl $4095, %ebx
+/*
-        andl $~4095, %ebx
+ * Copy the compressed kernel to the end of our buffer
-/* Copy the compressed kernel to the end of our buffer
 * where decompression in place becomes safe.
 */
-        pushl %esi
+        pushl   %esi
-        leal _end(%ebp), %esi
+        leal    (_bss-4)(%ebp), %esi
-        leal _end(%ebx), %edi
+        leal    (_bss-4)(%ebx), %edi
-        movl $(_end - startup_32), %ecx
+        movl    $(_bss - startup_32), %ecx
+        shrl    $2, %ecx
        std
-        rep
+        rep     movsl
-        movsb
        cld
-        popl %esi
+        popl    %esi
-/* Compute the kernel start address.
- */
-#ifdef CONFIG_RELOCATABLE
-        addl    $(CONFIG_PHYSICAL_ALIGN - 1), %ebp
-        andl    $(~(CONFIG_PHYSICAL_ALIGN - 1)), %ebp
-#else
-        movl    $LOAD_PHYSICAL_ADDR, %ebp
-#endif
 /*
 * Jump to the relocated address.
 */
-        leal relocated(%ebx), %eax
+        leal    relocated(%ebx), %eax
-        jmp *%eax
+        jmp     *%eax
 ENDPROC(startup_32)
-.section ".text"
+        .text
 relocated:
 /*
- * Clear BSS
+ * Clear BSS (stack is currently empty)
- */
-        xorl %eax,%eax
-        leal _edata(%ebx),%edi
-        leal _end(%ebx), %ecx
-        subl %edi,%ecx
-        cld
-        rep
-        stosb
-/*
- * Setup the stack for the decompressor
 */
-        leal boot_stack_end(%ebx), %esp
+        xorl    %eax, %eax
+        leal    _bss(%ebx), %edi
+        leal    _ebss(%ebx), %ecx
+        subl    %edi, %ecx
+        shrl    $2, %ecx
+        rep     stosl
 /*
 * Do the decompression, and jump to the new kernel..
 */
-        movl output_len(%ebx), %eax
+        leal    z_extract_offset_negative(%ebx), %ebp
-        pushl %eax
+                                /* push arguments for decompress_kernel: */
-                        # push arguments for decompress_kernel:
+        pushl   %ebp            /* output address */
-        pushl %ebp      # output address
+        pushl   $z_input_len    /* input_len */
-        movl input_len(%ebx), %eax
+        leal    input_data(%ebx), %eax
-        pushl %eax      # input_len
+        pushl   %eax            /* input_data */
-        leal input_data(%ebx), %eax
+        leal    boot_heap(%ebx), %eax
-        pushl %eax      # input_data
+        pushl   %eax            /* heap area */
-        leal boot_heap(%ebx), %eax
+        pushl   %esi            /* real mode pointer */
-        pushl %eax      # heap area
+        call    decompress_kernel
-        pushl %esi      # real mode pointer
+        addl    $20, %esp
-        call decompress_kernel
-        addl $20, %esp
-        popl %ecx
 #if CONFIG_RELOCATABLE
-/* Find the address of the relocations.
+/*
+ * Find the address of the relocations.
 */
-        movl %ebp, %edi
+        leal    z_output_len(%ebp), %edi
-        addl %ecx, %edi
-/* Calculate the delta between where vmlinux was compiled to run
+/*
+ * Calculate the delta between where vmlinux was compiled to run
 * and where it was actually loaded.
 */
-        movl %ebp, %ebx
+        movl    %ebp, %ebx
-        subl $LOAD_PHYSICAL_ADDR, %ebx
+        subl    $LOAD_PHYSICAL_ADDR, %ebx
-        jz   2f         /* Nothing to be done if loaded at compiled addr. */
+        jz      2f      /* Nothing to be done if loaded at compiled addr. */
 /*
 * Process relocations.
 */
-1:      subl $4, %edi
+1:      subl    $4, %edi
-        movl 0(%edi), %ecx
+        movl    (%edi), %ecx
-        testl %ecx, %ecx
+        testl   %ecx, %ecx
-        jz 2f
+        jz      2f
-        addl %ebx, -__PAGE_OFFSET(%ebx, %ecx)
+        addl    %ebx, -__PAGE_OFFSET(%ebx, %ecx)
-        jmp 1b
+        jmp     1b
 2:
 #endif
 /*
 * Jump to the decompressed kernel.
 */
-        xorl %ebx,%ebx
+        xorl    %ebx, %ebx
-        jmp *%ebp
+        jmp     *%ebp
-.bss
+/*
-/* Stack and heap for uncompression */
+ * Stack and heap for uncompression
-.balign 4
+ */
+        .bss
+        .balign 4
 boot_heap:
        .fill BOOT_HEAP_SIZE, 1, 0
 boot_stack:

diff --git a/arch/x86/boot/compressed/head_32.S b/arch/x86/boot/compressed/head_32.S index 3a8a866fb2e2..75e4f001e706 100644 --- a/arch/x86/boot/compressed/head_32.S +++ b/arch/x86/boot/compressed/head_32.S
@@ -12,16 +12,16 @@
12	* the page directory. [According to comments etc elsewhere on a compressed	12	* the page directory. [According to comments etc elsewhere on a compressed
13	* kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC]	13	* kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC]
14	*	14	*
15	* Page 0 is deliberately kept safe, since System Management Mode code in	15	* Page 0 is deliberately kept safe, since System Management Mode code in
16	* laptops may need to access the BIOS data stored there. This is also	16	* laptops may need to access the BIOS data stored there. This is also
17	* useful for future device drivers that either access the BIOS via VM86	17	* useful for future device drivers that either access the BIOS via VM86
18	* mode.	18	* mode.
19	*/	19	*/
20		20
21	/*	21	/*
22	* High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996	22	* High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
23	*/	23	*/
24	.text	24	.text
25		25
26	#include <linux/linkage.h>	26	#include <linux/linkage.h>
27	#include <asm/segment.h>	27	#include <asm/segment.h>
@@ -29,161 +29,151 @@
29	#include <asm/boot.h>	29	#include <asm/boot.h>
30	#include <asm/asm-offsets.h>	30	#include <asm/asm-offsets.h>
31		31
32	.section ".text.head","ax",@progbits	32	.section ".text.head","ax",@progbits
33	ENTRY(startup_32)	33	ENTRY(startup_32)
34	cld	34	cld
35	/* test KEEP_SEGMENTS flag to see if the bootloader is asking	35	/*
36	* us to not reload segments */	36	* Test KEEP_SEGMENTS flag to see if the bootloader is asking
37	testb $(1<<6), BP_loadflags(%esi)	37	* us to not reload segments
38	jnz 1f	38	*/
		39	testb $(1<<6), BP_loadflags(%esi)
		40	jnz 1f
39		41
40	cli	42	cli
41	movl $(__BOOT_DS),%eax	43	movl $__BOOT_DS, %eax
42	movl %eax,%ds	44	movl %eax, %ds
43	movl %eax,%es	45	movl %eax, %es
44	movl %eax,%fs	46	movl %eax, %fs
45	movl %eax,%gs	47	movl %eax, %gs
46	movl %eax,%ss	48	movl %eax, %ss
47	1:	49	1:
48		50
49	/* Calculate the delta between where we were compiled to run	51	/*
		52	* Calculate the delta between where we were compiled to run
50	* at and where we were actually loaded at. This can only be done	53	* at and where we were actually loaded at. This can only be done
51	* with a short local call on x86. Nothing else will tell us what	54	* with a short local call on x86. Nothing else will tell us what
52	* address we are running at. The reserved chunk of the real-mode	55	* address we are running at. The reserved chunk of the real-mode
53	* data at 0x1e4 (defined as a scratch field) are used as the stack	56	* data at 0x1e4 (defined as a scratch field) are used as the stack
54	* for this calculation. Only 4 bytes are needed.	57	* for this calculation. Only 4 bytes are needed.
55	*/	58	*/
56	leal (0x1e4+4)(%esi), %esp	59	leal (BP_scratch+4)(%esi), %esp
57	call 1f	60	call 1f
58	1: popl %ebp	61	1: popl %ebp
59	subl $1b, %ebp	62	subl $1b, %ebp
60		63
61	/* %ebp contains the address we are loaded at by the boot loader and %ebx	64	/*
		65	* %ebp contains the address we are loaded at by the boot loader and %ebx
62	* contains the address where we should move the kernel image temporarily	66	* contains the address where we should move the kernel image temporarily
63	* for safe in-place decompression.	67	* for safe in-place decompression.
64	*/	68	*/
65		69
66	#ifdef CONFIG_RELOCATABLE	70	#ifdef CONFIG_RELOCATABLE
67	movl %ebp, %ebx	71	movl %ebp, %ebx
68	addl $(CONFIG_PHYSICAL_ALIGN - 1), %ebx	72	movl BP_kernel_alignment(%esi), %eax
69	andl $(~(CONFIG_PHYSICAL_ALIGN - 1)), %ebx	73	decl %eax
		74	addl %eax, %ebx
		75	notl %eax
		76	andl %eax, %ebx
70	#else	77	#else
71	movl $LOAD_PHYSICAL_ADDR, %ebx	78	movl $LOAD_PHYSICAL_ADDR, %ebx
72	#endif	79	#endif
73		80
74	/* Replace the compressed data size with the uncompressed size */	81	/* Target address to relocate to for decompression */
75	subl input_len(%ebp), %ebx	82	addl $z_extract_offset, %ebx
76	movl output_len(%ebp), %eax	83
77	addl %eax, %ebx	84	/* Set up the stack */
78	/* Add 8 bytes for every 32K input block */	85	leal boot_stack_end(%ebx), %esp
79	shrl $12, %eax	86
80	addl %eax, %ebx	87	/* Zero EFLAGS */
81	/* Add 32K + 18 bytes of extra slack */	88	pushl $0
82	addl $(32768 + 18), %ebx	89	popfl
83	/* Align on a 4K boundary */	90
84	addl $4095, %ebx	91	/*
85	andl $~4095, %ebx	92	* Copy the compressed kernel to the end of our buffer
86
87	/* Copy the compressed kernel to the end of our buffer
88	* where decompression in place becomes safe.	93	* where decompression in place becomes safe.
89	*/	94	*/
90	pushl %esi	95	pushl %esi
91	leal _end(%ebp), %esi	96	leal (_bss-4)(%ebp), %esi
92	leal _end(%ebx), %edi	97	leal (_bss-4)(%ebx), %edi
93	movl $(_end - startup_32), %ecx	98	movl $(_bss - startup_32), %ecx
		99	shrl $2, %ecx
94	std	100	std
95	rep	101	rep movsl
96	movsb
97	cld	102	cld
98	popl %esi	103	popl %esi
99
100	/* Compute the kernel start address.
101	*/
102	#ifdef CONFIG_RELOCATABLE
103	addl $(CONFIG_PHYSICAL_ALIGN - 1), %ebp
104	andl $(~(CONFIG_PHYSICAL_ALIGN - 1)), %ebp
105	#else
106	movl $LOAD_PHYSICAL_ADDR, %ebp
107	#endif
108		104
109	/*	105	/*
110	* Jump to the relocated address.	106	* Jump to the relocated address.
111	*/	107	*/
112	leal relocated(%ebx), %eax	108	leal relocated(%ebx), %eax
113	jmp *%eax	109	jmp *%eax
114	ENDPROC(startup_32)	110	ENDPROC(startup_32)
115		111
116	.section ".text"	112	.text
117	relocated:	113	relocated:
118		114
119	/*	115	/*
120	* Clear BSS	116	* Clear BSS (stack is currently empty)
121	*/
122	xorl %eax,%eax
123	leal _edata(%ebx),%edi
124	leal _end(%ebx), %ecx
125	subl %edi,%ecx
126	cld
127	rep
128	stosb
129
130	/*
131	* Setup the stack for the decompressor
132	*/	117	*/
133	leal boot_stack_end(%ebx), %esp	118	xorl %eax, %eax
		119	leal _bss(%ebx), %edi
		120	leal _ebss(%ebx), %ecx
		121	subl %edi, %ecx
		122	shrl $2, %ecx
		123	rep stosl
134		124
135	/*	125	/*
136	* Do the decompression, and jump to the new kernel..	126	* Do the decompression, and jump to the new kernel..
137	*/	127	*/
138	movl output_len(%ebx), %eax	128	leal z_extract_offset_negative(%ebx), %ebp
139	pushl %eax	129	/* push arguments for decompress_kernel: */
140	# push arguments for decompress_kernel:	130	pushl %ebp /* output address */
141	pushl %ebp # output address	131	pushl $z_input_len /* input_len */
142	movl input_len(%ebx), %eax	132	leal input_data(%ebx), %eax
143	pushl %eax # input_len	133	pushl %eax /* input_data */
144	leal input_data(%ebx), %eax	134	leal boot_heap(%ebx), %eax
145	pushl %eax # input_data	135	pushl %eax /* heap area */
146	leal boot_heap(%ebx), %eax	136	pushl %esi /* real mode pointer */
147	pushl %eax # heap area	137	call decompress_kernel
148	pushl %esi # real mode pointer	138	addl $20, %esp
149	call decompress_kernel
150	addl $20, %esp
151	popl %ecx
152		139
153	#if CONFIG_RELOCATABLE	140	#if CONFIG_RELOCATABLE
154	/* Find the address of the relocations.	141	/*
		142	* Find the address of the relocations.
155	*/	143	*/
156	movl %ebp, %edi	144	leal z_output_len(%ebp), %edi
157	addl %ecx, %edi
158		145
159	/* Calculate the delta between where vmlinux was compiled to run	146	/*
		147	* Calculate the delta between where vmlinux was compiled to run
160	* and where it was actually loaded.	148	* and where it was actually loaded.
161	*/	149	*/
162	movl %ebp, %ebx	150	movl %ebp, %ebx
163	subl $LOAD_PHYSICAL_ADDR, %ebx	151	subl $LOAD_PHYSICAL_ADDR, %ebx
164	jz 2f /* Nothing to be done if loaded at compiled addr. */	152	jz 2f /* Nothing to be done if loaded at compiled addr. */
165	/*	153	/*
166	* Process relocations.	154	* Process relocations.
167	*/	155	*/
168		156
169	1: subl $4, %edi	157	1: subl $4, %edi
170	movl 0(%edi), %ecx	158	movl (%edi), %ecx
171	testl %ecx, %ecx	159	testl %ecx, %ecx
172	jz 2f	160	jz 2f
173	addl %ebx, -__PAGE_OFFSET(%ebx, %ecx)	161	addl %ebx, -__PAGE_OFFSET(%ebx, %ecx)
174	jmp 1b	162	jmp 1b
175	2:	163	2:
176	#endif	164	#endif
177		165
178	/*	166	/*
179	* Jump to the decompressed kernel.	167	* Jump to the decompressed kernel.
180	*/	168	*/
181	xorl %ebx,%ebx	169	xorl %ebx, %ebx
182	jmp *%ebp	170	jmp *%ebp
183		171
184	.bss	172	/*
185	/* Stack and heap for uncompression */	173	* Stack and heap for uncompression
186	.balign 4	174	*/
		175	.bss
		176	.balign 4
187	boot_heap:	177	boot_heap:
188	.fill BOOT_HEAP_SIZE, 1, 0	178	.fill BOOT_HEAP_SIZE, 1, 0
189	boot_stack:	179	boot_stack: