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 "pgtable.h"
  18 #include "../string.h"
  19 #include "../voffset.h"
  20 #include <asm/bootparam_utils.h>
  21
  22 /*
  23  * WARNING!!
  24  * This code is compiled with -fPIC and it is relocated dynamically at
  25  * run time, but no relocation processing is performed. This means that
  26  * it is not safe to place pointers in static structures.
  27  */
  28
  29 /* Macros used by the included decompressor code below. */
  30 #define STATIC          static
  31 /* Define an externally visible malloc()/free(). */
  32 #define MALLOC_VISIBLE
  33 #include <linux/decompress/mm.h>
  34
  35 /*
  36  * Provide definitions of memzero and memmove as some of the decompressors will
  37  * try to define their own functions if these are not defined as macros.
  38  */
  39 #define memzero(s, n)   memset((s), 0, (n))
  40 #ifndef memmove
  41 #define memmove         memmove
  42 /* Functions used by the included decompressor code below. */
  43 void *memmove(void *dest, const void *src, size_t n);
  44 #endif
  45
  46 /*
  47  * This is set up by the setup-routine at boot-time
  48  */
  49 struct boot_params *boot_params_ptr;
  50
  51 struct port_io_ops pio_ops;
  52
  53 memptr free_mem_ptr;
  54 memptr free_mem_end_ptr;
  55 int spurious_nmi_count;
  56
  57 static char *vidmem;
  58 static int vidport;
  59
  60 /* These might be accessed before .bss is cleared, so use .data instead. */
  61 static int lines __section(".data");
  62 static int cols __section(".data");
  63
  64 #ifdef CONFIG_KERNEL_GZIP
  65 #include "../../../../lib/decompress_inflate.c"
  66 #endif
  67
  68 #ifdef CONFIG_KERNEL_BZIP2
  69 #include "../../../../lib/decompress_bunzip2.c"
  70 #endif
  71
  72 #ifdef CONFIG_KERNEL_LZMA
  73 #include "../../../../lib/decompress_unlzma.c"
  74 #endif
  75
  76 #ifdef CONFIG_KERNEL_XZ
  77 #include "../../../../lib/decompress_unxz.c"
  78 #endif
  79
  80 #ifdef CONFIG_KERNEL_LZO
  81 #include "../../../../lib/decompress_unlzo.c"
  82 #endif
  83
  84 #ifdef CONFIG_KERNEL_LZ4
  85 #include "../../../../lib/decompress_unlz4.c"
  86 #endif
  87
  88 #ifdef CONFIG_KERNEL_ZSTD
  89 #include "../../../../lib/decompress_unzstd.c"
  90 #endif
  91 /*
  92  * NOTE: When adding a new decompressor, please update the analysis in
  93  * ../header.S.
  94  */
  95
  96 static void scroll(void)
  97 {
  98         int i;
  99
 100         memmove(vidmem, vidmem + cols * 2, (lines - 1) * cols * 2);
 101         for (i = (lines - 1) * cols * 2; i < lines * cols * 2; i += 2)
 102                 vidmem[i] = ' ';
 103 }
 104
 105 #define XMTRDY          0x20
 106
 107 #define TXR             0       /*  Transmit register (WRITE) */
 108 #define LSR             5       /*  Line Status               */
 109 static void serial_putchar(int ch)
 110 {
 111         unsigned timeout = 0xffff;
 112
 113         while ((inb(early_serial_base + LSR) & XMTRDY) == 0 && --timeout)
 114                 cpu_relax();
 115
 116         outb(ch, early_serial_base + TXR);
 117 }
 118
 119 void __putstr(const char *s)
 120 {
 121         int x, y, pos;
 122         char c;
 123
 124         if (early_serial_base) {
 125                 const char *str = s;
 126                 while (*str) {
 127                         if (*str == '\n')
 128                                 serial_putchar('\r');
 129                         serial_putchar(*str++);
 130                 }
 131         }
 132
 133         if (lines == 0 || cols == 0)
 134                 return;
 135
 136         x = boot_params_ptr->screen_info.orig_x;
 137         y = boot_params_ptr->screen_info.orig_y;
 138
 139         while ((c = *s++) != '\0') {
 140                 if (c == '\n') {
 141                         x = 0;
 142                         if (++y >= lines) {
 143                                 scroll();
 144                                 y--;
 145                         }
 146                 } else {
 147                         vidmem[(x + cols * y) * 2] = c;
 148                         if (++x >= cols) {
 149                                 x = 0;
 150                                 if (++y >= lines) {
 151                                         scroll();
 152                                         y--;
 153                                 }
 154                         }
 155                 }
 156         }
 157
 158         boot_params_ptr->screen_info.orig_x = x;
 159         boot_params_ptr->screen_info.orig_y = y;
 160
 161         pos = (x + cols * y) * 2;       /* Update cursor position */
 162         outb(14, vidport);
 163         outb(0xff & (pos >> 9), vidport+1);
 164         outb(15, vidport);
 165         outb(0xff & (pos >> 1), vidport+1);
 166 }
 167
 168 static noinline void __putnum(unsigned long value, unsigned int base,
 169                               int mindig)
 170 {
 171         char buf[8*sizeof(value)+1];
 172         char *p;
 173
 174         p = buf + sizeof(buf);
 175         *--p = '\0';
 176
 177         while (mindig-- > 0 || value) {
 178                 unsigned char digit = value % base;
 179                 digit += (digit >= 10) ? ('a'-10) : '0';
 180                 *--p = digit;
 181
 182                 value /= base;
 183         }
 184
 185         __putstr(p);
 186 }
 187
 188 void __puthex(unsigned long value)
 189 {
 190         __putnum(value, 16, sizeof(value)*2);
 191 }
 192
 193 void __putdec(unsigned long value)
 194 {
 195         __putnum(value, 10, 1);
 196 }
 197
 198 #ifdef CONFIG_X86_NEED_RELOCS
 199 static void handle_relocations(void *output, unsigned long output_len,
 200                                unsigned long virt_addr)
 201 {
 202         int *reloc;
 203         unsigned long delta, map, ptr;
 204         unsigned long min_addr = (unsigned long)output;
 205         unsigned long max_addr = min_addr + (VO___bss_start - VO__text);
 206
 207         /*
 208          * Calculate the delta between where vmlinux was linked to load
 209          * and where it was actually loaded.
 210          */
 211         delta = min_addr - LOAD_PHYSICAL_ADDR;
 212
 213         /*
 214          * The kernel contains a table of relocation addresses. Those
 215          * addresses have the final load address of the kernel in virtual
 216          * memory. We are currently working in the self map. So we need to
 217          * create an adjustment for kernel memory addresses to the self map.
 218          * This will involve subtracting out the base address of the kernel.
 219          */
 220         map = delta - __START_KERNEL_map;
 221
 222         /*
 223          * 32-bit always performs relocations. 64-bit relocations are only
 224          * needed if KASLR has chosen a different starting address offset
 225          * from __START_KERNEL_map.
 226          */
 227         if (IS_ENABLED(CONFIG_X86_64))
 228                 delta = virt_addr - LOAD_PHYSICAL_ADDR;
 229
 230         if (!delta) {
 231                 debug_putstr("No relocation needed... ");
 232                 return;
 233         }
 234         debug_putstr("Performing relocations... ");
 235
 236         /*
 237          * Process relocations: 32 bit relocations first then 64 bit after.
 238          * Three sets of binary relocations are added to the end of the kernel
 239          * before compression. Each relocation table entry is the kernel
 240          * address of the location which needs to be updated stored as a
 241          * 32-bit value which is sign extended to 64 bits.
 242          *
 243          * Format is:
 244          *
 245          * kernel bits...
 246          * 0 - zero terminator for 64 bit relocations
 247          * 64 bit relocation repeated
 248          * 0 - zero terminator for inverse 32 bit relocations
 249          * 32 bit inverse relocation repeated
 250          * 0 - zero terminator for 32 bit relocations
 251          * 32 bit relocation repeated
 252          *
 253          * So we work backwards from the end of the decompressed image.
 254          */
 255         for (reloc = output + output_len - sizeof(*reloc); *reloc; reloc--) {
 256                 long extended = *reloc;
 257                 extended += map;
 258
 259                 ptr = (unsigned long)extended;
 260                 if (ptr < min_addr || ptr > max_addr)
 261                         error("32-bit relocation outside of kernel!\n");
 262
 263                 *(uint32_t *)ptr += delta;
 264         }
 265 #ifdef CONFIG_X86_64
 266         while (*--reloc) {
 267                 long extended = *reloc;
 268                 extended += map;
 269
 270                 ptr = (unsigned long)extended;
 271                 if (ptr < min_addr || ptr > max_addr)
 272                         error("inverse 32-bit relocation outside of kernel!\n");
 273
 274                 *(int32_t *)ptr -= delta;
 275         }
 276         for (reloc--; *reloc; reloc--) {
 277                 long extended = *reloc;
 278                 extended += map;
 279
 280                 ptr = (unsigned long)extended;
 281                 if (ptr < min_addr || ptr > max_addr)
 282                         error("64-bit relocation outside of kernel!\n");
 283
 284                 *(uint64_t *)ptr += delta;
 285         }
 286 #endif
 287 }
 288 #else
 289 static inline void handle_relocations(void *output, unsigned long output_len,
 290                                       unsigned long virt_addr)
 291 { }
 292 #endif
 293
 294 static size_t parse_elf(void *output)
 295 {
 296 #ifdef CONFIG_X86_64
 297         Elf64_Ehdr ehdr;
 298         Elf64_Phdr *phdrs, *phdr;
 299 #else
 300         Elf32_Ehdr ehdr;
 301         Elf32_Phdr *phdrs, *phdr;
 302 #endif
 303         void *dest;
 304         int i;
 305
 306         memcpy(&ehdr, output, sizeof(ehdr));
 307         if (ehdr.e_ident[EI_MAG0] != ELFMAG0 ||
 308            ehdr.e_ident[EI_MAG1] != ELFMAG1 ||
 309            ehdr.e_ident[EI_MAG2] != ELFMAG2 ||
 310            ehdr.e_ident[EI_MAG3] != ELFMAG3)
 311                 error("Kernel is not a valid ELF file");
 312
 313         debug_putstr("Parsing ELF... ");
 314
 315         phdrs = malloc(sizeof(*phdrs) * ehdr.e_phnum);
 316         if (!phdrs)
 317                 error("Failed to allocate space for phdrs");
 318
 319         memcpy(phdrs, output + ehdr.e_phoff, sizeof(*phdrs) * ehdr.e_phnum);
 320
 321         for (i = 0; i < ehdr.e_phnum; i++) {
 322                 phdr = &phdrs[i];
 323
 324                 switch (phdr->p_type) {
 325                 case PT_LOAD:
 326 #ifdef CONFIG_X86_64
 327                         if ((phdr->p_align % 0x200000) != 0)
 328                                 error("Alignment of LOAD segment isn't multiple of 2MB");
 329 #endif
 330 #ifdef CONFIG_RELOCATABLE
 331                         dest = output;
 332                         dest += (phdr->p_paddr - LOAD_PHYSICAL_ADDR);
 333 #else
 334                         dest = (void *)(phdr->p_paddr);
 335 #endif
 336                         memmove(dest, output + phdr->p_offset, phdr->p_filesz);
 337                         break;
 338                 default: /* Ignore other PT_* */ break;
 339                 }
 340         }
 341
 342         free(phdrs);
 343
 344         return ehdr.e_entry - LOAD_PHYSICAL_ADDR;
 345 }
 346
 347 const unsigned long kernel_text_size = VO___start_rodata - VO__text;
 348 const unsigned long kernel_total_size = VO__end - VO__text;
 349
 350 static u8 boot_heap[BOOT_HEAP_SIZE] __aligned(4);
 351
 352 extern unsigned char input_data[];
 353 extern unsigned int input_len, output_len;
 354
 355 unsigned long decompress_kernel(unsigned char *outbuf, unsigned long virt_addr,
 356                                 void (*error)(char *x))
 357 {
 358         unsigned long entry;
 359
 360         if (!free_mem_ptr) {
 361                 free_mem_ptr     = (unsigned long)boot_heap;
 362                 free_mem_end_ptr = (unsigned long)boot_heap + sizeof(boot_heap);
 363         }
 364
 365         if (__decompress(input_data, input_len, NULL, NULL, outbuf, output_len,
 366                          NULL, error) < 0)
 367                 return ULONG_MAX;
 368
 369         entry = parse_elf(outbuf);
 370         handle_relocations(outbuf, output_len, virt_addr);
 371
 372         return entry;
 373 }
 374
 375 /*
 376  * Set the memory encryption xloadflag based on the mem_encrypt= command line
 377  * parameter, if provided.
 378  */
 379 static void parse_mem_encrypt(struct setup_header *hdr)
 380 {
 381         int on = cmdline_find_option_bool("mem_encrypt=on");
 382         int off = cmdline_find_option_bool("mem_encrypt=off");
 383
 384         if (on > off)
 385                 hdr->xloadflags |= XLF_MEM_ENCRYPTION;
 386 }
 387
 388 static void early_sev_detect(void)
 389 {
 390         /*
 391          * Accessing video memory causes guest termination because
 392          * the boot stage2 #VC handler of SEV-ES/SNP guests does not
 393          * support MMIO handling and kexec -c adds screen_info to the
 394          * boot parameters passed to the kexec kernel, which causes
 395          * console output to be dumped to both video and serial.
 396          */
 397         if (sev_status & MSR_AMD64_SEV_ES_ENABLED)
 398                 lines = cols = 0;
 399 }
 400
 401 /*
 402  * The compressed kernel image (ZO), has been moved so that its position
 403  * is against the end of the buffer used to hold the uncompressed kernel
 404  * image (VO) and the execution environment (.bss, .brk), which makes sure
 405  * there is room to do the in-place decompression. (See header.S for the
 406  * calculations.)
 407  *
 408  *                             |-----compressed kernel image------|
 409  *                             V                                  V
 410  * 0                       extract_offset                      +INIT_SIZE
 411  * |-----------|---------------|-------------------------|--------|
 412  *             |               |                         |        |
 413  *           VO__text      startup_32 of ZO          VO__end    ZO__end
 414  *             ^                                         ^
 415  *             |-------uncompressed kernel image---------|
 416  *
 417  */
 418 asmlinkage __visible void *extract_kernel(void *rmode, unsigned char *output)
 419 {
 420         unsigned long virt_addr = LOAD_PHYSICAL_ADDR;
 421         memptr heap = (memptr)boot_heap;
 422         unsigned long needed_size;
 423         size_t entry_offset;
 424
 425         /* Retain x86 boot parameters pointer passed from startup_32/64. */
 426         boot_params_ptr = rmode;
 427
 428         /* Clear flags intended for solely in-kernel use. */
 429         boot_params_ptr->hdr.loadflags &= ~KASLR_FLAG;
 430
 431         parse_mem_encrypt(&boot_params_ptr->hdr);
 432
 433         sanitize_boot_params(boot_params_ptr);
 434
 435         if (boot_params_ptr->screen_info.orig_video_mode == 7) {
 436                 vidmem = (char *) 0xb0000;
 437                 vidport = 0x3b4;
 438         } else {
 439                 vidmem = (char *) 0xb8000;
 440                 vidport = 0x3d4;
 441         }
 442
 443         lines = boot_params_ptr->screen_info.orig_video_lines;
 444         cols = boot_params_ptr->screen_info.orig_video_cols;
 445
 446         init_default_io_ops();
 447
 448         /*
 449          * Detect TDX guest environment.
 450          *
 451          * It has to be done before console_init() in order to use
 452          * paravirtualized port I/O operations if needed.
 453          */
 454         early_tdx_detect();
 455
 456         early_sev_detect();
 457
 458         console_init();
 459
 460         /*
 461          * Save RSDP address for later use. Have this after console_init()
 462          * so that early debugging output from the RSDP parsing code can be
 463          * collected.
 464          */
 465         boot_params_ptr->acpi_rsdp_addr = get_rsdp_addr();
 466
 467         debug_putstr("early console in extract_kernel\n");
 468
 469         free_mem_ptr     = heap;        /* Heap */
 470         free_mem_end_ptr = heap + BOOT_HEAP_SIZE;
 471
 472         /*
 473          * The memory hole needed for the kernel is the larger of either
 474          * the entire decompressed kernel plus relocation table, or the
 475          * entire decompressed kernel plus .bss and .brk sections.
 476          *
 477          * On X86_64, the memory is mapped with PMD pages. Round the
 478          * size up so that the full extent of PMD pages mapped is
 479          * included in the check against the valid memory table
 480          * entries. This ensures the full mapped area is usable RAM
 481          * and doesn't include any reserved areas.
 482          */
 483         needed_size = max_t(unsigned long, output_len, kernel_total_size);
 484 #ifdef CONFIG_X86_64
 485         needed_size = ALIGN(needed_size, MIN_KERNEL_ALIGN);
 486 #endif
 487
 488         /* Report initial kernel position details. */
 489         debug_putaddr(input_data);
 490         debug_putaddr(input_len);
 491         debug_putaddr(output);
 492         debug_putaddr(output_len);
 493         debug_putaddr(kernel_total_size);
 494         debug_putaddr(needed_size);
 495
 496 #ifdef CONFIG_X86_64
 497         /* Report address of 32-bit trampoline */
 498         debug_putaddr(trampoline_32bit);
 499 #endif
 500
 501         choose_random_location((unsigned long)input_data, input_len,
 502                                 (unsigned long *)&output,
 503                                 needed_size,
 504                                 &virt_addr);
 505
 506         /* Validate memory location choices. */
 507         if ((unsigned long)output & (MIN_KERNEL_ALIGN - 1))
 508                 error("Destination physical address inappropriately aligned");
 509         if (virt_addr & (MIN_KERNEL_ALIGN - 1))
 510                 error("Destination virtual address inappropriately aligned");
 511 #ifdef CONFIG_X86_64
 512         if (heap > 0x3fffffffffffUL)
 513                 error("Destination address too large");
 514         if (virt_addr + needed_size > KERNEL_IMAGE_SIZE)
 515                 error("Destination virtual address is beyond the kernel mapping area");
 516 #else
 517         if (heap > ((-__PAGE_OFFSET-(128<<20)-1) & 0x7fffffff))
 518                 error("Destination address too large");
 519 #endif
 520 #ifndef CONFIG_RELOCATABLE
 521         if (virt_addr != LOAD_PHYSICAL_ADDR)
 522                 error("Destination virtual address changed when not relocatable");
 523 #endif
 524
 525         debug_putstr("\nDecompressing Linux... ");
 526
 527         if (init_unaccepted_memory()) {
 528                 debug_putstr("Accepting memory... ");
 529                 accept_memory(__pa(output), needed_size);
 530         }
 531
 532         entry_offset = decompress_kernel(output, virt_addr, error);
 533
 534         debug_putstr("done.\nBooting the kernel (entry_offset: 0x");
 535         debug_puthex(entry_offset);
 536         debug_putstr(").\n");
 537
 538         /* Disable exception handling before booting the kernel */
 539         cleanup_exception_handling();
 540
 541         if (spurious_nmi_count) {
 542                 error_putstr("Spurious early NMIs ignored: ");
 543                 error_putdec(spurious_nmi_count);
 544                 error_putstr("\n");
 545         }
 546
 547         return output + entry_offset;
 548 }