Loading...
1/*
2 * header.S
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * Based on bootsect.S and setup.S
7 * modified by more people than can be counted
8 *
9 * Rewritten as a common file by H. Peter Anvin (Apr 2007)
10 *
11 * BIG FAT NOTE: We're in real mode using 64k segments. Therefore segment
12 * addresses must be multiplied by 16 to obtain their respective linear
13 * addresses. To avoid confusion, linear addresses are written using leading
14 * hex while segment addresses are written as segment:offset.
15 *
16 */
17
18#include <asm/segment.h>
19#include <generated/utsrelease.h>
20#include <asm/boot.h>
21#include <asm/e820.h>
22#include <asm/page_types.h>
23#include <asm/setup.h>
24#include "boot.h"
25#include "voffset.h"
26#include "zoffset.h"
27
28BOOTSEG = 0x07C0 /* original address of boot-sector */
29SYSSEG = 0x1000 /* historical load address >> 4 */
30
31#ifndef SVGA_MODE
32#define SVGA_MODE ASK_VGA
33#endif
34
35#ifndef RAMDISK
36#define RAMDISK 0
37#endif
38
39#ifndef ROOT_RDONLY
40#define ROOT_RDONLY 1
41#endif
42
43 .code16
44 .section ".bstext", "ax"
45
46 .global bootsect_start
47bootsect_start:
48
49 # Normalize the start address
50 ljmp $BOOTSEG, $start2
51
52start2:
53 movw %cs, %ax
54 movw %ax, %ds
55 movw %ax, %es
56 movw %ax, %ss
57 xorw %sp, %sp
58 sti
59 cld
60
61 movw $bugger_off_msg, %si
62
63msg_loop:
64 lodsb
65 andb %al, %al
66 jz bs_die
67 movb $0xe, %ah
68 movw $7, %bx
69 int $0x10
70 jmp msg_loop
71
72bs_die:
73 # Allow the user to press a key, then reboot
74 xorw %ax, %ax
75 int $0x16
76 int $0x19
77
78 # int 0x19 should never return. In case it does anyway,
79 # invoke the BIOS reset code...
80 ljmp $0xf000,$0xfff0
81
82 .section ".bsdata", "a"
83bugger_off_msg:
84 .ascii "Direct booting from floppy is no longer supported.\r\n"
85 .ascii "Please use a boot loader program instead.\r\n"
86 .ascii "\n"
87 .ascii "Remove disk and press any key to reboot . . .\r\n"
88 .byte 0
89
90
91 # Kernel attributes; used by setup. This is part 1 of the
92 # header, from the old boot sector.
93
94 .section ".header", "a"
95 .globl hdr
96hdr:
97setup_sects: .byte 0 /* Filled in by build.c */
98root_flags: .word ROOT_RDONLY
99syssize: .long 0 /* Filled in by build.c */
100ram_size: .word 0 /* Obsolete */
101vid_mode: .word SVGA_MODE
102root_dev: .word 0 /* Filled in by build.c */
103boot_flag: .word 0xAA55
104
105 # offset 512, entry point
106
107 .globl _start
108_start:
109 # Explicitly enter this as bytes, or the assembler
110 # tries to generate a 3-byte jump here, which causes
111 # everything else to push off to the wrong offset.
112 .byte 0xeb # short (2-byte) jump
113 .byte start_of_setup-1f
1141:
115
116 # Part 2 of the header, from the old setup.S
117
118 .ascii "HdrS" # header signature
119 .word 0x020a # header version number (>= 0x0105)
120 # or else old loadlin-1.5 will fail)
121 .globl realmode_swtch
122realmode_swtch: .word 0, 0 # default_switch, SETUPSEG
123start_sys_seg: .word SYSSEG # obsolete and meaningless, but just
124 # in case something decided to "use" it
125 .word kernel_version-512 # pointing to kernel version string
126 # above section of header is compatible
127 # with loadlin-1.5 (header v1.5). Don't
128 # change it.
129
130type_of_loader: .byte 0 # 0 means ancient bootloader, newer
131 # bootloaders know to change this.
132 # See Documentation/i386/boot.txt for
133 # assigned ids
134
135# flags, unused bits must be zero (RFU) bit within loadflags
136loadflags:
137LOADED_HIGH = 1 # If set, the kernel is loaded high
138CAN_USE_HEAP = 0x80 # If set, the loader also has set
139 # heap_end_ptr to tell how much
140 # space behind setup.S can be used for
141 # heap purposes.
142 # Only the loader knows what is free
143 .byte LOADED_HIGH
144
145setup_move_size: .word 0x8000 # size to move, when setup is not
146 # loaded at 0x90000. We will move setup
147 # to 0x90000 then just before jumping
148 # into the kernel. However, only the
149 # loader knows how much data behind
150 # us also needs to be loaded.
151
152code32_start: # here loaders can put a different
153 # start address for 32-bit code.
154 .long 0x100000 # 0x100000 = default for big kernel
155
156ramdisk_image: .long 0 # address of loaded ramdisk image
157 # Here the loader puts the 32-bit
158 # address where it loaded the image.
159 # This only will be read by the kernel.
160
161ramdisk_size: .long 0 # its size in bytes
162
163bootsect_kludge:
164 .long 0 # obsolete
165
166heap_end_ptr: .word _end+STACK_SIZE-512
167 # (Header version 0x0201 or later)
168 # space from here (exclusive) down to
169 # end of setup code can be used by setup
170 # for local heap purposes.
171
172ext_loader_ver:
173 .byte 0 # Extended boot loader version
174ext_loader_type:
175 .byte 0 # Extended boot loader type
176
177cmd_line_ptr: .long 0 # (Header version 0x0202 or later)
178 # If nonzero, a 32-bit pointer
179 # to the kernel command line.
180 # The command line should be
181 # located between the start of
182 # setup and the end of low
183 # memory (0xa0000), or it may
184 # get overwritten before it
185 # gets read. If this field is
186 # used, there is no longer
187 # anything magical about the
188 # 0x90000 segment; the setup
189 # can be located anywhere in
190 # low memory 0x10000 or higher.
191
192ramdisk_max: .long 0x7fffffff
193 # (Header version 0x0203 or later)
194 # The highest safe address for
195 # the contents of an initrd
196 # The current kernel allows up to 4 GB,
197 # but leave it at 2 GB to avoid
198 # possible bootloader bugs.
199
200kernel_alignment: .long CONFIG_PHYSICAL_ALIGN #physical addr alignment
201 #required for protected mode
202 #kernel
203#ifdef CONFIG_RELOCATABLE
204relocatable_kernel: .byte 1
205#else
206relocatable_kernel: .byte 0
207#endif
208min_alignment: .byte MIN_KERNEL_ALIGN_LG2 # minimum alignment
209pad3: .word 0
210
211cmdline_size: .long COMMAND_LINE_SIZE-1 #length of the command line,
212 #added with boot protocol
213 #version 2.06
214
215hardware_subarch: .long 0 # subarchitecture, added with 2.07
216 # default to 0 for normal x86 PC
217
218hardware_subarch_data: .quad 0
219
220payload_offset: .long ZO_input_data
221payload_length: .long ZO_z_input_len
222
223setup_data: .quad 0 # 64-bit physical pointer to
224 # single linked list of
225 # struct setup_data
226
227pref_address: .quad LOAD_PHYSICAL_ADDR # preferred load addr
228
229#define ZO_INIT_SIZE (ZO__end - ZO_startup_32 + ZO_z_extract_offset)
230#define VO_INIT_SIZE (VO__end - VO__text)
231#if ZO_INIT_SIZE > VO_INIT_SIZE
232#define INIT_SIZE ZO_INIT_SIZE
233#else
234#define INIT_SIZE VO_INIT_SIZE
235#endif
236init_size: .long INIT_SIZE # kernel initialization size
237
238# End of setup header #####################################################
239
240 .section ".entrytext", "ax"
241start_of_setup:
242#ifdef SAFE_RESET_DISK_CONTROLLER
243# Reset the disk controller.
244 movw $0x0000, %ax # Reset disk controller
245 movb $0x80, %dl # All disks
246 int $0x13
247#endif
248
249# Force %es = %ds
250 movw %ds, %ax
251 movw %ax, %es
252 cld
253
254# Apparently some ancient versions of LILO invoked the kernel with %ss != %ds,
255# which happened to work by accident for the old code. Recalculate the stack
256# pointer if %ss is invalid. Otherwise leave it alone, LOADLIN sets up the
257# stack behind its own code, so we can't blindly put it directly past the heap.
258
259 movw %ss, %dx
260 cmpw %ax, %dx # %ds == %ss?
261 movw %sp, %dx
262 je 2f # -> assume %sp is reasonably set
263
264 # Invalid %ss, make up a new stack
265 movw $_end, %dx
266 testb $CAN_USE_HEAP, loadflags
267 jz 1f
268 movw heap_end_ptr, %dx
2691: addw $STACK_SIZE, %dx
270 jnc 2f
271 xorw %dx, %dx # Prevent wraparound
272
2732: # Now %dx should point to the end of our stack space
274 andw $~3, %dx # dword align (might as well...)
275 jnz 3f
276 movw $0xfffc, %dx # Make sure we're not zero
2773: movw %ax, %ss
278 movzwl %dx, %esp # Clear upper half of %esp
279 sti # Now we should have a working stack
280
281# We will have entered with %cs = %ds+0x20, normalize %cs so
282# it is on par with the other segments.
283 pushw %ds
284 pushw $6f
285 lretw
2866:
287
288# Check signature at end of setup
289 cmpl $0x5a5aaa55, setup_sig
290 jne setup_bad
291
292# Zero the bss
293 movw $__bss_start, %di
294 movw $_end+3, %cx
295 xorl %eax, %eax
296 subw %di, %cx
297 shrw $2, %cx
298 rep; stosl
299
300# Jump to C code (should not return)
301 calll main
302
303# Setup corrupt somehow...
304setup_bad:
305 movl $setup_corrupt, %eax
306 calll puts
307 # Fall through...
308
309 .globl die
310 .type die, @function
311die:
312 hlt
313 jmp die
314
315 .size die, .-die
316
317 .section ".initdata", "a"
318setup_corrupt:
319 .byte 7
320 .string "No setup signature found...\n"
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * header.S
4 *
5 * Copyright (C) 1991, 1992 Linus Torvalds
6 *
7 * Based on bootsect.S and setup.S
8 * modified by more people than can be counted
9 *
10 * Rewritten as a common file by H. Peter Anvin (Apr 2007)
11 *
12 * BIG FAT NOTE: We're in real mode using 64k segments. Therefore segment
13 * addresses must be multiplied by 16 to obtain their respective linear
14 * addresses. To avoid confusion, linear addresses are written using leading
15 * hex while segment addresses are written as segment:offset.
16 *
17 */
18#include <linux/pe.h>
19#include <asm/segment.h>
20#include <asm/boot.h>
21#include <asm/page_types.h>
22#include <asm/setup.h>
23#include <asm/bootparam.h>
24#include "boot.h"
25#include "voffset.h"
26#include "zoffset.h"
27
28BOOTSEG = 0x07C0 /* original address of boot-sector */
29SYSSEG = 0x1000 /* historical load address >> 4 */
30
31#ifndef SVGA_MODE
32#define SVGA_MODE ASK_VGA
33#endif
34
35#ifndef ROOT_RDONLY
36#define ROOT_RDONLY 1
37#endif
38
39 .code16
40 .section ".bstext", "ax"
41
42 .global bootsect_start
43bootsect_start:
44#ifdef CONFIG_EFI_STUB
45 # "MZ", MS-DOS header
46 .word MZ_MAGIC
47#endif
48
49 # Normalize the start address
50 ljmp $BOOTSEG, $start2
51
52start2:
53 movw %cs, %ax
54 movw %ax, %ds
55 movw %ax, %es
56 movw %ax, %ss
57 xorw %sp, %sp
58 sti
59 cld
60
61 movw $bugger_off_msg, %si
62
63msg_loop:
64 lodsb
65 andb %al, %al
66 jz bs_die
67 movb $0xe, %ah
68 movw $7, %bx
69 int $0x10
70 jmp msg_loop
71
72bs_die:
73 # Allow the user to press a key, then reboot
74 xorw %ax, %ax
75 int $0x16
76 int $0x19
77
78 # int 0x19 should never return. In case it does anyway,
79 # invoke the BIOS reset code...
80 ljmp $0xf000,$0xfff0
81
82#ifdef CONFIG_EFI_STUB
83 .org 0x3c
84 #
85 # Offset to the PE header.
86 #
87 .long pe_header
88#endif /* CONFIG_EFI_STUB */
89
90 .section ".bsdata", "a"
91bugger_off_msg:
92 .ascii "Use a boot loader.\r\n"
93 .ascii "\n"
94 .ascii "Remove disk and press any key to reboot...\r\n"
95 .byte 0
96
97#ifdef CONFIG_EFI_STUB
98pe_header:
99 .long PE_MAGIC
100
101coff_header:
102#ifdef CONFIG_X86_32
103 .set image_file_add_flags, IMAGE_FILE_32BIT_MACHINE
104 .set pe_opt_magic, PE_OPT_MAGIC_PE32
105 .word IMAGE_FILE_MACHINE_I386
106#else
107 .set image_file_add_flags, 0
108 .set pe_opt_magic, PE_OPT_MAGIC_PE32PLUS
109 .word IMAGE_FILE_MACHINE_AMD64
110#endif
111 .word section_count # nr_sections
112 .long 0 # TimeDateStamp
113 .long 0 # PointerToSymbolTable
114 .long 1 # NumberOfSymbols
115 .word section_table - optional_header # SizeOfOptionalHeader
116 .word IMAGE_FILE_EXECUTABLE_IMAGE | \
117 image_file_add_flags | \
118 IMAGE_FILE_DEBUG_STRIPPED | \
119 IMAGE_FILE_LINE_NUMS_STRIPPED # Characteristics
120
121optional_header:
122 .word pe_opt_magic
123 .byte 0x02 # MajorLinkerVersion
124 .byte 0x14 # MinorLinkerVersion
125
126 # Filled in by build.c
127 .long 0 # SizeOfCode
128
129 .long 0 # SizeOfInitializedData
130 .long 0 # SizeOfUninitializedData
131
132 # Filled in by build.c
133 .long 0x0000 # AddressOfEntryPoint
134
135 .long 0x0200 # BaseOfCode
136#ifdef CONFIG_X86_32
137 .long 0 # data
138#endif
139
140extra_header_fields:
141 # PE specification requires ImageBase to be 64k aligned
142 .set image_base, (LOAD_PHYSICAL_ADDR + 0xffff) & ~0xffff
143#ifdef CONFIG_X86_32
144 .long image_base # ImageBase
145#else
146 .quad image_base # ImageBase
147#endif
148 .long 0x20 # SectionAlignment
149 .long 0x20 # FileAlignment
150 .word 0 # MajorOperatingSystemVersion
151 .word 0 # MinorOperatingSystemVersion
152 .word LINUX_EFISTUB_MAJOR_VERSION # MajorImageVersion
153 .word LINUX_EFISTUB_MINOR_VERSION # MinorImageVersion
154 .word 0 # MajorSubsystemVersion
155 .word 0 # MinorSubsystemVersion
156 .long 0 # Win32VersionValue
157
158 #
159 # The size of the bzImage is written in tools/build.c
160 #
161 .long 0 # SizeOfImage
162
163 .long 0x200 # SizeOfHeaders
164 .long 0 # CheckSum
165 .word IMAGE_SUBSYSTEM_EFI_APPLICATION # Subsystem (EFI application)
166 .word 0 # DllCharacteristics
167#ifdef CONFIG_X86_32
168 .long 0 # SizeOfStackReserve
169 .long 0 # SizeOfStackCommit
170 .long 0 # SizeOfHeapReserve
171 .long 0 # SizeOfHeapCommit
172#else
173 .quad 0 # SizeOfStackReserve
174 .quad 0 # SizeOfStackCommit
175 .quad 0 # SizeOfHeapReserve
176 .quad 0 # SizeOfHeapCommit
177#endif
178 .long 0 # LoaderFlags
179 .long (section_table - .) / 8 # NumberOfRvaAndSizes
180
181 .quad 0 # ExportTable
182 .quad 0 # ImportTable
183 .quad 0 # ResourceTable
184 .quad 0 # ExceptionTable
185 .quad 0 # CertificationTable
186 .quad 0 # BaseRelocationTable
187
188 # Section table
189section_table:
190 #
191 # The offset & size fields are filled in by build.c.
192 #
193 .ascii ".setup"
194 .byte 0
195 .byte 0
196 .long 0
197 .long 0x0 # startup_{32,64}
198 .long 0 # Size of initialized data
199 # on disk
200 .long 0x0 # startup_{32,64}
201 .long 0 # PointerToRelocations
202 .long 0 # PointerToLineNumbers
203 .word 0 # NumberOfRelocations
204 .word 0 # NumberOfLineNumbers
205 .long IMAGE_SCN_CNT_CODE | \
206 IMAGE_SCN_MEM_READ | \
207 IMAGE_SCN_MEM_EXECUTE | \
208 IMAGE_SCN_ALIGN_16BYTES # Characteristics
209
210 #
211 # The EFI application loader requires a relocation section
212 # because EFI applications must be relocatable. The .reloc
213 # offset & size fields are filled in by build.c.
214 #
215 .ascii ".reloc"
216 .byte 0
217 .byte 0
218 .long 0
219 .long 0
220 .long 0 # SizeOfRawData
221 .long 0 # PointerToRawData
222 .long 0 # PointerToRelocations
223 .long 0 # PointerToLineNumbers
224 .word 0 # NumberOfRelocations
225 .word 0 # NumberOfLineNumbers
226 .long IMAGE_SCN_CNT_INITIALIZED_DATA | \
227 IMAGE_SCN_MEM_READ | \
228 IMAGE_SCN_MEM_DISCARDABLE | \
229 IMAGE_SCN_ALIGN_1BYTES # Characteristics
230
231#ifdef CONFIG_EFI_MIXED
232 #
233 # The offset & size fields are filled in by build.c.
234 #
235 .asciz ".compat"
236 .long 0
237 .long 0x0
238 .long 0 # Size of initialized data
239 # on disk
240 .long 0x0
241 .long 0 # PointerToRelocations
242 .long 0 # PointerToLineNumbers
243 .word 0 # NumberOfRelocations
244 .word 0 # NumberOfLineNumbers
245 .long IMAGE_SCN_CNT_INITIALIZED_DATA | \
246 IMAGE_SCN_MEM_READ | \
247 IMAGE_SCN_MEM_DISCARDABLE | \
248 IMAGE_SCN_ALIGN_1BYTES # Characteristics
249#endif
250
251 #
252 # The offset & size fields are filled in by build.c.
253 #
254 .ascii ".text"
255 .byte 0
256 .byte 0
257 .byte 0
258 .long 0
259 .long 0x0 # startup_{32,64}
260 .long 0 # Size of initialized data
261 # on disk
262 .long 0x0 # startup_{32,64}
263 .long 0 # PointerToRelocations
264 .long 0 # PointerToLineNumbers
265 .word 0 # NumberOfRelocations
266 .word 0 # NumberOfLineNumbers
267 .long IMAGE_SCN_CNT_CODE | \
268 IMAGE_SCN_MEM_READ | \
269 IMAGE_SCN_MEM_EXECUTE | \
270 IMAGE_SCN_ALIGN_16BYTES # Characteristics
271
272 .set section_count, (. - section_table) / 40
273#endif /* CONFIG_EFI_STUB */
274
275 # Kernel attributes; used by setup. This is part 1 of the
276 # header, from the old boot sector.
277
278 .section ".header", "a"
279 .globl sentinel
280sentinel: .byte 0xff, 0xff /* Used to detect broken loaders */
281
282 .globl hdr
283hdr:
284setup_sects: .byte 0 /* Filled in by build.c */
285root_flags: .word ROOT_RDONLY
286syssize: .long 0 /* Filled in by build.c */
287ram_size: .word 0 /* Obsolete */
288vid_mode: .word SVGA_MODE
289root_dev: .word 0 /* Filled in by build.c */
290boot_flag: .word 0xAA55
291
292 # offset 512, entry point
293
294 .globl _start
295_start:
296 # Explicitly enter this as bytes, or the assembler
297 # tries to generate a 3-byte jump here, which causes
298 # everything else to push off to the wrong offset.
299 .byte 0xeb # short (2-byte) jump
300 .byte start_of_setup-1f
3011:
302
303 # Part 2 of the header, from the old setup.S
304
305 .ascii "HdrS" # header signature
306 .word 0x020f # header version number (>= 0x0105)
307 # or else old loadlin-1.5 will fail)
308 .globl realmode_swtch
309realmode_swtch: .word 0, 0 # default_switch, SETUPSEG
310start_sys_seg: .word SYSSEG # obsolete and meaningless, but just
311 # in case something decided to "use" it
312 .word kernel_version-512 # pointing to kernel version string
313 # above section of header is compatible
314 # with loadlin-1.5 (header v1.5). Don't
315 # change it.
316
317type_of_loader: .byte 0 # 0 means ancient bootloader, newer
318 # bootloaders know to change this.
319 # See Documentation/x86/boot.rst for
320 # assigned ids
321
322# flags, unused bits must be zero (RFU) bit within loadflags
323loadflags:
324 .byte LOADED_HIGH # The kernel is to be loaded high
325
326setup_move_size: .word 0x8000 # size to move, when setup is not
327 # loaded at 0x90000. We will move setup
328 # to 0x90000 then just before jumping
329 # into the kernel. However, only the
330 # loader knows how much data behind
331 # us also needs to be loaded.
332
333code32_start: # here loaders can put a different
334 # start address for 32-bit code.
335 .long 0x100000 # 0x100000 = default for big kernel
336
337ramdisk_image: .long 0 # address of loaded ramdisk image
338 # Here the loader puts the 32-bit
339 # address where it loaded the image.
340 # This only will be read by the kernel.
341
342ramdisk_size: .long 0 # its size in bytes
343
344bootsect_kludge:
345 .long 0 # obsolete
346
347heap_end_ptr: .word _end+STACK_SIZE-512
348 # (Header version 0x0201 or later)
349 # space from here (exclusive) down to
350 # end of setup code can be used by setup
351 # for local heap purposes.
352
353ext_loader_ver:
354 .byte 0 # Extended boot loader version
355ext_loader_type:
356 .byte 0 # Extended boot loader type
357
358cmd_line_ptr: .long 0 # (Header version 0x0202 or later)
359 # If nonzero, a 32-bit pointer
360 # to the kernel command line.
361 # The command line should be
362 # located between the start of
363 # setup and the end of low
364 # memory (0xa0000), or it may
365 # get overwritten before it
366 # gets read. If this field is
367 # used, there is no longer
368 # anything magical about the
369 # 0x90000 segment; the setup
370 # can be located anywhere in
371 # low memory 0x10000 or higher.
372
373initrd_addr_max: .long 0x7fffffff
374 # (Header version 0x0203 or later)
375 # The highest safe address for
376 # the contents of an initrd
377 # The current kernel allows up to 4 GB,
378 # but leave it at 2 GB to avoid
379 # possible bootloader bugs.
380
381kernel_alignment: .long CONFIG_PHYSICAL_ALIGN #physical addr alignment
382 #required for protected mode
383 #kernel
384#ifdef CONFIG_RELOCATABLE
385relocatable_kernel: .byte 1
386#else
387relocatable_kernel: .byte 0
388#endif
389min_alignment: .byte MIN_KERNEL_ALIGN_LG2 # minimum alignment
390
391xloadflags:
392#ifdef CONFIG_X86_64
393# define XLF0 XLF_KERNEL_64 /* 64-bit kernel */
394#else
395# define XLF0 0
396#endif
397
398#if defined(CONFIG_RELOCATABLE) && defined(CONFIG_X86_64)
399 /* kernel/boot_param/ramdisk could be loaded above 4g */
400# define XLF1 XLF_CAN_BE_LOADED_ABOVE_4G
401#else
402# define XLF1 0
403#endif
404
405#ifdef CONFIG_EFI_STUB
406# ifdef CONFIG_EFI_MIXED
407# define XLF23 (XLF_EFI_HANDOVER_32|XLF_EFI_HANDOVER_64)
408# else
409# ifdef CONFIG_X86_64
410# define XLF23 XLF_EFI_HANDOVER_64 /* 64-bit EFI handover ok */
411# else
412# define XLF23 XLF_EFI_HANDOVER_32 /* 32-bit EFI handover ok */
413# endif
414# endif
415#else
416# define XLF23 0
417#endif
418
419#if defined(CONFIG_X86_64) && defined(CONFIG_EFI) && defined(CONFIG_KEXEC_CORE)
420# define XLF4 XLF_EFI_KEXEC
421#else
422# define XLF4 0
423#endif
424
425#ifdef CONFIG_X86_64
426#ifdef CONFIG_X86_5LEVEL
427#define XLF56 (XLF_5LEVEL|XLF_5LEVEL_ENABLED)
428#else
429#define XLF56 XLF_5LEVEL
430#endif
431#else
432#define XLF56 0
433#endif
434
435 .word XLF0 | XLF1 | XLF23 | XLF4 | XLF56
436
437cmdline_size: .long COMMAND_LINE_SIZE-1 #length of the command line,
438 #added with boot protocol
439 #version 2.06
440
441hardware_subarch: .long 0 # subarchitecture, added with 2.07
442 # default to 0 for normal x86 PC
443
444hardware_subarch_data: .quad 0
445
446payload_offset: .long ZO_input_data
447payload_length: .long ZO_z_input_len
448
449setup_data: .quad 0 # 64-bit physical pointer to
450 # single linked list of
451 # struct setup_data
452
453pref_address: .quad LOAD_PHYSICAL_ADDR # preferred load addr
454
455#
456# Getting to provably safe in-place decompression is hard. Worst case
457# behaviours need to be analyzed. Here let's take the decompression of
458# a gzip-compressed kernel as example, to illustrate it:
459#
460# The file layout of gzip compressed kernel is:
461#
462# magic[2]
463# method[1]
464# flags[1]
465# timestamp[4]
466# extraflags[1]
467# os[1]
468# compressed data blocks[N]
469# crc[4] orig_len[4]
470#
471# ... resulting in +18 bytes overhead of uncompressed data.
472#
473# (For more information, please refer to RFC 1951 and RFC 1952.)
474#
475# Files divided into blocks
476# 1 bit (last block flag)
477# 2 bits (block type)
478#
479# 1 block occurs every 32K -1 bytes or when there 50% compression
480# has been achieved. The smallest block type encoding is always used.
481#
482# stored:
483# 32 bits length in bytes.
484#
485# fixed:
486# magic fixed tree.
487# symbols.
488#
489# dynamic:
490# dynamic tree encoding.
491# symbols.
492#
493#
494# The buffer for decompression in place is the length of the uncompressed
495# data, plus a small amount extra to keep the algorithm safe. The
496# compressed data is placed at the end of the buffer. The output pointer
497# is placed at the start of the buffer and the input pointer is placed
498# where the compressed data starts. Problems will occur when the output
499# pointer overruns the input pointer.
500#
501# The output pointer can only overrun the input pointer if the input
502# pointer is moving faster than the output pointer. A condition only
503# triggered by data whose compressed form is larger than the uncompressed
504# form.
505#
506# The worst case at the block level is a growth of the compressed data
507# of 5 bytes per 32767 bytes.
508#
509# The worst case internal to a compressed block is very hard to figure.
510# The worst case can at least be bounded by having one bit that represents
511# 32764 bytes and then all of the rest of the bytes representing the very
512# very last byte.
513#
514# All of which is enough to compute an amount of extra data that is required
515# to be safe. To avoid problems at the block level allocating 5 extra bytes
516# per 32767 bytes of data is sufficient. To avoid problems internal to a
517# block adding an extra 32767 bytes (the worst case uncompressed block size)
518# is sufficient, to ensure that in the worst case the decompressed data for
519# block will stop the byte before the compressed data for a block begins.
520# To avoid problems with the compressed data's meta information an extra 18
521# bytes are needed. Leading to the formula:
522#
523# extra_bytes = (uncompressed_size >> 12) + 32768 + 18
524#
525# Adding 8 bytes per 32K is a bit excessive but much easier to calculate.
526# Adding 32768 instead of 32767 just makes for round numbers.
527#
528# Above analysis is for decompressing gzip compressed kernel only. Up to
529# now 6 different decompressor are supported all together. And among them
530# xz stores data in chunks and has maximum chunk of 64K. Hence safety
531# margin should be updated to cover all decompressors so that we don't
532# need to deal with each of them separately. Please check
533# the description in lib/decompressor_xxx.c for specific information.
534#
535# extra_bytes = (uncompressed_size >> 12) + 65536 + 128
536#
537# LZ4 is even worse: data that cannot be further compressed grows by 0.4%,
538# or one byte per 256 bytes. OTOH, we can safely get rid of the +128 as
539# the size-dependent part now grows so fast.
540#
541# extra_bytes = (uncompressed_size >> 8) + 65536
542#
543# ZSTD compressed data grows by at most 3 bytes per 128K, and only has a 22
544# byte fixed overhead but has a maximum block size of 128K, so it needs a
545# larger margin.
546#
547# extra_bytes = (uncompressed_size >> 8) + 131072
548
549#define ZO_z_extra_bytes ((ZO_z_output_len >> 8) + 131072)
550#if ZO_z_output_len > ZO_z_input_len
551# define ZO_z_extract_offset (ZO_z_output_len + ZO_z_extra_bytes - \
552 ZO_z_input_len)
553#else
554# define ZO_z_extract_offset ZO_z_extra_bytes
555#endif
556
557/*
558 * The extract_offset has to be bigger than ZO head section. Otherwise when
559 * the head code is running to move ZO to the end of the buffer, it will
560 * overwrite the head code itself.
561 */
562#if (ZO__ehead - ZO_startup_32) > ZO_z_extract_offset
563# define ZO_z_min_extract_offset ((ZO__ehead - ZO_startup_32 + 4095) & ~4095)
564#else
565# define ZO_z_min_extract_offset ((ZO_z_extract_offset + 4095) & ~4095)
566#endif
567
568#define ZO_INIT_SIZE (ZO__end - ZO_startup_32 + ZO_z_min_extract_offset)
569
570#define VO_INIT_SIZE (VO__end - VO__text)
571#if ZO_INIT_SIZE > VO_INIT_SIZE
572# define INIT_SIZE ZO_INIT_SIZE
573#else
574# define INIT_SIZE VO_INIT_SIZE
575#endif
576
577init_size: .long INIT_SIZE # kernel initialization size
578handover_offset: .long 0 # Filled in by build.c
579kernel_info_offset: .long 0 # Filled in by build.c
580
581# End of setup header #####################################################
582
583 .section ".entrytext", "ax"
584start_of_setup:
585# Force %es = %ds
586 movw %ds, %ax
587 movw %ax, %es
588 cld
589
590# Apparently some ancient versions of LILO invoked the kernel with %ss != %ds,
591# which happened to work by accident for the old code. Recalculate the stack
592# pointer if %ss is invalid. Otherwise leave it alone, LOADLIN sets up the
593# stack behind its own code, so we can't blindly put it directly past the heap.
594
595 movw %ss, %dx
596 cmpw %ax, %dx # %ds == %ss?
597 movw %sp, %dx
598 je 2f # -> assume %sp is reasonably set
599
600 # Invalid %ss, make up a new stack
601 movw $_end, %dx
602 testb $CAN_USE_HEAP, loadflags
603 jz 1f
604 movw heap_end_ptr, %dx
6051: addw $STACK_SIZE, %dx
606 jnc 2f
607 xorw %dx, %dx # Prevent wraparound
608
6092: # Now %dx should point to the end of our stack space
610 andw $~3, %dx # dword align (might as well...)
611 jnz 3f
612 movw $0xfffc, %dx # Make sure we're not zero
6133: movw %ax, %ss
614 movzwl %dx, %esp # Clear upper half of %esp
615 sti # Now we should have a working stack
616
617# We will have entered with %cs = %ds+0x20, normalize %cs so
618# it is on par with the other segments.
619 pushw %ds
620 pushw $6f
621 lretw
6226:
623
624# Check signature at end of setup
625 cmpl $0x5a5aaa55, setup_sig
626 jne setup_bad
627
628# Zero the bss
629 movw $__bss_start, %di
630 movw $_end+3, %cx
631 xorl %eax, %eax
632 subw %di, %cx
633 shrw $2, %cx
634 rep; stosl
635
636# Jump to C code (should not return)
637 calll main
638
639# Setup corrupt somehow...
640setup_bad:
641 movl $setup_corrupt, %eax
642 calll puts
643 # Fall through...
644
645 .globl die
646 .type die, @function
647die:
648 hlt
649 jmp die
650
651 .size die, .-die
652
653 .section ".initdata", "a"
654setup_corrupt:
655 .byte 7
656 .string "No setup signature found...\n"