Linux Audio

Check our new training course

Loading...
v3.15
 
  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	"Direct floppy boot is not supported. "
 95	.ascii	"Use a boot loader program instead.\r\n"
 96	.ascii	"\n"
 97	.ascii	"Remove disk and press any key to reboot ...\r\n"
 98	.byte	0
 99
100#ifdef CONFIG_EFI_STUB
101pe_header:
102	.ascii	"PE"
103	.word 	0
104
105coff_header:
106#ifdef CONFIG_X86_32
107	.word	0x14c				# i386
108#else
109	.word	0x8664				# x86-64
 
 
 
 
110#endif
111	.word	3				# nr_sections
112	.long	0 				# TimeDateStamp
113	.long	0				# PointerToSymbolTable
114	.long	1				# NumberOfSymbols
115	.word	section_table - optional_header	# SizeOfOptionalHeader
116#ifdef CONFIG_X86_32
117	.word	0x306				# Characteristics.
118						# IMAGE_FILE_32BIT_MACHINE |
119						# IMAGE_FILE_DEBUG_STRIPPED |
120						# IMAGE_FILE_EXECUTABLE_IMAGE |
121						# IMAGE_FILE_LINE_NUMS_STRIPPED
122#else
123	.word	0x206				# Characteristics
124						# IMAGE_FILE_DEBUG_STRIPPED |
125						# IMAGE_FILE_EXECUTABLE_IMAGE |
126						# IMAGE_FILE_LINE_NUMS_STRIPPED
127#endif
128
129optional_header:
130#ifdef CONFIG_X86_32
131	.word	0x10b				# PE32 format
132#else
133	.word	0x20b 				# PE32+ format
134#endif
135	.byte	0x02				# MajorLinkerVersion
136	.byte	0x14				# MinorLinkerVersion
137
138	# Filled in by build.c
139	.long	0				# SizeOfCode
140
141	.long	0				# SizeOfInitializedData
142	.long	0				# SizeOfUninitializedData
143
144	# Filled in by build.c
145	.long	0x0000				# AddressOfEntryPoint
146
147	.long	0x0200				# BaseOfCode
148#ifdef CONFIG_X86_32
149	.long	0				# data
150#endif
151
152extra_header_fields:
 
 
153#ifdef CONFIG_X86_32
154	.long	0				# ImageBase
155#else
156	.quad	0				# ImageBase
157#endif
158	.long	0x20				# SectionAlignment
159	.long	0x20				# FileAlignment
160	.word	0				# MajorOperatingSystemVersion
161	.word	0				# MinorOperatingSystemVersion
162	.word	0				# MajorImageVersion
163	.word	0				# MinorImageVersion
164	.word	0				# MajorSubsystemVersion
165	.word	0				# MinorSubsystemVersion
166	.long	0				# Win32VersionValue
167
168	#
169	# The size of the bzImage is written in tools/build.c
170	#
171	.long	0				# SizeOfImage
172
173	.long	0x200				# SizeOfHeaders
174	.long	0				# CheckSum
175	.word	0xa				# Subsystem (EFI application)
 
 
 
176	.word	0				# DllCharacteristics
 
177#ifdef CONFIG_X86_32
178	.long	0				# SizeOfStackReserve
179	.long	0				# SizeOfStackCommit
180	.long	0				# SizeOfHeapReserve
181	.long	0				# SizeOfHeapCommit
182#else
183	.quad	0				# SizeOfStackReserve
184	.quad	0				# SizeOfStackCommit
185	.quad	0				# SizeOfHeapReserve
186	.quad	0				# SizeOfHeapCommit
187#endif
188	.long	0				# LoaderFlags
189	.long	0x6				# NumberOfRvaAndSizes
190
191	.quad	0				# ExportTable
192	.quad	0				# ImportTable
193	.quad	0				# ResourceTable
194	.quad	0				# ExceptionTable
195	.quad	0				# CertificationTable
196	.quad	0				# BaseRelocationTable
197
198	# Section table
199section_table:
200	#
201	# The offset & size fields are filled in by build.c.
202	#
203	.ascii	".setup"
204	.byte	0
205	.byte	0
206	.long	0
207	.long	0x0				# startup_{32,64}
208	.long	0				# Size of initialized data
209						# on disk
210	.long	0x0				# startup_{32,64}
211	.long	0				# PointerToRelocations
212	.long	0				# PointerToLineNumbers
213	.word	0				# NumberOfRelocations
214	.word	0				# NumberOfLineNumbers
215	.long	0x60500020			# Characteristics (section flags)
 
 
 
216
217	#
218	# The EFI application loader requires a relocation section
219	# because EFI applications must be relocatable. The .reloc
220	# offset & size fields are filled in by build.c.
221	#
222	.ascii	".reloc"
223	.byte	0
224	.byte	0
225	.long	0
226	.long	0
227	.long	0				# SizeOfRawData
228	.long	0				# PointerToRawData
229	.long	0				# PointerToRelocations
230	.long	0				# PointerToLineNumbers
231	.word	0				# NumberOfRelocations
232	.word	0				# NumberOfLineNumbers
233	.long	0x42100040			# Characteristics (section flags)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
234
235	#
236	# The offset & size fields are filled in by build.c.
237	#
238	.ascii	".text"
239	.byte	0
240	.byte	0
241	.byte	0
242	.long	0
243	.long	0x0				# startup_{32,64}
244	.long	0				# Size of initialized data
245						# on disk
246	.long	0x0				# startup_{32,64}
247	.long	0				# PointerToRelocations
248	.long	0				# PointerToLineNumbers
249	.word	0				# NumberOfRelocations
250	.word	0				# NumberOfLineNumbers
251	.long	0x60500020			# Characteristics (section flags)
 
 
 
252
 
253#endif /* CONFIG_EFI_STUB */
254
255	# Kernel attributes; used by setup.  This is part 1 of the
256	# header, from the old boot sector.
257
258	.section ".header", "a"
259	.globl	sentinel
260sentinel:	.byte 0xff, 0xff        /* Used to detect broken loaders */
261
262	.globl	hdr
263hdr:
264setup_sects:	.byte 0			/* Filled in by build.c */
265root_flags:	.word ROOT_RDONLY
266syssize:	.long 0			/* Filled in by build.c */
267ram_size:	.word 0			/* Obsolete */
268vid_mode:	.word SVGA_MODE
269root_dev:	.word 0			/* Filled in by build.c */
270boot_flag:	.word 0xAA55
271
272	# offset 512, entry point
273
274	.globl	_start
275_start:
276		# Explicitly enter this as bytes, or the assembler
277		# tries to generate a 3-byte jump here, which causes
278		# everything else to push off to the wrong offset.
279		.byte	0xeb		# short (2-byte) jump
280		.byte	start_of_setup-1f
2811:
282
283	# Part 2 of the header, from the old setup.S
284
285		.ascii	"HdrS"		# header signature
286		.word	0x020d		# header version number (>= 0x0105)
287					# or else old loadlin-1.5 will fail)
288		.globl realmode_swtch
289realmode_swtch:	.word	0, 0		# default_switch, SETUPSEG
290start_sys_seg:	.word	SYSSEG		# obsolete and meaningless, but just
291					# in case something decided to "use" it
292		.word	kernel_version-512 # pointing to kernel version string
293					# above section of header is compatible
294					# with loadlin-1.5 (header v1.5). Don't
295					# change it.
296
297type_of_loader:	.byte	0		# 0 means ancient bootloader, newer
298					# bootloaders know to change this.
299					# See Documentation/x86/boot.txt for
300					# assigned ids
301
302# flags, unused bits must be zero (RFU) bit within loadflags
303loadflags:
304		.byte	LOADED_HIGH	# The kernel is to be loaded high
305
306setup_move_size: .word  0x8000		# size to move, when setup is not
307					# loaded at 0x90000. We will move setup
308					# to 0x90000 then just before jumping
309					# into the kernel. However, only the
310					# loader knows how much data behind
311					# us also needs to be loaded.
312
313code32_start:				# here loaders can put a different
314					# start address for 32-bit code.
315		.long	0x100000	# 0x100000 = default for big kernel
316
317ramdisk_image:	.long	0		# address of loaded ramdisk image
318					# Here the loader puts the 32-bit
319					# address where it loaded the image.
320					# This only will be read by the kernel.
321
322ramdisk_size:	.long	0		# its size in bytes
323
324bootsect_kludge:
325		.long	0		# obsolete
326
327heap_end_ptr:	.word	_end+STACK_SIZE-512
328					# (Header version 0x0201 or later)
329					# space from here (exclusive) down to
330					# end of setup code can be used by setup
331					# for local heap purposes.
332
333ext_loader_ver:
334		.byte	0		# Extended boot loader version
335ext_loader_type:
336		.byte	0		# Extended boot loader type
337
338cmd_line_ptr:	.long	0		# (Header version 0x0202 or later)
339					# If nonzero, a 32-bit pointer
340					# to the kernel command line.
341					# The command line should be
342					# located between the start of
343					# setup and the end of low
344					# memory (0xa0000), or it may
345					# get overwritten before it
346					# gets read.  If this field is
347					# used, there is no longer
348					# anything magical about the
349					# 0x90000 segment; the setup
350					# can be located anywhere in
351					# low memory 0x10000 or higher.
352
353initrd_addr_max: .long 0x7fffffff
354					# (Header version 0x0203 or later)
355					# The highest safe address for
356					# the contents of an initrd
357					# The current kernel allows up to 4 GB,
358					# but leave it at 2 GB to avoid
359					# possible bootloader bugs.
360
361kernel_alignment:  .long CONFIG_PHYSICAL_ALIGN	#physical addr alignment
362						#required for protected mode
363						#kernel
364#ifdef CONFIG_RELOCATABLE
365relocatable_kernel:    .byte 1
366#else
367relocatable_kernel:    .byte 0
368#endif
369min_alignment:		.byte MIN_KERNEL_ALIGN_LG2	# minimum alignment
370
371xloadflags:
372#ifdef CONFIG_X86_64
373# define XLF0 XLF_KERNEL_64			/* 64-bit kernel */
374#else
375# define XLF0 0
376#endif
377
378#if defined(CONFIG_RELOCATABLE) && defined(CONFIG_X86_64)
379   /* kernel/boot_param/ramdisk could be loaded above 4g */
380# define XLF1 XLF_CAN_BE_LOADED_ABOVE_4G
381#else
382# define XLF1 0
383#endif
384
385#ifdef CONFIG_EFI_STUB
386# ifdef CONFIG_EFI_MIXED
387#  define XLF23 (XLF_EFI_HANDOVER_32|XLF_EFI_HANDOVER_64)
388# else
389#  ifdef CONFIG_X86_64
390#   define XLF23 XLF_EFI_HANDOVER_64		/* 64-bit EFI handover ok */
391#  else
392#   define XLF23 XLF_EFI_HANDOVER_32		/* 32-bit EFI handover ok */
393#  endif
394# endif
395#else
396# define XLF23 0
397#endif
398
399#if defined(CONFIG_X86_64) && defined(CONFIG_EFI) && defined(CONFIG_KEXEC)
400# define XLF4 XLF_EFI_KEXEC
401#else
402# define XLF4 0
403#endif
404
405			.word XLF0 | XLF1 | XLF23 | XLF4
 
 
 
 
 
 
 
 
 
 
406
407cmdline_size:   .long   COMMAND_LINE_SIZE-1     #length of the command line,
408                                                #added with boot protocol
409                                                #version 2.06
410
411hardware_subarch:	.long 0			# subarchitecture, added with 2.07
412						# default to 0 for normal x86 PC
413
414hardware_subarch_data:	.quad 0
415
416payload_offset:		.long ZO_input_data
417payload_length:		.long ZO_z_input_len
418
419setup_data:		.quad 0			# 64-bit physical pointer to
420						# single linked list of
421						# struct setup_data
422
423pref_address:		.quad LOAD_PHYSICAL_ADDR	# preferred load addr
424
425#define ZO_INIT_SIZE	(ZO__end - ZO_startup_32 + ZO_z_extract_offset)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
426#define VO_INIT_SIZE	(VO__end - VO__text)
427#if ZO_INIT_SIZE > VO_INIT_SIZE
428#define INIT_SIZE ZO_INIT_SIZE
429#else
430#define INIT_SIZE VO_INIT_SIZE
431#endif
 
432init_size:		.long INIT_SIZE		# kernel initialization size
433handover_offset:	.long 0			# Filled in by build.c
 
434
435# End of setup header #####################################################
436
437	.section ".entrytext", "ax"
438start_of_setup:
439# Force %es = %ds
440	movw	%ds, %ax
441	movw	%ax, %es
442	cld
443
444# Apparently some ancient versions of LILO invoked the kernel with %ss != %ds,
445# which happened to work by accident for the old code.  Recalculate the stack
446# pointer if %ss is invalid.  Otherwise leave it alone, LOADLIN sets up the
447# stack behind its own code, so we can't blindly put it directly past the heap.
448
449	movw	%ss, %dx
450	cmpw	%ax, %dx	# %ds == %ss?
451	movw	%sp, %dx
452	je	2f		# -> assume %sp is reasonably set
453
454	# Invalid %ss, make up a new stack
455	movw	$_end, %dx
456	testb	$CAN_USE_HEAP, loadflags
457	jz	1f
458	movw	heap_end_ptr, %dx
4591:	addw	$STACK_SIZE, %dx
460	jnc	2f
461	xorw	%dx, %dx	# Prevent wraparound
462
4632:	# Now %dx should point to the end of our stack space
464	andw	$~3, %dx	# dword align (might as well...)
465	jnz	3f
466	movw	$0xfffc, %dx	# Make sure we're not zero
4673:	movw	%ax, %ss
468	movzwl	%dx, %esp	# Clear upper half of %esp
469	sti			# Now we should have a working stack
470
471# We will have entered with %cs = %ds+0x20, normalize %cs so
472# it is on par with the other segments.
473	pushw	%ds
474	pushw	$6f
475	lretw
4766:
477
478# Check signature at end of setup
479	cmpl	$0x5a5aaa55, setup_sig
480	jne	setup_bad
481
482# Zero the bss
483	movw	$__bss_start, %di
484	movw	$_end+3, %cx
485	xorl	%eax, %eax
486	subw	%di, %cx
487	shrw	$2, %cx
488	rep; stosl
489
490# Jump to C code (should not return)
491	calll	main
492
493# Setup corrupt somehow...
494setup_bad:
495	movl	$setup_corrupt, %eax
496	calll	puts
497	# Fall through...
498
499	.globl	die
500	.type	die, @function
501die:
502	hlt
503	jmp	die
504
505	.size	die, .-die
506
507	.section ".initdata", "a"
508setup_corrupt:
509	.byte	7
510	.string	"No setup signature found...\n"
v6.2
  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"