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.
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
16 #include "../string.h"
17 #include "../voffset.h"
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.
26 /* Macros used by the included decompressor code below. */
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.
36 #define memzero(s, n) memset((s), 0, (n))
37 #define memmove memmove
39 /* Functions used by the included decompressor code below. */
40 void *memmove(void *dest
, const void *src
, size_t n
);
43 * This is set up by the setup-routine at boot-time
45 struct boot_params
*boot_params
;
48 memptr free_mem_end_ptr
;
52 static int lines
, cols
;
54 #ifdef CONFIG_KERNEL_GZIP
55 #include "../../../../lib/decompress_inflate.c"
58 #ifdef CONFIG_KERNEL_BZIP2
59 #include "../../../../lib/decompress_bunzip2.c"
62 #ifdef CONFIG_KERNEL_LZMA
63 #include "../../../../lib/decompress_unlzma.c"
66 #ifdef CONFIG_KERNEL_XZ
67 #include "../../../../lib/decompress_unxz.c"
70 #ifdef CONFIG_KERNEL_LZO
71 #include "../../../../lib/decompress_unlzo.c"
74 #ifdef CONFIG_KERNEL_LZ4
75 #include "../../../../lib/decompress_unlz4.c"
78 * NOTE: When adding a new decompressor, please update the analysis in
82 static void scroll(void)
86 memmove(vidmem
, vidmem
+ cols
* 2, (lines
- 1) * cols
* 2);
87 for (i
= (lines
- 1) * cols
* 2; i
< lines
* cols
* 2; i
+= 2)
93 #define TXR 0 /* Transmit register (WRITE) */
94 #define LSR 5 /* Line Status */
95 static void serial_putchar(int ch
)
97 unsigned timeout
= 0xffff;
99 while ((inb(early_serial_base
+ LSR
) & XMTRDY
) == 0 && --timeout
)
102 outb(ch
, early_serial_base
+ TXR
);
105 void __putstr(const char *s
)
110 if (early_serial_base
) {
114 serial_putchar('\r');
115 serial_putchar(*str
++);
119 if (boot_params
->screen_info
.orig_video_mode
== 0 &&
120 lines
== 0 && cols
== 0)
123 x
= boot_params
->screen_info
.orig_x
;
124 y
= boot_params
->screen_info
.orig_y
;
126 while ((c
= *s
++) != '\0') {
134 vidmem
[(x
+ cols
* y
) * 2] = c
;
145 boot_params
->screen_info
.orig_x
= x
;
146 boot_params
->screen_info
.orig_y
= y
;
148 pos
= (x
+ cols
* y
) * 2; /* Update cursor position */
150 outb(0xff & (pos
>> 9), vidport
+1);
152 outb(0xff & (pos
>> 1), vidport
+1);
155 void __puthex(unsigned long value
)
160 for (bits
= sizeof(value
) * 8 - 4; bits
>= 0; bits
-= 4) {
161 unsigned long digit
= (value
>> bits
) & 0xf;
164 alpha
[0] = '0' + digit
;
166 alpha
[0] = 'a' + (digit
- 0xA);
172 #if CONFIG_X86_NEED_RELOCS
173 static void handle_relocations(void *output
, unsigned long output_len
,
174 unsigned long virt_addr
)
177 unsigned long delta
, map
, ptr
;
178 unsigned long min_addr
= (unsigned long)output
;
179 unsigned long max_addr
= min_addr
+ (VO___bss_start
- VO__text
);
182 * Calculate the delta between where vmlinux was linked to load
183 * and where it was actually loaded.
185 delta
= min_addr
- LOAD_PHYSICAL_ADDR
;
188 * The kernel contains a table of relocation addresses. Those
189 * addresses have the final load address of the kernel in virtual
190 * memory. We are currently working in the self map. So we need to
191 * create an adjustment for kernel memory addresses to the self map.
192 * This will involve subtracting out the base address of the kernel.
194 map
= delta
- __START_KERNEL_map
;
197 * 32-bit always performs relocations. 64-bit relocations are only
198 * needed if KASLR has chosen a different starting address offset
199 * from __START_KERNEL_map.
201 if (IS_ENABLED(CONFIG_X86_64
))
202 delta
= virt_addr
- LOAD_PHYSICAL_ADDR
;
205 debug_putstr("No relocation needed... ");
208 debug_putstr("Performing relocations... ");
211 * Process relocations: 32 bit relocations first then 64 bit after.
212 * Three sets of binary relocations are added to the end of the kernel
213 * before compression. Each relocation table entry is the kernel
214 * address of the location which needs to be updated stored as a
215 * 32-bit value which is sign extended to 64 bits.
220 * 0 - zero terminator for 64 bit relocations
221 * 64 bit relocation repeated
222 * 0 - zero terminator for inverse 32 bit relocations
223 * 32 bit inverse relocation repeated
224 * 0 - zero terminator for 32 bit relocations
225 * 32 bit relocation repeated
227 * So we work backwards from the end of the decompressed image.
229 for (reloc
= output
+ output_len
- sizeof(*reloc
); *reloc
; reloc
--) {
230 long extended
= *reloc
;
233 ptr
= (unsigned long)extended
;
234 if (ptr
< min_addr
|| ptr
> max_addr
)
235 error("32-bit relocation outside of kernel!\n");
237 *(uint32_t *)ptr
+= delta
;
241 long extended
= *reloc
;
244 ptr
= (unsigned long)extended
;
245 if (ptr
< min_addr
|| ptr
> max_addr
)
246 error("inverse 32-bit relocation outside of kernel!\n");
248 *(int32_t *)ptr
-= delta
;
250 for (reloc
--; *reloc
; reloc
--) {
251 long extended
= *reloc
;
254 ptr
= (unsigned long)extended
;
255 if (ptr
< min_addr
|| ptr
> max_addr
)
256 error("64-bit relocation outside of kernel!\n");
258 *(uint64_t *)ptr
+= delta
;
263 static inline void handle_relocations(void *output
, unsigned long output_len
,
264 unsigned long virt_addr
)
268 static void parse_elf(void *output
)
272 Elf64_Phdr
*phdrs
, *phdr
;
275 Elf32_Phdr
*phdrs
, *phdr
;
280 memcpy(&ehdr
, output
, sizeof(ehdr
));
281 if (ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
||
282 ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
||
283 ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
||
284 ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
) {
285 error("Kernel is not a valid ELF file");
289 debug_putstr("Parsing ELF... ");
291 phdrs
= malloc(sizeof(*phdrs
) * ehdr
.e_phnum
);
293 error("Failed to allocate space for phdrs");
295 memcpy(phdrs
, output
+ ehdr
.e_phoff
, sizeof(*phdrs
) * ehdr
.e_phnum
);
297 for (i
= 0; i
< ehdr
.e_phnum
; i
++) {
300 switch (phdr
->p_type
) {
302 #ifdef CONFIG_RELOCATABLE
304 dest
+= (phdr
->p_paddr
- LOAD_PHYSICAL_ADDR
);
306 dest
= (void *)(phdr
->p_paddr
);
308 memmove(dest
, output
+ phdr
->p_offset
, phdr
->p_filesz
);
310 default: /* Ignore other PT_* */ break;
318 * The compressed kernel image (ZO), has been moved so that its position
319 * is against the end of the buffer used to hold the uncompressed kernel
320 * image (VO) and the execution environment (.bss, .brk), which makes sure
321 * there is room to do the in-place decompression. (See header.S for the
324 * |-----compressed kernel image------|
326 * 0 extract_offset +INIT_SIZE
327 * |-----------|---------------|-------------------------|--------|
329 * VO__text startup_32 of ZO VO__end ZO__end
331 * |-------uncompressed kernel image---------|
334 asmlinkage __visible
void *extract_kernel(void *rmode
, memptr heap
,
335 unsigned char *input_data
,
336 unsigned long input_len
,
337 unsigned char *output
,
338 unsigned long output_len
)
340 const unsigned long kernel_total_size
= VO__end
- VO__text
;
341 unsigned long virt_addr
= (unsigned long)output
;
343 /* Retain x86 boot parameters pointer passed from startup_32/64. */
346 /* Clear flags intended for solely in-kernel use. */
347 boot_params
->hdr
.loadflags
&= ~KASLR_FLAG
;
349 sanitize_boot_params(boot_params
);
351 if (boot_params
->screen_info
.orig_video_mode
== 7) {
352 vidmem
= (char *) 0xb0000;
355 vidmem
= (char *) 0xb8000;
359 lines
= boot_params
->screen_info
.orig_video_lines
;
360 cols
= boot_params
->screen_info
.orig_video_cols
;
363 debug_putstr("early console in extract_kernel\n");
365 free_mem_ptr
= heap
; /* Heap */
366 free_mem_end_ptr
= heap
+ BOOT_HEAP_SIZE
;
368 /* Report initial kernel position details. */
369 debug_putaddr(input_data
);
370 debug_putaddr(input_len
);
371 debug_putaddr(output
);
372 debug_putaddr(output_len
);
373 debug_putaddr(kernel_total_size
);
376 * The memory hole needed for the kernel is the larger of either
377 * the entire decompressed kernel plus relocation table, or the
378 * entire decompressed kernel plus .bss and .brk sections.
380 choose_random_location((unsigned long)input_data
, input_len
,
381 (unsigned long *)&output
,
382 max(output_len
, kernel_total_size
),
385 /* Validate memory location choices. */
386 if ((unsigned long)output
& (MIN_KERNEL_ALIGN
- 1))
387 error("Destination physical address inappropriately aligned");
388 if (virt_addr
& (MIN_KERNEL_ALIGN
- 1))
389 error("Destination virtual address inappropriately aligned");
391 if (heap
> 0x3fffffffffffUL
)
392 error("Destination address too large");
394 if (heap
> ((-__PAGE_OFFSET
-(128<<20)-1) & 0x7fffffff))
395 error("Destination address too large");
397 #ifndef CONFIG_RELOCATABLE
398 if ((unsigned long)output
!= LOAD_PHYSICAL_ADDR
)
399 error("Destination address does not match LOAD_PHYSICAL_ADDR");
400 if ((unsigned long)output
!= virt_addr
)
401 error("Destination virtual address changed when not relocatable");
404 debug_putstr("\nDecompressing Linux... ");
405 __decompress(input_data
, input_len
, NULL
, NULL
, output
, output_len
,
408 handle_relocations(output
, output_len
, virt_addr
);
409 debug_putstr("done.\nBooting the kernel.\n");
This page took 0.044973 seconds and 5 git commands to generate.