~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/boot/compressed/misc.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 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] = "";
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] = '' + digit;
166                 else
167                         alpha[0] = 'a' + (digit - 0xA);
168 
169                 __putstr(alpha);
170         }
171 }
172 
173 #if CONFIG_X86_NEED_RELOCS
174 static void handle_relocations(void *output, unsigned long output_len,
175                                unsigned long virt_addr)
176 {
177         int *reloc;
178         unsigned long delta, map, ptr;
179         unsigned long min_addr = (unsigned long)output;
180         unsigned long max_addr = min_addr + (VO___bss_start - VO__text);
181 
182         /*
183          * Calculate the delta between where vmlinux was linked to load
184          * and where it was actually loaded.
185          */
186         delta = min_addr - LOAD_PHYSICAL_ADDR;
187 
188         /*
189          * The kernel contains a table of relocation addresses. Those
190          * addresses have the final load address of the kernel in virtual
191          * memory. We are currently working in the self map. So we need to
192          * create an adjustment for kernel memory addresses to the self map.
193          * This will involve subtracting out the base address of the kernel.
194          */
195         map = delta - __START_KERNEL_map;
196 
197         /*
198          * 32-bit always performs relocations. 64-bit relocations are only
199          * needed if KASLR has chosen a different starting address offset
200          * from __START_KERNEL_map.
201          */
202         if (IS_ENABLED(CONFIG_X86_64))
203                 delta = virt_addr - LOAD_PHYSICAL_ADDR;
204 
205         if (!delta) {
206                 debug_putstr("No relocation needed... ");
207                 return;
208         }
209         debug_putstr("Performing relocations... ");
210 
211         /*
212          * Process relocations: 32 bit relocations first then 64 bit after.
213          * Three sets of binary relocations are added to the end of the kernel
214          * before compression. Each relocation table entry is the kernel
215          * address of the location which needs to be updated stored as a
216          * 32-bit value which is sign extended to 64 bits.
217          *
218          * Format is:
219          *
220          * kernel bits...
221          * 0 - zero terminator for 64 bit relocations
222          * 64 bit relocation repeated
223          * 0 - zero terminator for inverse 32 bit relocations
224          * 32 bit inverse relocation repeated
225          * 0 - zero terminator for 32 bit relocations
226          * 32 bit relocation repeated
227          *
228          * So we work backwards from the end of the decompressed image.
229          */
230         for (reloc = output + output_len - sizeof(*reloc); *reloc; reloc--) {
231                 long extended = *reloc;
232                 extended += map;
233 
234                 ptr = (unsigned long)extended;
235                 if (ptr < min_addr || ptr > max_addr)
236                         error("32-bit relocation outside of kernel!\n");
237 
238                 *(uint32_t *)ptr += delta;
239         }
240 #ifdef CONFIG_X86_64
241         while (*--reloc) {
242                 long extended = *reloc;
243                 extended += map;
244 
245                 ptr = (unsigned long)extended;
246                 if (ptr < min_addr || ptr > max_addr)
247                         error("inverse 32-bit relocation outside of kernel!\n");
248 
249                 *(int32_t *)ptr -= delta;
250         }
251         for (reloc--; *reloc; reloc--) {
252                 long extended = *reloc;
253                 extended += map;
254 
255                 ptr = (unsigned long)extended;
256                 if (ptr < min_addr || ptr > max_addr)
257                         error("64-bit relocation outside of kernel!\n");
258 
259                 *(uint64_t *)ptr += delta;
260         }
261 #endif
262 }
263 #else
264 static inline void handle_relocations(void *output, unsigned long output_len,
265                                       unsigned long virt_addr)
266 { }
267 #endif
268 
269 static void parse_elf(void *output)
270 {
271 #ifdef CONFIG_X86_64
272         Elf64_Ehdr ehdr;
273         Elf64_Phdr *phdrs, *phdr;
274 #else
275         Elf32_Ehdr ehdr;
276         Elf32_Phdr *phdrs, *phdr;
277 #endif
278         void *dest;
279         int i;
280 
281         memcpy(&ehdr, output, sizeof(ehdr));
282         if (ehdr.e_ident[EI_MAG0] != ELFMAG0 ||
283            ehdr.e_ident[EI_MAG1] != ELFMAG1 ||
284            ehdr.e_ident[EI_MAG2] != ELFMAG2 ||
285            ehdr.e_ident[EI_MAG3] != ELFMAG3) {
286                 error("Kernel is not a valid ELF file");
287                 return;
288         }
289 
290         debug_putstr("Parsing ELF... ");
291 
292         phdrs = malloc(sizeof(*phdrs) * ehdr.e_phnum);
293         if (!phdrs)
294                 error("Failed to allocate space for phdrs");
295 
296         memcpy(phdrs, output + ehdr.e_phoff, sizeof(*phdrs) * ehdr.e_phnum);
297 
298         for (i = 0; i < ehdr.e_phnum; i++) {
299                 phdr = &phdrs[i];
300 
301                 switch (phdr->p_type) {
302                 case PT_LOAD:
303 #ifdef CONFIG_X86_64
304                         if ((phdr->p_align % 0x200000) != 0)
305                                 error("Alignment of LOAD segment isn't multiple of 2MB");
306 #endif
307 #ifdef CONFIG_RELOCATABLE
308                         dest = output;
309                         dest += (phdr->p_paddr - LOAD_PHYSICAL_ADDR);
310 #else
311                         dest = (void *)(phdr->p_paddr);
312 #endif
313                         memmove(dest, output + phdr->p_offset, phdr->p_filesz);
314                         break;
315                 default: /* Ignore other PT_* */ break;
316                 }
317         }
318 
319         free(phdrs);
320 }
321 
322 /*
323  * The compressed kernel image (ZO), has been moved so that its position
324  * is against the end of the buffer used to hold the uncompressed kernel
325  * image (VO) and the execution environment (.bss, .brk), which makes sure
326  * there is room to do the in-place decompression. (See header.S for the
327  * calculations.)
328  *
329  *                             |-----compressed kernel image------|
330  *                             V                                  V
331  * 0                       extract_offset                      +INIT_SIZE
332  * |-----------|---------------|-------------------------|--------|
333  *             |               |                         |        |
334  *           VO__text      startup_32 of ZO          VO__end    ZO__end
335  *             ^                                         ^
336  *             |-------uncompressed kernel image---------|
337  *
338  */
339 asmlinkage __visible void *extract_kernel(void *rmode, memptr heap,
340                                   unsigned char *input_data,
341                                   unsigned long input_len,
342                                   unsigned char *output,
343                                   unsigned long output_len)
344 {
345         const unsigned long kernel_total_size = VO__end - VO__text;
346         unsigned long virt_addr = LOAD_PHYSICAL_ADDR;
347 
348         /* Retain x86 boot parameters pointer passed from startup_32/64. */
349         boot_params = rmode;
350 
351         /* Clear flags intended for solely in-kernel use. */
352         boot_params->hdr.loadflags &= ~KASLR_FLAG;
353 
354         sanitize_boot_params(boot_params);
355 
356         if (boot_params->screen_info.orig_video_mode == 7) {
357                 vidmem = (char *) 0xb0000;
358                 vidport = 0x3b4;
359         } else {
360                 vidmem = (char *) 0xb8000;
361                 vidport = 0x3d4;
362         }
363 
364         lines = boot_params->screen_info.orig_video_lines;
365         cols = boot_params->screen_info.orig_video_cols;
366 
367         console_init();
368         debug_putstr("early console in extract_kernel\n");
369 
370         free_mem_ptr     = heap;        /* Heap */
371         free_mem_end_ptr = heap + BOOT_HEAP_SIZE;
372 
373         /* Report initial kernel position details. */
374         debug_putaddr(input_data);
375         debug_putaddr(input_len);
376         debug_putaddr(output);
377         debug_putaddr(output_len);
378         debug_putaddr(kernel_total_size);
379 
380 #ifdef CONFIG_X86_64
381         /* Report address of 32-bit trampoline */
382         debug_putaddr(trampoline_32bit);
383 #endif
384 
385         /*
386          * The memory hole needed for the kernel is the larger of either
387          * the entire decompressed kernel plus relocation table, or the
388          * entire decompressed kernel plus .bss and .brk sections.
389          */
390         choose_random_location((unsigned long)input_data, input_len,
391                                 (unsigned long *)&output,
392                                 max(output_len, kernel_total_size),
393                                 &virt_addr);
394 
395         /* Validate memory location choices. */
396         if ((unsigned long)output & (MIN_KERNEL_ALIGN - 1))
397                 error("Destination physical address inappropriately aligned");
398         if (virt_addr & (MIN_KERNEL_ALIGN - 1))
399                 error("Destination virtual address inappropriately aligned");
400 #ifdef CONFIG_X86_64
401         if (heap > 0x3fffffffffffUL)
402                 error("Destination address too large");
403         if (virt_addr + max(output_len, kernel_total_size) > KERNEL_IMAGE_SIZE)
404                 error("Destination virtual address is beyond the kernel mapping area");
405 #else
406         if (heap > ((-__PAGE_OFFSET-(128<<20)-1) & 0x7fffffff))
407                 error("Destination address too large");
408 #endif
409 #ifndef CONFIG_RELOCATABLE
410         if ((unsigned long)output != LOAD_PHYSICAL_ADDR)
411                 error("Destination address does not match LOAD_PHYSICAL_ADDR");
412         if (virt_addr != LOAD_PHYSICAL_ADDR)
413                 error("Destination virtual address changed when not relocatable");
414 #endif
415 
416         debug_putstr("\nDecompressing Linux... ");
417         __decompress(input_data, input_len, NULL, NULL, output, output_len,
418                         NULL, error);
419         parse_elf(output);
420         handle_relocations(output, output_len, virt_addr);
421         debug_putstr("done.\nBooting the kernel.\n");
422         return output;
423 }
424 
425 void fortify_panic(const char *name)
426 {
427         error("detected buffer overflow");
428 }
429 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp