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 | #include <asm/bootparam_utils.h> |
21 | |
22 | /* |
23 | * WARNING!! |
24 | * This code is compiled with -fPIC and it is relocated dynamically at |
25 | * run time, but no relocation processing is performed. This means that |
26 | * it is not safe to place pointers in static structures. |
27 | */ |
28 | |
29 | /* Macros used by the included decompressor code below. */ |
30 | #define STATIC static |
31 | /* Define an externally visible malloc()/free(). */ |
32 | #define MALLOC_VISIBLE |
33 | #include <linux/decompress/mm.h> |
34 | |
35 | /* |
36 | * Provide definitions of memzero and memmove as some of the decompressors will |
37 | * try to define their own functions if these are not defined as macros. |
38 | */ |
39 | #define memzero(s, n) memset((s), 0, (n)) |
40 | #ifndef memmove |
41 | #define memmove memmove |
42 | /* Functions used by the included decompressor code below. */ |
43 | void *memmove(void *dest, const void *src, size_t n); |
44 | #endif |
45 | |
46 | /* |
47 | * This is set up by the setup-routine at boot-time |
48 | */ |
49 | struct boot_params *boot_params_ptr; |
50 | |
51 | struct port_io_ops pio_ops; |
52 | |
53 | memptr free_mem_ptr; |
54 | memptr free_mem_end_ptr; |
55 | |
56 | static char *vidmem; |
57 | static int vidport; |
58 | |
59 | /* These might be accessed before .bss is cleared, so use .data instead. */ |
60 | static int lines __section(".data" ); |
61 | static int cols __section(".data" ); |
62 | |
63 | #ifdef CONFIG_KERNEL_GZIP |
64 | #include "../../../../lib/decompress_inflate.c" |
65 | #endif |
66 | |
67 | #ifdef CONFIG_KERNEL_BZIP2 |
68 | #include "../../../../lib/decompress_bunzip2.c" |
69 | #endif |
70 | |
71 | #ifdef CONFIG_KERNEL_LZMA |
72 | #include "../../../../lib/decompress_unlzma.c" |
73 | #endif |
74 | |
75 | #ifdef CONFIG_KERNEL_XZ |
76 | #include "../../../../lib/decompress_unxz.c" |
77 | #endif |
78 | |
79 | #ifdef CONFIG_KERNEL_LZO |
80 | #include "../../../../lib/decompress_unlzo.c" |
81 | #endif |
82 | |
83 | #ifdef CONFIG_KERNEL_LZ4 |
84 | #include "../../../../lib/decompress_unlz4.c" |
85 | #endif |
86 | |
87 | #ifdef CONFIG_KERNEL_ZSTD |
88 | #include "../../../../lib/decompress_unzstd.c" |
89 | #endif |
90 | /* |
91 | * NOTE: When adding a new decompressor, please update the analysis in |
92 | * ../header.S. |
93 | */ |
94 | |
95 | static void scroll(void) |
96 | { |
97 | int i; |
98 | |
99 | memmove(dest: vidmem, src: vidmem + cols * 2, n: (lines - 1) * cols * 2); |
100 | for (i = (lines - 1) * cols * 2; i < lines * cols * 2; i += 2) |
101 | vidmem[i] = ' '; |
102 | } |
103 | |
104 | #define XMTRDY 0x20 |
105 | |
106 | #define TXR 0 /* Transmit register (WRITE) */ |
107 | #define LSR 5 /* Line Status */ |
108 | static void serial_putchar(int ch) |
109 | { |
110 | unsigned timeout = 0xffff; |
111 | |
112 | while ((inb(early_serial_base + LSR) & XMTRDY) == 0 && --timeout) |
113 | cpu_relax(); |
114 | |
115 | outb(ch, early_serial_base + TXR); |
116 | } |
117 | |
118 | void __putstr(const char *s) |
119 | { |
120 | int x, y, pos; |
121 | char c; |
122 | |
123 | if (early_serial_base) { |
124 | const char *str = s; |
125 | while (*str) { |
126 | if (*str == '\n') |
127 | serial_putchar(ch: '\r'); |
128 | serial_putchar(ch: *str++); |
129 | } |
130 | } |
131 | |
132 | if (lines == 0 || cols == 0) |
133 | return; |
134 | |
135 | x = boot_params_ptr->screen_info.orig_x; |
136 | y = boot_params_ptr->screen_info.orig_y; |
137 | |
138 | while ((c = *s++) != '\0') { |
139 | if (c == '\n') { |
140 | x = 0; |
141 | if (++y >= lines) { |
142 | scroll(); |
143 | y--; |
144 | } |
145 | } else { |
146 | vidmem[(x + cols * y) * 2] = c; |
147 | if (++x >= cols) { |
148 | x = 0; |
149 | if (++y >= lines) { |
150 | scroll(); |
151 | y--; |
152 | } |
153 | } |
154 | } |
155 | } |
156 | |
157 | boot_params_ptr->screen_info.orig_x = x; |
158 | boot_params_ptr->screen_info.orig_y = y; |
159 | |
160 | pos = (x + cols * y) * 2; /* Update cursor position */ |
161 | outb(14, vidport); |
162 | outb(0xff & (pos >> 9), vidport+1); |
163 | outb(15, vidport); |
164 | outb(0xff & (pos >> 1), vidport+1); |
165 | } |
166 | |
167 | void __puthex(unsigned long value) |
168 | { |
169 | char alpha[2] = "0" ; |
170 | int bits; |
171 | |
172 | for (bits = sizeof(value) * 8 - 4; bits >= 0; bits -= 4) { |
173 | unsigned long digit = (value >> bits) & 0xf; |
174 | |
175 | if (digit < 0xA) |
176 | alpha[0] = '0' + digit; |
177 | else |
178 | alpha[0] = 'a' + (digit - 0xA); |
179 | |
180 | __putstr(s: alpha); |
181 | } |
182 | } |
183 | |
184 | #ifdef CONFIG_X86_NEED_RELOCS |
185 | static void handle_relocations(void *output, unsigned long output_len, |
186 | unsigned long virt_addr) |
187 | { |
188 | int *reloc; |
189 | unsigned long delta, map, ptr; |
190 | unsigned long min_addr = (unsigned long)output; |
191 | unsigned long max_addr = min_addr + (VO___bss_start - VO__text); |
192 | |
193 | /* |
194 | * Calculate the delta between where vmlinux was linked to load |
195 | * and where it was actually loaded. |
196 | */ |
197 | delta = min_addr - LOAD_PHYSICAL_ADDR; |
198 | |
199 | /* |
200 | * The kernel contains a table of relocation addresses. Those |
201 | * addresses have the final load address of the kernel in virtual |
202 | * memory. We are currently working in the self map. So we need to |
203 | * create an adjustment for kernel memory addresses to the self map. |
204 | * This will involve subtracting out the base address of the kernel. |
205 | */ |
206 | map = delta - __START_KERNEL_map; |
207 | |
208 | /* |
209 | * 32-bit always performs relocations. 64-bit relocations are only |
210 | * needed if KASLR has chosen a different starting address offset |
211 | * from __START_KERNEL_map. |
212 | */ |
213 | if (IS_ENABLED(CONFIG_X86_64)) |
214 | delta = virt_addr - LOAD_PHYSICAL_ADDR; |
215 | |
216 | if (!delta) { |
217 | debug_putstr("No relocation needed... " ); |
218 | return; |
219 | } |
220 | debug_putstr("Performing relocations... " ); |
221 | |
222 | /* |
223 | * Process relocations: 32 bit relocations first then 64 bit after. |
224 | * Three sets of binary relocations are added to the end of the kernel |
225 | * before compression. Each relocation table entry is the kernel |
226 | * address of the location which needs to be updated stored as a |
227 | * 32-bit value which is sign extended to 64 bits. |
228 | * |
229 | * Format is: |
230 | * |
231 | * kernel bits... |
232 | * 0 - zero terminator for 64 bit relocations |
233 | * 64 bit relocation repeated |
234 | * 0 - zero terminator for inverse 32 bit relocations |
235 | * 32 bit inverse relocation repeated |
236 | * 0 - zero terminator for 32 bit relocations |
237 | * 32 bit relocation repeated |
238 | * |
239 | * So we work backwards from the end of the decompressed image. |
240 | */ |
241 | for (reloc = output + output_len - sizeof(*reloc); *reloc; reloc--) { |
242 | long extended = *reloc; |
243 | extended += map; |
244 | |
245 | ptr = (unsigned long)extended; |
246 | if (ptr < min_addr || ptr > max_addr) |
247 | error(m: "32-bit relocation outside of kernel!\n" ); |
248 | |
249 | *(uint32_t *)ptr += delta; |
250 | } |
251 | #ifdef CONFIG_X86_64 |
252 | while (*--reloc) { |
253 | long extended = *reloc; |
254 | extended += map; |
255 | |
256 | ptr = (unsigned long)extended; |
257 | if (ptr < min_addr || ptr > max_addr) |
258 | error(m: "inverse 32-bit relocation outside of kernel!\n" ); |
259 | |
260 | *(int32_t *)ptr -= delta; |
261 | } |
262 | for (reloc--; *reloc; reloc--) { |
263 | long extended = *reloc; |
264 | extended += map; |
265 | |
266 | ptr = (unsigned long)extended; |
267 | if (ptr < min_addr || ptr > max_addr) |
268 | error(m: "64-bit relocation outside of kernel!\n" ); |
269 | |
270 | *(uint64_t *)ptr += delta; |
271 | } |
272 | #endif |
273 | } |
274 | #else |
275 | static inline void handle_relocations(void *output, unsigned long output_len, |
276 | unsigned long virt_addr) |
277 | { } |
278 | #endif |
279 | |
280 | static size_t parse_elf(void *output) |
281 | { |
282 | #ifdef CONFIG_X86_64 |
283 | Elf64_Ehdr ehdr; |
284 | Elf64_Phdr *phdrs, *phdr; |
285 | #else |
286 | Elf32_Ehdr ehdr; |
287 | Elf32_Phdr *phdrs, *phdr; |
288 | #endif |
289 | void *dest; |
290 | int i; |
291 | |
292 | memcpy(&ehdr, output, sizeof(ehdr)); |
293 | if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || |
294 | ehdr.e_ident[EI_MAG1] != ELFMAG1 || |
295 | ehdr.e_ident[EI_MAG2] != ELFMAG2 || |
296 | ehdr.e_ident[EI_MAG3] != ELFMAG3) |
297 | error(m: "Kernel is not a valid ELF file" ); |
298 | |
299 | debug_putstr("Parsing ELF... " ); |
300 | |
301 | phdrs = malloc(size: sizeof(*phdrs) * ehdr.e_phnum); |
302 | if (!phdrs) |
303 | error(m: "Failed to allocate space for phdrs" ); |
304 | |
305 | memcpy(phdrs, output + ehdr.e_phoff, sizeof(*phdrs) * ehdr.e_phnum); |
306 | |
307 | for (i = 0; i < ehdr.e_phnum; i++) { |
308 | phdr = &phdrs[i]; |
309 | |
310 | switch (phdr->p_type) { |
311 | case PT_LOAD: |
312 | #ifdef CONFIG_X86_64 |
313 | if ((phdr->p_align % 0x200000) != 0) |
314 | error(m: "Alignment of LOAD segment isn't multiple of 2MB" ); |
315 | #endif |
316 | #ifdef CONFIG_RELOCATABLE |
317 | dest = output; |
318 | dest += (phdr->p_paddr - LOAD_PHYSICAL_ADDR); |
319 | #else |
320 | dest = (void *)(phdr->p_paddr); |
321 | #endif |
322 | memmove(dest, src: output + phdr->p_offset, n: phdr->p_filesz); |
323 | break; |
324 | default: /* Ignore other PT_* */ break; |
325 | } |
326 | } |
327 | |
328 | free(where: phdrs); |
329 | |
330 | return ehdr.e_entry - LOAD_PHYSICAL_ADDR; |
331 | } |
332 | |
333 | const unsigned long kernel_total_size = VO__end - VO__text; |
334 | |
335 | static u8 boot_heap[BOOT_HEAP_SIZE] __aligned(4); |
336 | |
337 | extern unsigned char input_data[]; |
338 | extern unsigned int input_len, output_len; |
339 | |
340 | unsigned long decompress_kernel(unsigned char *outbuf, unsigned long virt_addr, |
341 | void (*error)(char *x)) |
342 | { |
343 | unsigned long entry; |
344 | |
345 | if (!free_mem_ptr) { |
346 | free_mem_ptr = (unsigned long)boot_heap; |
347 | free_mem_end_ptr = (unsigned long)boot_heap + sizeof(boot_heap); |
348 | } |
349 | |
350 | if (__decompress(buf: input_data, len: input_len, NULL, NULL, out_buf: outbuf, out_len: output_len, |
351 | NULL, error) < 0) |
352 | return ULONG_MAX; |
353 | |
354 | entry = parse_elf(output: outbuf); |
355 | handle_relocations(output: outbuf, output_len, virt_addr); |
356 | |
357 | return entry; |
358 | } |
359 | |
360 | /* |
361 | * The compressed kernel image (ZO), has been moved so that its position |
362 | * is against the end of the buffer used to hold the uncompressed kernel |
363 | * image (VO) and the execution environment (.bss, .brk), which makes sure |
364 | * there is room to do the in-place decompression. (See header.S for the |
365 | * calculations.) |
366 | * |
367 | * |-----compressed kernel image------| |
368 | * V V |
369 | * 0 extract_offset +INIT_SIZE |
370 | * |-----------|---------------|-------------------------|--------| |
371 | * | | | | |
372 | * VO__text startup_32 of ZO VO__end ZO__end |
373 | * ^ ^ |
374 | * |-------uncompressed kernel image---------| |
375 | * |
376 | */ |
377 | asmlinkage __visible void *(void *rmode, unsigned char *output) |
378 | { |
379 | unsigned long virt_addr = LOAD_PHYSICAL_ADDR; |
380 | memptr heap = (memptr)boot_heap; |
381 | unsigned long needed_size; |
382 | size_t entry_offset; |
383 | |
384 | /* Retain x86 boot parameters pointer passed from startup_32/64. */ |
385 | boot_params_ptr = rmode; |
386 | |
387 | /* Clear flags intended for solely in-kernel use. */ |
388 | boot_params_ptr->hdr.loadflags &= ~KASLR_FLAG; |
389 | |
390 | sanitize_boot_params(boot_params: boot_params_ptr); |
391 | |
392 | if (boot_params_ptr->screen_info.orig_video_mode == 7) { |
393 | vidmem = (char *) 0xb0000; |
394 | vidport = 0x3b4; |
395 | } else { |
396 | vidmem = (char *) 0xb8000; |
397 | vidport = 0x3d4; |
398 | } |
399 | |
400 | lines = boot_params_ptr->screen_info.orig_video_lines; |
401 | cols = boot_params_ptr->screen_info.orig_video_cols; |
402 | |
403 | init_default_io_ops(); |
404 | |
405 | /* |
406 | * Detect TDX guest environment. |
407 | * |
408 | * It has to be done before console_init() in order to use |
409 | * paravirtualized port I/O operations if needed. |
410 | */ |
411 | early_tdx_detect(); |
412 | |
413 | console_init(); |
414 | |
415 | /* |
416 | * Save RSDP address for later use. Have this after console_init() |
417 | * so that early debugging output from the RSDP parsing code can be |
418 | * collected. |
419 | */ |
420 | boot_params_ptr->acpi_rsdp_addr = get_rsdp_addr(); |
421 | |
422 | debug_putstr("early console in extract_kernel\n" ); |
423 | |
424 | free_mem_ptr = heap; /* Heap */ |
425 | free_mem_end_ptr = heap + BOOT_HEAP_SIZE; |
426 | |
427 | /* |
428 | * The memory hole needed for the kernel is the larger of either |
429 | * the entire decompressed kernel plus relocation table, or the |
430 | * entire decompressed kernel plus .bss and .brk sections. |
431 | * |
432 | * On X86_64, the memory is mapped with PMD pages. Round the |
433 | * size up so that the full extent of PMD pages mapped is |
434 | * included in the check against the valid memory table |
435 | * entries. This ensures the full mapped area is usable RAM |
436 | * and doesn't include any reserved areas. |
437 | */ |
438 | needed_size = max_t(unsigned long, output_len, kernel_total_size); |
439 | #ifdef CONFIG_X86_64 |
440 | needed_size = ALIGN(needed_size, MIN_KERNEL_ALIGN); |
441 | #endif |
442 | |
443 | /* Report initial kernel position details. */ |
444 | debug_putaddr(input_data); |
445 | debug_putaddr(input_len); |
446 | debug_putaddr(output); |
447 | debug_putaddr(output_len); |
448 | debug_putaddr(kernel_total_size); |
449 | debug_putaddr(needed_size); |
450 | |
451 | #ifdef CONFIG_X86_64 |
452 | /* Report address of 32-bit trampoline */ |
453 | debug_putaddr(trampoline_32bit); |
454 | #endif |
455 | |
456 | choose_random_location(input: (unsigned long)input_data, input_size: input_len, |
457 | output: (unsigned long *)&output, |
458 | output_size: needed_size, |
459 | virt_addr: &virt_addr); |
460 | |
461 | /* Validate memory location choices. */ |
462 | if ((unsigned long)output & (MIN_KERNEL_ALIGN - 1)) |
463 | error(m: "Destination physical address inappropriately aligned" ); |
464 | if (virt_addr & (MIN_KERNEL_ALIGN - 1)) |
465 | error(m: "Destination virtual address inappropriately aligned" ); |
466 | #ifdef CONFIG_X86_64 |
467 | if (heap > 0x3fffffffffffUL) |
468 | error(m: "Destination address too large" ); |
469 | if (virt_addr + needed_size > KERNEL_IMAGE_SIZE) |
470 | error(m: "Destination virtual address is beyond the kernel mapping area" ); |
471 | #else |
472 | if (heap > ((-__PAGE_OFFSET-(128<<20)-1) & 0x7fffffff)) |
473 | error("Destination address too large" ); |
474 | #endif |
475 | #ifndef CONFIG_RELOCATABLE |
476 | if (virt_addr != LOAD_PHYSICAL_ADDR) |
477 | error("Destination virtual address changed when not relocatable" ); |
478 | #endif |
479 | |
480 | debug_putstr("\nDecompressing Linux... " ); |
481 | |
482 | if (init_unaccepted_memory()) { |
483 | debug_putstr("Accepting memory... " ); |
484 | accept_memory(__pa(output), __pa(output) + needed_size); |
485 | } |
486 | |
487 | entry_offset = decompress_kernel(outbuf: output, virt_addr, error); |
488 | |
489 | debug_putstr("done.\nBooting the kernel (entry_offset: 0x" ); |
490 | debug_puthex(entry_offset); |
491 | debug_putstr(").\n" ); |
492 | |
493 | /* Disable exception handling before booting the kernel */ |
494 | cleanup_exception_handling(); |
495 | |
496 | return output + entry_offset; |
497 | } |
498 | |
499 | void fortify_panic(const char *name) |
500 | { |
501 | error(m: "detected buffer overflow" ); |
502 | } |
503 | |