arch/x86/kernel/head_64.S

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  *  linux/arch/x86/kernel/head_64.S -- start in 32bit and switch to 64bit
   4  *
   5  *  Copyright (C) 2000 Andrea Arcangeli <[email protected]> SuSE
   6  *  Copyright (C) 2000 Pavel Machek <[email protected]>
   7  *  Copyright (C) 2000 Karsten Keil <[email protected]>
   8  *  Copyright (C) 2001,2002 Andi Kleen <[email protected]>
   9  *  Copyright (C) 2005 Eric Biederman <[email protected]>
  10  */
  11
  12
  13 #include <linux/linkage.h>
  14 #include <linux/threads.h>
  15 #include <linux/init.h>
  16 #include <linux/pgtable.h>
  17 #include <asm/segment.h>
  18 #include <asm/page.h>
  19 #include <asm/msr.h>
  20 #include <asm/cache.h>
  21 #include <asm/processor-flags.h>
  22 #include <asm/percpu.h>
  23 #include <asm/nops.h>
  24 #include "../entry/calling.h"
  25 #include <asm/export.h>
  26 #include <asm/nospec-branch.h>
  27 #include <asm/apicdef.h>
  28 #include <asm/fixmap.h>
  29 #include <asm/smp.h>
  30
  31 /*
  32  * We are not able to switch in one step to the final KERNEL ADDRESS SPACE
  33  * because we need identity-mapped pages.
  34  */
  35 #define l4_index(x)     (((x) >> 39) & 511)
  36 #define pud_index(x)    (((x) >> PUD_SHIFT) & (PTRS_PER_PUD-1))
  37
  38 L4_PAGE_OFFSET = l4_index(__PAGE_OFFSET_BASE_L4)
  39 L4_START_KERNEL = l4_index(__START_KERNEL_map)
  40
  41 L3_START_KERNEL = pud_index(__START_KERNEL_map)
  42
  43         .text
  44         __HEAD
  45         .code64
  46 SYM_CODE_START_NOALIGN(startup_64)
  47         UNWIND_HINT_END_OF_STACK
  48         /*
  49          * At this point the CPU runs in 64bit mode CS.L = 1 CS.D = 0,
  50          * and someone has loaded an identity mapped page table
  51          * for us.  These identity mapped page tables map all of the
  52          * kernel pages and possibly all of memory.
  53          *
  54          * %RSI holds the physical address of the boot_params structure
  55          * provided by the bootloader. Preserve it in %R15 so C function calls
  56          * will not clobber it.
  57          *
  58          * We come here either directly from a 64bit bootloader, or from
  59          * arch/x86/boot/compressed/head_64.S.
  60          *
  61          * We only come here initially at boot nothing else comes here.
  62          *
  63          * Since we may be loaded at an address different from what we were
  64          * compiled to run at we first fixup the physical addresses in our page
  65          * tables and then reload them.
  66          */
  67         mov     %rsi, %r15
  68
  69         /* Set up the stack for verify_cpu() */
  70         leaq    (__end_init_task - PTREGS_SIZE)(%rip), %rsp
  71
  72         leaq    _text(%rip), %rdi
  73
  74         /* Setup GSBASE to allow stack canary access for C code */
  75         movl    $MSR_GS_BASE, %ecx
  76         leaq    INIT_PER_CPU_VAR(fixed_percpu_data)(%rip), %rdx
  77         movl    %edx, %eax
  78         shrq    $32,  %rdx
  79         wrmsr
  80
  81         call    startup_64_setup_env
  82
  83         /* Now switch to __KERNEL_CS so IRET works reliably */
  84         pushq   $__KERNEL_CS
  85         leaq    .Lon_kernel_cs(%rip), %rax
  86         pushq   %rax
  87         lretq
  88
  89 .Lon_kernel_cs:
  90         UNWIND_HINT_END_OF_STACK
  91
  92 #ifdef CONFIG_AMD_MEM_ENCRYPT
  93         /*
  94          * Activate SEV/SME memory encryption if supported/enabled. This needs to
  95          * be done now, since this also includes setup of the SEV-SNP CPUID table,
  96          * which needs to be done before any CPUID instructions are executed in
  97          * subsequent code. Pass the boot_params pointer as the first argument.
  98          */
  99         movq    %r15, %rdi
 100         call    sme_enable
 101 #endif
 102
 103         /* Sanitize CPU configuration */
 104         call verify_cpu
 105
 106         /*
 107          * Perform pagetable fixups. Additionally, if SME is active, encrypt
 108          * the kernel and retrieve the modifier (SME encryption mask if SME
 109          * is active) to be added to the initial pgdir entry that will be
 110          * programmed into CR3.
 111          */
 112         leaq    _text(%rip), %rdi
 113         movq    %r15, %rsi
 114         call    __startup_64
 115
 116         /* Form the CR3 value being sure to include the CR3 modifier */
 117         addq    $(early_top_pgt - __START_KERNEL_map), %rax
 118         jmp 1f
 119 SYM_CODE_END(startup_64)
 120
 121 SYM_CODE_START(secondary_startup_64)
 122         UNWIND_HINT_END_OF_STACK
 123         ANNOTATE_NOENDBR
 124         /*
 125          * At this point the CPU runs in 64bit mode CS.L = 1 CS.D = 0,
 126          * and someone has loaded a mapped page table.
 127          *
 128          * We come here either from startup_64 (using physical addresses)
 129          * or from trampoline.S (using virtual addresses).
 130          *
 131          * Using virtual addresses from trampoline.S removes the need
 132          * to have any identity mapped pages in the kernel page table
 133          * after the boot processor executes this code.
 134          */
 135
 136         /* Sanitize CPU configuration */
 137         call verify_cpu
 138
 139         /*
 140          * The secondary_startup_64_no_verify entry point is only used by
 141          * SEV-ES guests. In those guests the call to verify_cpu() would cause
 142          * #VC exceptions which can not be handled at this stage of secondary
 143          * CPU bringup.
 144          *
 145          * All non SEV-ES systems, especially Intel systems, need to execute
 146          * verify_cpu() above to make sure NX is enabled.
 147          */
 148 SYM_INNER_LABEL(secondary_startup_64_no_verify, SYM_L_GLOBAL)
 149         UNWIND_HINT_END_OF_STACK
 150         ANNOTATE_NOENDBR
 151
 152         /* Clear %R15 which holds the boot_params pointer on the boot CPU */
 153         xorq    %r15, %r15
 154
 155         /*
 156          * Retrieve the modifier (SME encryption mask if SME is active) to be
 157          * added to the initial pgdir entry that will be programmed into CR3.
 158          */
 159 #ifdef CONFIG_AMD_MEM_ENCRYPT
 160         movq    sme_me_mask, %rax
 161 #else
 162         xorq    %rax, %rax
 163 #endif
 164
 165         /* Form the CR3 value being sure to include the CR3 modifier */
 166         addq    $(init_top_pgt - __START_KERNEL_map), %rax
 167 1:
 168
 169 #ifdef CONFIG_X86_MCE
 170         /*
 171          * Preserve CR4.MCE if the kernel will enable #MC support.
 172          * Clearing MCE may fault in some environments (that also force #MC
 173          * support). Any machine check that occurs before #MC support is fully
 174          * configured will crash the system regardless of the CR4.MCE value set
 175          * here.
 176          */
 177         movq    %cr4, %rcx
 178         andl    $X86_CR4_MCE, %ecx
 179 #else
 180         movl    $0, %ecx
 181 #endif
 182
 183         /* Enable PAE mode, PGE and LA57 */
 184         orl     $(X86_CR4_PAE | X86_CR4_PGE), %ecx
 185 #ifdef CONFIG_X86_5LEVEL
 186         testl   $1, __pgtable_l5_enabled(%rip)
 187         jz      1f
 188         orl     $X86_CR4_LA57, %ecx
 189 1:
 190 #endif
 191         movq    %rcx, %cr4
 192
 193         /* Setup early boot stage 4-/5-level pagetables. */
 194         addq    phys_base(%rip), %rax
 195
 196         /*
 197          * For SEV guests: Verify that the C-bit is correct. A malicious
 198          * hypervisor could lie about the C-bit position to perform a ROP
 199          * attack on the guest by writing to the unencrypted stack and wait for
 200          * the next RET instruction.
 201          */
 202         movq    %rax, %rdi
 203         call    sev_verify_cbit
 204
 205         /*
 206          * Switch to new page-table
 207          *
 208          * For the boot CPU this switches to early_top_pgt which still has the
 209          * indentity mappings present. The secondary CPUs will switch to the
 210          * init_top_pgt here, away from the trampoline_pgd and unmap the
 211          * indentity mapped ranges.
 212          */
 213         movq    %rax, %cr3
 214
 215         /*
 216          * Do a global TLB flush after the CR3 switch to make sure the TLB
 217          * entries from the identity mapping are flushed.
 218          */
 219         movq    %cr4, %rcx
 220         movq    %rcx, %rax
 221         xorq    $X86_CR4_PGE, %rcx
 222         movq    %rcx, %cr4
 223         movq    %rax, %cr4
 224
 225         /* Ensure I am executing from virtual addresses */
 226         movq    $1f, %rax
 227         ANNOTATE_RETPOLINE_SAFE
 228         jmp     *%rax
 229 1:
 230         UNWIND_HINT_END_OF_STACK
 231         ANNOTATE_NOENDBR // above
 232
 233 #ifdef CONFIG_SMP
 234         /*
 235          * For parallel boot, the APIC ID is read from the APIC, and then
 236          * used to look up the CPU number.  For booting a single CPU, the
 237          * CPU number is encoded in smpboot_control.
 238          *
 239          * Bit 31       STARTUP_READ_APICID (Read APICID from APIC)
 240          * Bit 0-23     CPU# if STARTUP_xx flags are not set
 241          */
 242         movl    smpboot_control(%rip), %ecx
 243         testl   $STARTUP_READ_APICID, %ecx
 244         jnz     .Lread_apicid
 245         /*
 246          * No control bit set, single CPU bringup. CPU number is provided
 247          * in bit 0-23. This is also the boot CPU case (CPU number 0).
 248          */
 249         andl    $(~STARTUP_PARALLEL_MASK), %ecx
 250         jmp     .Lsetup_cpu
 251
 252 .Lread_apicid:
 253         /* Check whether X2APIC mode is already enabled */
 254         mov     $MSR_IA32_APICBASE, %ecx
 255         rdmsr
 256         testl   $X2APIC_ENABLE, %eax
 257         jnz     .Lread_apicid_msr
 258
 259         /* Read the APIC ID from the fix-mapped MMIO space. */
 260         movq    apic_mmio_base(%rip), %rcx
 261         addq    $APIC_ID, %rcx
 262         movl    (%rcx), %eax
 263         shr     $24, %eax
 264         jmp     .Llookup_AP
 265
 266 .Lread_apicid_msr:
 267         mov     $APIC_X2APIC_ID_MSR, %ecx
 268         rdmsr
 269
 270 .Llookup_AP:
 271         /* EAX contains the APIC ID of the current CPU */
 272         xorq    %rcx, %rcx
 273         leaq    cpuid_to_apicid(%rip), %rbx
 274
 275 .Lfind_cpunr:
 276         cmpl    (%rbx,%rcx,4), %eax
 277         jz      .Lsetup_cpu
 278         inc     %ecx
 279 #ifdef CONFIG_FORCE_NR_CPUS
 280         cmpl    $NR_CPUS, %ecx
 281 #else
 282         cmpl    nr_cpu_ids(%rip), %ecx
 283 #endif
 284         jb      .Lfind_cpunr
 285
 286         /*  APIC ID not found in the table. Drop the trampoline lock and bail. */
 287         movq    trampoline_lock(%rip), %rax
 288         movl    $0, (%rax)
 289
 290 1:      cli
 291         hlt
 292         jmp     1b
 293
 294 .Lsetup_cpu:
 295         /* Get the per cpu offset for the given CPU# which is in ECX */
 296         movq    __per_cpu_offset(,%rcx,8), %rdx
 297 #else
 298         xorl    %edx, %edx /* zero-extended to clear all of RDX */
 299 #endif /* CONFIG_SMP */
 300
 301         /*
 302          * Setup a boot time stack - Any secondary CPU will have lost its stack
 303          * by now because the cr3-switch above unmaps the real-mode stack.
 304          *
 305          * RDX contains the per-cpu offset
 306          */
 307         movq    pcpu_hot + X86_current_task(%rdx), %rax
 308         movq    TASK_threadsp(%rax), %rsp
 309
 310         /*
 311          * Now that this CPU is running on its own stack, drop the realmode
 312          * protection. For the boot CPU the pointer is NULL!
 313          */
 314         movq    trampoline_lock(%rip), %rax
 315         testq   %rax, %rax
 316         jz      .Lsetup_gdt
 317         movl    $0, (%rax)
 318
 319 .Lsetup_gdt:
 320         /*
 321          * We must switch to a new descriptor in kernel space for the GDT
 322          * because soon the kernel won't have access anymore to the userspace
 323          * addresses where we're currently running on. We have to do that here
 324          * because in 32bit we couldn't load a 64bit linear address.
 325          */
 326         subq    $16, %rsp
 327         movw    $(GDT_SIZE-1), (%rsp)
 328         leaq    gdt_page(%rdx), %rax
 329         movq    %rax, 2(%rsp)
 330         lgdt    (%rsp)
 331         addq    $16, %rsp
 332
 333         /* set up data segments */
 334         xorl %eax,%eax
 335         movl %eax,%ds
 336         movl %eax,%ss
 337         movl %eax,%es
 338
 339         /*
 340          * We don't really need to load %fs or %gs, but load them anyway
 341          * to kill any stale realmode selectors.  This allows execution
 342          * under VT hardware.
 343          */
 344         movl %eax,%fs
 345         movl %eax,%gs
 346
 347         /* Set up %gs.
 348          *
 349          * The base of %gs always points to fixed_percpu_data. If the
 350          * stack protector canary is enabled, it is located at %gs:40.
 351          * Note that, on SMP, the boot cpu uses init data section until
 352          * the per cpu areas are set up.
 353          */
 354         movl    $MSR_GS_BASE,%ecx
 355 #ifndef CONFIG_SMP
 356         leaq    INIT_PER_CPU_VAR(fixed_percpu_data)(%rip), %rdx
 357 #endif
 358         movl    %edx, %eax
 359         shrq    $32, %rdx
 360         wrmsr
 361
 362         /* Setup and Load IDT */
 363         call    early_setup_idt
 364
 365         /* Check if nx is implemented */
 366         movl    $0x80000001, %eax
 367         cpuid
 368         movl    %edx,%edi
 369
 370         /* Setup EFER (Extended Feature Enable Register) */
 371         movl    $MSR_EFER, %ecx
 372         rdmsr
 373         /*
 374          * Preserve current value of EFER for comparison and to skip
 375          * EFER writes if no change was made (for TDX guest)
 376          */
 377         movl    %eax, %edx
 378         btsl    $_EFER_SCE, %eax        /* Enable System Call */
 379         btl     $20,%edi                /* No Execute supported? */
 380         jnc     1f
 381         btsl    $_EFER_NX, %eax
 382         btsq    $_PAGE_BIT_NX,early_pmd_flags(%rip)
 383
 384         /* Avoid writing EFER if no change was made (for TDX guest) */
 385 1:      cmpl    %edx, %eax
 386         je      1f
 387         xor     %edx, %edx
 388         wrmsr                           /* Make changes effective */
 389 1:
 390         /* Setup cr0 */
 391         movl    $CR0_STATE, %eax
 392         /* Make changes effective */
 393         movq    %rax, %cr0
 394
 395         /* zero EFLAGS after setting rsp */
 396         pushq $0
 397         popfq
 398
 399         /* Pass the boot_params pointer as first argument */
 400         movq    %r15, %rdi
 401
 402 .Ljump_to_C_code:
 403         /*
 404          * Jump to run C code and to be on a real kernel address.
 405          * Since we are running on identity-mapped space we have to jump
 406          * to the full 64bit address, this is only possible as indirect
 407          * jump.  In addition we need to ensure %cs is set so we make this
 408          * a far return.
 409          *
 410          * Note: do not change to far jump indirect with 64bit offset.
 411          *
 412          * AMD does not support far jump indirect with 64bit offset.
 413          * AMD64 Architecture Programmer's Manual, Volume 3: states only
 414          *      JMP FAR mem16:16 FF /5 Far jump indirect,
 415          *              with the target specified by a far pointer in memory.
 416          *      JMP FAR mem16:32 FF /5 Far jump indirect,
 417          *              with the target specified by a far pointer in memory.
 418          *
 419          * Intel64 does support 64bit offset.
 420          * Software Developer Manual Vol 2: states:
 421          *      FF /5 JMP m16:16 Jump far, absolute indirect,
 422          *              address given in m16:16
 423          *      FF /5 JMP m16:32 Jump far, absolute indirect,
 424          *              address given in m16:32.
 425          *      REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,
 426          *              address given in m16:64.
 427          */
 428         pushq   $.Lafter_lret   # put return address on stack for unwinder
 429         xorl    %ebp, %ebp      # clear frame pointer
 430         movq    initial_code(%rip), %rax
 431         pushq   $__KERNEL_CS    # set correct cs
 432         pushq   %rax            # target address in negative space
 433         lretq
 434 .Lafter_lret:
 435         ANNOTATE_NOENDBR
 436 SYM_CODE_END(secondary_startup_64)
 437
 438 #include "verify_cpu.S"
 439 #include "sev_verify_cbit.S"
 440
 441 #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_AMD_MEM_ENCRYPT)
 442 /*
 443  * Entry point for soft restart of a CPU. Invoked from xxx_play_dead() for
 444  * restarting the boot CPU or for restarting SEV guest CPUs after CPU hot
 445  * unplug. Everything is set up already except the stack.
 446  */
 447 SYM_CODE_START(soft_restart_cpu)
 448         ANNOTATE_NOENDBR
 449         UNWIND_HINT_END_OF_STACK
 450
 451         /* Find the idle task stack */
 452         movq    PER_CPU_VAR(pcpu_hot) + X86_current_task, %rcx
 453         movq    TASK_threadsp(%rcx), %rsp
 454
 455         jmp     .Ljump_to_C_code
 456 SYM_CODE_END(soft_restart_cpu)
 457 #endif
 458
 459 #ifdef CONFIG_AMD_MEM_ENCRYPT
 460 /*
 461  * VC Exception handler used during early boot when running on kernel
 462  * addresses, but before the switch to the idt_table can be made.
 463  * The early_idt_handler_array can't be used here because it calls into a lot
 464  * of __init code and this handler is also used during CPU offlining/onlining.
 465  * Therefore this handler ends up in the .text section so that it stays around
 466  * when .init.text is freed.
 467  */
 468 SYM_CODE_START_NOALIGN(vc_boot_ghcb)
 469         UNWIND_HINT_IRET_REGS offset=8
 470         ENDBR
 471
 472         /* Build pt_regs */
 473         PUSH_AND_CLEAR_REGS
 474
 475         /* Call C handler */
 476         movq    %rsp, %rdi
 477         movq    ORIG_RAX(%rsp), %rsi
 478         movq    initial_vc_handler(%rip), %rax
 479         ANNOTATE_RETPOLINE_SAFE
 480         call    *%rax
 481
 482         /* Unwind pt_regs */
 483         POP_REGS
 484
 485         /* Remove Error Code */
 486         addq    $8, %rsp
 487
 488         iretq
 489 SYM_CODE_END(vc_boot_ghcb)
 490 #endif
 491
 492         /* Both SMP bootup and ACPI suspend change these variables */
 493         __REFDATA
 494         .balign 8
 495 SYM_DATA(initial_code,  .quad x86_64_start_kernel)
 496 #ifdef CONFIG_AMD_MEM_ENCRYPT
 497 SYM_DATA(initial_vc_handler,    .quad handle_vc_boot_ghcb)
 498 #endif
 499
 500 SYM_DATA(trampoline_lock, .quad 0);
 501         __FINITDATA
 502
 503         __INIT
 504 SYM_CODE_START(early_idt_handler_array)
 505         i = 0
 506         .rept NUM_EXCEPTION_VECTORS
 507         .if ((EXCEPTION_ERRCODE_MASK >> i) & 1) == 0
 508                 UNWIND_HINT_IRET_REGS
 509                 ENDBR
 510                 pushq $0        # Dummy error code, to make stack frame uniform
 511         .else
 512                 UNWIND_HINT_IRET_REGS offset=8
 513                 ENDBR
 514         .endif
 515         pushq $i                # 72(%rsp) Vector number
 516         jmp early_idt_handler_common
 517         UNWIND_HINT_IRET_REGS
 518         i = i + 1
 519         .fill early_idt_handler_array + i*EARLY_IDT_HANDLER_SIZE - ., 1, 0xcc
 520         .endr
 521 SYM_CODE_END(early_idt_handler_array)
 522         ANNOTATE_NOENDBR // early_idt_handler_array[NUM_EXCEPTION_VECTORS]
 523
 524 SYM_CODE_START_LOCAL(early_idt_handler_common)
 525         UNWIND_HINT_IRET_REGS offset=16
 526         /*
 527          * The stack is the hardware frame, an error code or zero, and the
 528          * vector number.
 529          */
 530         cld
 531
 532         incl early_recursion_flag(%rip)
 533
 534         /* The vector number is currently in the pt_regs->di slot. */
 535         pushq %rsi                              /* pt_regs->si */
 536         movq 8(%rsp), %rsi                      /* RSI = vector number */
 537         movq %rdi, 8(%rsp)                      /* pt_regs->di = RDI */
 538         pushq %rdx                              /* pt_regs->dx */
 539         pushq %rcx                              /* pt_regs->cx */
 540         pushq %rax                              /* pt_regs->ax */
 541         pushq %r8                               /* pt_regs->r8 */
 542         pushq %r9                               /* pt_regs->r9 */
 543         pushq %r10                              /* pt_regs->r10 */
 544         pushq %r11                              /* pt_regs->r11 */
 545         pushq %rbx                              /* pt_regs->bx */
 546         pushq %rbp                              /* pt_regs->bp */
 547         pushq %r12                              /* pt_regs->r12 */
 548         pushq %r13                              /* pt_regs->r13 */
 549         pushq %r14                              /* pt_regs->r14 */
 550         pushq %r15                              /* pt_regs->r15 */
 551         UNWIND_HINT_REGS
 552
 553         movq %rsp,%rdi          /* RDI = pt_regs; RSI is already trapnr */
 554         call do_early_exception
 555
 556         decl early_recursion_flag(%rip)
 557         jmp restore_regs_and_return_to_kernel
 558 SYM_CODE_END(early_idt_handler_common)
 559
 560 #ifdef CONFIG_AMD_MEM_ENCRYPT
 561 /*
 562  * VC Exception handler used during very early boot. The
 563  * early_idt_handler_array can't be used because it returns via the
 564  * paravirtualized INTERRUPT_RETURN and pv-ops don't work that early.
 565  *
 566  * XXX it does, fix this.
 567  *
 568  * This handler will end up in the .init.text section and not be
 569  * available to boot secondary CPUs.
 570  */
 571 SYM_CODE_START_NOALIGN(vc_no_ghcb)
 572         UNWIND_HINT_IRET_REGS offset=8
 573         ENDBR
 574
 575         /* Build pt_regs */
 576         PUSH_AND_CLEAR_REGS
 577
 578         /* Call C handler */
 579         movq    %rsp, %rdi
 580         movq    ORIG_RAX(%rsp), %rsi
 581         call    do_vc_no_ghcb
 582
 583         /* Unwind pt_regs */
 584         POP_REGS
 585
 586         /* Remove Error Code */
 587         addq    $8, %rsp
 588
 589         /* Pure iret required here - don't use INTERRUPT_RETURN */
 590         iretq
 591 SYM_CODE_END(vc_no_ghcb)
 592 #endif
 593
 594 #define SYM_DATA_START_PAGE_ALIGNED(name)                       \
 595         SYM_START(name, SYM_L_GLOBAL, .balign PAGE_SIZE)
 596
 597 #ifdef CONFIG_PAGE_TABLE_ISOLATION
 598 /*
 599  * Each PGD needs to be 8k long and 8k aligned.  We do not
 600  * ever go out to userspace with these, so we do not
 601  * strictly *need* the second page, but this allows us to
 602  * have a single set_pgd() implementation that does not
 603  * need to worry about whether it has 4k or 8k to work
 604  * with.
 605  *
 606  * This ensures PGDs are 8k long:
 607  */
 608 #define PTI_USER_PGD_FILL       512
 609 /* This ensures they are 8k-aligned: */
 610 #define SYM_DATA_START_PTI_ALIGNED(name) \
 611         SYM_START(name, SYM_L_GLOBAL, .balign 2 * PAGE_SIZE)
 612 #else
 613 #define SYM_DATA_START_PTI_ALIGNED(name) \
 614         SYM_DATA_START_PAGE_ALIGNED(name)
 615 #define PTI_USER_PGD_FILL       0
 616 #endif
 617
 618 /* Automate the creation of 1 to 1 mapping pmd entries */
 619 #define PMDS(START, PERM, COUNT)                        \
 620         i = 0 ;                                         \
 621         .rept (COUNT) ;                                 \
 622         .quad   (START) + (i << PMD_SHIFT) + (PERM) ;   \
 623         i = i + 1 ;                                     \
 624         .endr
 625
 626         __INITDATA
 627         .balign 4
 628
 629 SYM_DATA_START_PTI_ALIGNED(early_top_pgt)
 630         .fill   512,8,0
 631         .fill   PTI_USER_PGD_FILL,8,0
 632 SYM_DATA_END(early_top_pgt)
 633
 634 SYM_DATA_START_PAGE_ALIGNED(early_dynamic_pgts)
 635         .fill   512*EARLY_DYNAMIC_PAGE_TABLES,8,0
 636 SYM_DATA_END(early_dynamic_pgts)
 637
 638 SYM_DATA(early_recursion_flag, .long 0)
 639
 640         .data
 641
 642 #if defined(CONFIG_XEN_PV) || defined(CONFIG_PVH)
 643 SYM_DATA_START_PTI_ALIGNED(init_top_pgt)
 644         .quad   level3_ident_pgt - __START_KERNEL_map + _KERNPG_TABLE_NOENC
 645         .org    init_top_pgt + L4_PAGE_OFFSET*8, 0
 646         .quad   level3_ident_pgt - __START_KERNEL_map + _KERNPG_TABLE_NOENC
 647         .org    init_top_pgt + L4_START_KERNEL*8, 0
 648         /* (2^48-(2*1024*1024*1024))/(2^39) = 511 */
 649         .quad   level3_kernel_pgt - __START_KERNEL_map + _PAGE_TABLE_NOENC
 650         .fill   PTI_USER_PGD_FILL,8,0
 651 SYM_DATA_END(init_top_pgt)
 652
 653 SYM_DATA_START_PAGE_ALIGNED(level3_ident_pgt)
 654         .quad   level2_ident_pgt - __START_KERNEL_map + _KERNPG_TABLE_NOENC
 655         .fill   511, 8, 0
 656 SYM_DATA_END(level3_ident_pgt)
 657 SYM_DATA_START_PAGE_ALIGNED(level2_ident_pgt)
 658         /*
 659          * Since I easily can, map the first 1G.
 660          * Don't set NX because code runs from these pages.
 661          *
 662          * Note: This sets _PAGE_GLOBAL despite whether
 663          * the CPU supports it or it is enabled.  But,
 664          * the CPU should ignore the bit.
 665          */
 666         PMDS(0, __PAGE_KERNEL_IDENT_LARGE_EXEC, PTRS_PER_PMD)
 667 SYM_DATA_END(level2_ident_pgt)
 668 #else
 669 SYM_DATA_START_PTI_ALIGNED(init_top_pgt)
 670         .fill   512,8,0
 671         .fill   PTI_USER_PGD_FILL,8,0
 672 SYM_DATA_END(init_top_pgt)
 673 #endif
 674
 675 #ifdef CONFIG_X86_5LEVEL
 676 SYM_DATA_START_PAGE_ALIGNED(level4_kernel_pgt)
 677         .fill   511,8,0
 678         .quad   level3_kernel_pgt - __START_KERNEL_map + _PAGE_TABLE_NOENC
 679 SYM_DATA_END(level4_kernel_pgt)
 680 #endif
 681
 682 SYM_DATA_START_PAGE_ALIGNED(level3_kernel_pgt)
 683         .fill   L3_START_KERNEL,8,0
 684         /* (2^48-(2*1024*1024*1024)-((2^39)*511))/(2^30) = 510 */
 685         .quad   level2_kernel_pgt - __START_KERNEL_map + _KERNPG_TABLE_NOENC
 686         .quad   level2_fixmap_pgt - __START_KERNEL_map + _PAGE_TABLE_NOENC
 687 SYM_DATA_END(level3_kernel_pgt)
 688
 689 SYM_DATA_START_PAGE_ALIGNED(level2_kernel_pgt)
 690         /*
 691          * Kernel high mapping.
 692          *
 693          * The kernel code+data+bss must be located below KERNEL_IMAGE_SIZE in
 694          * virtual address space, which is 1 GiB if RANDOMIZE_BASE is enabled,
 695          * 512 MiB otherwise.
 696          *
 697          * (NOTE: after that starts the module area, see MODULES_VADDR.)
 698          *
 699          * This table is eventually used by the kernel during normal runtime.
 700          * Care must be taken to clear out undesired bits later, like _PAGE_RW
 701          * or _PAGE_GLOBAL in some cases.
 702          */
 703         PMDS(0, __PAGE_KERNEL_LARGE_EXEC, KERNEL_IMAGE_SIZE/PMD_SIZE)
 704 SYM_DATA_END(level2_kernel_pgt)
 705
 706 SYM_DATA_START_PAGE_ALIGNED(level2_fixmap_pgt)
 707         .fill   (512 - 4 - FIXMAP_PMD_NUM),8,0
 708         pgtno = 0
 709         .rept (FIXMAP_PMD_NUM)
 710         .quad level1_fixmap_pgt + (pgtno << PAGE_SHIFT) - __START_KERNEL_map \
 711                 + _PAGE_TABLE_NOENC;
 712         pgtno = pgtno + 1
 713         .endr
 714         /* 6 MB reserved space + a 2MB hole */
 715         .fill   4,8,0
 716 SYM_DATA_END(level2_fixmap_pgt)
 717
 718 SYM_DATA_START_PAGE_ALIGNED(level1_fixmap_pgt)
 719         .rept (FIXMAP_PMD_NUM)
 720         .fill   512,8,0
 721         .endr
 722 SYM_DATA_END(level1_fixmap_pgt)
 723
 724 #undef PMDS
 725
 726         .data
 727         .align 16
 728
 729 SYM_DATA(smpboot_control,               .long 0)
 730
 731         .align 16
 732 /* This must match the first entry in level2_kernel_pgt */
 733 SYM_DATA(phys_base, .quad 0x0)
 734 EXPORT_SYMBOL(phys_base)
 735
 736 #include "../../x86/xen/xen-head.S"
 737
 738         __PAGE_ALIGNED_BSS
 739 SYM_DATA_START_PAGE_ALIGNED(empty_zero_page)
 740         .skip PAGE_SIZE
 741 SYM_DATA_END(empty_zero_page)
 742 EXPORT_SYMBOL(empty_zero_page)
 743