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

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

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ 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.85 ] ~ [ 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-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 /*
  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] = "";
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] = '' + 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 }
401 

~ [ 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