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, _egot and _end, 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, _egot and _end as
  56  * hidden:
  57  */
  58         .hidden _bss
  59         .hidden _ebss
  60         .hidden _got
  61         .hidden _egot
  62         .hidden _end
  63
  64         __HEAD
  65 ENTRY(startup_32)
  66         cld
  67         /*
  68          * Test KEEP_SEGMENTS flag to see if the bootloader is asking
  69          * us to not reload segments
  70          */
  71         testb   $KEEP_SEGMENTS, BP_loadflags(%esi)
  72         jnz     1f
  73
  74         cli
  75         movl    $__BOOT_DS, %eax
  76         movl    %eax, %ds
  77         movl    %eax, %es
  78         movl    %eax, %fs
  79         movl    %eax, %gs
  80         movl    %eax, %ss
  81 1:
  82
  83 /*
  84  * Calculate the delta between where we were compiled to run
  85  * at and where we were actually loaded at.  This can only be done
  86  * with a short local call on x86.  Nothing  else will tell us what
  87  * address we are running at.  The reserved chunk of the real-mode
  88  * data at 0x1e4 (defined as a scratch field) are used as the stack
  89  * for this calculation. Only 4 bytes are needed.
  90  */
  91         leal    (BP_scratch+4)(%esi), %esp
  92         call    1f
  93 1:      popl    %ebp
  94         subl    $1b, %ebp
  95
  96 /*
  97  * %ebp contains the address we are loaded at by the boot loader and %ebx
  98  * contains the address where we should move the kernel image temporarily
  99  * for safe in-place decompression.
 100  */
 101
 102 #ifdef CONFIG_RELOCATABLE
 103         movl    %ebp, %ebx
 104         movl    BP_kernel_alignment(%esi), %eax
 105         decl    %eax
 106         addl    %eax, %ebx
 107         notl    %eax
 108         andl    %eax, %ebx
 109         cmpl    $LOAD_PHYSICAL_ADDR, %ebx
 110         jae     1f
 111 #endif
 112         movl    $LOAD_PHYSICAL_ADDR, %ebx
 113 1:
 114
 115         /* Target address to relocate to for decompression */
 116         movl    BP_init_size(%esi), %eax
 117         subl    $_end, %eax
 118         addl    %eax, %ebx
 119
 120         /* Set up the stack */
 121         leal    boot_stack_end(%ebx), %esp
 122
 123         /* Zero EFLAGS */
 124         pushl   $0
 125         popfl
 126
 127 /*
 128  * Copy the compressed kernel to the end of our buffer
 129  * where decompression in place becomes safe.
 130  */
 131         pushl   %esi
 132         leal    (_bss-4)(%ebp), %esi
 133         leal    (_bss-4)(%ebx), %edi
 134         movl    $(_bss - startup_32), %ecx
 135         shrl    $2, %ecx
 136         std
 137         rep     movsl
 138         cld
 139         popl    %esi
 140
 141 /*
 142  * Jump to the relocated address.
 143  */
 144         leal    relocated(%ebx), %eax
 145         jmp     *%eax
 146 ENDPROC(startup_32)
 147
 148 #ifdef CONFIG_EFI_STUB
 149 /*
 150  * We don't need the return address, so set up the stack so efi_main() can find
 151  * its arguments.
 152  */
 153 ENTRY(efi_pe_entry)
 154         add     $0x4, %esp
 155
 156         call    1f
 157 1:      popl    %esi
 158         subl    $1b, %esi
 159
 160         popl    %ecx
 161         movl    %ecx, efi32_config(%esi)        /* Handle */
 162         popl    %ecx
 163         movl    %ecx, efi32_config+8(%esi)      /* EFI System table pointer */
 164
 165         /* Relocate efi_config->call() */
 166         leal    efi32_config(%esi), %eax
 167         add     %esi, 40(%eax)
 168         pushl   %eax
 169
 170         call    make_boot_params
 171         cmpl    $0, %eax
 172         je      fail
 173         movl    %esi, BP_code32_start(%eax)
 174         popl    %ecx
 175         pushl   %eax
 176         pushl   %ecx
 177         jmp     2f              /* Skip efi_config initialization */
 178 ENDPROC(efi_pe_entry)
 179
 180 ENTRY(efi32_stub_entry)
 181         add     $0x4, %esp
 182         popl    %ecx
 183         popl    %edx
 184
 185         call    1f
 186 1:      popl    %esi
 187         subl    $1b, %esi
 188
 189         movl    %ecx, efi32_config(%esi)        /* Handle */
 190         movl    %edx, efi32_config+8(%esi)      /* EFI System table pointer */
 191
 192         /* Relocate efi_config->call() */
 193         leal    efi32_config(%esi), %eax
 194         add     %esi, 40(%eax)
 195         pushl   %eax
 196 2:
 197         call    efi_main
 198         cmpl    $0, %eax
 199         movl    %eax, %esi
 200         jne     2f
 201 fail:
 202         /* EFI init failed, so hang. */
 203         hlt
 204         jmp     fail
 205 2:
 206         movl    BP_code32_start(%esi), %eax
 207         leal    startup_32(%eax), %eax
 208         jmp     *%eax
 209 ENDPROC(efi32_stub_entry)
 210 #endif
 211
 212         .text
 213 relocated:
 214
 215 /*
 216  * Clear BSS (stack is currently empty)
 217  */
 218         xorl    %eax, %eax
 219         leal    _bss(%ebx), %edi
 220         leal    _ebss(%ebx), %ecx
 221         subl    %edi, %ecx
 222         shrl    $2, %ecx
 223         rep     stosl
 224
 225 /*
 226  * Adjust our own GOT
 227  */
 228         leal    _got(%ebx), %edx
 229         leal    _egot(%ebx), %ecx
 230 1:
 231         cmpl    %ecx, %edx
 232         jae     2f
 233         addl    %ebx, (%edx)
 234         addl    $4, %edx
 235         jmp     1b
 236 2:
 237
 238 /*
 239  * Do the extraction, and jump to the new kernel..
 240  */
 241                                 /* push arguments for extract_kernel: */
 242         pushl   $z_output_len   /* decompressed length, end of relocs */
 243
 244         movl    BP_init_size(%esi), %eax
 245         subl    $_end, %eax
 246         movl    %ebx, %ebp
 247         subl    %eax, %ebp
 248         pushl   %ebp            /* output address */
 249
 250         pushl   $z_input_len    /* input_len */
 251         leal    input_data(%ebx), %eax
 252         pushl   %eax            /* input_data */
 253         leal    boot_heap(%ebx), %eax
 254         pushl   %eax            /* heap area */
 255         pushl   %esi            /* real mode pointer */
 256         call    extract_kernel  /* returns kernel location in %eax */
 257         addl    $24, %esp
 258
 259 /*
 260  * Jump to the extracted kernel.
 261  */
 262         xorl    %ebx, %ebx
 263         jmp     *%eax
 264
 265 #ifdef CONFIG_EFI_STUB
 266         .data
 267 efi32_config:
 268         .fill 5,8,0
 269         .long efi_call_phys
 270         .long 0
 271         .byte 0
 272 #endif
 273
 274 /*
 275  * Stack and heap for uncompression
 276  */
 277         .bss
 278         .balign 4
 279 boot_heap:
 280         .fill BOOT_HEAP_SIZE, 1, 0
 281 boot_stack:
 282         .fill BOOT_STACK_SIZE, 1, 0
 283 boot_stack_end: