arch/x86/boot/compressed/head_64.S

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  *  linux/boot/head.S
   4  *
   5  *  Copyright (C) 1991, 1992, 1993  Linus Torvalds
   6  */
   7
   8 /*
   9  *  head.S contains the 32-bit startup code.
  10  *
  11  * NOTE!!! Startup happens at absolute address 0x00001000, which is also where
  12  * the page directory will exist. The startup code will be overwritten by
  13  * the page directory. [According to comments etc elsewhere on a compressed
  14  * kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC]
  15  *
  16  * Page 0 is deliberately kept safe, since System Management Mode code in
  17  * laptops may need to access the BIOS data stored there.  This is also
  18  * useful for future device drivers that either access the BIOS via VM86
  19  * mode.
  20  */
  21
  22 /*
  23  * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
  24  */
  25         .code32
  26         .text
  27
  28 #include <linux/init.h>
  29 #include <linux/linkage.h>
  30 #include <asm/segment.h>
  31 #include <asm/boot.h>
  32 #include <asm/msr.h>
  33 #include <asm/processor-flags.h>
  34 #include <asm/asm-offsets.h>
  35 #include <asm/bootparam.h>
  36 #include <asm/desc_defs.h>
  37 #include <asm/trapnr.h>
  38 #include "pgtable.h"
  39
  40 /*
  41  * Fix alignment at 16 bytes. Following CONFIG_FUNCTION_ALIGNMENT will result
  42  * in assembly errors due to trying to move .org backward due to the excessive
  43  * alignment.
  44  */
  45 #undef __ALIGN
  46 #define __ALIGN         .balign 16, 0x90
  47
  48 /*
  49  * Locally defined symbols should be marked hidden:
  50  */
  51         .hidden _bss
  52         .hidden _ebss
  53         .hidden _end
  54
  55         __HEAD
  56
  57 /*
  58  * This macro gives the relative virtual address of X, i.e. the offset of X
  59  * from startup_32. This is the same as the link-time virtual address of X,
  60  * since startup_32 is at 0, but defining it this way tells the
  61  * assembler/linker that we do not want the actual run-time address of X. This
  62  * prevents the linker from trying to create unwanted run-time relocation
  63  * entries for the reference when the compressed kernel is linked as PIE.
  64  *
  65  * A reference X(%reg) will result in the link-time VA of X being stored with
  66  * the instruction, and a run-time R_X86_64_RELATIVE relocation entry that
  67  * adds the 64-bit base address where the kernel is loaded.
  68  *
  69  * Replacing it with (X-startup_32)(%reg) results in the offset being stored,
  70  * and no run-time relocation.
  71  *
  72  * The macro should be used as a displacement with a base register containing
  73  * the run-time address of startup_32 [i.e. rva(X)(%reg)], or as an immediate
  74  * [$ rva(X)].
  75  *
  76  * This macro can only be used from within the .head.text section, since the
  77  * expression requires startup_32 to be in the same section as the code being
  78  * assembled.
  79  */
  80 #define rva(X) ((X) - startup_32)
  81
  82         .code32
  83 SYM_FUNC_START(startup_32)
  84         /*
  85          * 32bit entry is 0 and it is ABI so immutable!
  86          * If we come here directly from a bootloader,
  87          * kernel(text+data+bss+brk) ramdisk, zero_page, command line
  88          * all need to be under the 4G limit.
  89          */
  90         cld
  91         cli
  92
  93 /*
  94  * Calculate the delta between where we were compiled to run
  95  * at and where we were actually loaded at.  This can only be done
  96  * with a short local call on x86.  Nothing  else will tell us what
  97  * address we are running at.  The reserved chunk of the real-mode
  98  * data at 0x1e4 (defined as a scratch field) are used as the stack
  99  * for this calculation. Only 4 bytes are needed.
 100  */
 101         leal    (BP_scratch+4)(%esi), %esp
 102         call    1f
 103 1:      popl    %ebp
 104         subl    $ rva(1b), %ebp
 105
 106         /* Load new GDT with the 64bit segments using 32bit descriptor */
 107         leal    rva(gdt)(%ebp), %eax
 108         movl    %eax, 2(%eax)
 109         lgdt    (%eax)
 110
 111         /* Load segment registers with our descriptors */
 112         movl    $__BOOT_DS, %eax
 113         movl    %eax, %ds
 114         movl    %eax, %es
 115         movl    %eax, %fs
 116         movl    %eax, %gs
 117         movl    %eax, %ss
 118
 119         /* Setup a stack and load CS from current GDT */
 120         leal    rva(boot_stack_end)(%ebp), %esp
 121
 122         pushl   $__KERNEL32_CS
 123         leal    rva(1f)(%ebp), %eax
 124         pushl   %eax
 125         lretl
 126 1:
 127
 128         /* Setup Exception handling for SEV-ES */
 129 #ifdef CONFIG_AMD_MEM_ENCRYPT
 130         call    startup32_load_idt
 131 #endif
 132
 133         /* Make sure cpu supports long mode. */
 134         call    verify_cpu
 135         testl   %eax, %eax
 136         jnz     .Lno_longmode
 137
 138 /*
 139  * Compute the delta between where we were compiled to run at
 140  * and where the code will actually run at.
 141  *
 142  * %ebp contains the address we are loaded at by the boot loader and %ebx
 143  * contains the address where we should move the kernel image temporarily
 144  * for safe in-place decompression.
 145  */
 146
 147 #ifdef CONFIG_RELOCATABLE
 148         movl    %ebp, %ebx
 149
 150 #ifdef CONFIG_EFI_STUB
 151 /*
 152  * If we were loaded via the EFI LoadImage service, startup_32 will be at an
 153  * offset to the start of the space allocated for the image. efi_pe_entry will
 154  * set up image_offset to tell us where the image actually starts, so that we
 155  * can use the full available buffer.
 156  *      image_offset = startup_32 - image_base
 157  * Otherwise image_offset will be zero and has no effect on the calculations.
 158  */
 159         subl    rva(image_offset)(%ebp), %ebx
 160 #endif
 161
 162         movl    BP_kernel_alignment(%esi), %eax
 163         decl    %eax
 164         addl    %eax, %ebx
 165         notl    %eax
 166         andl    %eax, %ebx
 167         cmpl    $LOAD_PHYSICAL_ADDR, %ebx
 168         jae     1f
 169 #endif
 170         movl    $LOAD_PHYSICAL_ADDR, %ebx
 171 1:
 172
 173         /* Target address to relocate to for decompression */
 174         addl    BP_init_size(%esi), %ebx
 175         subl    $ rva(_end), %ebx
 176
 177 /*
 178  * Prepare for entering 64 bit mode
 179  */
 180
 181         /* Enable PAE mode */
 182         movl    %cr4, %eax
 183         orl     $X86_CR4_PAE, %eax
 184         movl    %eax, %cr4
 185
 186  /*
 187   * Build early 4G boot pagetable
 188   */
 189         /*
 190          * If SEV is active then set the encryption mask in the page tables.
 191          * This will ensure that when the kernel is copied and decompressed
 192          * it will be done so encrypted.
 193          */
 194         xorl    %edx, %edx
 195 #ifdef  CONFIG_AMD_MEM_ENCRYPT
 196         call    get_sev_encryption_bit
 197         xorl    %edx, %edx
 198         testl   %eax, %eax
 199         jz      1f
 200         subl    $32, %eax       /* Encryption bit is always above bit 31 */
 201         bts     %eax, %edx      /* Set encryption mask for page tables */
 202         /*
 203          * Set MSR_AMD64_SEV_ENABLED_BIT in sev_status so that
 204          * startup32_check_sev_cbit() will do a check. sev_enable() will
 205          * initialize sev_status with all the bits reported by
 206          * MSR_AMD_SEV_STATUS later, but only MSR_AMD64_SEV_ENABLED_BIT
 207          * needs to be set for now.
 208          */
 209         movl    $1, rva(sev_status)(%ebp)
 210 1:
 211 #endif
 212
 213         /* Initialize Page tables to 0 */
 214         leal    rva(pgtable)(%ebx), %edi
 215         xorl    %eax, %eax
 216         movl    $(BOOT_INIT_PGT_SIZE/4), %ecx
 217         rep     stosl
 218
 219         /* Build Level 4 */
 220         leal    rva(pgtable + 0)(%ebx), %edi
 221         leal    0x1007 (%edi), %eax
 222         movl    %eax, 0(%edi)
 223         addl    %edx, 4(%edi)
 224
 225         /* Build Level 3 */
 226         leal    rva(pgtable + 0x1000)(%ebx), %edi
 227         leal    0x1007(%edi), %eax
 228         movl    $4, %ecx
 229 1:      movl    %eax, 0x00(%edi)
 230         addl    %edx, 0x04(%edi)
 231         addl    $0x00001000, %eax
 232         addl    $8, %edi
 233         decl    %ecx
 234         jnz     1b
 235
 236         /* Build Level 2 */
 237         leal    rva(pgtable + 0x2000)(%ebx), %edi
 238         movl    $0x00000183, %eax
 239         movl    $2048, %ecx
 240 1:      movl    %eax, 0(%edi)
 241         addl    %edx, 4(%edi)
 242         addl    $0x00200000, %eax
 243         addl    $8, %edi
 244         decl    %ecx
 245         jnz     1b
 246
 247         /* Enable the boot page tables */
 248         leal    rva(pgtable)(%ebx), %eax
 249         movl    %eax, %cr3
 250
 251         /* Enable Long mode in EFER (Extended Feature Enable Register) */
 252         movl    $MSR_EFER, %ecx
 253         rdmsr
 254         btsl    $_EFER_LME, %eax
 255         wrmsr
 256
 257         /* After gdt is loaded */
 258         xorl    %eax, %eax
 259         lldt    %ax
 260         movl    $__BOOT_TSS, %eax
 261         ltr     %ax
 262
 263 #ifdef CONFIG_AMD_MEM_ENCRYPT
 264         /* Check if the C-bit position is correct when SEV is active */
 265         call    startup32_check_sev_cbit
 266 #endif
 267
 268         /*
 269          * Setup for the jump to 64bit mode
 270          *
 271          * When the jump is performed we will be in long mode but
 272          * in 32bit compatibility mode with EFER.LME = 1, CS.L = 0, CS.D = 1
 273          * (and in turn EFER.LMA = 1).  To jump into 64bit mode we use
 274          * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
 275          * We place all of the values on our mini stack so lret can
 276          * used to perform that far jump.
 277          */
 278         leal    rva(startup_64)(%ebp), %eax
 279 #ifdef CONFIG_EFI_MIXED
 280         cmpb    $1, rva(efi_is64)(%ebp)
 281         je      1f
 282         leal    rva(startup_64_mixed_mode)(%ebp), %eax
 283 1:
 284 #endif
 285
 286         pushl   $__KERNEL_CS
 287         pushl   %eax
 288
 289         /* Enter paged protected Mode, activating Long Mode */
 290         movl    $CR0_STATE, %eax
 291         movl    %eax, %cr0
 292
 293         /* Jump from 32bit compatibility mode into 64bit mode. */
 294         lret
 295 SYM_FUNC_END(startup_32)
 296
 297         .code64
 298         .org 0x200
 299 SYM_CODE_START(startup_64)
 300         /*
 301          * 64bit entry is 0x200 and it is ABI so immutable!
 302          * We come here either from startup_32 or directly from a
 303          * 64bit bootloader.
 304          * If we come here from a bootloader, kernel(text+data+bss+brk),
 305          * ramdisk, zero_page, command line could be above 4G.
 306          * We depend on an identity mapped page table being provided
 307          * that maps our entire kernel(text+data+bss+brk), zero page
 308          * and command line.
 309          */
 310
 311         cld
 312         cli
 313
 314         /* Setup data segments. */
 315         xorl    %eax, %eax
 316         movl    %eax, %ds
 317         movl    %eax, %es
 318         movl    %eax, %ss
 319         movl    %eax, %fs
 320         movl    %eax, %gs
 321
 322         /*
 323          * Compute the decompressed kernel start address.  It is where
 324          * we were loaded at aligned to a 2M boundary. %rbp contains the
 325          * decompressed kernel start address.
 326          *
 327          * If it is a relocatable kernel then decompress and run the kernel
 328          * from load address aligned to 2MB addr, otherwise decompress and
 329          * run the kernel from LOAD_PHYSICAL_ADDR
 330          *
 331          * We cannot rely on the calculation done in 32-bit mode, since we
 332          * may have been invoked via the 64-bit entry point.
 333          */
 334
 335         /* Start with the delta to where the kernel will run at. */
 336 #ifdef CONFIG_RELOCATABLE
 337         leaq    startup_32(%rip) /* - $startup_32 */, %rbp
 338
 339 #ifdef CONFIG_EFI_STUB
 340 /*
 341  * If we were loaded via the EFI LoadImage service, startup_32 will be at an
 342  * offset to the start of the space allocated for the image. efi_pe_entry will
 343  * set up image_offset to tell us where the image actually starts, so that we
 344  * can use the full available buffer.
 345  *      image_offset = startup_32 - image_base
 346  * Otherwise image_offset will be zero and has no effect on the calculations.
 347  */
 348         movl    image_offset(%rip), %eax
 349         subq    %rax, %rbp
 350 #endif
 351
 352         movl    BP_kernel_alignment(%rsi), %eax
 353         decl    %eax
 354         addq    %rax, %rbp
 355         notq    %rax
 356         andq    %rax, %rbp
 357         cmpq    $LOAD_PHYSICAL_ADDR, %rbp
 358         jae     1f
 359 #endif
 360         movq    $LOAD_PHYSICAL_ADDR, %rbp
 361 1:
 362
 363         /* Target address to relocate to for decompression */
 364         movl    BP_init_size(%rsi), %ebx
 365         subl    $ rva(_end), %ebx
 366         addq    %rbp, %rbx
 367
 368         /* Set up the stack */
 369         leaq    rva(boot_stack_end)(%rbx), %rsp
 370
 371         /*
 372          * At this point we are in long mode with 4-level paging enabled,
 373          * but we might want to enable 5-level paging or vice versa.
 374          *
 375          * The problem is that we cannot do it directly. Setting or clearing
 376          * CR4.LA57 in long mode would trigger #GP. So we need to switch off
 377          * long mode and paging first.
 378          *
 379          * We also need a trampoline in lower memory to switch over from
 380          * 4- to 5-level paging for cases when the bootloader puts the kernel
 381          * above 4G, but didn't enable 5-level paging for us.
 382          *
 383          * The same trampoline can be used to switch from 5- to 4-level paging
 384          * mode, like when starting 4-level paging kernel via kexec() when
 385          * original kernel worked in 5-level paging mode.
 386          *
 387          * For the trampoline, we need the top page table to reside in lower
 388          * memory as we don't have a way to load 64-bit values into CR3 in
 389          * 32-bit mode.
 390          *
 391          * We go though the trampoline even if we don't have to: if we're
 392          * already in a desired paging mode. This way the trampoline code gets
 393          * tested on every boot.
 394          */
 395
 396         /* Make sure we have GDT with 32-bit code segment */
 397         leaq    gdt64(%rip), %rax
 398         addq    %rax, 2(%rax)
 399         lgdt    (%rax)
 400
 401         /* Reload CS so IRET returns to a CS actually in the GDT */
 402         pushq   $__KERNEL_CS
 403         leaq    .Lon_kernel_cs(%rip), %rax
 404         pushq   %rax
 405         lretq
 406
 407 .Lon_kernel_cs:
 408         /*
 409          * RSI holds a pointer to a boot_params structure provided by the
 410          * loader, and this needs to be preserved across C function calls. So
 411          * move it into a callee saved register.
 412          */
 413         movq    %rsi, %r15
 414
 415         call    load_stage1_idt
 416
 417 #ifdef CONFIG_AMD_MEM_ENCRYPT
 418         /*
 419          * Now that the stage1 interrupt handlers are set up, #VC exceptions from
 420          * CPUID instructions can be properly handled for SEV-ES guests.
 421          *
 422          * For SEV-SNP, the CPUID table also needs to be set up in advance of any
 423          * CPUID instructions being issued, so go ahead and do that now via
 424          * sev_enable(), which will also handle the rest of the SEV-related
 425          * detection/setup to ensure that has been done in advance of any dependent
 426          * code. Pass the boot_params pointer as the first argument.
 427          */
 428         movq    %r15, %rdi
 429         call    sev_enable
 430 #endif
 431
 432         /*
 433          * paging_prepare() sets up the trampoline and checks if we need to
 434          * enable 5-level paging.
 435          *
 436          * paging_prepare() returns a two-quadword structure which lands
 437          * into RDX:RAX:
 438          *   - Address of the trampoline is returned in RAX.
 439          *   - Non zero RDX means trampoline needs to enable 5-level
 440          *     paging.
 441          *
 442          * Pass the boot_params pointer as the first argument.
 443          */
 444         movq    %r15, %rdi
 445         call    paging_prepare
 446
 447         /* Save the trampoline address in RCX */
 448         movq    %rax, %rcx
 449
 450         leaq    TRAMPOLINE_32BIT_CODE_OFFSET(%rax), %rax
 451         call    *%rax
 452
 453         /*
 454          * cleanup_trampoline() would restore trampoline memory.
 455          *
 456          * RDI is address of the page table to use instead of page table
 457          * in trampoline memory (if required).
 458          */
 459         leaq    rva(top_pgtable)(%rbx), %rdi
 460         call    cleanup_trampoline
 461
 462         /* Zero EFLAGS */
 463         pushq   $0
 464         popfq
 465
 466 /*
 467  * Copy the compressed kernel to the end of our buffer
 468  * where decompression in place becomes safe.
 469  */
 470         leaq    (_bss-8)(%rip), %rsi
 471         leaq    rva(_bss-8)(%rbx), %rdi
 472         movl    $(_bss - startup_32), %ecx
 473         shrl    $3, %ecx
 474         std
 475         rep     movsq
 476         cld
 477
 478         /*
 479          * The GDT may get overwritten either during the copy we just did or
 480          * during extract_kernel below. To avoid any issues, repoint the GDTR
 481          * to the new copy of the GDT.
 482          */
 483         leaq    rva(gdt64)(%rbx), %rax
 484         leaq    rva(gdt)(%rbx), %rdx
 485         movq    %rdx, 2(%rax)
 486         lgdt    (%rax)
 487
 488 /*
 489  * Jump to the relocated address.
 490  */
 491         leaq    rva(.Lrelocated)(%rbx), %rax
 492         jmp     *%rax
 493 SYM_CODE_END(startup_64)
 494
 495         .text
 496 SYM_FUNC_START_LOCAL_NOALIGN(.Lrelocated)
 497
 498 /*
 499  * Clear BSS (stack is currently empty)
 500  */
 501         xorl    %eax, %eax
 502         leaq    _bss(%rip), %rdi
 503         leaq    _ebss(%rip), %rcx
 504         subq    %rdi, %rcx
 505         shrq    $3, %rcx
 506         rep     stosq
 507
 508         call    load_stage2_idt
 509
 510         /* Pass boot_params to initialize_identity_maps() */
 511         movq    %r15, %rdi
 512         call    initialize_identity_maps
 513
 514 /*
 515  * Do the extraction, and jump to the new kernel..
 516  */
 517         /* pass struct boot_params pointer */
 518         movq    %r15, %rdi
 519         leaq    boot_heap(%rip), %rsi   /* malloc area for uncompression */
 520         leaq    input_data(%rip), %rdx  /* input_data */
 521         movl    input_len(%rip), %ecx   /* input_len */
 522         movq    %rbp, %r8               /* output target address */
 523         movl    output_len(%rip), %r9d  /* decompressed length, end of relocs */
 524         call    extract_kernel          /* returns kernel entry point in %rax */
 525
 526 /*
 527  * Jump to the decompressed kernel.
 528  */
 529         movq    %r15, %rsi
 530         jmp     *%rax
 531 SYM_FUNC_END(.Lrelocated)
 532
 533 /*
 534  * This is the 32-bit trampoline that will be copied over to low memory.
 535  *
 536  * Return address is at the top of the stack (might be above 4G).
 537  * ECX contains the base address of the trampoline memory.
 538  * Non zero RDX means trampoline needs to enable 5-level paging.
 539  */
 540 SYM_CODE_START(trampoline_32bit_src)
 541         /*
 542          * Preserve live 64-bit registers on the stack: this is necessary
 543          * because the architecture does not guarantee that GPRs will retain
 544          * their full 64-bit values across a 32-bit mode switch.
 545          */
 546         pushq   %r15
 547         pushq   %rbp
 548         pushq   %rbx
 549
 550         /* Set up 32-bit addressable stack and push the old RSP value */
 551         leaq    (TRAMPOLINE_32BIT_STACK_END - 8)(%rcx), %rbx
 552         movq    %rsp, (%rbx)
 553         movq    %rbx, %rsp
 554
 555         /* Take the address of the trampoline exit code */
 556         leaq    .Lret(%rip), %rbx
 557
 558         /* Switch to compatibility mode (CS.L = 0 CS.D = 1) via far return */
 559         pushq   $__KERNEL32_CS
 560         leaq    0f(%rip), %rax
 561         pushq   %rax
 562         lretq
 563
 564 .Lret:
 565         /* Restore the preserved 64-bit registers */
 566         movq    (%rsp), %rsp
 567         popq    %rbx
 568         popq    %rbp
 569         popq    %r15
 570         retq
 571
 572         .code32
 573 0:
 574         /* Set up data and stack segments */
 575         movl    $__KERNEL_DS, %eax
 576         movl    %eax, %ds
 577         movl    %eax, %ss
 578
 579         /* Disable paging */
 580         movl    %cr0, %eax
 581         btrl    $X86_CR0_PG_BIT, %eax
 582         movl    %eax, %cr0
 583
 584         /* Check what paging mode we want to be in after the trampoline */
 585         testl   %edx, %edx
 586         jz      1f
 587
 588         /* We want 5-level paging: don't touch CR3 if it already points to 5-level page tables */
 589         movl    %cr4, %eax
 590         testl   $X86_CR4_LA57, %eax
 591         jnz     3f
 592         jmp     2f
 593 1:
 594         /* We want 4-level paging: don't touch CR3 if it already points to 4-level page tables */
 595         movl    %cr4, %eax
 596         testl   $X86_CR4_LA57, %eax
 597         jz      3f
 598 2:
 599         /* Point CR3 to the trampoline's new top level page table */
 600         leal    TRAMPOLINE_32BIT_PGTABLE_OFFSET(%ecx), %eax
 601         movl    %eax, %cr3
 602 3:
 603         /* Set EFER.LME=1 as a precaution in case hypervsior pulls the rug */
 604         pushl   %ecx
 605         pushl   %edx
 606         movl    $MSR_EFER, %ecx
 607         rdmsr
 608         btsl    $_EFER_LME, %eax
 609         /* Avoid writing EFER if no change was made (for TDX guest) */
 610         jc      1f
 611         wrmsr
 612 1:      popl    %edx
 613         popl    %ecx
 614
 615 #ifdef CONFIG_X86_MCE
 616         /*
 617          * Preserve CR4.MCE if the kernel will enable #MC support.
 618          * Clearing MCE may fault in some environments (that also force #MC
 619          * support). Any machine check that occurs before #MC support is fully
 620          * configured will crash the system regardless of the CR4.MCE value set
 621          * here.
 622          */
 623         movl    %cr4, %eax
 624         andl    $X86_CR4_MCE, %eax
 625 #else
 626         movl    $0, %eax
 627 #endif
 628
 629         /* Enable PAE and LA57 (if required) paging modes */
 630         orl     $X86_CR4_PAE, %eax
 631         testl   %edx, %edx
 632         jz      1f
 633         orl     $X86_CR4_LA57, %eax
 634 1:
 635         movl    %eax, %cr4
 636
 637         /* Prepare the stack for far return to Long Mode */
 638         pushl   $__KERNEL_CS
 639         pushl   %ebx
 640
 641         /* Enable paging again. */
 642         movl    %cr0, %eax
 643         btsl    $X86_CR0_PG_BIT, %eax
 644         movl    %eax, %cr0
 645
 646         lret
 647 SYM_CODE_END(trampoline_32bit_src)
 648
 649         /*
 650          * The trampoline code has a size limit.
 651          * Make sure we fail to compile if the trampoline code grows
 652          * beyond TRAMPOLINE_32BIT_CODE_SIZE bytes.
 653          */
 654         .org    trampoline_32bit_src + TRAMPOLINE_32BIT_CODE_SIZE
 655
 656 SYM_FUNC_START_LOCAL_NOALIGN(.Lno_longmode)
 657         /* This isn't an x86-64 CPU, so hang intentionally, we cannot continue */
 658 1:
 659         hlt
 660         jmp     1b
 661 SYM_FUNC_END(.Lno_longmode)
 662
 663         .globl  verify_cpu
 664 #include "../../kernel/verify_cpu.S"
 665
 666         .data
 667 SYM_DATA_START_LOCAL(gdt64)
 668         .word   gdt_end - gdt - 1
 669         .quad   gdt - gdt64
 670 SYM_DATA_END(gdt64)
 671         .balign 8
 672 SYM_DATA_START_LOCAL(gdt)
 673         .word   gdt_end - gdt - 1
 674         .long   0
 675         .word   0
 676         .quad   0x00cf9a000000ffff      /* __KERNEL32_CS */
 677         .quad   0x00af9a000000ffff      /* __KERNEL_CS */
 678         .quad   0x00cf92000000ffff      /* __KERNEL_DS */
 679         .quad   0x0080890000000000      /* TS descriptor */
 680         .quad   0x0000000000000000      /* TS continued */
 681 SYM_DATA_END_LABEL(gdt, SYM_L_LOCAL, gdt_end)
 682
 683 SYM_DATA_START(boot_idt_desc)
 684         .word   boot_idt_end - boot_idt - 1
 685         .quad   0
 686 SYM_DATA_END(boot_idt_desc)
 687         .balign 8
 688 SYM_DATA_START(boot_idt)
 689         .rept   BOOT_IDT_ENTRIES
 690         .quad   0
 691         .quad   0
 692         .endr
 693 SYM_DATA_END_LABEL(boot_idt, SYM_L_GLOBAL, boot_idt_end)
 694
 695 /*
 696  * Stack and heap for uncompression
 697  */
 698         .bss
 699         .balign 4
 700 SYM_DATA_LOCAL(boot_heap,       .fill BOOT_HEAP_SIZE, 1, 0)
 701
 702 SYM_DATA_START_LOCAL(boot_stack)
 703         .fill BOOT_STACK_SIZE, 1, 0
 704         .balign 16
 705 SYM_DATA_END_LABEL(boot_stack, SYM_L_LOCAL, boot_stack_end)
 706
 707 /*
 708  * Space for page tables (not in .bss so not zeroed)
 709  */
 710         .section ".pgtable","aw",@nobits
 711         .balign 4096
 712 SYM_DATA_LOCAL(pgtable,         .fill BOOT_PGT_SIZE, 1, 0)
 713
 714 /*
 715  * The page table is going to be used instead of page table in the trampoline
 716  * memory.
 717  */
 718 SYM_DATA_LOCAL(top_pgtable,     .fill PAGE_SIZE, 1, 0)