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