4 * This is a collection of several routines from gzip-1.0.3
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
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
17 #undef CONFIG_PARAVIRT
19 #define _ASM_DESC_H_ 1
23 #define _LINUX_STRING_H_ 1
24 #define __LINUX_BITMAP_H 1
27 #include <linux/linkage.h>
28 #include <linux/screen_info.h>
29 #include <linux/elf.h>
33 #include <asm/bootparam.h>
36 * This code is compiled with -fPIC and it is relocated dynamically
37 * at run time, but no relocation processing is performed.
38 * This means that it is not safe to place pointers in static structures.
42 * Getting to provable safe in place decompression is hard.
43 * Worst case behaviours need to be analyzed.
44 * Background information:
53 * compressed data blocks[N]
56 * resulting in 18 bytes of non compressed data overhead.
58 * Files divided into blocks
59 * 1 bit (last block flag)
62 * 1 block occurs every 32K -1 bytes or when there 50% compression
63 * has been achieved. The smallest block type encoding is always used.
66 * 32 bits length in bytes.
73 * dynamic tree encoding.
77 * The buffer for decompression in place is the length of the
78 * uncompressed data, plus a small amount extra to keep the algorithm safe.
79 * The compressed data is placed at the end of the buffer. The output
80 * pointer is placed at the start of the buffer and the input pointer
81 * is placed where the compressed data starts. Problems will occur
82 * when the output pointer overruns the input pointer.
84 * The output pointer can only overrun the input pointer if the input
85 * pointer is moving faster than the output pointer. A condition only
86 * triggered by data whose compressed form is larger than the uncompressed
89 * The worst case at the block level is a growth of the compressed data
90 * of 5 bytes per 32767 bytes.
92 * The worst case internal to a compressed block is very hard to figure.
93 * The worst case can at least be boundined by having one bit that represents
94 * 32764 bytes and then all of the rest of the bytes representing the very
97 * All of which is enough to compute an amount of extra data that is required
98 * to be safe. To avoid problems at the block level allocating 5 extra bytes
99 * per 32767 bytes of data is sufficient. To avoind problems internal to a
100 * block adding an extra 32767 bytes (the worst case uncompressed block size)
101 * is sufficient, to ensure that in the worst case the decompressed data for
102 * block will stop the byte before the compressed data for a block begins.
103 * To avoid problems with the compressed data's meta information an extra 18
104 * bytes are needed. Leading to the formula:
106 * extra_bytes = (uncompressed_size >> 12) + 32768 + 18 + decompressor_size.
108 * Adding 8 bytes per 32K is a bit excessive but much easier to calculate.
109 * Adding 32768 instead of 32767 just makes for round numbers.
110 * Adding the decompressor_size is necessary as it musht live after all
111 * of the data as well. Last I measured the decompressor is about 14K.
112 * 10K of actual data and 4K of bss.
120 #define OF(args) args
121 #define STATIC static
125 #define memzero(s, n) memset((s), 0, (n))
127 typedef unsigned char uch
;
128 typedef unsigned short ush
;
129 typedef unsigned long ulg
;
132 * Window size must be at least 32k, and a power of two.
133 * We don't actually have a window just a huge output buffer,
134 * so we report a 2G window size, as that should always be
135 * larger than our output buffer:
137 #define WSIZE 0x80000000
140 static unsigned char *inbuf
;
142 /* Sliding window buffer (and final output buffer): */
143 static unsigned char *window
;
145 /* Valid bytes in inbuf: */
146 static unsigned insize
;
148 /* Index of next byte to be processed in inbuf: */
149 static unsigned inptr
;
151 /* Bytes in output buffer: */
152 static unsigned outcnt
;
155 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ASCII text */
156 #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gz file */
157 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
158 #define ORIG_NAM 0x08 /* bit 3 set: original file name present */
159 #define COMMENT 0x10 /* bit 4 set: file comment present */
160 #define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */
161 #define RESERVED 0xC0 /* bit 6, 7: reserved */
163 #define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf())
165 /* Diagnostic functions */
167 # define Assert(cond, msg) do { if (!(cond)) error(msg); } while (0)
168 # define Trace(x) do { fprintf x; } while (0)
169 # define Tracev(x) do { if (verbose) fprintf x ; } while (0)
170 # define Tracevv(x) do { if (verbose > 1) fprintf x ; } while (0)
171 # define Tracec(c, x) do { if (verbose && (c)) fprintf x ; } while (0)
172 # define Tracecv(c, x) do { if (verbose > 1 && (c)) fprintf x ; } while (0)
174 # define Assert(cond, msg)
178 # define Tracec(c, x)
179 # define Tracecv(c, x)
182 static int fill_inbuf(void);
183 static void flush_window(void);
184 static void error(char *m
);
185 static void gzip_mark(void **);
186 static void gzip_release(void **);
189 * This is set up by the setup-routine at boot-time
191 static struct boot_params
*real_mode
; /* Pointer to real-mode data */
194 extern unsigned char input_data
[];
195 extern int input_len
;
197 static long bytes_out
;
199 static void *malloc(int size
);
200 static void free(void *where
);
202 static void *memset(void *s
, int c
, unsigned n
);
203 static void *memcpy(void *dest
, const void *src
, unsigned n
);
205 static void putstr(const char *);
210 #define memptr unsigned
213 static memptr free_mem_ptr
;
214 static memptr free_mem_end_ptr
;
218 static int lines
, cols
;
220 #ifdef CONFIG_X86_NUMAQ
224 #include "../../../../lib/inflate.c"
226 static void *malloc(int size
)
231 error("Malloc error");
232 if (free_mem_ptr
<= 0)
233 error("Memory error");
235 free_mem_ptr
= (free_mem_ptr
+ 3) & ~3; /* Align */
237 p
= (void *)free_mem_ptr
;
238 free_mem_ptr
+= size
;
240 if (free_mem_ptr
>= free_mem_end_ptr
)
241 error("Out of memory");
246 static void free(void *where
)
250 static void gzip_mark(void **ptr
)
252 *ptr
= (void *) free_mem_ptr
;
255 static void gzip_release(void **ptr
)
257 free_mem_ptr
= (memptr
) *ptr
;
260 static void scroll(void)
264 memcpy(vidmem
, vidmem
+ cols
* 2, (lines
- 1) * cols
* 2);
265 for (i
= (lines
- 1) * cols
* 2; i
< lines
* cols
* 2; i
+= 2)
269 static void putstr(const char *s
)
275 if (real_mode
->screen_info
.orig_video_mode
== 0 &&
276 lines
== 0 && cols
== 0)
280 x
= real_mode
->screen_info
.orig_x
;
281 y
= real_mode
->screen_info
.orig_y
;
283 while ((c
= *s
++) != '\0') {
291 vidmem
[(x
+ cols
* y
) * 2] = c
;
302 real_mode
->screen_info
.orig_x
= x
;
303 real_mode
->screen_info
.orig_y
= y
;
305 pos
= (x
+ cols
* y
) * 2; /* Update cursor position */
307 outb(0xff & (pos
>> 9), vidport
+1);
309 outb(0xff & (pos
>> 1), vidport
+1);
312 static void *memset(void *s
, int c
, unsigned n
)
317 for (i
= 0; i
< n
; i
++) ss
[i
] = c
;
321 static void *memcpy(void *dest
, const void *src
, unsigned n
)
327 for (i
= 0; i
< n
; i
++) d
[i
] = s
[i
];
331 /* ===========================================================================
332 * Fill the input buffer. This is called only when the buffer is empty
333 * and at least one byte is really needed.
335 static int fill_inbuf(void)
337 error("ran out of input data");
341 /* ===========================================================================
342 * Write the output window window[0..outcnt-1] and update crc and bytes_out.
343 * (Used for the decompressed data only.)
345 static void flush_window(void)
347 /* With my window equal to my output buffer
348 * I only need to compute the crc here.
350 unsigned long c
= crc
; /* temporary variable */
352 unsigned char *in
, ch
;
355 for (n
= 0; n
< outcnt
; n
++) {
357 c
= crc_32_tab
[((int)c
^ ch
) & 0xff] ^ (c
>> 8);
360 bytes_out
+= (unsigned long)outcnt
;
364 static void error(char *x
)
368 putstr("\n\n -- System halted");
374 static void parse_elf(void *output
)
378 Elf64_Phdr
*phdrs
, *phdr
;
381 Elf32_Phdr
*phdrs
, *phdr
;
386 memcpy(&ehdr
, output
, sizeof(ehdr
));
387 if (ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
||
388 ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
||
389 ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
||
390 ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
) {
391 error("Kernel is not a valid ELF file");
396 putstr("Parsing ELF... ");
398 phdrs
= malloc(sizeof(*phdrs
) * ehdr
.e_phnum
);
400 error("Failed to allocate space for phdrs");
402 memcpy(phdrs
, output
+ ehdr
.e_phoff
, sizeof(*phdrs
) * ehdr
.e_phnum
);
404 for (i
= 0; i
< ehdr
.e_phnum
; i
++) {
407 switch (phdr
->p_type
) {
409 #ifdef CONFIG_RELOCATABLE
411 dest
+= (phdr
->p_paddr
- LOAD_PHYSICAL_ADDR
);
413 dest
= (void *)(phdr
->p_paddr
);
416 output
+ phdr
->p_offset
,
419 default: /* Ignore other PT_* */ break;
424 asmlinkage
void decompress_kernel(void *rmode
, memptr heap
,
425 unsigned char *input_data
,
426 unsigned long input_len
,
427 unsigned char *output
)
431 if (real_mode
->hdr
.loadflags
& QUIET_FLAG
)
434 if (real_mode
->screen_info
.orig_video_mode
== 7) {
435 vidmem
= (char *) 0xb0000;
438 vidmem
= (char *) 0xb8000;
442 lines
= real_mode
->screen_info
.orig_video_lines
;
443 cols
= real_mode
->screen_info
.orig_video_cols
;
445 window
= output
; /* Output buffer (Normally at 1M) */
446 free_mem_ptr
= heap
; /* Heap */
447 free_mem_end_ptr
= heap
+ BOOT_HEAP_SIZE
;
448 inbuf
= input_data
; /* Input buffer */
453 if ((unsigned long)output
& (__KERNEL_ALIGN
- 1))
454 error("Destination address not 2M aligned");
455 if ((unsigned long)output
>= 0xffffffffffUL
)
456 error("Destination address too large");
458 if ((u32
)output
& (CONFIG_PHYSICAL_ALIGN
- 1))
459 error("Destination address not CONFIG_PHYSICAL_ALIGN aligned");
460 if (heap
> ((-__PAGE_OFFSET
-(512<<20)-1) & 0x7fffffff))
461 error("Destination address too large");
462 #ifndef CONFIG_RELOCATABLE
463 if ((u32
)output
!= LOAD_PHYSICAL_ADDR
)
464 error("Wrong destination address");
470 putstr("\nDecompressing Linux... ");
474 putstr("done.\nBooting the kernel.\n");
This page took 0.056242 seconds and 5 git commands to generate.