x86/boot/header.S

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