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