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