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         /*
 472          * Load the address of trampoline_return() into RDI.
 473          * It will be used by the trampoline to return to the main code.
 474          */
 475         leaq    trampoline_return(%rip), %rdi
 476
 477         /* Switch to compatibility mode (CS.L = 0 CS.D = 1) via far return */
 478         pushq   $__KERNEL32_CS
 479         leaq    TRAMPOLINE_32BIT_CODE_OFFSET(%rax), %rax
 480         pushq   %rax
 481         lretq
 482 trampoline_return:
 483         /* Restore the stack, the 32-bit trampoline uses its own stack */
 484         leaq    rva(boot_stack_end)(%rbx), %rsp
 485
 486         /*
 487          * cleanup_trampoline() would restore trampoline memory.
 488          *
 489          * RDI is address of the page table to use instead of page table
 490          * in trampoline memory (if required).
 491          *
 492          * RSI holds real mode data and needs to be preserved across
 493          * this function call.
 494          */
 495         pushq   %rsi
 496         leaq    rva(top_pgtable)(%rbx), %rdi
 497         call    cleanup_trampoline
 498         popq    %rsi
 499
 500         /* Zero EFLAGS */
 501         pushq   $0
 502         popfq
 503
 504 /*
 505  * Copy the compressed kernel to the end of our buffer
 506  * where decompression in place becomes safe.
 507  */
 508         pushq   %rsi
 509         leaq    (_bss-8)(%rip), %rsi
 510         leaq    rva(_bss-8)(%rbx), %rdi
 511         movl    $(_bss - startup_32), %ecx
 512         shrl    $3, %ecx
 513         std
 514         rep     movsq
 515         cld
 516         popq    %rsi
 517
 518         /*
 519          * The GDT may get overwritten either during the copy we just did or
 520          * during extract_kernel below. To avoid any issues, repoint the GDTR
 521          * to the new copy of the GDT.
 522          */
 523         leaq    rva(gdt64)(%rbx), %rax
 524         leaq    rva(gdt)(%rbx), %rdx
 525         movq    %rdx, 2(%rax)
 526         lgdt    (%rax)
 527
 528 /*
 529  * Jump to the relocated address.
 530  */
 531         leaq    rva(.Lrelocated)(%rbx), %rax
 532         jmp     *%rax
 533 SYM_CODE_END(startup_64)
 534
 535 #ifdef CONFIG_EFI_STUB
 536         .org 0x390
 537 SYM_FUNC_START(efi64_stub_entry)
 538 SYM_FUNC_START_ALIAS(efi_stub_entry)
 539         and     $~0xf, %rsp                     /* realign the stack */
 540         movq    %rdx, %rbx                      /* save boot_params pointer */
 541         call    efi_main
 542         movq    %rbx,%rsi
 543         leaq    rva(startup_64)(%rax), %rax
 544         jmp     *%rax
 545 SYM_FUNC_END(efi64_stub_entry)
 546 SYM_FUNC_END_ALIAS(efi_stub_entry)
 547 #endif
 548
 549         .text
 550 SYM_FUNC_START_LOCAL_NOALIGN(.Lrelocated)
 551
 552 /*
 553  * Clear BSS (stack is currently empty)
 554  */
 555         xorl    %eax, %eax
 556         leaq    _bss(%rip), %rdi
 557         leaq    _ebss(%rip), %rcx
 558         subq    %rdi, %rcx
 559         shrq    $3, %rcx
 560         rep     stosq
 561
 562 /*
 563  * If running as an SEV guest, the encryption mask is required in the
 564  * page-table setup code below. When the guest also has SEV-ES enabled
 565  * set_sev_encryption_mask() will cause #VC exceptions, but the stage2
 566  * handler can't map its GHCB because the page-table is not set up yet.
 567  * So set up the encryption mask here while still on the stage1 #VC
 568  * handler. Then load stage2 IDT and switch to the kernel's own
 569  * page-table.
 570  */
 571         pushq   %rsi
 572         call    set_sev_encryption_mask
 573         call    load_stage2_idt
 574
 575         /* Pass boot_params to initialize_identity_maps() */
 576         movq    (%rsp), %rdi
 577         call    initialize_identity_maps
 578         popq    %rsi
 579
 580 /*
 581  * Do the extraction, and jump to the new kernel..
 582  */
 583         pushq   %rsi                    /* Save the real mode argument */
 584         movq    %rsi, %rdi              /* real mode address */
 585         leaq    boot_heap(%rip), %rsi   /* malloc area for uncompression */
 586         leaq    input_data(%rip), %rdx  /* input_data */
 587         movl    input_len(%rip), %ecx   /* input_len */
 588         movq    %rbp, %r8               /* output target address */
 589         movl    output_len(%rip), %r9d  /* decompressed length, end of relocs */
 590         call    extract_kernel          /* returns kernel location in %rax */
 591         popq    %rsi
 592
 593 /*
 594  * Jump to the decompressed kernel.
 595  */
 596         jmp     *%rax
 597 SYM_FUNC_END(.Lrelocated)
 598
 599         .code32
 600 /*
 601  * This is the 32-bit trampoline that will be copied over to low memory.
 602  *
 603  * RDI contains the return address (might be above 4G).
 604  * ECX contains the base address of the trampoline memory.
 605  * Non zero RDX means trampoline needs to enable 5-level paging.
 606  */
 607 SYM_CODE_START(trampoline_32bit_src)
 608         /* Set up data and stack segments */
 609         movl    $__KERNEL_DS, %eax
 610         movl    %eax, %ds
 611         movl    %eax, %ss
 612
 613         /* Set up new stack */
 614         leal    TRAMPOLINE_32BIT_STACK_END(%ecx), %esp
 615
 616         /* Disable paging */
 617         movl    %cr0, %eax
 618         btrl    $X86_CR0_PG_BIT, %eax
 619         movl    %eax, %cr0
 620
 621         /* Check what paging mode we want to be in after the trampoline */
 622         testl   %edx, %edx
 623         jz      1f
 624
 625         /* We want 5-level paging: don't touch CR3 if it already points to 5-level page tables */
 626         movl    %cr4, %eax
 627         testl   $X86_CR4_LA57, %eax
 628         jnz     3f
 629         jmp     2f
 630 1:
 631         /* We want 4-level paging: don't touch CR3 if it already points to 4-level page tables */
 632         movl    %cr4, %eax
 633         testl   $X86_CR4_LA57, %eax
 634         jz      3f
 635 2:
 636         /* Point CR3 to the trampoline's new top level page table */
 637         leal    TRAMPOLINE_32BIT_PGTABLE_OFFSET(%ecx), %eax
 638         movl    %eax, %cr3
 639 3:
 640         /* Set EFER.LME=1 as a precaution in case hypervsior pulls the rug */
 641         pushl   %ecx
 642         pushl   %edx
 643         movl    $MSR_EFER, %ecx
 644         rdmsr
 645         btsl    $_EFER_LME, %eax
 646         wrmsr
 647         popl    %edx
 648         popl    %ecx
 649
 650         /* Enable PAE and LA57 (if required) paging modes */
 651         movl    $X86_CR4_PAE, %eax
 652         testl   %edx, %edx
 653         jz      1f
 654         orl     $X86_CR4_LA57, %eax
 655 1:
 656         movl    %eax, %cr4
 657
 658         /* Calculate address of paging_enabled() once we are executing in the trampoline */
 659         leal    .Lpaging_enabled - trampoline_32bit_src + TRAMPOLINE_32BIT_CODE_OFFSET(%ecx), %eax
 660
 661         /* Prepare the stack for far return to Long Mode */
 662         pushl   $__KERNEL_CS
 663         pushl   %eax
 664
 665         /* Enable paging again */
 666         movl    $(X86_CR0_PG | X86_CR0_PE), %eax
 667         movl    %eax, %cr0
 668
 669         lret
 670 SYM_CODE_END(trampoline_32bit_src)
 671
 672         .code64
 673 SYM_FUNC_START_LOCAL_NOALIGN(.Lpaging_enabled)
 674         /* Return from the trampoline */
 675         jmp     *%rdi
 676 SYM_FUNC_END(.Lpaging_enabled)
 677
 678         /*
 679          * The trampoline code has a size limit.
 680          * Make sure we fail to compile if the trampoline code grows
 681          * beyond TRAMPOLINE_32BIT_CODE_SIZE bytes.
 682          */
 683         .org    trampoline_32bit_src + TRAMPOLINE_32BIT_CODE_SIZE
 684
 685         .code32
 686 SYM_FUNC_START_LOCAL_NOALIGN(.Lno_longmode)
 687         /* This isn't an x86-64 CPU, so hang intentionally, we cannot continue */
 688 1:
 689         hlt
 690         jmp     1b
 691 SYM_FUNC_END(.Lno_longmode)
 692
 693 #include "../../kernel/verify_cpu.S"
 694
 695         .data
 696 SYM_DATA_START_LOCAL(gdt64)
 697         .word   gdt_end - gdt - 1
 698         .quad   gdt - gdt64
 699 SYM_DATA_END(gdt64)
 700         .balign 8
 701 SYM_DATA_START_LOCAL(gdt)
 702         .word   gdt_end - gdt - 1
 703         .long   0
 704         .word   0
 705         .quad   0x00cf9a000000ffff      /* __KERNEL32_CS */
 706         .quad   0x00af9a000000ffff      /* __KERNEL_CS */
 707         .quad   0x00cf92000000ffff      /* __KERNEL_DS */
 708         .quad   0x0080890000000000      /* TS descriptor */
 709         .quad   0x0000000000000000      /* TS continued */
 710 SYM_DATA_END_LABEL(gdt, SYM_L_LOCAL, gdt_end)
 711
 712 SYM_DATA_START(boot_idt_desc)
 713         .word   boot_idt_end - boot_idt - 1
 714         .quad   0
 715 SYM_DATA_END(boot_idt_desc)
 716         .balign 8
 717 SYM_DATA_START(boot_idt)
 718         .rept   BOOT_IDT_ENTRIES
 719         .quad   0
 720         .quad   0
 721         .endr
 722 SYM_DATA_END_LABEL(boot_idt, SYM_L_GLOBAL, boot_idt_end)
 723
 724 #ifdef CONFIG_AMD_MEM_ENCRYPT
 725 SYM_DATA_START(boot32_idt_desc)
 726         .word   boot32_idt_end - boot32_idt - 1
 727         .long   0
 728 SYM_DATA_END(boot32_idt_desc)
 729         .balign 8
 730 SYM_DATA_START(boot32_idt)
 731         .rept 32
 732         .quad 0
 733         .endr
 734 SYM_DATA_END_LABEL(boot32_idt, SYM_L_GLOBAL, boot32_idt_end)
 735 #endif
 736
 737 #ifdef CONFIG_EFI_STUB
 738 SYM_DATA(image_offset, .long 0)
 739 #endif
 740 #ifdef CONFIG_EFI_MIXED
 741 SYM_DATA_LOCAL(efi32_boot_args, .long 0, 0, 0)
 742 SYM_DATA(efi_is64, .byte 1)
 743
 744 #define ST32_boottime           60 // offsetof(efi_system_table_32_t, boottime)
 745 #define BS32_handle_protocol    88 // offsetof(efi_boot_services_32_t, handle_protocol)
 746 #define LI32_image_base         32 // offsetof(efi_loaded_image_32_t, image_base)
 747
 748         __HEAD
 749         .code32
 750 SYM_FUNC_START(efi32_pe_entry)
 751 /*
 752  * efi_status_t efi32_pe_entry(efi_handle_t image_handle,
 753  *                             efi_system_table_32_t *sys_table)
 754  */
 755
 756         pushl   %ebp
 757         movl    %esp, %ebp
 758         pushl   %eax                            // dummy push to allocate loaded_image
 759
 760         pushl   %ebx                            // save callee-save registers
 761         pushl   %edi
 762
 763         call    verify_cpu                      // check for long mode support
 764         testl   %eax, %eax
 765         movl    $0x80000003, %eax               // EFI_UNSUPPORTED
 766         jnz     2f
 767
 768         call    1f
 769 1:      pop     %ebx
 770         subl    $ rva(1b), %ebx
 771
 772         /* Get the loaded image protocol pointer from the image handle */
 773         leal    -4(%ebp), %eax
 774         pushl   %eax                            // &loaded_image
 775         leal    rva(loaded_image_proto)(%ebx), %eax
 776         pushl   %eax                            // pass the GUID address
 777         pushl   8(%ebp)                         // pass the image handle
 778
 779         /*
 780          * Note the alignment of the stack frame.
 781          *   sys_table
 782          *   handle             <-- 16-byte aligned on entry by ABI
 783          *   return address
 784          *   frame pointer
 785          *   loaded_image       <-- local variable
 786          *   saved %ebx         <-- 16-byte aligned here
 787          *   saved %edi
 788          *   &loaded_image
 789          *   &loaded_image_proto
 790          *   handle             <-- 16-byte aligned for call to handle_protocol
 791          */
 792
 793         movl    12(%ebp), %eax                  // sys_table
 794         movl    ST32_boottime(%eax), %eax       // sys_table->boottime
 795         call    *BS32_handle_protocol(%eax)     // sys_table->boottime->handle_protocol
 796         addl    $12, %esp                       // restore argument space
 797         testl   %eax, %eax
 798         jnz     2f
 799
 800         movl    8(%ebp), %ecx                   // image_handle
 801         movl    12(%ebp), %edx                  // sys_table
 802         movl    -4(%ebp), %esi                  // loaded_image
 803         movl    LI32_image_base(%esi), %esi     // loaded_image->image_base
 804         movl    %ebx, %ebp                      // startup_32 for efi32_pe_stub_entry
 805         /*
 806          * We need to set the image_offset variable here since startup_32() will
 807          * use it before we get to the 64-bit efi_pe_entry() in C code.
 808          */
 809         subl    %esi, %ebx
 810         movl    %ebx, rva(image_offset)(%ebp)   // save image_offset
 811         jmp     efi32_pe_stub_entry
 812
 813 2:      popl    %edi                            // restore callee-save registers
 814         popl    %ebx
 815         leave
 816         ret
 817 SYM_FUNC_END(efi32_pe_entry)
 818
 819         .section ".rodata"
 820         /* EFI loaded image protocol GUID */
 821         .balign 4
 822 SYM_DATA_START_LOCAL(loaded_image_proto)
 823         .long   0x5b1b31a1
 824         .word   0x9562, 0x11d2
 825         .byte   0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b
 826 SYM_DATA_END(loaded_image_proto)
 827 #endif
 828
 829 #ifdef CONFIG_AMD_MEM_ENCRYPT
 830         __HEAD
 831         .code32
 832 /*
 833  * Write an IDT entry into boot32_idt
 834  *
 835  * Parameters:
 836  *
 837  * %eax:        Handler address
 838  * %edx:        Vector number
 839  *
 840  * Physical offset is expected in %ebp
 841  */
 842 SYM_FUNC_START(startup32_set_idt_entry)
 843         push    %ebx
 844         push    %ecx
 845
 846         /* IDT entry address to %ebx */
 847         leal    rva(boot32_idt)(%ebp), %ebx
 848         shl     $3, %edx
 849         addl    %edx, %ebx
 850
 851         /* Build IDT entry, lower 4 bytes */
 852         movl    %eax, %edx
 853         andl    $0x0000ffff, %edx       # Target code segment offset [15:0]
 854         movl    $__KERNEL32_CS, %ecx    # Target code segment selector
 855         shl     $16, %ecx
 856         orl     %ecx, %edx
 857
 858         /* Store lower 4 bytes to IDT */
 859         movl    %edx, (%ebx)
 860
 861         /* Build IDT entry, upper 4 bytes */
 862         movl    %eax, %edx
 863         andl    $0xffff0000, %edx       # Target code segment offset [31:16]
 864         orl     $0x00008e00, %edx       # Present, Type 32-bit Interrupt Gate
 865
 866         /* Store upper 4 bytes to IDT */
 867         movl    %edx, 4(%ebx)
 868
 869         pop     %ecx
 870         pop     %ebx
 871         ret
 872 SYM_FUNC_END(startup32_set_idt_entry)
 873 #endif
 874
 875 SYM_FUNC_START(startup32_load_idt)
 876 #ifdef CONFIG_AMD_MEM_ENCRYPT
 877         /* #VC handler */
 878         leal    rva(startup32_vc_handler)(%ebp), %eax
 879         movl    $X86_TRAP_VC, %edx
 880         call    startup32_set_idt_entry
 881
 882         /* Load IDT */
 883         leal    rva(boot32_idt)(%ebp), %eax
 884         movl    %eax, rva(boot32_idt_desc+2)(%ebp)
 885         lidt    rva(boot32_idt_desc)(%ebp)
 886 #endif
 887         ret
 888 SYM_FUNC_END(startup32_load_idt)
 889
 890 /*
 891  * Check for the correct C-bit position when the startup_32 boot-path is used.
 892  *
 893  * The check makes use of the fact that all memory is encrypted when paging is
 894  * disabled. The function creates 64 bits of random data using the RDRAND
 895  * instruction. RDRAND is mandatory for SEV guests, so always available. If the
 896  * hypervisor violates that the kernel will crash right here.
 897  *
 898  * The 64 bits of random data are stored to a memory location and at the same
 899  * time kept in the %eax and %ebx registers. Since encryption is always active
 900  * when paging is off the random data will be stored encrypted in main memory.
 901  *
 902  * Then paging is enabled. When the C-bit position is correct all memory is
 903  * still mapped encrypted and comparing the register values with memory will
 904  * succeed. An incorrect C-bit position will map all memory unencrypted, so that
 905  * the compare will use the encrypted random data and fail.
 906  */
 907 SYM_FUNC_START(startup32_check_sev_cbit)
 908 #ifdef CONFIG_AMD_MEM_ENCRYPT
 909         pushl   %eax
 910         pushl   %ebx
 911         pushl   %ecx
 912         pushl   %edx
 913
 914         /* Check for non-zero sev_status */
 915         movl    rva(sev_status)(%ebp), %eax
 916         testl   %eax, %eax
 917         jz      4f
 918
 919         /*
 920          * Get two 32-bit random values - Don't bail out if RDRAND fails
 921          * because it is better to prevent forward progress if no random value
 922          * can be gathered.
 923          */
 924 1:      rdrand  %eax
 925         jnc     1b
 926 2:      rdrand  %ebx
 927         jnc     2b
 928
 929         /* Store to memory and keep it in the registers */
 930         movl    %eax, rva(sev_check_data)(%ebp)
 931         movl    %ebx, rva(sev_check_data+4)(%ebp)
 932
 933         /* Enable paging to see if encryption is active */
 934         movl    %cr0, %edx                       /* Backup %cr0 in %edx */
 935         movl    $(X86_CR0_PG | X86_CR0_PE), %ecx /* Enable Paging and Protected mode */
 936         movl    %ecx, %cr0
 937
 938         cmpl    %eax, rva(sev_check_data)(%ebp)
 939         jne     3f
 940         cmpl    %ebx, rva(sev_check_data+4)(%ebp)
 941         jne     3f
 942
 943         movl    %edx, %cr0      /* Restore previous %cr0 */
 944
 945         jmp     4f
 946
 947 3:      /* Check failed - hlt the machine */
 948         hlt
 949         jmp     3b
 950
 951 4:
 952         popl    %edx
 953         popl    %ecx
 954         popl    %ebx
 955         popl    %eax
 956 #endif
 957         ret
 958 SYM_FUNC_END(startup32_check_sev_cbit)
 959
 960 /*
 961  * Stack and heap for uncompression
 962  */
 963         .bss
 964         .balign 4
 965 SYM_DATA_LOCAL(boot_heap,       .fill BOOT_HEAP_SIZE, 1, 0)
 966
 967 SYM_DATA_START_LOCAL(boot_stack)
 968         .fill BOOT_STACK_SIZE, 1, 0
 969         .balign 16
 970 SYM_DATA_END_LABEL(boot_stack, SYM_L_LOCAL, boot_stack_end)
 971
 972 /*
 973  * Space for page tables (not in .bss so not zeroed)
 974  */
 975         .section ".pgtable","aw",@nobits
 976         .balign 4096
 977 SYM_DATA_LOCAL(pgtable,         .fill BOOT_PGT_SIZE, 1, 0)
 978
 979 /*
 980  * The page table is going to be used instead of page table in the trampoline
 981  * memory.
 982  */
 983 SYM_DATA_LOCAL(top_pgtable,     .fill PAGE_SIZE, 1, 0)