]>
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 | ||
818a08f8 IC |
12 | /* |
13 | * we have to be careful, because no indirections are allowed here, and | |
14 | * paravirt_ops is a kind of one. As it will only run in baremetal anyway, | |
15 | * we just keep it from happening | |
16 | */ | |
d3561b7f | 17 | #undef CONFIG_PARAVIRT |
099e1377 IC |
18 | #ifdef CONFIG_X86_32 |
19 | #define _ASM_DESC_H_ 1 | |
20 | #endif | |
21 | ||
778cb929 IC |
22 | #ifdef CONFIG_X86_64 |
23 | #define _LINUX_STRING_H_ 1 | |
24 | #define __LINUX_BITMAP_H 1 | |
25 | #endif | |
26 | ||
1da177e4 | 27 | #include <linux/linkage.h> |
7e7f358c | 28 | #include <linux/screen_info.h> |
099e1377 | 29 | #include <linux/elf.h> |
1da177e4 | 30 | #include <asm/io.h> |
968de4f0 | 31 | #include <asm/page.h> |
e69f202d | 32 | #include <asm/boot.h> |
968de4f0 EB |
33 | |
34 | /* WARNING!! | |
35 | * This code is compiled with -fPIC and it is relocated dynamically | |
36 | * at run time, but no relocation processing is performed. | |
37 | * This means that it is not safe to place pointers in static structures. | |
38 | */ | |
39 | ||
40 | /* | |
41 | * Getting to provable safe in place decompression is hard. | |
27b46d76 | 42 | * Worst case behaviours need to be analyzed. |
968de4f0 EB |
43 | * Background information: |
44 | * | |
45 | * The file layout is: | |
46 | * magic[2] | |
47 | * method[1] | |
48 | * flags[1] | |
49 | * timestamp[4] | |
50 | * extraflags[1] | |
51 | * os[1] | |
52 | * compressed data blocks[N] | |
53 | * crc[4] orig_len[4] | |
54 | * | |
55 | * resulting in 18 bytes of non compressed data overhead. | |
56 | * | |
57 | * Files divided into blocks | |
58 | * 1 bit (last block flag) | |
59 | * 2 bits (block type) | |
60 | * | |
1180e01d IM |
61 | * 1 block occurs every 32K -1 bytes or when there 50% compression |
62 | * has been achieved. The smallest block type encoding is always used. | |
968de4f0 EB |
63 | * |
64 | * stored: | |
65 | * 32 bits length in bytes. | |
66 | * | |
67 | * fixed: | |
68 | * magic fixed tree. | |
69 | * symbols. | |
70 | * | |
71 | * dynamic: | |
72 | * dynamic tree encoding. | |
73 | * symbols. | |
74 | * | |
75 | * | |
76 | * The buffer for decompression in place is the length of the | |
77 | * uncompressed data, plus a small amount extra to keep the algorithm safe. | |
78 | * The compressed data is placed at the end of the buffer. The output | |
79 | * pointer is placed at the start of the buffer and the input pointer | |
80 | * is placed where the compressed data starts. Problems will occur | |
81 | * when the output pointer overruns the input pointer. | |
82 | * | |
83 | * The output pointer can only overrun the input pointer if the input | |
84 | * pointer is moving faster than the output pointer. A condition only | |
85 | * triggered by data whose compressed form is larger than the uncompressed | |
86 | * form. | |
87 | * | |
88 | * The worst case at the block level is a growth of the compressed data | |
89 | * of 5 bytes per 32767 bytes. | |
90 | * | |
91 | * The worst case internal to a compressed block is very hard to figure. | |
92 | * The worst case can at least be boundined by having one bit that represents | |
93 | * 32764 bytes and then all of the rest of the bytes representing the very | |
94 | * very last byte. | |
95 | * | |
96 | * All of which is enough to compute an amount of extra data that is required | |
97 | * to be safe. To avoid problems at the block level allocating 5 extra bytes | |
1180e01d IM |
98 | * per 32767 bytes of data is sufficient. To avoind problems internal to a |
99 | * block adding an extra 32767 bytes (the worst case uncompressed block size) | |
100 | * is sufficient, to ensure that in the worst case the decompressed data for | |
968de4f0 EB |
101 | * block will stop the byte before the compressed data for a block begins. |
102 | * To avoid problems with the compressed data's meta information an extra 18 | |
103 | * bytes are needed. Leading to the formula: | |
104 | * | |
105 | * extra_bytes = (uncompressed_size >> 12) + 32768 + 18 + decompressor_size. | |
106 | * | |
107 | * Adding 8 bytes per 32K is a bit excessive but much easier to calculate. | |
108 | * Adding 32768 instead of 32767 just makes for round numbers. | |
109 | * Adding the decompressor_size is necessary as it musht live after all | |
110 | * of the data as well. Last I measured the decompressor is about 14K. | |
27b46d76 | 111 | * 10K of actual data and 4K of bss. |
968de4f0 EB |
112 | * |
113 | */ | |
1da177e4 LT |
114 | |
115 | /* | |
116 | * gzip declarations | |
117 | */ | |
118 | ||
1180e01d IM |
119 | #define OF(args) args |
120 | #define STATIC static | |
1da177e4 LT |
121 | |
122 | #undef memset | |
123 | #undef memcpy | |
1180e01d | 124 | #define memzero(s, n) memset((s), 0, (n)) |
1da177e4 | 125 | |
1180e01d IM |
126 | typedef unsigned char uch; |
127 | typedef unsigned short ush; | |
128 | typedef unsigned long ulg; | |
1da177e4 | 129 | |
1180e01d IM |
130 | /* |
131 | * Window size must be at least 32k, and a power of two. | |
132 | * We don't actually have a window just a huge output buffer, | |
133 | * so we report a 2G window size, as that should always be | |
134 | * larger than our output buffer: | |
135 | */ | |
136 | #define WSIZE 0x80000000 | |
137 | ||
138 | /* Input buffer: */ | |
139 | static unsigned char *inbuf; | |
140 | ||
141 | /* Sliding window buffer (and final output buffer): */ | |
142 | static unsigned char *window; | |
143 | ||
144 | /* Valid bytes in inbuf: */ | |
145 | static unsigned insize; | |
1da177e4 | 146 | |
1180e01d IM |
147 | /* Index of next byte to be processed in inbuf: */ |
148 | static unsigned inptr; | |
1da177e4 | 149 | |
1180e01d IM |
150 | /* Bytes in output buffer: */ |
151 | static unsigned outcnt; | |
1da177e4 LT |
152 | |
153 | /* gzip flag byte */ | |
1180e01d IM |
154 | #define ASCII_FLAG 0x01 /* bit 0 set: file probably ASCII text */ |
155 | #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gz file */ | |
156 | #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ | |
157 | #define ORIG_NAM 0x08 /* bit 3 set: original file name present */ | |
158 | #define COMMENT 0x10 /* bit 4 set: file comment present */ | |
159 | #define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */ | |
160 | #define RESERVED 0xC0 /* bit 6, 7: reserved */ | |
1da177e4 | 161 | |
1180e01d | 162 | #define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf()) |
fd77c7ca | 163 | |
1da177e4 LT |
164 | /* Diagnostic functions */ |
165 | #ifdef DEBUG | |
1180e01d IM |
166 | # define Assert(cond, msg) do { if (!(cond)) error(msg); } while (0) |
167 | # define Trace(x) do { fprintf x; } while (0) | |
168 | # define Tracev(x) do { if (verbose) fprintf x ; } while (0) | |
169 | # define Tracevv(x) do { if (verbose > 1) fprintf x ; } while (0) | |
170 | # define Tracec(c, x) do { if (verbose && (c)) fprintf x ; } while (0) | |
171 | # define Tracecv(c, x) do { if (verbose > 1 && (c)) fprintf x ; } while (0) | |
1da177e4 | 172 | #else |
fd77c7ca | 173 | # define Assert(cond, msg) |
1da177e4 LT |
174 | # define Trace(x) |
175 | # define Tracev(x) | |
176 | # define Tracevv(x) | |
fd77c7ca PC |
177 | # define Tracec(c, x) |
178 | # define Tracecv(c, x) | |
1da177e4 LT |
179 | #endif |
180 | ||
181 | static int fill_inbuf(void); | |
182 | static void flush_window(void); | |
183 | static void error(char *m); | |
184 | static void gzip_mark(void **); | |
185 | static void gzip_release(void **); | |
fd77c7ca | 186 | |
1da177e4 LT |
187 | /* |
188 | * This is set up by the setup-routine at boot-time | |
189 | */ | |
190 | static unsigned char *real_mode; /* Pointer to real-mode data */ | |
191 | ||
192 | #define RM_EXT_MEM_K (*(unsigned short *)(real_mode + 0x2)) | |
193 | #ifndef STANDARD_MEMORY_BIOS_CALL | |
194 | #define RM_ALT_MEM_K (*(unsigned long *)(real_mode + 0x1e0)) | |
195 | #endif | |
196 | #define RM_SCREEN_INFO (*(struct screen_info *)(real_mode+0)) | |
197 | ||
b79c4df7 | 198 | extern unsigned char input_data[]; |
1da177e4 LT |
199 | extern int input_len; |
200 | ||
fd77c7ca | 201 | static long bytes_out; |
1da177e4 LT |
202 | |
203 | static void *malloc(int size); | |
204 | static void free(void *where); | |
205 | ||
b79c4df7 CDH |
206 | static void *memset(void *s, int c, unsigned n); |
207 | static void *memcpy(void *dest, const void *src, unsigned n); | |
208 | ||
1da177e4 LT |
209 | static void putstr(const char *); |
210 | ||
778cb929 IC |
211 | #ifdef CONFIG_X86_64 |
212 | #define memptr long | |
213 | #else | |
214 | #define memptr unsigned | |
215 | #endif | |
216 | ||
217 | static memptr free_mem_ptr; | |
218 | static memptr free_mem_end_ptr; | |
1da177e4 | 219 | |
778cb929 IC |
220 | #ifdef CONFIG_X86_64 |
221 | #define HEAP_SIZE 0x7000 | |
222 | #else | |
35c74226 | 223 | #define HEAP_SIZE 0x4000 |
778cb929 | 224 | #endif |
1da177e4 | 225 | |
03056c88 | 226 | static char *vidmem; |
1da177e4 LT |
227 | static int vidport; |
228 | static int lines, cols; | |
229 | ||
230 | #ifdef CONFIG_X86_NUMAQ | |
d5d2448d | 231 | void *xquad_portio; |
1da177e4 LT |
232 | #endif |
233 | ||
234 | #include "../../../../lib/inflate.c" | |
235 | ||
236 | static void *malloc(int size) | |
237 | { | |
238 | void *p; | |
239 | ||
fd77c7ca PC |
240 | if (size < 0) |
241 | error("Malloc error"); | |
242 | if (free_mem_ptr <= 0) | |
243 | error("Memory error"); | |
1da177e4 LT |
244 | |
245 | free_mem_ptr = (free_mem_ptr + 3) & ~3; /* Align */ | |
246 | ||
247 | p = (void *)free_mem_ptr; | |
248 | free_mem_ptr += size; | |
249 | ||
250 | if (free_mem_ptr >= free_mem_end_ptr) | |
251 | error("Out of memory"); | |
252 | ||
253 | return p; | |
254 | } | |
255 | ||
256 | static void free(void *where) | |
257 | { /* Don't care */ | |
258 | } | |
259 | ||
260 | static void gzip_mark(void **ptr) | |
261 | { | |
262 | *ptr = (void *) free_mem_ptr; | |
263 | } | |
264 | ||
265 | static void gzip_release(void **ptr) | |
266 | { | |
778cb929 | 267 | free_mem_ptr = (memptr) *ptr; |
1da177e4 | 268 | } |
fd77c7ca | 269 | |
1da177e4 LT |
270 | static void scroll(void) |
271 | { | |
272 | int i; | |
273 | ||
fd77c7ca PC |
274 | memcpy(vidmem, vidmem + cols * 2, (lines - 1) * cols * 2); |
275 | for (i = (lines - 1) * cols * 2; i < lines * cols * 2; i += 2) | |
1da177e4 LT |
276 | vidmem[i] = ' '; |
277 | } | |
278 | ||
279 | static void putstr(const char *s) | |
280 | { | |
fd77c7ca | 281 | int x, y, pos; |
1da177e4 LT |
282 | char c; |
283 | ||
778cb929 | 284 | #ifdef CONFIG_X86_32 |
a24e7851 RR |
285 | if (RM_SCREEN_INFO.orig_video_mode == 0 && lines == 0 && cols == 0) |
286 | return; | |
778cb929 | 287 | #endif |
a24e7851 | 288 | |
1da177e4 LT |
289 | x = RM_SCREEN_INFO.orig_x; |
290 | y = RM_SCREEN_INFO.orig_y; | |
291 | ||
fd77c7ca PC |
292 | while ((c = *s++) != '\0') { |
293 | if (c == '\n') { | |
1da177e4 | 294 | x = 0; |
fd77c7ca | 295 | if (++y >= lines) { |
1da177e4 LT |
296 | scroll(); |
297 | y--; | |
298 | } | |
299 | } else { | |
818a08f8 | 300 | vidmem [(x + cols * y) * 2] = c; |
fd77c7ca | 301 | if (++x >= cols) { |
1da177e4 | 302 | x = 0; |
fd77c7ca | 303 | if (++y >= lines) { |
1da177e4 LT |
304 | scroll(); |
305 | y--; | |
306 | } | |
307 | } | |
308 | } | |
309 | } | |
310 | ||
311 | RM_SCREEN_INFO.orig_x = x; | |
312 | RM_SCREEN_INFO.orig_y = y; | |
313 | ||
314 | pos = (x + cols * y) * 2; /* Update cursor position */ | |
b02aae9c RH |
315 | outb(14, vidport); |
316 | outb(0xff & (pos >> 9), vidport+1); | |
317 | outb(15, vidport); | |
318 | outb(0xff & (pos >> 1), vidport+1); | |
1da177e4 LT |
319 | } |
320 | ||
fd77c7ca | 321 | static void *memset(void *s, int c, unsigned n) |
1da177e4 LT |
322 | { |
323 | int i; | |
ade1af77 | 324 | char *ss = s; |
1da177e4 | 325 | |
fd77c7ca | 326 | for (i = 0; i < n; i++) ss[i] = c; |
1da177e4 LT |
327 | return s; |
328 | } | |
329 | ||
fd77c7ca | 330 | static void *memcpy(void *dest, const void *src, unsigned n) |
1da177e4 LT |
331 | { |
332 | int i; | |
ade1af77 JE |
333 | const char *s = src; |
334 | char *d = dest; | |
1da177e4 | 335 | |
fd77c7ca | 336 | for (i = 0; i < n; i++) d[i] = s[i]; |
b79c4df7 | 337 | return dest; |
1da177e4 LT |
338 | } |
339 | ||
340 | /* =========================================================================== | |
341 | * Fill the input buffer. This is called only when the buffer is empty | |
342 | * and at least one byte is really needed. | |
343 | */ | |
344 | static int fill_inbuf(void) | |
345 | { | |
968de4f0 EB |
346 | error("ran out of input data"); |
347 | return 0; | |
1da177e4 LT |
348 | } |
349 | ||
350 | /* =========================================================================== | |
351 | * Write the output window window[0..outcnt-1] and update crc and bytes_out. | |
352 | * (Used for the decompressed data only.) | |
353 | */ | |
1da177e4 LT |
354 | static void flush_window(void) |
355 | { | |
968de4f0 EB |
356 | /* With my window equal to my output buffer |
357 | * I only need to compute the crc here. | |
358 | */ | |
1180e01d | 359 | unsigned long c = crc; /* temporary variable */ |
968de4f0 | 360 | unsigned n; |
1180e01d | 361 | unsigned char *in, ch; |
968de4f0 EB |
362 | |
363 | in = window; | |
364 | for (n = 0; n < outcnt; n++) { | |
365 | ch = *in++; | |
366 | c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8); | |
367 | } | |
368 | crc = c; | |
1180e01d | 369 | bytes_out += (unsigned long)outcnt; |
968de4f0 | 370 | outcnt = 0; |
1da177e4 LT |
371 | } |
372 | ||
373 | static void error(char *x) | |
374 | { | |
375 | putstr("\n\n"); | |
376 | putstr(x); | |
377 | putstr("\n\n -- System halted"); | |
378 | ||
ff3cf856 IM |
379 | while (1) |
380 | asm("hlt"); | |
1da177e4 LT |
381 | } |
382 | ||
099e1377 IC |
383 | static void parse_elf(void *output) |
384 | { | |
385 | #ifdef CONFIG_X86_64 | |
386 | Elf64_Ehdr ehdr; | |
387 | Elf64_Phdr *phdrs, *phdr; | |
388 | #else | |
389 | Elf32_Ehdr ehdr; | |
390 | Elf32_Phdr *phdrs, *phdr; | |
391 | #endif | |
392 | void *dest; | |
393 | int i; | |
394 | ||
395 | memcpy(&ehdr, output, sizeof(ehdr)); | |
fd77c7ca | 396 | if (ehdr.e_ident[EI_MAG0] != ELFMAG0 || |
099e1377 IC |
397 | ehdr.e_ident[EI_MAG1] != ELFMAG1 || |
398 | ehdr.e_ident[EI_MAG2] != ELFMAG2 || | |
fd77c7ca | 399 | ehdr.e_ident[EI_MAG3] != ELFMAG3) { |
099e1377 IC |
400 | error("Kernel is not a valid ELF file"); |
401 | return; | |
402 | } | |
403 | ||
404 | putstr("Parsing ELF... "); | |
405 | ||
406 | phdrs = malloc(sizeof(*phdrs) * ehdr.e_phnum); | |
407 | if (!phdrs) | |
408 | error("Failed to allocate space for phdrs"); | |
409 | ||
410 | memcpy(phdrs, output + ehdr.e_phoff, sizeof(*phdrs) * ehdr.e_phnum); | |
411 | ||
fd77c7ca | 412 | for (i = 0; i < ehdr.e_phnum; i++) { |
099e1377 IC |
413 | phdr = &phdrs[i]; |
414 | ||
415 | switch (phdr->p_type) { | |
416 | case PT_LOAD: | |
417 | #ifdef CONFIG_RELOCATABLE | |
418 | dest = output; | |
419 | dest += (phdr->p_paddr - LOAD_PHYSICAL_ADDR); | |
420 | #else | |
fd77c7ca | 421 | dest = (void *)(phdr->p_paddr); |
099e1377 IC |
422 | #endif |
423 | memcpy(dest, | |
424 | output + phdr->p_offset, | |
425 | phdr->p_filesz); | |
426 | break; | |
427 | default: /* Ignore other PT_* */ break; | |
428 | } | |
429 | } | |
430 | } | |
431 | ||
778cb929 | 432 | asmlinkage void decompress_kernel(void *rmode, memptr heap, |
1180e01d IM |
433 | unsigned char *input_data, |
434 | unsigned long input_len, | |
435 | unsigned char *output) | |
1da177e4 LT |
436 | { |
437 | real_mode = rmode; | |
438 | ||
439 | if (RM_SCREEN_INFO.orig_video_mode == 7) { | |
440 | vidmem = (char *) 0xb0000; | |
441 | vidport = 0x3b4; | |
442 | } else { | |
443 | vidmem = (char *) 0xb8000; | |
444 | vidport = 0x3d4; | |
445 | } | |
446 | ||
447 | lines = RM_SCREEN_INFO.orig_video_lines; | |
448 | cols = RM_SCREEN_INFO.orig_video_cols; | |
449 | ||
818a08f8 | 450 | window = output; /* Output buffer (Normally at 1M) */ |
4c83d653 IC |
451 | free_mem_ptr = heap; /* Heap */ |
452 | free_mem_end_ptr = heap + HEAP_SIZE; | |
818a08f8 | 453 | inbuf = input_data; /* Input buffer */ |
968de4f0 EB |
454 | insize = input_len; |
455 | inptr = 0; | |
456 | ||
778cb929 | 457 | #ifdef CONFIG_X86_64 |
1180e01d | 458 | if ((unsigned long)output & (__KERNEL_ALIGN - 1)) |
778cb929 | 459 | error("Destination address not 2M aligned"); |
1180e01d | 460 | if ((unsigned long)output >= 0xffffffffffUL) |
778cb929 IC |
461 | error("Destination address too large"); |
462 | #else | |
1180e01d | 463 | if ((u32)output & (CONFIG_PHYSICAL_ALIGN - 1)) |
e69f202d | 464 | error("Destination address not CONFIG_PHYSICAL_ALIGN aligned"); |
4c83d653 | 465 | if (heap > ((-__PAGE_OFFSET-(512<<20)-1) & 0x7fffffff)) |
968de4f0 EB |
466 | error("Destination address too large"); |
467 | #ifndef CONFIG_RELOCATABLE | |
e69f202d | 468 | if ((u32)output != LOAD_PHYSICAL_ADDR) |
968de4f0 | 469 | error("Wrong destination address"); |
778cb929 | 470 | #endif |
968de4f0 | 471 | #endif |
1da177e4 LT |
472 | |
473 | makecrc(); | |
6b3c0426 | 474 | putstr("\nDecompressing Linux... "); |
1da177e4 | 475 | gunzip(); |
099e1377 | 476 | parse_elf(output); |
6b3c0426 | 477 | putstr("done.\nBooting the kernel.\n"); |
968de4f0 | 478 | return; |
1da177e4 | 479 | } |