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