arch/x86/boot/compressed/head_32.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         .text
  26
  27 #include <linux/init.h>
  28 #include <linux/linkage.h>
  29 #include <asm/segment.h>
  30 #include <asm/page_types.h>
  31 #include <asm/boot.h>
  32 #include <asm/asm-offsets.h>
  33 #include <asm/bootparam.h>
  34
  35 /*
  36  * The 32-bit x86 assembler in binutils 2.26 will generate R_386_GOT32X
  37  * relocation to get the symbol address in PIC.  When the compressed x86
  38  * kernel isn't built as PIC, the linker optimizes R_386_GOT32X
  39  * relocations to their fixed symbol addresses.  However, when the
  40  * compressed x86 kernel is loaded at a different address, it leads
  41  * to the following load failure:
  42  *
  43  *   Failed to allocate space for phdrs
  44  *
  45  * during the decompression stage.
  46  *
  47  * If the compressed x86 kernel is relocatable at run-time, it should be
  48  * compiled with -fPIE, instead of -fPIC, if possible and should be built as
  49  * Position Independent Executable (PIE) so that linker won't optimize
  50  * R_386_GOT32X relocation to its fixed symbol address.  Older
  51  * linkers generate R_386_32 relocations against locally defined symbols,
  52  * _bss, _ebss, _got and _egot, in PIE.  It isn't wrong, just less
  53  * optimal than R_386_RELATIVE.  But the x86 kernel fails to properly handle
  54  * R_386_32 relocations when relocating the kernel.  To generate
  55  * R_386_RELATIVE relocations, we mark _bss, _ebss, _got and _egot as
  56  * hidden:
  57  */
  58         .hidden _bss
  59         .hidden _ebss
  60         .hidden _got
  61         .hidden _egot
  62
  63         __HEAD
  64 SYM_FUNC_START(startup_32)
  65         cld
  66         cli
  67
  68 /*
  69  * Calculate the delta between where we were compiled to run
  70  * at and where we were actually loaded at.  This can only be done
  71  * with a short local call on x86.  Nothing  else will tell us what
  72  * address we are running at.  The reserved chunk of the real-mode
  73  * data at 0x1e4 (defined as a scratch field) are used as the stack
  74  * for this calculation. Only 4 bytes are needed.
  75  */
  76         leal    (BP_scratch+4)(%esi), %esp
  77         call    1f
  78 1:      popl    %edx
  79         subl    $1b, %edx
  80
  81         /* Load new GDT */
  82         leal    gdt(%edx), %eax
  83         movl    %eax, 2(%eax)
  84         lgdt    (%eax)
  85
  86         /* Load segment registers with our descriptors */
  87         movl    $__BOOT_DS, %eax
  88         movl    %eax, %ds
  89         movl    %eax, %es
  90         movl    %eax, %fs
  91         movl    %eax, %gs
  92         movl    %eax, %ss
  93
  94 /*
  95  * %edx contains the address we are loaded at by the boot loader and %ebx
  96  * contains the address where we should move the kernel image temporarily
  97  * for safe in-place decompression. %ebp contains the address that the kernel
  98  * will be decompressed to.
  99  */
 100
 101 #ifdef CONFIG_RELOCATABLE
 102         movl    %edx, %ebx
 103
 104 #ifdef CONFIG_EFI_STUB
 105 /*
 106  * If we were loaded via the EFI LoadImage service, startup_32() will be at an
 107  * offset to the start of the space allocated for the image. efi_pe_entry() will
 108  * set up image_offset to tell us where the image actually starts, so that we
 109  * can use the full available buffer.
 110  *      image_offset = startup_32 - image_base
 111  * Otherwise image_offset will be zero and has no effect on the calculations.
 112  */
 113         subl    image_offset(%edx), %ebx
 114 #endif
 115
 116         movl    BP_kernel_alignment(%esi), %eax
 117         decl    %eax
 118         addl    %eax, %ebx
 119         notl    %eax
 120         andl    %eax, %ebx
 121         cmpl    $LOAD_PHYSICAL_ADDR, %ebx
 122         jae     1f
 123 #endif
 124         movl    $LOAD_PHYSICAL_ADDR, %ebx
 125 1:
 126
 127         movl    %ebx, %ebp      // Save the output address for later
 128         /* Target address to relocate to for decompression */
 129         addl    BP_init_size(%esi), %ebx
 130         subl    $_end, %ebx
 131
 132         /* Set up the stack */
 133         leal    boot_stack_end(%ebx), %esp
 134
 135         /* Zero EFLAGS */
 136         pushl   $0
 137         popfl
 138
 139 /*
 140  * Copy the compressed kernel to the end of our buffer
 141  * where decompression in place becomes safe.
 142  */
 143         pushl   %esi
 144         leal    (_bss-4)(%edx), %esi
 145         leal    (_bss-4)(%ebx), %edi
 146         movl    $(_bss - startup_32), %ecx
 147         shrl    $2, %ecx
 148         std
 149         rep     movsl
 150         cld
 151         popl    %esi
 152
 153         /*
 154          * The GDT may get overwritten either during the copy we just did or
 155          * during extract_kernel below. To avoid any issues, repoint the GDTR
 156          * to the new copy of the GDT.
 157          */
 158         leal    gdt(%ebx), %eax
 159         movl    %eax, 2(%eax)
 160         lgdt    (%eax)
 161
 162 /*
 163  * Jump to the relocated address.
 164  */
 165         leal    .Lrelocated(%ebx), %eax
 166         jmp     *%eax
 167 SYM_FUNC_END(startup_32)
 168
 169 #ifdef CONFIG_EFI_STUB
 170 SYM_FUNC_START(efi32_stub_entry)
 171 SYM_FUNC_START_ALIAS(efi_stub_entry)
 172         add     $0x4, %esp
 173         movl    8(%esp), %esi   /* save boot_params pointer */
 174         call    efi_main
 175         leal    startup_32(%eax), %eax
 176         jmp     *%eax
 177 SYM_FUNC_END(efi32_stub_entry)
 178 SYM_FUNC_END_ALIAS(efi_stub_entry)
 179 #endif
 180
 181         .text
 182 SYM_FUNC_START_LOCAL_NOALIGN(.Lrelocated)
 183
 184 /*
 185  * Clear BSS (stack is currently empty)
 186  */
 187         xorl    %eax, %eax
 188         leal    _bss(%ebx), %edi
 189         leal    _ebss(%ebx), %ecx
 190         subl    %edi, %ecx
 191         shrl    $2, %ecx
 192         rep     stosl
 193
 194 /*
 195  * Adjust our own GOT
 196  */
 197         leal    _got(%ebx), %edx
 198         leal    _egot(%ebx), %ecx
 199 1:
 200         cmpl    %ecx, %edx
 201         jae     2f
 202         addl    %ebx, (%edx)
 203         addl    $4, %edx
 204         jmp     1b
 205 2:
 206
 207 /*
 208  * Do the extraction, and jump to the new kernel..
 209  */
 210                                 /* push arguments for extract_kernel: */
 211         pushl   $z_output_len   /* decompressed length, end of relocs */
 212
 213         pushl   %ebp            /* output address */
 214
 215         pushl   $z_input_len    /* input_len */
 216         leal    input_data(%ebx), %eax
 217         pushl   %eax            /* input_data */
 218         leal    boot_heap(%ebx), %eax
 219         pushl   %eax            /* heap area */
 220         pushl   %esi            /* real mode pointer */
 221         call    extract_kernel  /* returns kernel location in %eax */
 222         addl    $24, %esp
 223
 224 /*
 225  * Jump to the extracted kernel.
 226  */
 227         xorl    %ebx, %ebx
 228         jmp     *%eax
 229 SYM_FUNC_END(.Lrelocated)
 230
 231         .data
 232         .balign 8
 233 SYM_DATA_START_LOCAL(gdt)
 234         .word   gdt_end - gdt - 1
 235         .long   0
 236         .word   0
 237         .quad   0x0000000000000000      /* Reserved */
 238         .quad   0x00cf9a000000ffff      /* __KERNEL_CS */
 239         .quad   0x00cf92000000ffff      /* __KERNEL_DS */
 240 SYM_DATA_END_LABEL(gdt, SYM_L_LOCAL, gdt_end)
 241
 242 #ifdef CONFIG_EFI_STUB
 243 SYM_DATA(image_offset, .long 0)
 244 #endif
 245
 246 /*
 247  * Stack and heap for uncompression
 248  */
 249         .bss
 250         .balign 4
 251 boot_heap:
 252         .fill BOOT_HEAP_SIZE, 1, 0
 253 boot_stack:
 254         .fill BOOT_STACK_SIZE, 1, 0
 255 boot_stack_end: