Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * misc.c | |
818a08f8 IC |
3 | * |
4 | * This is a collection of several routines from gzip-1.0.3 | |
1da177e4 LT |
5 | * adapted for Linux. |
6 | * | |
7 | * malloc by Hannu Savolainen 1993 and Matthias Urlichs 1994 | |
8 | * puts by Nick Holloway 1993, better puts by Martin Mares 1995 | |
9 | * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996 | |
10 | */ | |
11 | ||
8fee13a4 | 12 | #include "misc.h" |
968de4f0 EB |
13 | |
14 | /* WARNING!! | |
15 | * This code is compiled with -fPIC and it is relocated dynamically | |
16 | * at run time, but no relocation processing is performed. | |
17 | * This means that it is not safe to place pointers in static structures. | |
18 | */ | |
19 | ||
20 | /* | |
21 | * Getting to provable safe in place decompression is hard. | |
27b46d76 | 22 | * Worst case behaviours need to be analyzed. |
968de4f0 EB |
23 | * Background information: |
24 | * | |
25 | * The file layout is: | |
26 | * magic[2] | |
27 | * method[1] | |
28 | * flags[1] | |
29 | * timestamp[4] | |
30 | * extraflags[1] | |
31 | * os[1] | |
32 | * compressed data blocks[N] | |
33 | * crc[4] orig_len[4] | |
34 | * | |
35 | * resulting in 18 bytes of non compressed data overhead. | |
36 | * | |
37 | * Files divided into blocks | |
38 | * 1 bit (last block flag) | |
39 | * 2 bits (block type) | |
40 | * | |
1180e01d IM |
41 | * 1 block occurs every 32K -1 bytes or when there 50% compression |
42 | * has been achieved. The smallest block type encoding is always used. | |
968de4f0 EB |
43 | * |
44 | * stored: | |
45 | * 32 bits length in bytes. | |
46 | * | |
47 | * fixed: | |
48 | * magic fixed tree. | |
49 | * symbols. | |
50 | * | |
51 | * dynamic: | |
52 | * dynamic tree encoding. | |
53 | * symbols. | |
54 | * | |
55 | * | |
56 | * The buffer for decompression in place is the length of the | |
57 | * uncompressed data, plus a small amount extra to keep the algorithm safe. | |
58 | * The compressed data is placed at the end of the buffer. The output | |
59 | * pointer is placed at the start of the buffer and the input pointer | |
60 | * is placed where the compressed data starts. Problems will occur | |
61 | * when the output pointer overruns the input pointer. | |
62 | * | |
63 | * The output pointer can only overrun the input pointer if the input | |
64 | * pointer is moving faster than the output pointer. A condition only | |
65 | * triggered by data whose compressed form is larger than the uncompressed | |
66 | * form. | |
67 | * | |
68 | * The worst case at the block level is a growth of the compressed data | |
69 | * of 5 bytes per 32767 bytes. | |
70 | * | |
71 | * The worst case internal to a compressed block is very hard to figure. | |
72 | * The worst case can at least be boundined by having one bit that represents | |
73 | * 32764 bytes and then all of the rest of the bytes representing the very | |
74 | * very last byte. | |
75 | * | |
76 | * All of which is enough to compute an amount of extra data that is required | |
77 | * to be safe. To avoid problems at the block level allocating 5 extra bytes | |
1180e01d IM |
78 | * per 32767 bytes of data is sufficient. To avoind problems internal to a |
79 | * block adding an extra 32767 bytes (the worst case uncompressed block size) | |
80 | * is sufficient, to ensure that in the worst case the decompressed data for | |
968de4f0 EB |
81 | * block will stop the byte before the compressed data for a block begins. |
82 | * To avoid problems with the compressed data's meta information an extra 18 | |
83 | * bytes are needed. Leading to the formula: | |
84 | * | |
85 | * extra_bytes = (uncompressed_size >> 12) + 32768 + 18 + decompressor_size. | |
86 | * | |
87 | * Adding 8 bytes per 32K is a bit excessive but much easier to calculate. | |
88 | * Adding 32768 instead of 32767 just makes for round numbers. | |
89 | * Adding the decompressor_size is necessary as it musht live after all | |
90 | * of the data as well. Last I measured the decompressor is about 14K. | |
27b46d76 | 91 | * 10K of actual data and 4K of bss. |
968de4f0 EB |
92 | * |
93 | */ | |
1da177e4 LT |
94 | |
95 | /* | |
96 | * gzip declarations | |
97 | */ | |
1180e01d | 98 | #define STATIC static |
1da177e4 LT |
99 | |
100 | #undef memset | |
101 | #undef memcpy | |
1180e01d | 102 | #define memzero(s, n) memset((s), 0, (n)) |
1da177e4 | 103 | |
1da177e4 | 104 | |
1da177e4 | 105 | static void error(char *m); |
fd77c7ca | 106 | |
1da177e4 LT |
107 | /* |
108 | * This is set up by the setup-routine at boot-time | |
109 | */ | |
8fee13a4 | 110 | struct boot_params *real_mode; /* Pointer to real-mode data */ |
8fee13a4 | 111 | static int debug; |
1da177e4 | 112 | |
6175ddf0 BG |
113 | void *memset(void *s, int c, size_t n); |
114 | void *memcpy(void *dest, const void *src, size_t n); | |
b79c4df7 | 115 | |
778cb929 IC |
116 | #ifdef CONFIG_X86_64 |
117 | #define memptr long | |
118 | #else | |
119 | #define memptr unsigned | |
120 | #endif | |
121 | ||
122 | static memptr free_mem_ptr; | |
123 | static memptr free_mem_end_ptr; | |
1da177e4 | 124 | |
03056c88 | 125 | static char *vidmem; |
1da177e4 LT |
126 | static int vidport; |
127 | static int lines, cols; | |
128 | ||
ae03c499 AK |
129 | #ifdef CONFIG_KERNEL_GZIP |
130 | #include "../../../../lib/decompress_inflate.c" | |
131 | #endif | |
132 | ||
133 | #ifdef CONFIG_KERNEL_BZIP2 | |
134 | #include "../../../../lib/decompress_bunzip2.c" | |
135 | #endif | |
136 | ||
137 | #ifdef CONFIG_KERNEL_LZMA | |
138 | #include "../../../../lib/decompress_unlzma.c" | |
139 | #endif | |
1da177e4 | 140 | |
30314804 LC |
141 | #ifdef CONFIG_KERNEL_XZ |
142 | #include "../../../../lib/decompress_unxz.c" | |
143 | #endif | |
144 | ||
13510997 AT |
145 | #ifdef CONFIG_KERNEL_LZO |
146 | #include "../../../../lib/decompress_unlzo.c" | |
147 | #endif | |
148 | ||
1da177e4 LT |
149 | static void scroll(void) |
150 | { | |
151 | int i; | |
152 | ||
fd77c7ca PC |
153 | memcpy(vidmem, vidmem + cols * 2, (lines - 1) * cols * 2); |
154 | for (i = (lines - 1) * cols * 2; i < lines * cols * 2; i += 2) | |
1da177e4 LT |
155 | vidmem[i] = ' '; |
156 | } | |
157 | ||
8fee13a4 YL |
158 | #define XMTRDY 0x20 |
159 | ||
160 | #define TXR 0 /* Transmit register (WRITE) */ | |
161 | #define LSR 5 /* Line Status */ | |
162 | static void serial_putchar(int ch) | |
163 | { | |
164 | unsigned timeout = 0xffff; | |
165 | ||
166 | while ((inb(early_serial_base + LSR) & XMTRDY) == 0 && --timeout) | |
167 | cpu_relax(); | |
168 | ||
169 | outb(ch, early_serial_base + TXR); | |
170 | } | |
171 | ||
172 | void __putstr(int error, const char *s) | |
1da177e4 | 173 | { |
fd77c7ca | 174 | int x, y, pos; |
1da177e4 LT |
175 | char c; |
176 | ||
6bcb13b3 BC |
177 | #ifndef CONFIG_X86_VERBOSE_BOOTUP |
178 | if (!error) | |
179 | return; | |
180 | #endif | |
8fee13a4 YL |
181 | if (early_serial_base) { |
182 | const char *str = s; | |
183 | while (*str) { | |
184 | if (*str == '\n') | |
185 | serial_putchar('\r'); | |
186 | serial_putchar(*str++); | |
187 | } | |
188 | } | |
6bcb13b3 | 189 | |
23968f71 KH |
190 | if (real_mode->screen_info.orig_video_mode == 0 && |
191 | lines == 0 && cols == 0) | |
a24e7851 RR |
192 | return; |
193 | ||
23968f71 KH |
194 | x = real_mode->screen_info.orig_x; |
195 | y = real_mode->screen_info.orig_y; | |
1da177e4 | 196 | |
fd77c7ca PC |
197 | while ((c = *s++) != '\0') { |
198 | if (c == '\n') { | |
1da177e4 | 199 | x = 0; |
fd77c7ca | 200 | if (++y >= lines) { |
1da177e4 LT |
201 | scroll(); |
202 | y--; | |
203 | } | |
204 | } else { | |
020878ac | 205 | vidmem[(x + cols * y) * 2] = c; |
fd77c7ca | 206 | if (++x >= cols) { |
1da177e4 | 207 | x = 0; |
fd77c7ca | 208 | if (++y >= lines) { |
1da177e4 LT |
209 | scroll(); |
210 | y--; | |
211 | } | |
212 | } | |
213 | } | |
214 | } | |
215 | ||
23968f71 KH |
216 | real_mode->screen_info.orig_x = x; |
217 | real_mode->screen_info.orig_y = y; | |
1da177e4 LT |
218 | |
219 | pos = (x + cols * y) * 2; /* Update cursor position */ | |
b02aae9c RH |
220 | outb(14, vidport); |
221 | outb(0xff & (pos >> 9), vidport+1); | |
222 | outb(15, vidport); | |
223 | outb(0xff & (pos >> 1), vidport+1); | |
1da177e4 LT |
224 | } |
225 | ||
e605a425 JM |
226 | static void debug_putstr(const char *s) |
227 | { | |
228 | if (debug) | |
229 | putstr(s); | |
230 | } | |
231 | ||
6175ddf0 | 232 | void *memset(void *s, int c, size_t n) |
1da177e4 LT |
233 | { |
234 | int i; | |
ade1af77 | 235 | char *ss = s; |
1da177e4 | 236 | |
020878ac PC |
237 | for (i = 0; i < n; i++) |
238 | ss[i] = c; | |
1da177e4 LT |
239 | return s; |
240 | } | |
68f4d5a0 | 241 | #ifdef CONFIG_X86_32 |
6175ddf0 | 242 | void *memcpy(void *dest, const void *src, size_t n) |
1da177e4 | 243 | { |
68f4d5a0 ZY |
244 | int d0, d1, d2; |
245 | asm volatile( | |
246 | "rep ; movsl\n\t" | |
247 | "movl %4,%%ecx\n\t" | |
248 | "rep ; movsb\n\t" | |
249 | : "=&c" (d0), "=&D" (d1), "=&S" (d2) | |
250 | : "0" (n >> 2), "g" (n & 3), "1" (dest), "2" (src) | |
251 | : "memory"); | |
1da177e4 | 252 | |
b79c4df7 | 253 | return dest; |
1da177e4 | 254 | } |
68f4d5a0 ZY |
255 | #else |
256 | void *memcpy(void *dest, const void *src, size_t n) | |
257 | { | |
258 | long d0, d1, d2; | |
259 | asm volatile( | |
260 | "rep ; movsq\n\t" | |
261 | "movq %4,%%rcx\n\t" | |
262 | "rep ; movsb\n\t" | |
263 | : "=&c" (d0), "=&D" (d1), "=&S" (d2) | |
264 | : "0" (n >> 3), "g" (n & 7), "1" (dest), "2" (src) | |
265 | : "memory"); | |
1da177e4 | 266 | |
68f4d5a0 ZY |
267 | return dest; |
268 | } | |
269 | #endif | |
1da177e4 LT |
270 | |
271 | static void error(char *x) | |
272 | { | |
6bcb13b3 BC |
273 | __putstr(1, "\n\n"); |
274 | __putstr(1, x); | |
275 | __putstr(1, "\n\n -- System halted"); | |
1da177e4 | 276 | |
ff3cf856 IM |
277 | while (1) |
278 | asm("hlt"); | |
1da177e4 LT |
279 | } |
280 | ||
099e1377 IC |
281 | static void parse_elf(void *output) |
282 | { | |
283 | #ifdef CONFIG_X86_64 | |
284 | Elf64_Ehdr ehdr; | |
285 | Elf64_Phdr *phdrs, *phdr; | |
286 | #else | |
287 | Elf32_Ehdr ehdr; | |
288 | Elf32_Phdr *phdrs, *phdr; | |
289 | #endif | |
290 | void *dest; | |
291 | int i; | |
292 | ||
293 | memcpy(&ehdr, output, sizeof(ehdr)); | |
fd77c7ca | 294 | if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || |
099e1377 IC |
295 | ehdr.e_ident[EI_MAG1] != ELFMAG1 || |
296 | ehdr.e_ident[EI_MAG2] != ELFMAG2 || | |
fd77c7ca | 297 | ehdr.e_ident[EI_MAG3] != ELFMAG3) { |
099e1377 IC |
298 | error("Kernel is not a valid ELF file"); |
299 | return; | |
300 | } | |
301 | ||
e605a425 | 302 | debug_putstr("Parsing ELF... "); |
099e1377 IC |
303 | |
304 | phdrs = malloc(sizeof(*phdrs) * ehdr.e_phnum); | |
305 | if (!phdrs) | |
306 | error("Failed to allocate space for phdrs"); | |
307 | ||
308 | memcpy(phdrs, output + ehdr.e_phoff, sizeof(*phdrs) * ehdr.e_phnum); | |
309 | ||
fd77c7ca | 310 | for (i = 0; i < ehdr.e_phnum; i++) { |
099e1377 IC |
311 | phdr = &phdrs[i]; |
312 | ||
313 | switch (phdr->p_type) { | |
314 | case PT_LOAD: | |
315 | #ifdef CONFIG_RELOCATABLE | |
316 | dest = output; | |
317 | dest += (phdr->p_paddr - LOAD_PHYSICAL_ADDR); | |
318 | #else | |
fd77c7ca | 319 | dest = (void *)(phdr->p_paddr); |
099e1377 IC |
320 | #endif |
321 | memcpy(dest, | |
322 | output + phdr->p_offset, | |
323 | phdr->p_filesz); | |
324 | break; | |
325 | default: /* Ignore other PT_* */ break; | |
326 | } | |
327 | } | |
5067cf53 JJ |
328 | |
329 | free(phdrs); | |
099e1377 IC |
330 | } |
331 | ||
778cb929 | 332 | asmlinkage void decompress_kernel(void *rmode, memptr heap, |
1180e01d IM |
333 | unsigned char *input_data, |
334 | unsigned long input_len, | |
335 | unsigned char *output) | |
1da177e4 LT |
336 | { |
337 | real_mode = rmode; | |
338 | ||
8fee13a4 YL |
339 | if (cmdline_find_option_bool("debug")) |
340 | debug = 1; | |
3b6b9293 | 341 | |
23968f71 | 342 | if (real_mode->screen_info.orig_video_mode == 7) { |
1da177e4 LT |
343 | vidmem = (char *) 0xb0000; |
344 | vidport = 0x3b4; | |
345 | } else { | |
346 | vidmem = (char *) 0xb8000; | |
347 | vidport = 0x3d4; | |
348 | } | |
349 | ||
23968f71 KH |
350 | lines = real_mode->screen_info.orig_video_lines; |
351 | cols = real_mode->screen_info.orig_video_cols; | |
1da177e4 | 352 | |
8fee13a4 | 353 | console_init(); |
e605a425 | 354 | debug_putstr("early console in decompress_kernel\n"); |
8fee13a4 | 355 | |
4c83d653 | 356 | free_mem_ptr = heap; /* Heap */ |
7c539764 | 357 | free_mem_end_ptr = heap + BOOT_HEAP_SIZE; |
968de4f0 | 358 | |
7ed42a28 PA |
359 | if ((unsigned long)output & (MIN_KERNEL_ALIGN - 1)) |
360 | error("Destination address inappropriately aligned"); | |
778cb929 | 361 | #ifdef CONFIG_X86_64 |
7ed42a28 | 362 | if (heap > 0x3fffffffffffUL) |
778cb929 IC |
363 | error("Destination address too large"); |
364 | #else | |
147dd561 | 365 | if (heap > ((-__PAGE_OFFSET-(128<<20)-1) & 0x7fffffff)) |
968de4f0 | 366 | error("Destination address too large"); |
7ed42a28 | 367 | #endif |
968de4f0 | 368 | #ifndef CONFIG_RELOCATABLE |
7ed42a28 | 369 | if ((unsigned long)output != LOAD_PHYSICAL_ADDR) |
968de4f0 EB |
370 | error("Wrong destination address"); |
371 | #endif | |
1da177e4 | 372 | |
e605a425 | 373 | debug_putstr("\nDecompressing Linux... "); |
ae03c499 | 374 | decompress(input_data, input_len, NULL, NULL, output, NULL, error); |
099e1377 | 375 | parse_elf(output); |
e605a425 | 376 | debug_putstr("done.\nBooting the kernel.\n"); |
968de4f0 | 377 | return; |
1da177e4 | 378 | } |