arch/x86/boot/compressed/misc.c

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