[mirror_ubuntu-bionic-kernel.git] / arch / x86 / boot / header.S

/* SPDX-License-Identifier: GPL-2.0 */
/*
 *	header.S
 *
 *	Copyright (C) 1991, 1992 Linus Torvalds
 *
 *	Based on bootsect.S and setup.S
 *	modified by more people than can be counted
 *
 *	Rewritten as a common file by H. Peter Anvin (Apr 2007)
 *
 * BIG FAT NOTE: We're in real mode using 64k segments.  Therefore segment
 * addresses must be multiplied by 16 to obtain their respective linear
 * addresses. To avoid confusion, linear addresses are written using leading
 * hex while segment addresses are written as segment:offset.
 *
 */

#include <asm/segment.h>
#include <asm/boot.h>
#include <asm/page_types.h>
#include <asm/setup.h>
#include <asm/bootparam.h>
#include "boot.h"
#include "voffset.h"
#include "zoffset.h"

BOOTSEG		= 0x07C0		/* original address of boot-sector */
SYSSEG		= 0x1000		/* historical load address >> 4 */

#ifndef SVGA_MODE
#define SVGA_MODE ASK_VGA
#endif

#ifndef ROOT_RDONLY
#define ROOT_RDONLY 1
#endif

	.code16
	.section ".bstext", "ax"

	.global bootsect_start
bootsect_start:
#ifdef CONFIG_EFI_STUB
	# "MZ", MS-DOS header
	.byte 0x4d
	.byte 0x5a
#endif

	# Normalize the start address
	ljmp	$BOOTSEG, $start2

start2:
	movw	%cs, %ax
	movw	%ax, %ds
	movw	%ax, %es
	movw	%ax, %ss
	xorw	%sp, %sp
	sti
	cld

	movw	$bugger_off_msg, %si

msg_loop:
	lodsb
	andb	%al, %al
	jz	bs_die
	movb	$0xe, %ah
	movw	$7, %bx
	int	$0x10
	jmp	msg_loop

bs_die:
	# Allow the user to press a key, then reboot
	xorw	%ax, %ax
	int	$0x16
	int	$0x19

	# int 0x19 should never return.  In case it does anyway,
	# invoke the BIOS reset code...
	ljmp	$0xf000,$0xfff0

#ifdef CONFIG_EFI_STUB
	.org	0x3c
	#
	# Offset to the PE header.
	#
	.long	pe_header
#endif /* CONFIG_EFI_STUB */

	.section ".bsdata", "a"
bugger_off_msg:
	.ascii	"Use a boot loader.\r\n"
	.ascii	"\n"
	.ascii	"Remove disk and press any key to reboot...\r\n"
	.byte	0

#ifdef CONFIG_EFI_STUB
pe_header:
	.ascii	"PE"
	.word 	0

coff_header:
#ifdef CONFIG_X86_32
	.word	0x14c				# i386
#else
	.word	0x8664				# x86-64
#endif
	.word	4				# nr_sections
	.long	0 				# TimeDateStamp
	.long	0				# PointerToSymbolTable
	.long	1				# NumberOfSymbols
	.word	section_table - optional_header	# SizeOfOptionalHeader
#ifdef CONFIG_X86_32
	.word	0x306				# Characteristics.
						# IMAGE_FILE_32BIT_MACHINE |
						# IMAGE_FILE_DEBUG_STRIPPED |
						# IMAGE_FILE_EXECUTABLE_IMAGE |
						# IMAGE_FILE_LINE_NUMS_STRIPPED
#else
	.word	0x206				# Characteristics
						# IMAGE_FILE_DEBUG_STRIPPED |
						# IMAGE_FILE_EXECUTABLE_IMAGE |
						# IMAGE_FILE_LINE_NUMS_STRIPPED
#endif

optional_header:
#ifdef CONFIG_X86_32
	.word	0x10b				# PE32 format
#else
	.word	0x20b 				# PE32+ format
#endif
	.byte	0x02				# MajorLinkerVersion
	.byte	0x14				# MinorLinkerVersion

	# Filled in by build.c
	.long	0				# SizeOfCode

	.long	0				# SizeOfInitializedData
	.long	0				# SizeOfUninitializedData

	# Filled in by build.c
	.long	0x0000				# AddressOfEntryPoint

	.long	0x0200				# BaseOfCode
#ifdef CONFIG_X86_32
	.long	0				# data
#endif

extra_header_fields:
#ifdef CONFIG_X86_32
	.long	0				# ImageBase
#else
	.quad	0				# ImageBase
#endif
	.long	0x20				# SectionAlignment
	.long	0x20				# FileAlignment
	.word	0				# MajorOperatingSystemVersion
	.word	0				# MinorOperatingSystemVersion
	.word	0				# MajorImageVersion
	.word	0				# MinorImageVersion
	.word	0				# MajorSubsystemVersion
	.word	0				# MinorSubsystemVersion
	.long	0				# Win32VersionValue

	#
	# The size of the bzImage is written in tools/build.c
	#
	.long	0				# SizeOfImage

	.long	0x200				# SizeOfHeaders
	.long	0				# CheckSum
	.word	0xa				# Subsystem (EFI application)
	.word	0				# DllCharacteristics
#ifdef CONFIG_X86_32
	.long	0				# SizeOfStackReserve
	.long	0				# SizeOfStackCommit
	.long	0				# SizeOfHeapReserve
	.long	0				# SizeOfHeapCommit
#else
	.quad	0				# SizeOfStackReserve
	.quad	0				# SizeOfStackCommit
	.quad	0				# SizeOfHeapReserve
	.quad	0				# SizeOfHeapCommit
#endif
	.long	0				# LoaderFlags
	.long	0x6				# NumberOfRvaAndSizes

	.quad	0				# ExportTable
	.quad	0				# ImportTable
	.quad	0				# ResourceTable
	.quad	0				# ExceptionTable
	.quad	0				# CertificationTable
	.quad	0				# BaseRelocationTable

	# Section table
section_table:
	#
	# The offset & size fields are filled in by build.c.
	#
	.ascii	".setup"
	.byte	0
	.byte	0
	.long	0
	.long	0x0				# startup_{32,64}
	.long	0				# Size of initialized data
						# on disk
	.long	0x0				# startup_{32,64}
	.long	0				# PointerToRelocations
	.long	0				# PointerToLineNumbers
	.word	0				# NumberOfRelocations
	.word	0				# NumberOfLineNumbers
	.long	0x60500020			# Characteristics (section flags)

	#
	# The EFI application loader requires a relocation section
	# because EFI applications must be relocatable. The .reloc
	# offset & size fields are filled in by build.c.
	#
	.ascii	".reloc"
	.byte	0
	.byte	0
	.long	0
	.long	0
	.long	0				# SizeOfRawData
	.long	0				# PointerToRawData
	.long	0				# PointerToRelocations
	.long	0				# PointerToLineNumbers
	.word	0				# NumberOfRelocations
	.word	0				# NumberOfLineNumbers
	.long	0x42100040			# Characteristics (section flags)

	#
	# The offset & size fields are filled in by build.c.
	#
	.ascii	".text"
	.byte	0
	.byte	0
	.byte	0
	.long	0
	.long	0x0				# startup_{32,64}
	.long	0				# Size of initialized data
						# on disk
	.long	0x0				# startup_{32,64}
	.long	0				# PointerToRelocations
	.long	0				# PointerToLineNumbers
	.word	0				# NumberOfRelocations
	.word	0				# NumberOfLineNumbers
	.long	0x60500020			# Characteristics (section flags)

	#
	# The offset & size fields are filled in by build.c.
	#
	.ascii	".bss"
	.byte	0
	.byte	0
	.byte	0
	.byte	0
	.long	0
	.long	0x0
	.long	0				# Size of initialized data
						# on disk
	.long	0x0
	.long	0				# PointerToRelocations
	.long	0				# PointerToLineNumbers
	.word	0				# NumberOfRelocations
	.word	0				# NumberOfLineNumbers
	.long	0xc8000080			# Characteristics (section flags)

#endif /* CONFIG_EFI_STUB */

	# Kernel attributes; used by setup.  This is part 1 of the
	# header, from the old boot sector.

	.section ".header", "a"
	.globl	sentinel
sentinel:	.byte 0xff, 0xff        /* Used to detect broken loaders */

	.globl	hdr
hdr:
setup_sects:	.byte 0			/* Filled in by build.c */
root_flags:	.word ROOT_RDONLY
syssize:	.long 0			/* Filled in by build.c */
ram_size:	.word 0			/* Obsolete */
vid_mode:	.word SVGA_MODE
root_dev:	.word 0			/* Filled in by build.c */
boot_flag:	.word 0xAA55

	# offset 512, entry point

	.globl	_start
_start:
		# Explicitly enter this as bytes, or the assembler
		# tries to generate a 3-byte jump here, which causes
		# everything else to push off to the wrong offset.
		.byte	0xeb		# short (2-byte) jump
		.byte	start_of_setup-1f
1:

	# Part 2 of the header, from the old setup.S

		.ascii	"HdrS"		# header signature
		.word	0x020d		# header version number (>= 0x0105)
					# or else old loadlin-1.5 will fail)
		.globl realmode_swtch
realmode_swtch:	.word	0, 0		# default_switch, SETUPSEG
start_sys_seg:	.word	SYSSEG		# obsolete and meaningless, but just
					# in case something decided to "use" it
		.word	kernel_version-512 # pointing to kernel version string
					# above section of header is compatible
					# with loadlin-1.5 (header v1.5). Don't
					# change it.

type_of_loader:	.byte	0		# 0 means ancient bootloader, newer
					# bootloaders know to change this.
					# See Documentation/x86/boot.txt for
					# assigned ids

# flags, unused bits must be zero (RFU) bit within loadflags
loadflags:
		.byte	LOADED_HIGH	# The kernel is to be loaded high

setup_move_size: .word  0x8000		# size to move, when setup is not
					# loaded at 0x90000. We will move setup
					# to 0x90000 then just before jumping
					# into the kernel. However, only the
					# loader knows how much data behind
					# us also needs to be loaded.

code32_start:				# here loaders can put a different
					# start address for 32-bit code.
		.long	0x100000	# 0x100000 = default for big kernel

ramdisk_image:	.long	0		# address of loaded ramdisk image
					# Here the loader puts the 32-bit
					# address where it loaded the image.
					# This only will be read by the kernel.

ramdisk_size:	.long	0		# its size in bytes

bootsect_kludge:
		.long	0		# obsolete

heap_end_ptr:	.word	_end+STACK_SIZE-512
					# (Header version 0x0201 or later)
					# space from here (exclusive) down to
					# end of setup code can be used by setup
					# for local heap purposes.

ext_loader_ver:
		.byte	0		# Extended boot loader version
ext_loader_type:
		.byte	0		# Extended boot loader type

cmd_line_ptr:	.long	0		# (Header version 0x0202 or later)
					# If nonzero, a 32-bit pointer
					# to the kernel command line.
					# The command line should be
					# located between the start of
					# setup and the end of low
					# memory (0xa0000), or it may
					# get overwritten before it
					# gets read.  If this field is
					# used, there is no longer
					# anything magical about the
					# 0x90000 segment; the setup
					# can be located anywhere in
					# low memory 0x10000 or higher.

initrd_addr_max: .long 0x7fffffff
					# (Header version 0x0203 or later)
					# The highest safe address for
					# the contents of an initrd
					# The current kernel allows up to 4 GB,
					# but leave it at 2 GB to avoid
					# possible bootloader bugs.

kernel_alignment:  .long CONFIG_PHYSICAL_ALIGN	#physical addr alignment
						#required for protected mode
						#kernel
#ifdef CONFIG_RELOCATABLE
relocatable_kernel:    .byte 1
#else
relocatable_kernel:    .byte 0
#endif
min_alignment:		.byte MIN_KERNEL_ALIGN_LG2	# minimum alignment

xloadflags:
#ifdef CONFIG_X86_64
# define XLF0 XLF_KERNEL_64			/* 64-bit kernel */
#else
# define XLF0 0
#endif

#if defined(CONFIG_RELOCATABLE) && defined(CONFIG_X86_64)
   /* kernel/boot_param/ramdisk could be loaded above 4g */
# define XLF1 XLF_CAN_BE_LOADED_ABOVE_4G
#else
# define XLF1 0
#endif

#ifdef CONFIG_EFI_STUB
# ifdef CONFIG_EFI_MIXED
#  define XLF23 (XLF_EFI_HANDOVER_32|XLF_EFI_HANDOVER_64)
# else
#  ifdef CONFIG_X86_64
#   define XLF23 XLF_EFI_HANDOVER_64		/* 64-bit EFI handover ok */
#  else
#   define XLF23 XLF_EFI_HANDOVER_32		/* 32-bit EFI handover ok */
#  endif
# endif
#else
# define XLF23 0
#endif

#if defined(CONFIG_X86_64) && defined(CONFIG_EFI) && defined(CONFIG_KEXEC_CORE)
# define XLF4 XLF_EFI_KEXEC
#else
# define XLF4 0
#endif

			.word XLF0 | XLF1 | XLF23 | XLF4

cmdline_size:   .long   COMMAND_LINE_SIZE-1     #length of the command line,
                                                #added with boot protocol
                                                #version 2.06

hardware_subarch:	.long 0			# subarchitecture, added with 2.07
						# default to 0 for normal x86 PC

hardware_subarch_data:	.quad 0

payload_offset:		.long ZO_input_data
payload_length:		.long ZO_z_input_len

setup_data:		.quad 0			# 64-bit physical pointer to
						# single linked list of
						# struct setup_data

pref_address:		.quad LOAD_PHYSICAL_ADDR	# preferred load addr

#
# Getting to provably safe in-place decompression is hard. Worst case
# behaviours need to be analyzed. Here let's take the decompression of
# a gzip-compressed kernel as example, to illustrate it:
#
# The file layout of gzip compressed kernel is:
#
#    magic[2]
#    method[1]
#    flags[1]
#    timestamp[4]
#    extraflags[1]
#    os[1]
#    compressed data blocks[N]
#    crc[4] orig_len[4]
#
# ... resulting in +18 bytes overhead of uncompressed data.
#
# (For more information, please refer to RFC 1951 and RFC 1952.)
#
# Files divided into blocks
# 1 bit (last block flag)
# 2 bits (block type)
#
# 1 block occurs every 32K -1 bytes or when there 50% compression
# has been achieved. The smallest block type encoding is always used.
#
# stored:
#    32 bits length in bytes.
#
# fixed:
#    magic fixed tree.
#    symbols.
#
# dynamic:
#    dynamic tree encoding.
#    symbols.
#
#
# The buffer for decompression in place is the length of the uncompressed
# data, plus a small amount extra to keep the algorithm safe. The
# compressed data is placed at the end of the buffer.  The output pointer
# is placed at the start of the buffer and the input pointer is placed
# where the compressed data starts. Problems will occur when the output
# pointer overruns the input pointer.
#
# The output pointer can only overrun the input pointer if the input
# pointer is moving faster than the output pointer.  A condition only
# triggered by data whose compressed form is larger than the uncompressed
# form.
#
# The worst case at the block level is a growth of the compressed data
# of 5 bytes per 32767 bytes.
#
# The worst case internal to a compressed block is very hard to figure.
# The worst case can at least be bounded by having one bit that represents
# 32764 bytes and then all of the rest of the bytes representing the very
# very last byte.
#
# All of which is enough to compute an amount of extra data that is required
# to be safe.  To avoid problems at the block level allocating 5 extra bytes
# per 32767 bytes of data is sufficient.  To avoid problems internal to a
# block adding an extra 32767 bytes (the worst case uncompressed block size)
# is sufficient, to ensure that in the worst case the decompressed data for
# block will stop the byte before the compressed data for a block begins.
# To avoid problems with the compressed data's meta information an extra 18
# bytes are needed.  Leading to the formula:
#
# extra_bytes = (uncompressed_size >> 12) + 32768 + 18
#
# Adding 8 bytes per 32K is a bit excessive but much easier to calculate.
# Adding 32768 instead of 32767 just makes for round numbers.
#
# Above analysis is for decompressing gzip compressed kernel only. Up to
# now 6 different decompressor are supported all together. And among them
# xz stores data in chunks and has maximum chunk of 64K. Hence safety
# margin should be updated to cover all decompressors so that we don't
# need to deal with each of them separately. Please check
# the description in lib/decompressor_xxx.c for specific information.
#
# extra_bytes = (uncompressed_size >> 12) + 65536 + 128
#
# LZ4 is even worse: data that cannot be further compressed grows by 0.4%,
# or one byte per 256 bytes. OTOH, we can safely get rid of the +128 as
# the size-dependent part now grows so fast.
#
# extra_bytes = (uncompressed_size >> 8) + 65536

#define ZO_z_extra_bytes	((ZO_z_output_len >> 8) + 65536)
#if ZO_z_output_len > ZO_z_input_len
# define ZO_z_extract_offset	(ZO_z_output_len + ZO_z_extra_bytes - \
				 ZO_z_input_len)
#else
# define ZO_z_extract_offset	ZO_z_extra_bytes
#endif

/*
 * The extract_offset has to be bigger than ZO head section. Otherwise when
 * the head code is running to move ZO to the end of the buffer, it will
 * overwrite the head code itself.
 */
#if (ZO__ehead - ZO_startup_32) > ZO_z_extract_offset
# define ZO_z_min_extract_offset ((ZO__ehead - ZO_startup_32 + 4095) & ~4095)
#else
# define ZO_z_min_extract_offset ((ZO_z_extract_offset + 4095) & ~4095)
#endif

#define ZO_INIT_SIZE	(ZO__end - ZO_startup_32 + ZO_z_min_extract_offset)

#define VO_INIT_SIZE	(VO__end - VO__text)
#if ZO_INIT_SIZE > VO_INIT_SIZE
# define INIT_SIZE ZO_INIT_SIZE
#else
# define INIT_SIZE VO_INIT_SIZE
#endif

init_size:		.long INIT_SIZE		# kernel initialization size
handover_offset:	.long 0			# Filled in by build.c

# End of setup header #####################################################

	.section ".entrytext", "ax"
start_of_setup:
# Force %es = %ds
	movw	%ds, %ax
	movw	%ax, %es
	cld

# Apparently some ancient versions of LILO invoked the kernel with %ss != %ds,
# which happened to work by accident for the old code.  Recalculate the stack
# pointer if %ss is invalid.  Otherwise leave it alone, LOADLIN sets up the
# stack behind its own code, so we can't blindly put it directly past the heap.

	movw	%ss, %dx
	cmpw	%ax, %dx	# %ds == %ss?
	movw	%sp, %dx
	je	2f		# -> assume %sp is reasonably set

	# Invalid %ss, make up a new stack
	movw	$_end, %dx
	testb	$CAN_USE_HEAP, loadflags
	jz	1f
	movw	heap_end_ptr, %dx
1:	addw	$STACK_SIZE, %dx
	jnc	2f
	xorw	%dx, %dx	# Prevent wraparound

2:	# Now %dx should point to the end of our stack space
	andw	$~3, %dx	# dword align (might as well...)
	jnz	3f
	movw	$0xfffc, %dx	# Make sure we're not zero
3:	movw	%ax, %ss
	movzwl	%dx, %esp	# Clear upper half of %esp
	sti			# Now we should have a working stack

# We will have entered with %cs = %ds+0x20, normalize %cs so
# it is on par with the other segments.
	pushw	%ds
	pushw	$6f
	lretw
6:

# Check signature at end of setup
	cmpl	$0x5a5aaa55, setup_sig
	jne	setup_bad

# Zero the bss
	movw	$__bss_start, %di
	movw	$_end+3, %cx
	xorl	%eax, %eax
	subw	%di, %cx
	shrw	$2, %cx
	rep; stosl

# Jump to C code (should not return)
	calll	main

# Setup corrupt somehow...
setup_bad:
	movl	$setup_corrupt, %eax
	calll	puts
	# Fall through...

	.globl	die
	.type	die, @function
die:
	hlt
	jmp	die

	.size	die, .-die

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