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  * Locally defined symbols should be marked hidden:
  42  */
  43         .hidden _bss
  44         .hidden _ebss
  45         .hidden _end
  46
  47         __HEAD
  48
  49 /*
  50  * This macro gives the relative virtual address of X, i.e. the offset of X
  51  * from startup_32. This is the same as the link-time virtual address of X,
  52  * since startup_32 is at 0, but defining it this way tells the
  53  * assembler/linker that we do not want the actual run-time address of X. This
  54  * prevents the linker from trying to create unwanted run-time relocation
  55  * entries for the reference when the compressed kernel is linked as PIE.
  56  *
  57  * A reference X(%reg) will result in the link-time VA of X being stored with
  58  * the instruction, and a run-time R_X86_64_RELATIVE relocation entry that
  59  * adds the 64-bit base address where the kernel is loaded.
  60  *
  61  * Replacing it with (X-startup_32)(%reg) results in the offset being stored,
  62  * and no run-time relocation.
  63  *
  64  * The macro should be used as a displacement with a base register containing
  65  * the run-time address of startup_32 [i.e. rva(X)(%reg)], or as an immediate
  66  * [$ rva(X)].
  67  *
  68  * This macro can only be used from within the .head.text section, since the
  69  * expression requires startup_32 to be in the same section as the code being
  70  * assembled.
  71  */
  72 #define rva(X) ((X) - startup_32)
  73
  74         .code32
  75 SYM_FUNC_START(startup_32)
  76         /*
  77          * 32bit entry is 0 and it is ABI so immutable!
  78          * If we come here directly from a bootloader,
  79          * kernel(text+data+bss+brk) ramdisk, zero_page, command line
  80          * all need to be under the 4G limit.
  81          */
  82         cld
  83         cli
  84
  85 /*
  86  * Calculate the delta between where we were compiled to run
  87  * at and where we were actually loaded at.  This can only be done
  88  * with a short local call on x86.  Nothing  else will tell us what
  89  * address we are running at.  The reserved chunk of the real-mode
  90  * data at 0x1e4 (defined as a scratch field) are used as the stack
  91  * for this calculation. Only 4 bytes are needed.
  92  */
  93         leal    (BP_scratch+4)(%esi), %esp
  94         call    1f
  95 1:      popl    %ebp
  96         subl    $ rva(1b), %ebp
  97
  98         /* Load new GDT with the 64bit segments using 32bit descriptor */
  99         leal    rva(gdt)(%ebp), %eax
 100         movl    %eax, 2(%eax)
 101         lgdt    (%eax)
 102
 103         /* Load segment registers with our descriptors */
 104         movl    $__BOOT_DS, %eax
 105         movl    %eax, %ds
 106         movl    %eax, %es
 107         movl    %eax, %fs
 108         movl    %eax, %gs
 109         movl    %eax, %ss
 110
 111         /* Setup a stack and load CS from current GDT */
 112         leal    rva(boot_stack_end)(%ebp), %esp
 113
 114         pushl   $__KERNEL32_CS
 115         leal    rva(1f)(%ebp), %eax
 116         pushl   %eax
 117         lretl
 118 1:
 119
 120         /* Setup Exception handling for SEV-ES */
 121         call    startup32_load_idt
 122
 123         /* Make sure cpu supports long mode. */
 124         call    verify_cpu
 125         testl   %eax, %eax
 126         jnz     .Lno_longmode
 127
 128 /*
 129  * Compute the delta between where we were compiled to run at
 130  * and where the code will actually run at.
 131  *
 132  * %ebp contains the address we are loaded at by the boot loader and %ebx
 133  * contains the address where we should move the kernel image temporarily
 134  * for safe in-place decompression.
 135  */
 136
 137 #ifdef CONFIG_RELOCATABLE
 138         movl    %ebp, %ebx
 139
 140 #ifdef CONFIG_EFI_STUB
 141 /*
 142  * If we were loaded via the EFI LoadImage service, startup_32 will be at an
 143  * offset to the start of the space allocated for the image. efi_pe_entry will
 144  * set up image_offset to tell us where the image actually starts, so that we
 145  * can use the full available buffer.
 146  *      image_offset = startup_32 - image_base
 147  * Otherwise image_offset will be zero and has no effect on the calculations.
 148  */
 149         subl    rva(image_offset)(%ebp), %ebx
 150 #endif
 151
 152         movl    BP_kernel_alignment(%esi), %eax
 153         decl    %eax
 154         addl    %eax, %ebx
 155         notl    %eax
 156         andl    %eax, %ebx
 157         cmpl    $LOAD_PHYSICAL_ADDR, %ebx
 158         jae     1f
 159 #endif
 160         movl    $LOAD_PHYSICAL_ADDR, %ebx
 161 1:
 162
 163         /* Target address to relocate to for decompression */
 164         addl    BP_init_size(%esi), %ebx
 165         subl    $ rva(_end), %ebx
 166
 167 /*
 168  * Prepare for entering 64 bit mode
 169  */
 170
 171         /* Enable PAE mode */
 172         movl    %cr4, %eax
 173         orl     $X86_CR4_PAE, %eax
 174         movl    %eax, %cr4
 175
 176  /*
 177   * Build early 4G boot pagetable
 178   */
 179         /*
 180          * If SEV is active then set the encryption mask in the page tables.
 181          * This will insure that when the kernel is copied and decompressed
 182          * it will be done so encrypted.
 183          */
 184         call    get_sev_encryption_bit
 185         xorl    %edx, %edx
 186 #ifdef  CONFIG_AMD_MEM_ENCRYPT
 187         testl   %eax, %eax
 188         jz      1f
 189         subl    $32, %eax       /* Encryption bit is always above bit 31 */
 190         bts     %eax, %edx      /* Set encryption mask for page tables */
 191         /*
 192          * Mark SEV as active in sev_status so that startup32_check_sev_cbit()
 193          * will do a check. The sev_status memory will be fully initialized
 194          * with the contents of MSR_AMD_SEV_STATUS later in
 195          * set_sev_encryption_mask(). For now it is sufficient to know that SEV
 196          * is active.
 197          */
 198         movl    $1, rva(sev_status)(%ebp)
 199 1:
 200 #endif
 201
 202         /* Initialize Page tables to 0 */
 203         leal    rva(pgtable)(%ebx), %edi
 204         xorl    %eax, %eax
 205         movl    $(BOOT_INIT_PGT_SIZE/4), %ecx
 206         rep     stosl
 207
 208         /* Build Level 4 */
 209         leal    rva(pgtable + 0)(%ebx), %edi
 210         leal    0x1007 (%edi), %eax
 211         movl    %eax, 0(%edi)
 212         addl    %edx, 4(%edi)
 213
 214         /* Build Level 3 */
 215         leal    rva(pgtable + 0x1000)(%ebx), %edi
 216         leal    0x1007(%edi), %eax
 217         movl    $4, %ecx
 218 1:      movl    %eax, 0x00(%edi)
 219         addl    %edx, 0x04(%edi)
 220         addl    $0x00001000, %eax
 221         addl    $8, %edi
 222         decl    %ecx
 223         jnz     1b
 224
 225         /* Build Level 2 */
 226         leal    rva(pgtable + 0x2000)(%ebx), %edi
 227         movl    $0x00000183, %eax
 228         movl    $2048, %ecx
 229 1:      movl    %eax, 0(%edi)
 230         addl    %edx, 4(%edi)
 231         addl    $0x00200000, %eax
 232         addl    $8, %edi
 233         decl    %ecx
 234         jnz     1b
 235
 236         /* Enable the boot page tables */
 237         leal    rva(pgtable)(%ebx), %eax
 238         movl    %eax, %cr3
 239
 240         /* Enable Long mode in EFER (Extended Feature Enable Register) */
 241         movl    $MSR_EFER, %ecx
 242         rdmsr
 243         btsl    $_EFER_LME, %eax
 244         wrmsr
 245
 246         /* After gdt is loaded */
 247         xorl    %eax, %eax
 248         lldt    %ax
 249         movl    $__BOOT_TSS, %eax
 250         ltr     %ax
 251
 252         /*
 253          * Setup for the jump to 64bit mode
 254          *
 255          * When the jump is performed we will be in long mode but
 256          * in 32bit compatibility mode with EFER.LME = 1, CS.L = 0, CS.D = 1
 257          * (and in turn EFER.LMA = 1).  To jump into 64bit mode we use
 258          * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
 259          * We place all of the values on our mini stack so lret can
 260          * used to perform that far jump.
 261          */
 262         leal    rva(startup_64)(%ebp), %eax
 263 #ifdef CONFIG_EFI_MIXED
 264         movl    rva(efi32_boot_args)(%ebp), %edi
 265         testl   %edi, %edi
 266         jz      1f
 267         leal    rva(efi64_stub_entry)(%ebp), %eax
 268         movl    rva(efi32_boot_args+4)(%ebp), %esi
 269         movl    rva(efi32_boot_args+8)(%ebp), %edx      // saved bootparams pointer
 270         testl   %edx, %edx
 271         jnz     1f
 272         /*
 273          * efi_pe_entry uses MS calling convention, which requires 32 bytes of
 274          * shadow space on the stack even if all arguments are passed in
 275          * registers. We also need an additional 8 bytes for the space that
 276          * would be occupied by the return address, and this also results in
 277          * the correct stack alignment for entry.
 278          */
 279         subl    $40, %esp
 280         leal    rva(efi_pe_entry)(%ebp), %eax
 281         movl    %edi, %ecx                      // MS calling convention
 282         movl    %esi, %edx
 283 1:
 284 #endif
 285         /* Check if the C-bit position is correct when SEV is active */
 286         call    startup32_check_sev_cbit
 287
 288         pushl   $__KERNEL_CS
 289         pushl   %eax
 290
 291         /* Enter paged protected Mode, activating Long Mode */
 292         movl    $(X86_CR0_PG | X86_CR0_PE), %eax /* Enable Paging and Protected mode */
 293         movl    %eax, %cr0
 294
 295         /* Jump from 32bit compatibility mode into 64bit mode. */
 296         lret
 297 SYM_FUNC_END(startup_32)
 298
 299 #ifdef CONFIG_EFI_MIXED
 300         .org 0x190
 301 SYM_FUNC_START(efi32_stub_entry)
 302         add     $0x4, %esp              /* Discard return address */
 303         popl    %ecx
 304         popl    %edx
 305         popl    %esi
 306
 307         call    1f
 308 1:      pop     %ebp
 309         subl    $ rva(1b), %ebp
 310
 311         movl    %esi, rva(efi32_boot_args+8)(%ebp)
 312 SYM_INNER_LABEL(efi32_pe_stub_entry, SYM_L_LOCAL)
 313         movl    %ecx, rva(efi32_boot_args)(%ebp)
 314         movl    %edx, rva(efi32_boot_args+4)(%ebp)
 315         movb    $0, rva(efi_is64)(%ebp)
 316
 317         /* Save firmware GDTR and code/data selectors */
 318         sgdtl   rva(efi32_boot_gdt)(%ebp)
 319         movw    %cs, rva(efi32_boot_cs)(%ebp)
 320         movw    %ds, rva(efi32_boot_ds)(%ebp)
 321
 322         /* Store firmware IDT descriptor */
 323         sidtl   rva(efi32_boot_idt)(%ebp)
 324
 325         /* Disable paging */
 326         movl    %cr0, %eax
 327         btrl    $X86_CR0_PG_BIT, %eax
 328         movl    %eax, %cr0
 329
 330         jmp     startup_32
 331 SYM_FUNC_END(efi32_stub_entry)
 332 #endif
 333
 334         .code64
 335         .org 0x200
 336 SYM_CODE_START(startup_64)
 337         /*
 338          * 64bit entry is 0x200 and it is ABI so immutable!
 339          * We come here either from startup_32 or directly from a
 340          * 64bit bootloader.
 341          * If we come here from a bootloader, kernel(text+data+bss+brk),
 342          * ramdisk, zero_page, command line could be above 4G.
 343          * We depend on an identity mapped page table being provided
 344          * that maps our entire kernel(text+data+bss+brk), zero page
 345          * and command line.
 346          */
 347
 348         cld
 349         cli
 350
 351         /* Setup data segments. */
 352         xorl    %eax, %eax
 353         movl    %eax, %ds
 354         movl    %eax, %es
 355         movl    %eax, %ss
 356         movl    %eax, %fs
 357         movl    %eax, %gs
 358
 359         /*
 360          * Compute the decompressed kernel start address.  It is where
 361          * we were loaded at aligned to a 2M boundary. %rbp contains the
 362          * decompressed kernel start address.
 363          *
 364          * If it is a relocatable kernel then decompress and run the kernel
 365          * from load address aligned to 2MB addr, otherwise decompress and
 366          * run the kernel from LOAD_PHYSICAL_ADDR
 367          *
 368          * We cannot rely on the calculation done in 32-bit mode, since we
 369          * may have been invoked via the 64-bit entry point.
 370          */
 371
 372         /* Start with the delta to where the kernel will run at. */
 373 #ifdef CONFIG_RELOCATABLE
 374         leaq    startup_32(%rip) /* - $startup_32 */, %rbp
 375
 376 #ifdef CONFIG_EFI_STUB
 377 /*
 378  * If we were loaded via the EFI LoadImage service, startup_32 will be at an
 379  * offset to the start of the space allocated for the image. efi_pe_entry will
 380  * set up image_offset to tell us where the image actually starts, so that we
 381  * can use the full available buffer.
 382  *      image_offset = startup_32 - image_base
 383  * Otherwise image_offset will be zero and has no effect on the calculations.
 384  */
 385         movl    image_offset(%rip), %eax
 386         subq    %rax, %rbp
 387 #endif
 388
 389         movl    BP_kernel_alignment(%rsi), %eax
 390         decl    %eax
 391         addq    %rax, %rbp
 392         notq    %rax
 393         andq    %rax, %rbp
 394         cmpq    $LOAD_PHYSICAL_ADDR, %rbp
 395         jae     1f
 396 #endif
 397         movq    $LOAD_PHYSICAL_ADDR, %rbp
 398 1:
 399
 400         /* Target address to relocate to for decompression */
 401         movl    BP_init_size(%rsi), %ebx
 402         subl    $ rva(_end), %ebx
 403         addq    %rbp, %rbx
 404
 405         /* Set up the stack */
 406         leaq    rva(boot_stack_end)(%rbx), %rsp
 407
 408         /*
 409          * At this point we are in long mode with 4-level paging enabled,
 410          * but we might want to enable 5-level paging or vice versa.
 411          *
 412          * The problem is that we cannot do it directly. Setting or clearing
 413          * CR4.LA57 in long mode would trigger #GP. So we need to switch off
 414          * long mode and paging first.
 415          *
 416          * We also need a trampoline in lower memory to switch over from
 417          * 4- to 5-level paging for cases when the bootloader puts the kernel
 418          * above 4G, but didn't enable 5-level paging for us.
 419          *
 420          * The same trampoline can be used to switch from 5- to 4-level paging
 421          * mode, like when starting 4-level paging kernel via kexec() when
 422          * original kernel worked in 5-level paging mode.
 423          *
 424          * For the trampoline, we need the top page table to reside in lower
 425          * memory as we don't have a way to load 64-bit values into CR3 in
 426          * 32-bit mode.
 427          *
 428          * We go though the trampoline even if we don't have to: if we're
 429          * already in a desired paging mode. This way the trampoline code gets
 430          * tested on every boot.
 431          */
 432
 433         /* Make sure we have GDT with 32-bit code segment */
 434         leaq    gdt64(%rip), %rax
 435         addq    %rax, 2(%rax)
 436         lgdt    (%rax)
 437
 438         /* Reload CS so IRET returns to a CS actually in the GDT */
 439         pushq   $__KERNEL_CS
 440         leaq    .Lon_kernel_cs(%rip), %rax
 441         pushq   %rax
 442         lretq
 443
 444 .Lon_kernel_cs:
 445
 446         pushq   %rsi
 447         call    load_stage1_idt
 448         popq    %rsi
 449
 450         /*
 451          * paging_prepare() sets up the trampoline and checks if we need to
 452          * enable 5-level paging.
 453          *
 454          * paging_prepare() returns a two-quadword structure which lands
 455          * into RDX:RAX:
 456          *   - Address of the trampoline is returned in RAX.
 457          *   - Non zero RDX means trampoline needs to enable 5-level
 458          *     paging.
 459          *
 460          * RSI holds real mode data and needs to be preserved across
 461          * this function call.
 462          */
 463         pushq   %rsi
 464         movq    %rsi, %rdi              /* real mode address */
 465         call    paging_prepare
 466         popq    %rsi
 467
 468         /* Save the trampoline address in RCX */
 469         movq    %rax, %rcx
 470
 471         /* Set up 32-bit addressable stack */
 472         leaq    TRAMPOLINE_32BIT_STACK_END(%rcx), %rsp
 473
 474         /*
 475          * Preserve live 64-bit registers on the stack: this is necessary
 476          * because the architecture does not guarantee that GPRs will retain
 477          * their full 64-bit values across a 32-bit mode switch.
 478          */
 479         pushq   %rbp
 480         pushq   %rbx
 481         pushq   %rsi
 482
 483         /*
 484          * Push the 64-bit address of trampoline_return() onto the new stack.
 485          * It will be used by the trampoline to return to the main code. Due to
 486          * the 32-bit mode switch, it cannot be kept it in a register either.
 487          */
 488         leaq    trampoline_return(%rip), %rdi
 489         pushq   %rdi
 490
 491         /* Switch to compatibility mode (CS.L = 0 CS.D = 1) via far return */
 492         pushq   $__KERNEL32_CS
 493         leaq    TRAMPOLINE_32BIT_CODE_OFFSET(%rax), %rax
 494         pushq   %rax
 495         lretq
 496 trampoline_return:
 497         /* Restore live 64-bit registers */
 498         popq    %rsi
 499         popq    %rbx
 500         popq    %rbp
 501
 502         /* Restore the stack, the 32-bit trampoline uses its own stack */
 503         leaq    rva(boot_stack_end)(%rbx), %rsp
 504
 505         /*
 506          * cleanup_trampoline() would restore trampoline memory.
 507          *
 508          * RDI is address of the page table to use instead of page table
 509          * in trampoline memory (if required).
 510          *
 511          * RSI holds real mode data and needs to be preserved across
 512          * this function call.
 513          */
 514         pushq   %rsi
 515         leaq    rva(top_pgtable)(%rbx), %rdi
 516         call    cleanup_trampoline
 517         popq    %rsi
 518
 519         /* Zero EFLAGS */
 520         pushq   $0
 521         popfq
 522
 523 /*
 524  * Copy the compressed kernel to the end of our buffer
 525  * where decompression in place becomes safe.
 526  */
 527         pushq   %rsi
 528         leaq    (_bss-8)(%rip), %rsi
 529         leaq    rva(_bss-8)(%rbx), %rdi
 530         movl    $(_bss - startup_32), %ecx
 531         shrl    $3, %ecx
 532         std
 533         rep     movsq
 534         cld
 535         popq    %rsi
 536
 537         /*
 538          * The GDT may get overwritten either during the copy we just did or
 539          * during extract_kernel below. To avoid any issues, repoint the GDTR
 540          * to the new copy of the GDT.
 541          */
 542         leaq    rva(gdt64)(%rbx), %rax
 543         leaq    rva(gdt)(%rbx), %rdx
 544         movq    %rdx, 2(%rax)
 545         lgdt    (%rax)
 546
 547 /*
 548  * Jump to the relocated address.
 549  */
 550         leaq    rva(.Lrelocated)(%rbx), %rax
 551         jmp     *%rax
 552 SYM_CODE_END(startup_64)
 553
 554 #ifdef CONFIG_EFI_STUB
 555         .org 0x390
 556 SYM_FUNC_START(efi64_stub_entry)
 557 SYM_FUNC_START_ALIAS(efi_stub_entry)
 558         and     $~0xf, %rsp                     /* realign the stack */
 559         movq    %rdx, %rbx                      /* save boot_params pointer */
 560         call    efi_main
 561         movq    %rbx,%rsi
 562         leaq    rva(startup_64)(%rax), %rax
 563         jmp     *%rax
 564 SYM_FUNC_END(efi64_stub_entry)
 565 SYM_FUNC_END_ALIAS(efi_stub_entry)
 566 #endif
 567
 568         .text
 569 SYM_FUNC_START_LOCAL_NOALIGN(.Lrelocated)
 570
 571 /*
 572  * Clear BSS (stack is currently empty)
 573  */
 574         xorl    %eax, %eax
 575         leaq    _bss(%rip), %rdi
 576         leaq    _ebss(%rip), %rcx
 577         subq    %rdi, %rcx
 578         shrq    $3, %rcx
 579         rep     stosq
 580
 581 /*
 582  * If running as an SEV guest, the encryption mask is required in the
 583  * page-table setup code below. When the guest also has SEV-ES enabled
 584  * set_sev_encryption_mask() will cause #VC exceptions, but the stage2
 585  * handler can't map its GHCB because the page-table is not set up yet.
 586  * So set up the encryption mask here while still on the stage1 #VC
 587  * handler. Then load stage2 IDT and switch to the kernel's own
 588  * page-table.
 589  */
 590         pushq   %rsi
 591         call    set_sev_encryption_mask
 592         call    load_stage2_idt
 593
 594         /* Pass boot_params to initialize_identity_maps() */
 595         movq    (%rsp), %rdi
 596         call    initialize_identity_maps
 597         popq    %rsi
 598
 599 /*
 600  * Do the extraction, and jump to the new kernel..
 601  */
 602         pushq   %rsi                    /* Save the real mode argument */
 603         movq    %rsi, %rdi              /* real mode address */
 604         leaq    boot_heap(%rip), %rsi   /* malloc area for uncompression */
 605         leaq    input_data(%rip), %rdx  /* input_data */
 606         movl    input_len(%rip), %ecx   /* input_len */
 607         movq    %rbp, %r8               /* output target address */
 608         movl    output_len(%rip), %r9d  /* decompressed length, end of relocs */
 609         call    extract_kernel          /* returns kernel location in %rax */
 610         popq    %rsi
 611
 612 /*
 613  * Jump to the decompressed kernel.
 614  */
 615         jmp     *%rax
 616 SYM_FUNC_END(.Lrelocated)
 617
 618         .code32
 619 /*
 620  * This is the 32-bit trampoline that will be copied over to low memory.
 621  *
 622  * Return address is at the top of the stack (might be above 4G).
 623  * ECX contains the base address of the trampoline memory.
 624  * Non zero RDX means trampoline needs to enable 5-level paging.
 625  */
 626 SYM_CODE_START(trampoline_32bit_src)
 627         /* Set up data and stack segments */
 628         movl    $__KERNEL_DS, %eax
 629         movl    %eax, %ds
 630         movl    %eax, %ss
 631
 632         /* Disable paging */
 633         movl    %cr0, %eax
 634         btrl    $X86_CR0_PG_BIT, %eax
 635         movl    %eax, %cr0
 636
 637         /* Check what paging mode we want to be in after the trampoline */
 638         testl   %edx, %edx
 639         jz      1f
 640
 641         /* We want 5-level paging: don't touch CR3 if it already points to 5-level page tables */
 642         movl    %cr4, %eax
 643         testl   $X86_CR4_LA57, %eax
 644         jnz     3f
 645         jmp     2f
 646 1:
 647         /* We want 4-level paging: don't touch CR3 if it already points to 4-level page tables */
 648         movl    %cr4, %eax
 649         testl   $X86_CR4_LA57, %eax
 650         jz      3f
 651 2:
 652         /* Point CR3 to the trampoline's new top level page table */
 653         leal    TRAMPOLINE_32BIT_PGTABLE_OFFSET(%ecx), %eax
 654         movl    %eax, %cr3
 655 3:
 656         /* Set EFER.LME=1 as a precaution in case hypervsior pulls the rug */
 657         pushl   %ecx
 658         pushl   %edx
 659         movl    $MSR_EFER, %ecx
 660         rdmsr
 661         btsl    $_EFER_LME, %eax
 662         wrmsr
 663         popl    %edx
 664         popl    %ecx
 665
 666         /* Enable PAE and LA57 (if required) paging modes */
 667         movl    $X86_CR4_PAE, %eax
 668         testl   %edx, %edx
 669         jz      1f
 670         orl     $X86_CR4_LA57, %eax
 671 1:
 672         movl    %eax, %cr4
 673
 674         /* Calculate address of paging_enabled() once we are executing in the trampoline */
 675         leal    .Lpaging_enabled - trampoline_32bit_src + TRAMPOLINE_32BIT_CODE_OFFSET(%ecx), %eax
 676
 677         /* Prepare the stack for far return to Long Mode */
 678         pushl   $__KERNEL_CS
 679         pushl   %eax
 680
 681         /* Enable paging again */
 682         movl    $(X86_CR0_PG | X86_CR0_PE), %eax
 683         movl    %eax, %cr0
 684
 685         lret
 686 SYM_CODE_END(trampoline_32bit_src)
 687
 688         .code64
 689 SYM_FUNC_START_LOCAL_NOALIGN(.Lpaging_enabled)
 690         /* Return from the trampoline */
 691         retq
 692 SYM_FUNC_END(.Lpaging_enabled)
 693
 694         /*
 695          * The trampoline code has a size limit.
 696          * Make sure we fail to compile if the trampoline code grows
 697          * beyond TRAMPOLINE_32BIT_CODE_SIZE bytes.
 698          */
 699         .org    trampoline_32bit_src + TRAMPOLINE_32BIT_CODE_SIZE
 700
 701         .code32
 702 SYM_FUNC_START_LOCAL_NOALIGN(.Lno_longmode)
 703         /* This isn't an x86-64 CPU, so hang intentionally, we cannot continue */
 704 1:
 705         hlt
 706         jmp     1b
 707 SYM_FUNC_END(.Lno_longmode)
 708
 709 #include "../../kernel/verify_cpu.S"
 710
 711         .data
 712 SYM_DATA_START_LOCAL(gdt64)
 713         .word   gdt_end - gdt - 1
 714         .quad   gdt - gdt64
 715 SYM_DATA_END(gdt64)
 716         .balign 8
 717 SYM_DATA_START_LOCAL(gdt)
 718         .word   gdt_end - gdt - 1
 719         .long   0
 720         .word   0
 721         .quad   0x00cf9a000000ffff      /* __KERNEL32_CS */
 722         .quad   0x00af9a000000ffff      /* __KERNEL_CS */
 723         .quad   0x00cf92000000ffff      /* __KERNEL_DS */
 724         .quad   0x0080890000000000      /* TS descriptor */
 725         .quad   0x0000000000000000      /* TS continued */
 726 SYM_DATA_END_LABEL(gdt, SYM_L_LOCAL, gdt_end)
 727
 728 SYM_DATA_START(boot_idt_desc)
 729         .word   boot_idt_end - boot_idt - 1
 730         .quad   0
 731 SYM_DATA_END(boot_idt_desc)
 732         .balign 8
 733 SYM_DATA_START(boot_idt)
 734         .rept   BOOT_IDT_ENTRIES
 735         .quad   0
 736         .quad   0
 737         .endr
 738 SYM_DATA_END_LABEL(boot_idt, SYM_L_GLOBAL, boot_idt_end)
 739
 740 #ifdef CONFIG_AMD_MEM_ENCRYPT
 741 SYM_DATA_START(boot32_idt_desc)
 742         .word   boot32_idt_end - boot32_idt - 1
 743         .long   0
 744 SYM_DATA_END(boot32_idt_desc)
 745         .balign 8
 746 SYM_DATA_START(boot32_idt)
 747         .rept 32
 748         .quad 0
 749         .endr
 750 SYM_DATA_END_LABEL(boot32_idt, SYM_L_GLOBAL, boot32_idt_end)
 751 #endif
 752
 753 #ifdef CONFIG_EFI_STUB
 754 SYM_DATA(image_offset, .long 0)
 755 #endif
 756 #ifdef CONFIG_EFI_MIXED
 757 SYM_DATA_LOCAL(efi32_boot_args, .long 0, 0, 0)
 758 SYM_DATA(efi_is64, .byte 1)
 759
 760 #define ST32_boottime           60 // offsetof(efi_system_table_32_t, boottime)
 761 #define BS32_handle_protocol    88 // offsetof(efi_boot_services_32_t, handle_protocol)
 762 #define LI32_image_base         32 // offsetof(efi_loaded_image_32_t, image_base)
 763
 764         __HEAD
 765         .code32
 766 SYM_FUNC_START(efi32_pe_entry)
 767 /*
 768  * efi_status_t efi32_pe_entry(efi_handle_t image_handle,
 769  *                             efi_system_table_32_t *sys_table)
 770  */
 771
 772         pushl   %ebp
 773         movl    %esp, %ebp
 774         pushl   %eax                            // dummy push to allocate loaded_image
 775
 776         pushl   %ebx                            // save callee-save registers
 777         pushl   %edi
 778
 779         call    verify_cpu                      // check for long mode support
 780         testl   %eax, %eax
 781         movl    $0x80000003, %eax               // EFI_UNSUPPORTED
 782         jnz     2f
 783
 784         call    1f
 785 1:      pop     %ebx
 786         subl    $ rva(1b), %ebx
 787
 788         /* Get the loaded image protocol pointer from the image handle */
 789         leal    -4(%ebp), %eax
 790         pushl   %eax                            // &loaded_image
 791         leal    rva(loaded_image_proto)(%ebx), %eax
 792         pushl   %eax                            // pass the GUID address
 793         pushl   8(%ebp)                         // pass the image handle
 794
 795         /*
 796          * Note the alignment of the stack frame.
 797          *   sys_table
 798          *   handle             <-- 16-byte aligned on entry by ABI
 799          *   return address
 800          *   frame pointer
 801          *   loaded_image       <-- local variable
 802          *   saved %ebx         <-- 16-byte aligned here
 803          *   saved %edi
 804          *   &loaded_image
 805          *   &loaded_image_proto
 806          *   handle             <-- 16-byte aligned for call to handle_protocol
 807          */
 808
 809         movl    12(%ebp), %eax                  // sys_table
 810         movl    ST32_boottime(%eax), %eax       // sys_table->boottime
 811         call    *BS32_handle_protocol(%eax)     // sys_table->boottime->handle_protocol
 812         addl    $12, %esp                       // restore argument space
 813         testl   %eax, %eax
 814         jnz     2f
 815
 816         movl    8(%ebp), %ecx                   // image_handle
 817         movl    12(%ebp), %edx                  // sys_table
 818         movl    -4(%ebp), %esi                  // loaded_image
 819         movl    LI32_image_base(%esi), %esi     // loaded_image->image_base
 820         movl    %ebx, %ebp                      // startup_32 for efi32_pe_stub_entry
 821         /*
 822          * We need to set the image_offset variable here since startup_32() will
 823          * use it before we get to the 64-bit efi_pe_entry() in C code.
 824          */
 825         subl    %esi, %ebx
 826         movl    %ebx, rva(image_offset)(%ebp)   // save image_offset
 827         jmp     efi32_pe_stub_entry
 828
 829 2:      popl    %edi                            // restore callee-save registers
 830         popl    %ebx
 831         leave
 832         RET
 833 SYM_FUNC_END(efi32_pe_entry)
 834
 835         .section ".rodata"
 836         /* EFI loaded image protocol GUID */
 837         .balign 4
 838 SYM_DATA_START_LOCAL(loaded_image_proto)
 839         .long   0x5b1b31a1
 840         .word   0x9562, 0x11d2
 841         .byte   0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b
 842 SYM_DATA_END(loaded_image_proto)
 843 #endif
 844
 845 #ifdef CONFIG_AMD_MEM_ENCRYPT
 846         __HEAD
 847         .code32
 848 /*
 849  * Write an IDT entry into boot32_idt
 850  *
 851  * Parameters:
 852  *
 853  * %eax:        Handler address
 854  * %edx:        Vector number
 855  *
 856  * Physical offset is expected in %ebp
 857  */
 858 SYM_FUNC_START(startup32_set_idt_entry)
 859         push    %ebx
 860         push    %ecx
 861
 862         /* IDT entry address to %ebx */
 863         leal    rva(boot32_idt)(%ebp), %ebx
 864         shl     $3, %edx
 865         addl    %edx, %ebx
 866
 867         /* Build IDT entry, lower 4 bytes */
 868         movl    %eax, %edx
 869         andl    $0x0000ffff, %edx       # Target code segment offset [15:0]
 870         movl    $__KERNEL32_CS, %ecx    # Target code segment selector
 871         shl     $16, %ecx
 872         orl     %ecx, %edx
 873
 874         /* Store lower 4 bytes to IDT */
 875         movl    %edx, (%ebx)
 876
 877         /* Build IDT entry, upper 4 bytes */
 878         movl    %eax, %edx
 879         andl    $0xffff0000, %edx       # Target code segment offset [31:16]
 880         orl     $0x00008e00, %edx       # Present, Type 32-bit Interrupt Gate
 881
 882         /* Store upper 4 bytes to IDT */
 883         movl    %edx, 4(%ebx)
 884
 885         pop     %ecx
 886         pop     %ebx
 887         RET
 888 SYM_FUNC_END(startup32_set_idt_entry)
 889 #endif
 890
 891 SYM_FUNC_START(startup32_load_idt)
 892 #ifdef CONFIG_AMD_MEM_ENCRYPT
 893         /* #VC handler */
 894         leal    rva(startup32_vc_handler)(%ebp), %eax
 895         movl    $X86_TRAP_VC, %edx
 896         call    startup32_set_idt_entry
 897
 898         /* Load IDT */
 899         leal    rva(boot32_idt)(%ebp), %eax
 900         movl    %eax, rva(boot32_idt_desc+2)(%ebp)
 901         lidt    rva(boot32_idt_desc)(%ebp)
 902 #endif
 903         RET
 904 SYM_FUNC_END(startup32_load_idt)
 905
 906 /*
 907  * Check for the correct C-bit position when the startup_32 boot-path is used.
 908  *
 909  * The check makes use of the fact that all memory is encrypted when paging is
 910  * disabled. The function creates 64 bits of random data using the RDRAND
 911  * instruction. RDRAND is mandatory for SEV guests, so always available. If the
 912  * hypervisor violates that the kernel will crash right here.
 913  *
 914  * The 64 bits of random data are stored to a memory location and at the same
 915  * time kept in the %eax and %ebx registers. Since encryption is always active
 916  * when paging is off the random data will be stored encrypted in main memory.
 917  *
 918  * Then paging is enabled. When the C-bit position is correct all memory is
 919  * still mapped encrypted and comparing the register values with memory will
 920  * succeed. An incorrect C-bit position will map all memory unencrypted, so that
 921  * the compare will use the encrypted random data and fail.
 922  */
 923 SYM_FUNC_START(startup32_check_sev_cbit)
 924 #ifdef CONFIG_AMD_MEM_ENCRYPT
 925         pushl   %eax
 926         pushl   %ebx
 927         pushl   %ecx
 928         pushl   %edx
 929
 930         /* Check for non-zero sev_status */
 931         movl    rva(sev_status)(%ebp), %eax
 932         testl   %eax, %eax
 933         jz      4f
 934
 935         /*
 936          * Get two 32-bit random values - Don't bail out if RDRAND fails
 937          * because it is better to prevent forward progress if no random value
 938          * can be gathered.
 939          */
 940 1:      rdrand  %eax
 941         jnc     1b
 942 2:      rdrand  %ebx
 943         jnc     2b
 944
 945         /* Store to memory and keep it in the registers */
 946         movl    %eax, rva(sev_check_data)(%ebp)
 947         movl    %ebx, rva(sev_check_data+4)(%ebp)
 948
 949         /* Enable paging to see if encryption is active */
 950         movl    %cr0, %edx                       /* Backup %cr0 in %edx */
 951         movl    $(X86_CR0_PG | X86_CR0_PE), %ecx /* Enable Paging and Protected mode */
 952         movl    %ecx, %cr0
 953
 954         cmpl    %eax, rva(sev_check_data)(%ebp)
 955         jne     3f
 956         cmpl    %ebx, rva(sev_check_data+4)(%ebp)
 957         jne     3f
 958
 959         movl    %edx, %cr0      /* Restore previous %cr0 */
 960
 961         jmp     4f
 962
 963 3:      /* Check failed - hlt the machine */
 964         hlt
 965         jmp     3b
 966
 967 4:
 968         popl    %edx
 969         popl    %ecx
 970         popl    %ebx
 971         popl    %eax
 972 #endif
 973         RET
 974 SYM_FUNC_END(startup32_check_sev_cbit)
 975
 976 /*
 977  * Stack and heap for uncompression
 978  */
 979         .bss
 980         .balign 4
 981 SYM_DATA_LOCAL(boot_heap,       .fill BOOT_HEAP_SIZE, 1, 0)
 982
 983 SYM_DATA_START_LOCAL(boot_stack)
 984         .fill BOOT_STACK_SIZE, 1, 0
 985         .balign 16
 986 SYM_DATA_END_LABEL(boot_stack, SYM_L_LOCAL, boot_stack_end)
 987
 988 /*
 989  * Space for page tables (not in .bss so not zeroed)
 990  */
 991         .section ".pgtable","aw",@nobits
 992         .balign 4096
 993 SYM_DATA_LOCAL(pgtable,         .fill BOOT_PGT_SIZE, 1, 0)
 994
 995 /*
 996  * The page table is going to be used instead of page table in the trampoline
 997  * memory.
 998  */
 999 SYM_DATA_LOCAL(top_pgtable,     .fill PAGE_SIZE, 1, 0)