1 /* SPDX-License-Identifier: GPL-2.0 */
5 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Based on bootsect.S and setup.S
8 * modified by more people than can be counted
10 * Rewritten as a common file by H. Peter Anvin (Apr 2007)
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.
19 #include <asm/segment.h>
21 #include <asm/page_types.h>
22 #include <asm/setup.h>
23 #include <asm/bootparam.h>
28 BOOTSEG = 0x07C0 /* original address of boot-sector */
29 SYSSEG = 0x1000 /* historical load address >> 4 */
32 #define SVGA_MODE ASK_VGA
40 .section ".bstext", "ax"
42 .global bootsect_start
44 #ifdef CONFIG_EFI_STUB
49 # Normalize the start address
50 ljmp $BOOTSEG, $start2
61 movw $bugger_off_msg, %si
73 # Allow the user to press a key, then reboot
78 # int 0x19 should never return. In case it does anyway,
79 # invoke the BIOS reset code...
82 #ifdef CONFIG_EFI_STUB
85 # Offset to the PE header.
88 #endif /* CONFIG_EFI_STUB */
90 .section ".bsdata", "a"
92 .ascii "Use a boot loader.\r\n"
94 .ascii "Remove disk and press any key to reboot...\r\n"
97 #ifdef CONFIG_EFI_STUB
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
107 .set image_file_add_flags, 0
108 .set pe_opt_magic, PE_OPT_MAGIC_PE32PLUS
109 .word IMAGE_FILE_MACHINE_AMD64
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
123 .byte 0x02 # MajorLinkerVersion
124 .byte 0x14 # MinorLinkerVersion
126 # Filled in by build.c
129 .long 0 # SizeOfInitializedData
130 .long 0 # SizeOfUninitializedData
132 # Filled in by build.c
133 .long 0x0000 # AddressOfEntryPoint
135 .long 0x0200 # BaseOfCode
141 # PE specification requires ImageBase to be 64k aligned
142 .set image_base, (LOAD_PHYSICAL_ADDR + 0xffff) & ~0xffff
144 .long image_base # ImageBase
146 .quad image_base # ImageBase
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
159 # The size of the bzImage is written in tools/build.c
161 .long 0 # SizeOfImage
163 .long 0x200 # SizeOfHeaders
165 .word IMAGE_SUBSYSTEM_EFI_APPLICATION # Subsystem (EFI application)
166 #ifdef CONFIG_DXE_MEM_ATTRIBUTES
167 .word IMAGE_DLL_CHARACTERISTICS_NX_COMPAT # DllCharacteristics
169 .word 0 # DllCharacteristics
172 .long 0 # SizeOfStackReserve
173 .long 0 # SizeOfStackCommit
174 .long 0 # SizeOfHeapReserve
175 .long 0 # SizeOfHeapCommit
177 .quad 0 # SizeOfStackReserve
178 .quad 0 # SizeOfStackCommit
179 .quad 0 # SizeOfHeapReserve
180 .quad 0 # SizeOfHeapCommit
182 .long 0 # LoaderFlags
183 .long (section_table - .) / 8 # NumberOfRvaAndSizes
185 .quad 0 # ExportTable
186 .quad 0 # ImportTable
187 .quad 0 # ResourceTable
188 .quad 0 # ExceptionTable
189 .quad 0 # CertificationTable
190 .quad 0 # BaseRelocationTable
195 # The offset & size fields are filled in by build.c.
201 .long 0x0 # startup_{32,64}
202 .long 0 # Size of initialized data
204 .long 0x0 # startup_{32,64}
205 .long 0 # PointerToRelocations
206 .long 0 # PointerToLineNumbers
207 .word 0 # NumberOfRelocations
208 .word 0 # NumberOfLineNumbers
209 .long IMAGE_SCN_CNT_CODE | \
210 IMAGE_SCN_MEM_READ | \
211 IMAGE_SCN_MEM_EXECUTE | \
212 IMAGE_SCN_ALIGN_16BYTES # Characteristics
215 # The EFI application loader requires a relocation section
216 # because EFI applications must be relocatable. The .reloc
217 # offset & size fields are filled in by build.c.
224 .long 0 # SizeOfRawData
225 .long 0 # PointerToRawData
226 .long 0 # PointerToRelocations
227 .long 0 # PointerToLineNumbers
228 .word 0 # NumberOfRelocations
229 .word 0 # NumberOfLineNumbers
230 .long IMAGE_SCN_CNT_INITIALIZED_DATA | \
231 IMAGE_SCN_MEM_READ | \
232 IMAGE_SCN_MEM_DISCARDABLE | \
233 IMAGE_SCN_ALIGN_1BYTES # Characteristics
235 #ifdef CONFIG_EFI_MIXED
237 # The offset & size fields are filled in by build.c.
242 .long 0 # Size of initialized data
245 .long 0 # PointerToRelocations
246 .long 0 # PointerToLineNumbers
247 .word 0 # NumberOfRelocations
248 .word 0 # NumberOfLineNumbers
249 .long IMAGE_SCN_CNT_INITIALIZED_DATA | \
250 IMAGE_SCN_MEM_READ | \
251 IMAGE_SCN_MEM_DISCARDABLE | \
252 IMAGE_SCN_ALIGN_1BYTES # Characteristics
256 # The offset & size fields are filled in by build.c.
263 .long 0x0 # startup_{32,64}
264 .long 0 # Size of initialized data
266 .long 0x0 # startup_{32,64}
267 .long 0 # PointerToRelocations
268 .long 0 # PointerToLineNumbers
269 .word 0 # NumberOfRelocations
270 .word 0 # NumberOfLineNumbers
271 .long IMAGE_SCN_CNT_CODE | \
272 IMAGE_SCN_MEM_READ | \
273 IMAGE_SCN_MEM_EXECUTE | \
274 IMAGE_SCN_ALIGN_16BYTES # Characteristics
276 .set section_count, (. - section_table) / 40
277 #endif /* CONFIG_EFI_STUB */
279 # Kernel attributes; used by setup. This is part 1 of the
280 # header, from the old boot sector.
282 .section ".header", "a"
284 sentinel: .byte 0xff, 0xff /* Used to detect broken loaders */
288 setup_sects: .byte 0 /* Filled in by build.c */
289 root_flags: .word ROOT_RDONLY
290 syssize: .long 0 /* Filled in by build.c */
291 ram_size: .word 0 /* Obsolete */
292 vid_mode: .word SVGA_MODE
293 root_dev: .word 0 /* Filled in by build.c */
294 boot_flag: .word 0xAA55
296 # offset 512, entry point
300 # Explicitly enter this as bytes, or the assembler
301 # tries to generate a 3-byte jump here, which causes
302 # everything else to push off to the wrong offset.
303 .byte 0xeb # short (2-byte) jump
304 .byte start_of_setup-1f
307 # Part 2 of the header, from the old setup.S
309 .ascii "HdrS" # header signature
310 .word 0x020f # header version number (>= 0x0105)
311 # or else old loadlin-1.5 will fail)
312 .globl realmode_swtch
313 realmode_swtch: .word 0, 0 # default_switch, SETUPSEG
314 start_sys_seg: .word SYSSEG # obsolete and meaningless, but just
315 # in case something decided to "use" it
316 .word kernel_version-512 # pointing to kernel version string
317 # above section of header is compatible
318 # with loadlin-1.5 (header v1.5). Don't
321 type_of_loader: .byte 0 # 0 means ancient bootloader, newer
322 # bootloaders know to change this.
323 # See Documentation/x86/boot.rst for
326 # flags, unused bits must be zero (RFU) bit within loadflags
328 .byte LOADED_HIGH # The kernel is to be loaded high
330 setup_move_size: .word 0x8000 # size to move, when setup is not
331 # loaded at 0x90000. We will move setup
332 # to 0x90000 then just before jumping
333 # into the kernel. However, only the
334 # loader knows how much data behind
335 # us also needs to be loaded.
337 code32_start: # here loaders can put a different
338 # start address for 32-bit code.
339 .long 0x100000 # 0x100000 = default for big kernel
341 ramdisk_image: .long 0 # address of loaded ramdisk image
342 # Here the loader puts the 32-bit
343 # address where it loaded the image.
344 # This only will be read by the kernel.
346 ramdisk_size: .long 0 # its size in bytes
351 heap_end_ptr: .word _end+STACK_SIZE-512
352 # (Header version 0x0201 or later)
353 # space from here (exclusive) down to
354 # end of setup code can be used by setup
355 # for local heap purposes.
358 .byte 0 # Extended boot loader version
360 .byte 0 # Extended boot loader type
362 cmd_line_ptr: .long 0 # (Header version 0x0202 or later)
363 # If nonzero, a 32-bit pointer
364 # to the kernel command line.
365 # The command line should be
366 # located between the start of
367 # setup and the end of low
368 # memory (0xa0000), or it may
369 # get overwritten before it
370 # gets read. If this field is
371 # used, there is no longer
372 # anything magical about the
373 # 0x90000 segment; the setup
374 # can be located anywhere in
375 # low memory 0x10000 or higher.
377 initrd_addr_max: .long 0x7fffffff
378 # (Header version 0x0203 or later)
379 # The highest safe address for
380 # the contents of an initrd
381 # The current kernel allows up to 4 GB,
382 # but leave it at 2 GB to avoid
383 # possible bootloader bugs.
385 kernel_alignment: .long CONFIG_PHYSICAL_ALIGN #physical addr alignment
386 #required for protected mode
388 #ifdef CONFIG_RELOCATABLE
389 relocatable_kernel: .byte 1
391 relocatable_kernel: .byte 0
393 min_alignment: .byte MIN_KERNEL_ALIGN_LG2 # minimum alignment
397 # define XLF0 XLF_KERNEL_64 /* 64-bit kernel */
402 #if defined(CONFIG_RELOCATABLE) && defined(CONFIG_X86_64)
403 /* kernel/boot_param/ramdisk could be loaded above 4g */
404 # define XLF1 XLF_CAN_BE_LOADED_ABOVE_4G
409 #ifdef CONFIG_EFI_STUB
410 # ifdef CONFIG_EFI_MIXED
411 # define XLF23 (XLF_EFI_HANDOVER_32|XLF_EFI_HANDOVER_64)
413 # ifdef CONFIG_X86_64
414 # define XLF23 XLF_EFI_HANDOVER_64 /* 64-bit EFI handover ok */
416 # define XLF23 XLF_EFI_HANDOVER_32 /* 32-bit EFI handover ok */
423 #if defined(CONFIG_X86_64) && defined(CONFIG_EFI) && defined(CONFIG_KEXEC_CORE)
424 # define XLF4 XLF_EFI_KEXEC
430 #ifdef CONFIG_X86_5LEVEL
431 #define XLF56 (XLF_5LEVEL|XLF_5LEVEL_ENABLED)
433 #define XLF56 XLF_5LEVEL
439 .word XLF0 | XLF1 | XLF23 | XLF4 | XLF56
441 cmdline_size: .long COMMAND_LINE_SIZE-1 #length of the command line,
442 #added with boot protocol
445 hardware_subarch: .long 0 # subarchitecture, added with 2.07
446 # default to 0 for normal x86 PC
448 hardware_subarch_data: .quad 0
450 payload_offset: .long ZO_input_data
451 payload_length: .long ZO_z_input_len
453 setup_data: .quad 0 # 64-bit physical pointer to
454 # single linked list of
457 pref_address: .quad LOAD_PHYSICAL_ADDR # preferred load addr
460 # Getting to provably safe in-place decompression is hard. Worst case
461 # behaviours need to be analyzed. Here let's take the decompression of
462 # a gzip-compressed kernel as example, to illustrate it:
464 # The file layout of gzip compressed kernel is:
472 # compressed data blocks[N]
475 # ... resulting in +18 bytes overhead of uncompressed data.
477 # (For more information, please refer to RFC 1951 and RFC 1952.)
479 # Files divided into blocks
480 # 1 bit (last block flag)
481 # 2 bits (block type)
483 # 1 block occurs every 32K -1 bytes or when there 50% compression
484 # has been achieved. The smallest block type encoding is always used.
487 # 32 bits length in bytes.
494 # dynamic tree encoding.
498 # The buffer for decompression in place is the length of the uncompressed
499 # data, plus a small amount extra to keep the algorithm safe. The
500 # compressed data is placed at the end of the buffer. The output pointer
501 # is placed at the start of the buffer and the input pointer is placed
502 # where the compressed data starts. Problems will occur when the output
503 # pointer overruns the input pointer.
505 # The output pointer can only overrun the input pointer if the input
506 # pointer is moving faster than the output pointer. A condition only
507 # triggered by data whose compressed form is larger than the uncompressed
510 # The worst case at the block level is a growth of the compressed data
511 # of 5 bytes per 32767 bytes.
513 # The worst case internal to a compressed block is very hard to figure.
514 # The worst case can at least be bounded by having one bit that represents
515 # 32764 bytes and then all of the rest of the bytes representing the very
518 # All of which is enough to compute an amount of extra data that is required
519 # to be safe. To avoid problems at the block level allocating 5 extra bytes
520 # per 32767 bytes of data is sufficient. To avoid problems internal to a
521 # block adding an extra 32767 bytes (the worst case uncompressed block size)
522 # is sufficient, to ensure that in the worst case the decompressed data for
523 # block will stop the byte before the compressed data for a block begins.
524 # To avoid problems with the compressed data's meta information an extra 18
525 # bytes are needed. Leading to the formula:
527 # extra_bytes = (uncompressed_size >> 12) + 32768 + 18
529 # Adding 8 bytes per 32K is a bit excessive but much easier to calculate.
530 # Adding 32768 instead of 32767 just makes for round numbers.
532 # Above analysis is for decompressing gzip compressed kernel only. Up to
533 # now 6 different decompressor are supported all together. And among them
534 # xz stores data in chunks and has maximum chunk of 64K. Hence safety
535 # margin should be updated to cover all decompressors so that we don't
536 # need to deal with each of them separately. Please check
537 # the description in lib/decompressor_xxx.c for specific information.
539 # extra_bytes = (uncompressed_size >> 12) + 65536 + 128
541 # LZ4 is even worse: data that cannot be further compressed grows by 0.4%,
542 # or one byte per 256 bytes. OTOH, we can safely get rid of the +128 as
543 # the size-dependent part now grows so fast.
545 # extra_bytes = (uncompressed_size >> 8) + 65536
547 # ZSTD compressed data grows by at most 3 bytes per 128K, and only has a 22
548 # byte fixed overhead but has a maximum block size of 128K, so it needs a
551 # extra_bytes = (uncompressed_size >> 8) + 131072
553 #define ZO_z_extra_bytes ((ZO_z_output_len >> 8) + 131072)
554 #if ZO_z_output_len > ZO_z_input_len
555 # define ZO_z_extract_offset (ZO_z_output_len + ZO_z_extra_bytes - \
558 # define ZO_z_extract_offset ZO_z_extra_bytes
562 * The extract_offset has to be bigger than ZO head section. Otherwise when
563 * the head code is running to move ZO to the end of the buffer, it will
564 * overwrite the head code itself.
566 #if (ZO__ehead - ZO_startup_32) > ZO_z_extract_offset
567 # define ZO_z_min_extract_offset ((ZO__ehead - ZO_startup_32 + 4095) & ~4095)
569 # define ZO_z_min_extract_offset ((ZO_z_extract_offset + 4095) & ~4095)
572 #define ZO_INIT_SIZE (ZO__end - ZO_startup_32 + ZO_z_min_extract_offset)
574 #define VO_INIT_SIZE (VO__end - VO__text)
575 #if ZO_INIT_SIZE > VO_INIT_SIZE
576 # define INIT_SIZE ZO_INIT_SIZE
578 # define INIT_SIZE VO_INIT_SIZE
581 init_size: .long INIT_SIZE # kernel initialization size
582 handover_offset: .long 0 # Filled in by build.c
583 kernel_info_offset: .long 0 # Filled in by build.c
585 # End of setup header #####################################################
587 .section ".entrytext", "ax"
594 # Apparently some ancient versions of LILO invoked the kernel with %ss != %ds,
595 # which happened to work by accident for the old code. Recalculate the stack
596 # pointer if %ss is invalid. Otherwise leave it alone, LOADLIN sets up the
597 # stack behind its own code, so we can't blindly put it directly past the heap.
600 cmpw %ax, %dx # %ds == %ss?
602 je 2f # -> assume %sp is reasonably set
604 # Invalid %ss, make up a new stack
606 testb $CAN_USE_HEAP, loadflags
608 movw heap_end_ptr, %dx
609 1: addw $STACK_SIZE, %dx
611 xorw %dx, %dx # Prevent wraparound
613 2: # Now %dx should point to the end of our stack space
614 andw $~3, %dx # dword align (might as well...)
616 movw $0xfffc, %dx # Make sure we're not zero
618 movzwl %dx, %esp # Clear upper half of %esp
619 sti # Now we should have a working stack
621 # We will have entered with %cs = %ds+0x20, normalize %cs so
622 # it is on par with the other segments.
628 # Check signature at end of setup
629 cmpl $0x5a5aaa55, setup_sig
633 movw $__bss_start, %di
640 # Jump to C code (should not return)
643 # Setup corrupt somehow...
645 movl $setup_corrupt, %eax
657 .section ".initdata", "a"
660 .string "No setup signature found...\n"