arch/x86/boot/compressed/misc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * misc.c
   4  *
   5  * This is a collection of several routines used to extract the kernel
   6  * which includes KASLR relocation, decompression, ELF parsing, and
   7  * relocation processing. Additionally included are the screen and serial
   8  * output functions and related debugging support functions.
   9  *
  10  * malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994
  11  * puts by Nick Holloway 1993, better puts by Martin Mares 1995
  12  * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
  13  */
  14
  15 #include "misc.h"
  16 #include "error.h"
  17 #include "../string.h"
  18 #include "../voffset.h"
  19 #include <asm/bootparam_utils.h>
  20
  21 /*
  22  * WARNING!!
  23  * This code is compiled with -fPIC and it is relocated dynamically at
  24  * run time, but no relocation processing is performed. This means that
  25  * it is not safe to place pointers in static structures.
  26  */
  27
  28 /* Macros used by the included decompressor code below. */
  29 #define STATIC          static
  30
  31 /*
  32  * Use normal definitions of mem*() from string.c. There are already
  33  * included header files which expect a definition of memset() and by
  34  * the time we define memset macro, it is too late.
  35  */
  36 #undef memcpy
  37 #undef memset
  38 #define memzero(s, n)   memset((s), 0, (n))
  39 #define memmove         memmove
  40
  41 /* Functions used by the included decompressor code below. */
  42 void *memmove(void *dest, const void *src, size_t n);
  43
  44 /*
  45  * This is set up by the setup-routine at boot-time
  46  */
  47 struct boot_params *boot_params;
  48
  49 memptr free_mem_ptr;
  50 memptr free_mem_end_ptr;
  51
  52 static char *vidmem;
  53 static int vidport;
  54 static int lines, cols;
  55
  56 #ifdef CONFIG_KERNEL_GZIP
  57 #include "../../../../lib/decompress_inflate.c"
  58 #endif
  59
  60 #ifdef CONFIG_KERNEL_BZIP2
  61 #include "../../../../lib/decompress_bunzip2.c"
  62 #endif
  63
  64 #ifdef CONFIG_KERNEL_LZMA
  65 #include "../../../../lib/decompress_unlzma.c"
  66 #endif
  67
  68 #ifdef CONFIG_KERNEL_XZ
  69 #include "../../../../lib/decompress_unxz.c"
  70 #endif
  71
  72 #ifdef CONFIG_KERNEL_LZO
  73 #include "../../../../lib/decompress_unlzo.c"
  74 #endif
  75
  76 #ifdef CONFIG_KERNEL_LZ4
  77 #include "../../../../lib/decompress_unlz4.c"
  78 #endif
  79 /*
  80  * NOTE: When adding a new decompressor, please update the analysis in
  81  * ../header.S.
  82  */
  83
  84 static void scroll(void)
  85 {
  86         int i;
  87
  88         memmove(vidmem, vidmem + cols * 2, (lines - 1) * cols * 2);
  89         for (i = (lines - 1) * cols * 2; i < lines * cols * 2; i += 2)
  90                 vidmem[i] = ' ';
  91 }
  92
  93 #define XMTRDY          0x20
  94
  95 #define TXR             0       /*  Transmit register (WRITE) */
  96 #define LSR             5       /*  Line Status               */
  97 static void serial_putchar(int ch)
  98 {
  99         unsigned timeout = 0xffff;
 100
 101         while ((inb(early_serial_base + LSR) & XMTRDY) == 0 && --timeout)
 102                 cpu_relax();
 103
 104         outb(ch, early_serial_base + TXR);
 105 }
 106
 107 void __putstr(const char *s)
 108 {
 109         int x, y, pos;
 110         char c;
 111
 112         if (early_serial_base) {
 113                 const char *str = s;
 114                 while (*str) {
 115                         if (*str == '\n')
 116                                 serial_putchar('\r');
 117                         serial_putchar(*str++);
 118                 }
 119         }
 120
 121         if (lines == 0 || cols == 0)
 122                 return;
 123
 124         x = boot_params->screen_info.orig_x;
 125         y = boot_params->screen_info.orig_y;
 126
 127         while ((c = *s++) != '\0') {
 128                 if (c == '\n') {
 129                         x = 0;
 130                         if (++y >= lines) {
 131                                 scroll();
 132                                 y--;
 133                         }
 134                 } else {
 135                         vidmem[(x + cols * y) * 2] = c;
 136                         if (++x >= cols) {
 137                                 x = 0;
 138                                 if (++y >= lines) {
 139                                         scroll();
 140                                         y--;
 141                                 }
 142                         }
 143                 }
 144         }
 145
 146         boot_params->screen_info.orig_x = x;
 147         boot_params->screen_info.orig_y = y;
 148
 149         pos = (x + cols * y) * 2;       /* Update cursor position */
 150         outb(14, vidport);
 151         outb(0xff & (pos >> 9), vidport+1);
 152         outb(15, vidport);
 153         outb(0xff & (pos >> 1), vidport+1);
 154 }
 155
 156 void __puthex(unsigned long value)
 157 {
 158         char alpha[2] = "0";
 159         int bits;
 160
 161         for (bits = sizeof(value) * 8 - 4; bits >= 0; bits -= 4) {
 162                 unsigned long digit = (value >> bits) & 0xf;
 163
 164                 if (digit < 0xA)
 165                         alpha[0] = '0' + digit;
 166                 else
 167                         alpha[0] = 'a' + (digit - 0xA);
 168
 169                 __putstr(alpha);
 170         }
 171 }
 172
 173 static bool l5_supported(void)
 174 {
 175         /* Check if leaf 7 is supported. */
 176         if (native_cpuid_eax(0) < 7)
 177                 return 0;
 178
 179         /* Check if la57 is supported. */
 180         return native_cpuid_ecx(7) & (1 << (X86_FEATURE_LA57 & 31));
 181 }
 182
 183 #if CONFIG_X86_NEED_RELOCS
 184 static void handle_relocations(void *output, unsigned long output_len,
 185                                unsigned long virt_addr)
 186 {
 187         int *reloc;
 188         unsigned long delta, map, ptr;
 189         unsigned long min_addr = (unsigned long)output;
 190         unsigned long max_addr = min_addr + (VO___bss_start - VO__text);
 191
 192         /*
 193          * Calculate the delta between where vmlinux was linked to load
 194          * and where it was actually loaded.
 195          */
 196         delta = min_addr - LOAD_PHYSICAL_ADDR;
 197
 198         /*
 199          * The kernel contains a table of relocation addresses. Those
 200          * addresses have the final load address of the kernel in virtual
 201          * memory. We are currently working in the self map. So we need to
 202          * create an adjustment for kernel memory addresses to the self map.
 203          * This will involve subtracting out the base address of the kernel.
 204          */
 205         map = delta - __START_KERNEL_map;
 206
 207         /*
 208          * 32-bit always performs relocations. 64-bit relocations are only
 209          * needed if KASLR has chosen a different starting address offset
 210          * from __START_KERNEL_map.
 211          */
 212         if (IS_ENABLED(CONFIG_X86_64))
 213                 delta = virt_addr - LOAD_PHYSICAL_ADDR;
 214
 215         if (!delta) {
 216                 debug_putstr("No relocation needed... ");
 217                 return;
 218         }
 219         debug_putstr("Performing relocations... ");
 220
 221         /*
 222          * Process relocations: 32 bit relocations first then 64 bit after.
 223          * Three sets of binary relocations are added to the end of the kernel
 224          * before compression. Each relocation table entry is the kernel
 225          * address of the location which needs to be updated stored as a
 226          * 32-bit value which is sign extended to 64 bits.
 227          *
 228          * Format is:
 229          *
 230          * kernel bits...
 231          * 0 - zero terminator for 64 bit relocations
 232          * 64 bit relocation repeated
 233          * 0 - zero terminator for inverse 32 bit relocations
 234          * 32 bit inverse relocation repeated
 235          * 0 - zero terminator for 32 bit relocations
 236          * 32 bit relocation repeated
 237          *
 238          * So we work backwards from the end of the decompressed image.
 239          */
 240         for (reloc = output + output_len - sizeof(*reloc); *reloc; reloc--) {
 241                 long extended = *reloc;
 242                 extended += map;
 243
 244                 ptr = (unsigned long)extended;
 245                 if (ptr < min_addr || ptr > max_addr)
 246                         error("32-bit relocation outside of kernel!\n");
 247
 248                 *(uint32_t *)ptr += delta;
 249         }
 250 #ifdef CONFIG_X86_64
 251         while (*--reloc) {
 252                 long extended = *reloc;
 253                 extended += map;
 254
 255                 ptr = (unsigned long)extended;
 256                 if (ptr < min_addr || ptr > max_addr)
 257                         error("inverse 32-bit relocation outside of kernel!\n");
 258
 259                 *(int32_t *)ptr -= delta;
 260         }
 261         for (reloc--; *reloc; reloc--) {
 262                 long extended = *reloc;
 263                 extended += map;
 264
 265                 ptr = (unsigned long)extended;
 266                 if (ptr < min_addr || ptr > max_addr)
 267                         error("64-bit relocation outside of kernel!\n");
 268
 269                 *(uint64_t *)ptr += delta;
 270         }
 271 #endif
 272 }
 273 #else
 274 static inline void handle_relocations(void *output, unsigned long output_len,
 275                                       unsigned long virt_addr)
 276 { }
 277 #endif
 278
 279 static void parse_elf(void *output)
 280 {
 281 #ifdef CONFIG_X86_64
 282         Elf64_Ehdr ehdr;
 283         Elf64_Phdr *phdrs, *phdr;
 284 #else
 285         Elf32_Ehdr ehdr;
 286         Elf32_Phdr *phdrs, *phdr;
 287 #endif
 288         void *dest;
 289         int i;
 290
 291         memcpy(&ehdr, output, sizeof(ehdr));
 292         if (ehdr.e_ident[EI_MAG0] != ELFMAG0 ||
 293            ehdr.e_ident[EI_MAG1] != ELFMAG1 ||
 294            ehdr.e_ident[EI_MAG2] != ELFMAG2 ||
 295            ehdr.e_ident[EI_MAG3] != ELFMAG3) {
 296                 error("Kernel is not a valid ELF file");
 297                 return;
 298         }
 299
 300         debug_putstr("Parsing ELF... ");
 301
 302         phdrs = malloc(sizeof(*phdrs) * ehdr.e_phnum);
 303         if (!phdrs)
 304                 error("Failed to allocate space for phdrs");
 305
 306         memcpy(phdrs, output + ehdr.e_phoff, sizeof(*phdrs) * ehdr.e_phnum);
 307
 308         for (i = 0; i < ehdr.e_phnum; i++) {
 309                 phdr = &phdrs[i];
 310
 311                 switch (phdr->p_type) {
 312                 case PT_LOAD:
 313 #ifdef CONFIG_X86_64
 314                         if ((phdr->p_align % 0x200000) != 0)
 315                                 error("Alignment of LOAD segment isn't multiple of 2MB");
 316 #endif
 317 #ifdef CONFIG_RELOCATABLE
 318                         dest = output;
 319                         dest += (phdr->p_paddr - LOAD_PHYSICAL_ADDR);
 320 #else
 321                         dest = (void *)(phdr->p_paddr);
 322 #endif
 323                         memmove(dest, output + phdr->p_offset, phdr->p_filesz);
 324                         break;
 325                 default: /* Ignore other PT_* */ break;
 326                 }
 327         }
 328
 329         free(phdrs);
 330 }
 331
 332 /*
 333  * The compressed kernel image (ZO), has been moved so that its position
 334  * is against the end of the buffer used to hold the uncompressed kernel
 335  * image (VO) and the execution environment (.bss, .brk), which makes sure
 336  * there is room to do the in-place decompression. (See header.S for the
 337  * calculations.)
 338  *
 339  *                             |-----compressed kernel image------|
 340  *                             V                                  V
 341  * 0                       extract_offset                      +INIT_SIZE
 342  * |-----------|---------------|-------------------------|--------|
 343  *             |               |                         |        |
 344  *           VO__text      startup_32 of ZO          VO__end    ZO__end
 345  *             ^                                         ^
 346  *             |-------uncompressed kernel image---------|
 347  *
 348  */
 349 asmlinkage __visible void *extract_kernel(void *rmode, memptr heap,
 350                                   unsigned char *input_data,
 351                                   unsigned long input_len,
 352                                   unsigned char *output,
 353                                   unsigned long output_len)
 354 {
 355         const unsigned long kernel_total_size = VO__end - VO__text;
 356         unsigned long virt_addr = LOAD_PHYSICAL_ADDR;
 357
 358         /* Retain x86 boot parameters pointer passed from startup_32/64. */
 359         boot_params = rmode;
 360
 361         /* Clear flags intended for solely in-kernel use. */
 362         boot_params->hdr.loadflags &= ~KASLR_FLAG;
 363
 364         sanitize_boot_params(boot_params);
 365
 366         if (boot_params->screen_info.orig_video_mode == 7) {
 367                 vidmem = (char *) 0xb0000;
 368                 vidport = 0x3b4;
 369         } else {
 370                 vidmem = (char *) 0xb8000;
 371                 vidport = 0x3d4;
 372         }
 373
 374         lines = boot_params->screen_info.orig_video_lines;
 375         cols = boot_params->screen_info.orig_video_cols;
 376
 377         console_init();
 378         debug_putstr("early console in extract_kernel\n");
 379
 380         if (IS_ENABLED(CONFIG_X86_5LEVEL) && !l5_supported()) {
 381                 error("This linux kernel as configured requires 5-level paging\n"
 382                         "This CPU does not support the required 'cr4.la57' feature\n"
 383                         "Unable to boot - please use a kernel appropriate for your CPU\n");
 384         }
 385
 386         free_mem_ptr     = heap;        /* Heap */
 387         free_mem_end_ptr = heap + BOOT_HEAP_SIZE;
 388
 389         /* Report initial kernel position details. */
 390         debug_putaddr(input_data);
 391         debug_putaddr(input_len);
 392         debug_putaddr(output);
 393         debug_putaddr(output_len);
 394         debug_putaddr(kernel_total_size);
 395
 396         /*
 397          * The memory hole needed for the kernel is the larger of either
 398          * the entire decompressed kernel plus relocation table, or the
 399          * entire decompressed kernel plus .bss and .brk sections.
 400          */
 401         choose_random_location((unsigned long)input_data, input_len,
 402                                 (unsigned long *)&output,
 403                                 max(output_len, kernel_total_size),
 404                                 &virt_addr);
 405
 406         /* Validate memory location choices. */
 407         if ((unsigned long)output & (MIN_KERNEL_ALIGN - 1))
 408                 error("Destination physical address inappropriately aligned");
 409         if (virt_addr & (MIN_KERNEL_ALIGN - 1))
 410                 error("Destination virtual address inappropriately aligned");
 411 #ifdef CONFIG_X86_64
 412         if (heap > 0x3fffffffffffUL)
 413                 error("Destination address too large");
 414         if (virt_addr + max(output_len, kernel_total_size) > KERNEL_IMAGE_SIZE)
 415                 error("Destination virtual address is beyond the kernel mapping area");
 416 #else
 417         if (heap > ((-__PAGE_OFFSET-(128<<20)-1) & 0x7fffffff))
 418                 error("Destination address too large");
 419 #endif
 420 #ifndef CONFIG_RELOCATABLE
 421         if ((unsigned long)output != LOAD_PHYSICAL_ADDR)
 422                 error("Destination address does not match LOAD_PHYSICAL_ADDR");
 423         if (virt_addr != LOAD_PHYSICAL_ADDR)
 424                 error("Destination virtual address changed when not relocatable");
 425 #endif
 426
 427         debug_putstr("\nDecompressing Linux... ");
 428         __decompress(input_data, input_len, NULL, NULL, output, output_len,
 429                         NULL, error);
 430         parse_elf(output);
 431         handle_relocations(output, output_len, virt_addr);
 432         debug_putstr("done.\nBooting the kernel.\n");
 433         return output;
 434 }
 435
 436 void fortify_panic(const char *name)
 437 {
 438         error("detected buffer overflow");
 439 }