Lines Matching +full:boot +full:- +full:page +full:- +full:step
1 .. SPDX-License-Identifier: GPL-2.0
4 The Linux/x86 Boot Protocol
7 On the x86 platform, the Linux kernel uses a rather complicated boot
12 real-mode DOS as a mainstream operating system.
14 Currently, the following versions of the Linux/x86 boot protocol exist.
22 boot loader and the kernel. setup.S made relocatable,
28 Protocol 2.02 (Kernel 2.4.0-test3-pre3) New command line protocol.
31 safe for systems which use the EBDA from SMM or 32-bit
35 Protocol 2.03 (Kernel 2.4.18-pre1) Explicitly makes the highest possible
44 the boot command line.
46 Protocol 2.07 (Kernel 2.6.24) Added paravirtualised boot protocol.
54 Protocol 2.09 (Kernel 2.6.26) Added a field of 64-bit physical
59 pref_address fields. Added extended boot loader IDs.
68 Protocol 2.13 (Kernel 3.14) Support 32- and 64-bit flags being set in
69 xloadflags to support booting a 64-bit kernel from 32-bit
74 ("x86/boot: Add ACPI RSDP address to setup_header")
86 features to the boot loader. Due to very limited space available in
89 communicate things to the boot loader is the kernel_info.
99 0A0000 +------------------------+
101 09A000 +------------------------+
103 | Stack/heap | For use by the kernel real-mode code.
104 098000 +------------------------+
105 | Kernel setup | The kernel real-mode code.
106 090200 +------------------------+
107 | Kernel boot sector | The kernel legacy boot sector.
108 090000 +------------------------+
109 | Protected-mode kernel | The bulk of the kernel image.
110 010000 +------------------------+
111 | Boot loader | <- Boot sector entry point 0000:7C00
112 001000 +------------------------+
114 000800 +------------------------+
116 000600 +------------------------+
118 000000 +------------------------+
120 When using bzImage, the protected-mode kernel was relocated to
121 0x100000 ("high memory"), and the kernel real-mode block (boot sector,
127 It is desirable to keep the "memory ceiling" -- the highest point in
128 low memory touched by the boot loader -- as low as possible, since
131 memory. The boot loader should use the "INT 12h" BIOS call to verify
135 low, there is usually nothing the boot loader can do but to report an
136 error to the user. The boot loader should therefore be designed to
139 0x90000 segment, the boot loader should make sure not to use memory
142 For a modern bzImage kernel with boot protocol version >= 2.02, a
146 | Protected-mode kernel |
147 100000 +------------------------+
149 0A0000 +------------------------+
153 X+10000 +------------------------+
154 | Stack/heap | For use by the kernel real-mode code.
155 X+08000 +------------------------+
156 | Kernel setup | The kernel real-mode code.
157 | Kernel boot sector | The kernel legacy boot sector.
158 X +------------------------+
159 | Boot loader | <- Boot sector entry point 0000:7C00
160 001000 +------------------------+
162 000800 +------------------------+
164 000600 +------------------------+
166 000000 +------------------------+
168 ... where the address X is as low as the design of the boot loader permits.
171 The Real-Mode Kernel Header
174 In the following text, and anywhere in the kernel boot sequence, "a
178 The first step in loading a Linux kernel should be to load the
179 real-mode code (boot sector and setup code) and then examine the
180 following header at offset 0x01f1. The real-mode code can total up to
181 32K, although the boot loader may choose to load only the first two
191 01F4/4 2.04+(2) syssize The size of the 32-bit code in 16-byte paras
192 01F8/2 ALL ram_size DO NOT USE - for bootsect.S use only
198 0206/2 2.00+ version Boot protocol version supported
199 0208/4 2.00+ realmode_swtch Boot loader hook (see below)
200 020C/2 2.00+ start_sys_seg The load-low segment (0x1000) (obsolete)
202 0210/1 2.00+ type_of_loader Boot loader identifier
203 0211/1 2.00+ loadflags Boot protocol option flags
205 0214/4 2.00+ code32_start Boot loader hook (see below)
206 0218/4 2.00+ ramdisk_image initrd load address (set by boot loader)
207 021C/4 2.00+ ramdisk_size initrd size (set by boot loader)
208 0220/4 2.00+ bootsect_kludge DO NOT USE - for bootsect.S use only
210 0226/1 2.02+(3) ext_loader_ver Extended boot loader version
211 0227/1 2.02+(3) ext_loader_type Extended boot loader ID
212 0228/4 2.02+ cmd_line_ptr 32-bit pointer to the kernel command line
217 0236/2 2.12+ xloadflags Boot protocol option flags
220 0240/8 2.07+ hardware_subarch_data Subarchitecture-specific data
223 0250/8 2.09+ setup_data 64-bit physical pointer to linked list
235 (2) For boot protocol prior to 2.04, the upper two bytes of the syssize
239 (3) Ignored, but safe to set, for boot protocols 2.02-2.09.
242 the boot protocol version is "old". Loading an old kernel, the
247 Real-mode kernel must be located at 0x90000.
263 All general purpose boot loaders should write the fields marked
264 (obligatory). Boot loaders who want to load the kernel at a
266 boot loaders can ignore those fields.
277 The size of the setup code in 512-byte sectors. If this field is
278 0, the real value is 4. The real-mode code consists of the boot
279 sector (always one 512-byte sector) plus the setup code.
299 The size of the protected-mode code in units of 16-byte paragraphs.
368 Contains the boot protocol version, in (major << 8)+minor format,
379 Boot loader hook (see ADVANCED BOOT LOADER HOOKS below.)
397 If set to a nonzero value, contains a pointer to a NUL-terminated
398 human-readable kernel version number string, less 0x200. This can
419 If your boot loader has an assigned id (see table below), enter
420 0xTV here, where T is an identifier for the boot loader and V is
423 For boot loader IDs above T = 0xD, write T = 0xE to this field and
430 type_of_loader <- 0xE4
431 ext_loader_type <- 0x05
432 ext_loader_ver <- 0x23
434 Assigned boot loader ids (hexadecimal):
438 (0x00 reserved for pre-2.00 bootloader)
440 2 bootsect-loader
446 8 U-Boot
451 D kexec-tools
456 <http://sebastian-plotz.blogspot.de>
474 - If 0, the protected-mode code is loaded at 0x10000.
475 - If 1, the protected-mode code is loaded at 0x100000.
479 - Used internally by the compressed kernel to communicate
482 - If 1, KASLR enabled.
483 - If 0, KASLR disabled.
487 - If 0, print early messages.
488 - If 1, suppress early messages.
498 - This flag is obsolete.
511 Protocol: 2.00-2.01
517 the kernel command line) moved in addition to the real-mode kernel
520 The unit is bytes starting with the beginning of the boot sector.
523 if the real-mode code is loaded at 0x90000.
533 address of the kernel, and can be used by the boot loader to
538 1. as a boot loader hook (see Advanced Boot Loader Hooks below.)
551 The 32-bit linear address of the initial ramdisk or ramfs. Leave at
580 Set this field to the offset (from the beginning of the real-mode
594 The use of this field is boot loader specific. If not written, it
626 same 64K segment as the real-mode code itself.
628 Fill in this field even if your boot loader does not support a
631 zero, the kernel will assume that your boot loader does not support
642 ramdisk/ramfs contents. For boot protocols 2.02 or earlier, this
672 If this field is nonzero, the protected-mode part of the kernel can
674 After loading, the boot loader must set the code32_start field to
675 point to the loaded code, or to a boot loader hook.
685 alignment required, as opposed to preferred, by the kernel to boot.
686 If a boot loader makes use of this field, it should update the
693 power-of-two alignment from kernel_alignment down to this alignment.
706 - If 1, this kernel has the legacy 64-bit entry point at 0x200.
710 - If 1, kernel/boot_params/cmdline/ramdisk can be above 4G.
714 - If 1, the kernel supports the 32-bit EFI handoff entry point
719 - If 1, the kernel supports the 64-bit EFI handoff entry point
724 - If 1, the kernel supports kexec EFI boot with EFI runtime support.
747 pieces such as interrupt handling, page table handling, and
763 Type: write (subarch-dependent)
779 If non-zero then this field contains the offset from the beginning
780 of the protected-mode code to the payload.
806 The 64-bit physical pointer to NULL terminated single linked list of
807 struct setup_data. This is used to define a more extensible boot
818 Where, the next is a 64-bit physical pointer to the next node of
830 and because it has a 32-bit length field. However, it is important that
831 intermediate stages of the boot process have a way to identify which
847 and stack space can be limited in boot contexts.
880 A non-relocatable kernel will unconditionally move itself and to run
893 as the total amount of memory the kernel needs to boot, but it can
894 be used by a relocating boot loader to help select a safe load
911 the EFI handover protocol entry point. Boot loaders using the EFI
912 handover protocol to boot the kernel should jump to this offset.
942 a long time, for lack of alternatives and -- especially early on -- inertia.
944 available to a BIOS-based loader (setup_data is, though).
947 2-byte jump field, which doubles as a length field for the structure, combined
948 with the size of the "hole" in struct boot_params that a protected-mode loader
951 without revising the boot protocol entirely, breaking backwards compatibility.
955 the kernel image, because it is .bss and has no image-provided content.
970 .long kernel_info_var_len_data - kernel_info
971 .long kernel_info_end - kernel_info
976 .long example_struct_end - example_struct
982 .long example_strings_end - example_strings
988 This way the kernel_info is self-contained blob.
991 Each variable size data header/magic can be any 4-character string,
1035 From boot protocol version 2.08 onwards the CRC-32 is calculated over
1045 The kernel command line has become an important way for the boot
1047 relevant to the boot loader itself, see "special command line options"
1050 The kernel command line is a null-terminated string. The maximum
1055 If the boot protocol version is 2.02 or later, the address of the
1063 - At offset 0x0020 (word), "cmd_line_magic", enter the magic
1066 - At offset 0x0022 (word), "cmd_line_offset", enter the offset
1068 real-mode kernel).
1070 - The kernel command line *must* be within the memory region
1075 Memory Layout of The Real-Mode Code
1078 The real-mode code requires a stack/heap to be set up, as well as
1080 in the real-mode accessible memory in bottom megabyte.
1089 - When loading a zImage kernel ((loadflags & 0x01) == 0).
1090 - When loading a 2.01 or earlier boot protocol kernel.
1093 For the 2.00 and 2.01 boot protocols, the real-mode code
1096 real-mode code must be loaded at 0x90000.
1100 For boot protocol 2.02 or higher, the command line does not have to be
1101 located in the same 64K segment as the real-mode setup code; it is
1105 The kernel command line should not be located below the real-mode
1109 Sample Boot Configuration
1118 0x0000-0x7fff Real mode kernel
1119 0x8000-0xdfff Stack and heap
1120 0xe000-0xffff Kernel command line
1126 0x0000-0x7fff Real mode kernel
1127 0x8000-0x97ff Stack and heap
1128 0x9800-0x9fff Kernel command line
1131 Such a boot loader should enter the following fields in the header::
1133 unsigned long base_ptr; /* base address for real-mode segment */
1152 heap_end_ptr = heap_end - 0x200;
1173 /* A very old kernel MUST have its real-mode code
1177 /* Copy the real-mode kernel */
1186 (64-(setup_sects+1))*512);
1193 The 32-bit (non-real-mode) kernel starts at offset (setup_sects+1)*512
1205 the entire 0x10000-0x90000 range of memory. This means it is pretty
1206 much a requirement for these kernels to load the real-mode part at
1212 If the command line provided by the boot loader is entered by the
1215 though not all of them are actually meaningful to the kernel. Boot
1216 loader authors who need additional command line options for the boot
1218 Documentation/admin-guide/kernel-parameters.rst to make sure they will not
1240 obviously bootloader-dependent, and some boot loaders
1243 In addition, some boot loaders add the following options to the
1244 user-specified command line:
1247 The boot image which was loaded. Again, the meaning of <file>
1248 is obviously bootloader-dependent.
1253 If these options are added by the boot loader, it is highly
1254 recommended that they are located *first*, before the user-specified
1255 or configuration-specified command line. Otherwise, "init=/bin/sh"
1264 kernel. This means that if you loaded your real-mode kernel code at
1267 At entry, ds = es = ss should point to the start of the real-mode
1271 the kernel, it is recommended that the boot loader sets fs = gs = ds =
1283 /* Set up the real-mode kernel stack */
1290 If your boot sector accesses a floppy drive, it is recommended to
1292 kernel boot leaves interrupts off and thus the motor will not be
1294 a demand-loaded module!
1297 Advanced Boot Loader Hooks
1300 If the boot loader runs in a particularly hostile environment (such as
1302 standard memory location requirements. Such a boot loader may use the
1311 A 16-bit real mode far subroutine invoked immediately before
1316 A 32-bit flat-mode routine *jumped* to immediately after the
1323 that was in this field before your boot loader overwrote it
1327 32-bit Boot Protocol
1331 LinuxBIOS, etc, and kexec, the 16-bit real mode setup code in kernel
1332 based on legacy BIOS can not be used, so a 32-bit boot protocol needs
1335 In 32-bit boot protocol, the first step in loading a Linux kernel
1336 should be to setup the boot parameters (struct boot_params,
1337 traditionally known as "zero page"). The memory for struct boot_params
1346 boot_params as that of 16-bit boot protocol, the boot loader should
1348 described in chapter Documentation/arch/x86/zero-page.rst.
1350 After setting up the struct boot_params, the boot loader can load the
1351 32/64-bit kernel in the same way as that of 16-bit boot protocol.
1353 In 32-bit boot protocol, the kernel is started by jumping to the
1354 32-bit kernel entry point, which is the start address of loaded
1355 32/64-bit kernel.
1357 At entry, the CPU must be in 32-bit protected mode with paging
1365 64-bit Boot Protocol
1369 and we need a 64-bit boot protocol.
1371 In 64-bit boot protocol, the first step in loading a Linux kernel
1372 should be to setup the boot parameters (struct boot_params,
1373 traditionally known as "zero page"). The memory for struct boot_params
1382 boot_params as that of 16-bit boot protocol, the boot loader should
1384 in chapter Documentation/arch/x86/zero-page.rst.
1386 After setting up the struct boot_params, the boot loader can load
1387 64-bit kernel in the same way as that of 16-bit boot protocol, but
1390 In 64-bit boot protocol, the kernel is started by jumping to the
1391 64-bit kernel entry point, which is the start address of loaded
1392 64-bit kernel plus 0x200.
1394 At entry, the CPU must be in 64-bit mode with paging enabled.
1396 kernel and zero page and command line buffer get ident mapping;
1407 This protocol allows boot loaders to defer initialisation to the EFI
1408 boot stub. The boot loader is required to load the kernel/initrd(s)
1409 from the boot media and jump to the EFI handover protocol entry point
1410 which is hdr->handover_offset bytes from the beginning of
1413 The boot loader MUST respect the kernel's PE/COFF metadata when it comes
1423 'handle' is the EFI image handle passed to the boot loader by the EFI
1424 firmware, 'table' is the EFI system table - these are the first two
1426 UEFI specification. 'bp' is the boot loader-allocated boot params.
1428 The boot loader *must* fill out the following fields in bp::
1430 - hdr.cmd_line_ptr
1431 - hdr.ramdisk_image (if applicable)
1432 - hdr.ramdisk_size (if applicable)
1444 [0] https://github.com/u-boot/u-boot/commit/ec80b4735a593961fe701cc3a5d717d4739b0fd0