[转贴]分析内核对gzip压缩文件进行解压的方法

雪中独行

原文出自：http://www.linuxforum.net
作者：opera
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

概述
----
1) Linux的初始内核映象以gzip压缩文件的格式存放在zImage或bzImage之中, 内核的自举
代码将它解压到1M内存开始处. 在内核初始化时, 如果加载了压缩的initrd映象, 内核会将
它解压到内存盘中, 这两处解压过程都使用了lib/inflate.c文件.

2) inflate.c是从gzip源程序中分离出来的, 包含了一些对全局数据的直接引用, 在使用时
需要直接嵌入到代码中. gzip压缩文件时总是在前32K字节的范围内寻找重复的字符串进行
编码, 在解压时需要一个至少为32K字节的解压缓冲区, 它定义为window[WSIZE].
inflate.c使用get_byte()读取输入文件, 它被定义成宏来提高效率. 输入缓冲区指针必须
定义为inptr, inflate.c中对之有减量操作. inflate.c调用flush_window()来输出window
缓冲区中的解压出的字节串, 每次输出长度用outcnt变量表示. 在flush_window()中, 还必
须对输出字节串计算CRC并且刷新crc变量.  在调用gunzip()开始解压之前, 调用makecrc()
初始化CRC计算表. 最后gunzip()返回0表示解压成功.

3) zImage或bzImage由16位引导代码和32位内核自解压映象两个部分组成. 对于zImage, 内
核自解压映象被加载到物理地址0x1000, 内核被解压到1M的部位. 对于bzImage, 内核自解
压映象被加载到1M开始的地方, 内核被解压为两个片段, 一个起始于物理地址0x2000-0x90000,
另一个起始于高端解压映象之后, 离1M开始处不小于低端片段最大长度的区域. 解压完成后,
这两个片段被合并到1M的起始位置.

解压根内存盘映象文件的代码
--------------------------

1. 
   
2. ; drivers/block/rd.c
   
3. #ifdef BUILD_CRAMDISK
   
4. 
   
5. /*
   
6. * gzip declarations
   
7. */
   
8. 
   
9. #define OF(args)  args        ; 用于函数原型声明的宏
   
10. 
    
11. #ifndef memzero
    
12. #define memzero(s, n)     memset ((s), 0, (n))
    
13. #endif
    
14. 
    
15. typedef unsigned char  uch;        定义inflate.c所使用的3种数据类型
    
16. typedef unsigned short ush;
    
17. typedef unsigned long  ulg;
    
18. 
    
19. #define INBUFSIZ 4096                用户输入缓冲区尺寸
    
20. #define WSIZE 0x8000    /* window size--must be a power of two, and */
    
21.                         /*  at least 32K for zip's deflate method */
    
22. 
    
23. static uch *inbuf;        用户输入缓冲区,与inflate.c无关
    
24. static uch *window;        解压窗口
    
25. 
    
26. static unsigned insize;  /* valid bytes in inbuf */
    
27. static unsigned inptr;   /* index of next byte to be processed in inbuf */
    
28. static unsigned outcnt;  /* bytes in output buffer */
    
29. static int exit_code;
    
30. static long bytes_out;        总解压输出长度,与inflate.c无关
    
31. static struct file *crd_infp, *crd_outfp;
    
32. 
    
33. #define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf()) 读取输入缓冲区中一个字节
    
34.                
    
35. /* Diagnostic functions (stubbed out) */ 一些调试宏
    
36. #define Assert(cond,msg)
    
37. #define Trace(x)
    
38. #define Tracev(x)
    
39. #define Tracevv(x)
    
40. #define Tracec(c,x)
    
41. #define Tracecv(c,x)
    
42. 
    
43. #define STATIC static
    
44. 
    
45. static int  fill_inbuf(void);
    
46. static void flush_window(void);
    
47. static void *malloc(int size);
    
48. static void free(void *where);
    
49. static void error(char *m);
    
50. static void gzip_mark(void **);
    
51. static void gzip_release(void **);
    
52. 
    
53. #include "../../lib/inflate.c"
    
54. 
    
55. static void __init *malloc(int size)
    
56. {
    
57.         return kmalloc(size, GFP_KERNEL);
    
58. }
    
59. 
    
60. static void __init free(void *where)
    
61. {
    
62.         kfree(where);
    
63. }
    
64. 
    
65. static void __init gzip_mark(void **ptr)
    
66. {
    
67.         ; 读取用户一个标记
    
68. }
    
69. 
    
70. static void __init gzip_release(void **ptr)
    
71. {
    
72.         ; 归还用户标记
    
73. }
    
74. 
    
75. 
    
76. /* ===========================================================================
    
77. * Fill the input buffer. This is called only when the buffer is empty
    
78. * and at least one byte is really needed.
    
79. */
    
80. static int __init fill_inbuf(void) 填充输入缓冲区
    
81. {
    
82.         if (exit_code) return -1;
    
83.        
    
84.         insize = crd_infp->;f_op->;read(crd_infp, inbuf, INBUFSIZ,
    
85.                                       &crd_infp->;f_pos);
    
86.         if (insize == 0) return -1;
    
87. 
    
88.         inptr = 1;
    
89. 
    
90.         return inbuf[0];
    
91. }
    
92. 
    
93. /* ===========================================================================
    
94. * Write the output window window[0..outcnt-1] and update crc and bytes_out.
    
95. * (Used for the decompressed data only.)
    
96. */
    
97. static void __init flush_window(void) 输出window缓冲区中outcnt个字节串
    
98. {
    
99.     ulg c = crc;         /* temporary variable */
    
100.     unsigned n;
     
101.     uch *in, ch;
     
102.    
     
103.     crd_outfp->;f_op->;write(crd_outfp, window, outcnt, &crd_outfp->;f_pos);
     
104.     in = window;
     
105.     for (n = 0; n < outcnt; n++) {
     
106.             ch = *in++;
     
107.             c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >;>; 8); 计算输出串的CRC
     
108.     }
     
109.     crc = c;
     
110.     bytes_out += (ulg)outcnt; 刷新总字节数
     
111.     outcnt = 0;
     
112. }
     
113. 
     
114. static void __init error(char *x) 解压出错调用的函数
     
115. {
     
116.         printk(KERN_ERR "%s", x);
     
117.         exit_code = 1;
     
118. }
     
119. 
     
120. static int __init
     
121. crd_load(struct file * fp, struct file *outfp)
     
122. {
     
123.         int result;
     
124. 
     
125.         insize = 0;                /* valid bytes in inbuf */
     
126.         inptr = 0;                /* index of next byte to be processed in inbuf */
     
127.         outcnt = 0;                /* bytes in output buffer */
     
128.         exit_code = 0;
     
129.         bytes_out = 0;
     
130.         crc = (ulg)0xffffffffL; /* shift register contents */
     
131. 
     
132.         crd_infp = fp;
     
133.         crd_outfp = outfp;
     
134.         inbuf = kmalloc(INBUFSIZ, GFP_KERNEL);
     
135.         if (inbuf == 0) {
     
136.                 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n");
     
137.                 return -1;
     
138.         }
     
139.         window = kmalloc(WSIZE, GFP_KERNEL);
     
140.         if (window == 0) {
     
141.                 printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n");
     
142.                 kfree(inbuf);
     
143.                 return -1;
     
144.         }
     
145.         makecrc();
     
146.         result = gunzip();
     
147.         kfree(inbuf);
     
148.         kfree(window);
     
149.         return result;
     
150. }
     
151. 
     
152. #endif  /* BUILD_CRAMDISK */
     
153. 
     
154. 
     
155. 32位内核自解压代码
     
156. ------------------
     
157. 
     
158. ; arch/i386/boot/compressed/head.S
     
159. .text
     
160. 
     
161. #include
     
162. #include
     
163. 
     
164.         .globl startup_32        对于zImage该入口地址为0x1000; 对于bzImage为0x101000
     
165.        
     
166. startup_32:
     
167.         cld
     
168.         cli
     
169.         movl $(__KERNEL_DS),%eax
     
170.         movl %eax,%ds
     
171.         movl %eax,%es
     
172.         movl %eax,%fs
     
173.         movl %eax,%gs
     
174. 
     
175.         lss SYMBOL_NAME(stack_start),%esp        # 自解压代码的堆栈为misc.c中定义的16K字节的数组
     
176.         xorl %eax,%eax
     
177. 1:        incl %eax                # check that A20 really IS enabled
     
178.         movl %eax,0x000000        # loop forever if it isn't
     
179.         cmpl %eax,0x100000
     
180.         je 1b
     
181. 
     
182. /*
     
183. * Initialize eflags.  Some BIOS's leave bits like NT set.  This would
     
184. * confuse the debugger if this code is traced.
     
185. * XXX - best to initialize before switching to protected mode.
     
186. */
     
187.         pushl $0
     
188.         popfl
     
189. /*
     
190. * Clear BSS        清除解压程序的BSS段
     
191. */
     
192.         xorl %eax,%eax
     
193.         movl $ SYMBOL_NAME(_edata),%edi
     
194.         movl $ SYMBOL_NAME(_end),%ecx
     
195.         subl %edi,%ecx
     
196.         cld
     
197.         rep
     
198.         stosb
     
199. /*
     
200. * Do the decompression, and jump to the new kernel..
     
201. */
     
202.         subl $16,%esp        # place for structure on the stack
     
203.         movl %esp,%eax
     
204.         pushl %esi        # real mode pointer as second arg
     
205.         pushl %eax        # address of structure as first arg
     
206.         call SYMBOL_NAME(decompress_kernel)
     
207.         orl  %eax,%eax        # 如果返回非零,则表示为内核解压为低端和高端的两个片断
     
208.         jnz  3f
     
209.         popl %esi        # discard address
     
210.         popl %esi        # real mode pointer
     
211.         xorl %ebx,%ebx
     
212.         ljmp $(__KERNEL_CS), $0x100000        # 运行start_kernel
     
213. 
     
214. /*
     
215. * We come here, if we were loaded high.
     
216. * We need to move the move-in-place routine down to 0x1000
     
217. * and then start it with the buffer addresses in registers,
     
218. * which we got from the stack.
     
219. */
     
220. 3:
     
221.         movl $move_routine_start,%esi
     
222.         movl $0x1000,%edi
     
223.         movl $move_routine_end,%ecx
     
224.         subl %esi,%ecx
     
225.         addl $3,%ecx
     
226.         shrl $2,%ecx        # 按字取整
     
227.         cld
     
228.         rep
     
229.         movsl        # 将内核片断合并代码复制到0x1000区域, 内核的片段起始为0x2000
     
230. 
     
231.         popl %esi        # discard the address
     
232.         popl %ebx        # real mode pointer
     
233.         popl %esi        # low_buffer_start  内核低端片段的起始地址
     
234.         popl %ecx        # lcount                  内核低端片段的字节数量
     
235.         popl %edx        # high_buffer_start 内核高端片段的起始地址
     
236.         popl %eax        # hcount                  内核高端片段的字节数量
     
237.         movl $0x100000,%edi                  内核合并的起始地址
     
238.         cli                # make sure we don't get interrupted
     
239.         ljmp $(__KERNEL_CS), $0x1000 # and jump to the move routine
     
240. 
     
241. /*
     
242. * Routine (template) for moving the decompressed kernel in place,
     
243. * if we were high loaded. This _must_ PIC-code !
     
244. */
     
245. move_routine_start:
     
246.         movl %ecx,%ebp
     
247.         shrl $2,%ecx
     
248.         rep
     
249.         movsl                        # 按字拷贝第1个片段
     
250.         movl %ebp,%ecx
     
251.         andl $3,%ecx
     
252.         rep
     
253.         movsb                        # 传送不完全字
     
254.         movl %edx,%esi
     
255.         movl %eax,%ecx        # NOTE: rep movsb won't move if %ecx == 0
     
256.         addl $3,%ecx
     
257.         shrl $2,%ecx        # 按字对齐
     
258.         rep
     
259.         movsl                        # 按字拷贝第2个片段
     
260.         movl %ebx,%esi        # Restore setup pointer
     
261.         xorl %ebx,%ebx
     
262.         ljmp $(__KERNEL_CS), $0x100000        # 运行start_kernel
     
263. move_routine_end:
     
264. 
     
265. ; arch/i386/boot/compressed/misc.c
     
266. 
     
267. /*
     
268. * gzip declarations
     
269. */
     
270. 
     
271. #define OF(args)  args
     
272. #define STATIC static
     
273. 
     
274. #undef memset
     
275. #undef memcpy
     
276. #define memzero(s, n)     memset ((s), 0, (n))
     
277. 
     
278. typedef unsigned char  uch;
     
279. typedef unsigned short ush;
     
280. typedef unsigned long  ulg;
     
281. 
     
282. #define WSIZE 0x8000                /* Window size must be at least 32k, */
     
283.                                 /* and a power of two */
     
284. 
     
285. static uch *inbuf;             /* input buffer */
     
286. static uch window[WSIZE];    /* Sliding window buffer */
     
287. 
     
288. static unsigned insize = 0;  /* valid bytes in inbuf */
     
289. static unsigned inptr = 0;   /* index of next byte to be processed in inbuf */
     
290. static unsigned outcnt = 0;  /* bytes in output buffer */
     
291. 
     
292. /* gzip flag byte */
     
293. #define ASCII_FLAG   0x01 /* bit 0 set: file probably ASCII text */
     
294. #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
     
295. #define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
     
296. #define ORIG_NAME    0x08 /* bit 3 set: original file name present */
     
297. #define COMMENT      0x10 /* bit 4 set: file comment present */
     
298. #define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
     
299. #define RESERVED     0xC0 /* bit 6,7:   reserved */
     
300. 
     
301. #define get_byte()  (inptr < insize ? inbuf[inptr++] : fill_inbuf())
     
302.                
     
303. /* Diagnostic functions */
     
304. #ifdef DEBUG
     
305. #  define Assert(cond,msg) {if(!(cond)) error(msg);}
     
306. #  define Trace(x) fprintf x
     
307. #  define Tracev(x) {if (verbose) fprintf x ;}
     
308. #  define Tracevv(x) {if (verbose>;1) fprintf x ;}
     
309. #  define Tracec(c,x) {if (verbose && (c)) fprintf x ;}
     
310. #  define Tracecv(c,x) {if (verbose>;1 && (c)) fprintf x ;}
     
311. #else
     
312. #  define Assert(cond,msg)
     
313. #  define Trace(x)
     
314. #  define Tracev(x)
     
315. #  define Tracevv(x)
     
316. #  define Tracec(c,x)
     
317. #  define Tracecv(c,x)
     
318. #endif
     
319. 
     
320. static int  fill_inbuf(void);
     
321. static void flush_window(void);
     
322. static void error(char *m);
     
323. static void gzip_mark(void **);
     
324. static void gzip_release(void **);
     
325.   
     
326. /*
     
327. * This is set up by the setup-routine at boot-time
     
328. */
     
329. static unsigned char *real_mode; /* Pointer to real-mode data */
     
330. 
     
331. #define EXT_MEM_K   (*(unsigned short *)(real_mode + 0x2))
     
332. #ifndef STANDARD_MEMORY_BIOS_CALL
     
333. #define ALT_MEM_K   (*(unsigned long *)(real_mode + 0x1e0))
     
334. #endif
     
335. #define SCREEN_INFO (*(struct screen_info *)(real_mode+0))
     
336. 
     
337. extern char input_data[];
     
338. extern int input_len;
     
339. 
     
340. static long bytes_out = 0;
     
341. static uch *output_data;
     
342. static unsigned long output_ptr = 0;
     
343. 
     
344. 
     
345. static void *malloc(int size);
     
346. static void free(void *where);
     
347. static void error(char *m);
     
348. static void gzip_mark(void **);
     
349. static void gzip_release(void **);
     
350. 
     
351. static void puts(const char *);
     
352.   
     
353. extern int end;
     
354. static long free_mem_ptr = (long)&end;
     
355. static long free_mem_end_ptr;
     
356. 
     
357. #define INPLACE_MOVE_ROUTINE  0x1000        内核片段合并代码的运行地址
     
358. #define LOW_BUFFER_START      0x2000        内核低端解压片段的起始地址
     
359. #define LOW_BUFFER_MAX       0x90000        内核低端解压片段的终止地址
     
360. #define HEAP_SIZE             0x3000        为解压低码保留的堆的尺寸,堆起始于BSS的结束
     
361. static unsigned int low_buffer_end, low_buffer_size;
     
362. static int high_loaded =0;
     
363. static uch *high_buffer_start /* = (uch *)(((ulg)&end) + HEAP_SIZE)*/;
     
364. 
     
365. static char *vidmem = (char *)0xb8000;
     
366. static int vidport;
     
367. static int lines, cols;
     
368. 
     
369. #include "../../../../lib/inflate.c"
     
370. 
     
371. static void *malloc(int size)
     
372. {
     
373.         void *p;
     
374. 
     
375.         if (size <0) error("Malloc error\n");
     
376.         if (free_mem_ptr <= 0) error("Memory error\n");
     
377. 
     
378.         free_mem_ptr = (free_mem_ptr + 3) & ~3;        /* Align */
     
379. 
     
380.         p = (void *)free_mem_ptr;
     
381.         free_mem_ptr += size;
     
382. 
     
383.         if (free_mem_ptr >;= free_mem_end_ptr)
     
384.                 error("\nOut of memory\n");
     
385. 
     
386.         return p;
     
387. }
     
388. 
     
389. static void free(void *where)
     
390. {        /* Don't care */
     
391. }
     
392. 
     
393. static void gzip_mark(void **ptr)
     
394. {
     
395.         *ptr = (void *) free_mem_ptr;
     
396. }
     
397. 
     
398. static void gzip_release(void **ptr)
     
399. {
     
400.         free_mem_ptr = (long) *ptr;
     
401. }
     
402. 
     
403. static void scroll(void)
     
404. {
     
405.         int i;
     
406. 
     
407.         memcpy ( vidmem, vidmem + cols * 2, ( lines - 1 ) * cols * 2 );
     
408.         for ( i = ( lines - 1 ) * cols * 2; i < lines * cols * 2; i += 2 )
     
409.                 vidmem[ i ] = ' ';
     
410. }
     
411. 
     
412. static void puts(const char *s)
     
413. {
     
414.         int x,y,pos;
     
415.         char c;
     
416. 
     
417.         x = SCREEN_INFO.orig_x;
     
418.         y = SCREEN_INFO.orig_y;
     
419. 
     
420.         while ( ( c = *s++ ) != '\0' ) {
     
421.                 if ( c == '\n' ) {
     
422.                         x = 0;
     
423.                         if ( ++y >;= lines ) {
     
424.                                 scroll();
     
425.                                 y--;
     
426.                         }
     
427.                 } else {
     
428.                         vidmem [ ( x + cols * y ) * 2 ] = c;
     
429.                         if ( ++x >;= cols ) {
     
430.                                 x = 0;
     
431.                                 if ( ++y >;= lines ) {
     
432.                                         scroll();
     
433.                                         y--;
     
434.                                 }
     
435.                         }
     
436.                 }
     
437.         }
     
438. 
     
439.         SCREEN_INFO.orig_x = x;
     
440.         SCREEN_INFO.orig_y = y;
     
441. 
     
442.         pos = (x + cols * y) * 2;        /* Update cursor position */
     
443.         outb_p(14, vidport);
     
444.         outb_p(0xff & (pos >;>; 9), vidport+1);
     
445.         outb_p(15, vidport);
     
446.         outb_p(0xff & (pos >;>; 1), vidport+1);
     
447. }
     
448. 
     
449. void* memset(void* s, int c, size_t n)
     
450. {
     
451.         int i;
     
452.         char *ss = (char*)s;
     
453. 
     
454.         for (i=0;i        return s;
     
455. }
     
456. 
     
457. void* memcpy(void* __dest, __const void* __src,
     
458.                             size_t __n)
     
459. {
     
460.         int i;
     
461.         char *d = (char *)__dest, *s = (char *)__src;
     
462. 
     
463.         for (i=0;i<__n;i++) d[ i ] = s[ i ];
     
464.         return __dest;
     
465. }
     
466. 
     
467. /* ===========================================================================
     
468. * Fill the input buffer. This is called only when the buffer is empty
     
469. * and at least one byte is really needed.
     
470. */
     
471. static int fill_inbuf(void)
     
472. {
     
473.         if (insize != 0) {
     
474.                 error("ran out of input data\n");
     
475.         }
     
476. 
     
477.         inbuf = input_data;
     
478.         insize = input_len;
     
479.         inptr = 1;
     
480.         return inbuf[0];
     
481. }
     
482. 
     
483. /* ===========================================================================
     
484. * Write the output window window[0..outcnt-1] and update crc and bytes_out.
     
485. * (Used for the decompressed data only.)
     
486. */
     
487. static void flush_window_low(void)
     
488. {
     
489.     ulg c = crc;         /* temporary variable */
     
490.     unsigned n;
     
491.     uch *in, *out, ch;
     
492.    
     
493.     in = window;
     
494.     out = &output_data[output_ptr];
     
495.     for (n = 0; n < outcnt; n++) {
     
496.             ch = *out++ = *in++;
     
497.             c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >;>; 8);
     
498.     }
     
499.     crc = c;
     
500.     bytes_out += (ulg)outcnt;
     
501.     output_ptr += (ulg)outcnt;
     
502.     outcnt = 0;
     
503. }
     
504. 
     
505. static void flush_window_high(void)
     
506. {
     
507.     ulg c = crc;         /* temporary variable */
     
508.     unsigned n;
     
509.     uch *in,  ch;
     
510.     in = window;
     
511.     for (n = 0; n < outcnt; n++) {
     
512.         ch = *output_data++ = *in++;
     
513.         if ((ulg)output_data == low_buffer_end) output_data=high_buffer_start;
     
514.         c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >;>; 8);
     
515.     }
     
516.     crc = c;
     
517.     bytes_out += (ulg)outcnt;
     
518.     outcnt = 0;
     
519. }
     
520. 
     
521. static void flush_window(void)
     
522. {
     
523.         if (high_loaded) flush_window_high();
     
524.         else flush_window_low();
     
525. }
     
526. 
     
527. static void error(char *x)
     
528. {
     
529.         puts("\n\n");
     
530.         puts(x);
     
531.         puts("\n\n -- System halted");
     
532. 
     
533.         while(1);        /* Halt */
     
534. }
     
535. 
     
536. #define STACK_SIZE (4096)
     
537. 
     
538. long user_stack [STACK_SIZE];
     
539. 
     
540. struct {
     
541.         long * a;
     
542.         short b;
     
543.         } stack_start = { & user_stack [STACK_SIZE] , __KERNEL_DS };
     
544. 
     
545. void setup_normal_output_buffer(void) 对于zImage, 直接解压到1M
     
546. {
     
547. #ifdef STANDARD_MEMORY_BIOS_CALL
     
548.         if (EXT_MEM_K < 1024) error("Less than 2MB of memory.\n");
     
549. #else
     
550.         if ((ALT_MEM_K >; EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) < 1024) error("Less than 2MB of memory.\n");
     
551. #endif
     
552.         output_data = (char *)0x100000; /* Points to 1M */
     
553.         free_mem_end_ptr = (long)real_mode;
     
554. }
     
555. 
     
556. struct moveparams {
     
557.         uch *low_buffer_start;  int lcount;
     
558.         uch *high_buffer_start; int hcount;
     
559. };
     
560. 
     
561. void setup_output_buffer_if_we_run_high(struct moveparams *mv)
     
562. {
     
563.         high_buffer_start = (uch *)(((ulg)&end) + HEAP_SIZE); 内核高端片段的最小起始地址
     
564. #ifdef STANDARD_MEMORY_BIOS_CALL
     
565.         if (EXT_MEM_K < (3*1024)) error("Less than 4MB of memory.\n");
     
566. #else
     
567.         if ((ALT_MEM_K >; EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) < (3*1024)) error("Less than 4MB of memory.\n");
     
568. #endif       
     
569.         mv->;low_buffer_start = output_data = (char *)LOW_BUFFER_START;
     
570.         low_buffer_end = ((unsigned int)real_mode >; LOW_BUFFER_MAX
     
571.           ? LOW_BUFFER_MAX : (unsigned int)real_mode) & ~0xfff;
     
572.         low_buffer_size = low_buffer_end - LOW_BUFFER_START;
     
573.         high_loaded = 1;
     
574.         free_mem_end_ptr = (long)high_buffer_start;
     
575.         if ( (0x100000 + low_buffer_size) >; ((ulg)high_buffer_start)) {
     
576.                 ; 如果高端片段的最小起始地址小于它实际应加载的地址,则将它置为实际地址,
     
577.                 ; 这样高端片段就无需再次移动了,否则它要向前移动
     
578.                 high_buffer_start = (uch *)(0x100000 + low_buffer_size);
     
579.                 mv->;hcount = 0; /* say: we need not to move high_buffer */
     
580.         }
     
581.         else mv->;hcount = -1; 待定
     
582.         mv->;high_buffer_start = high_buffer_start;
     
583. }
     
584. 
     
585. void close_output_buffer_if_we_run_high(struct moveparams *mv)
     
586. {
     
587.         if (bytes_out >; low_buffer_size) {
     
588.                 mv->;lcount = low_buffer_size;
     
589.                 if (mv->;hcount)
     
590.                         mv->;hcount = bytes_out - low_buffer_size; 求出高端片段的字节数
     
591.         } else { 如果解压后内核只有低端的一个片段
     
592.                 mv->;lcount = bytes_out;
     
593.                 mv->;hcount = 0;
     
594.         }
     
595. }
     
596. 
     
597. int decompress_kernel(struct moveparams *mv, void *rmode)
     
598. {
     
599.         real_mode = rmode;
     
600. 
     
601.         if (SCREEN_INFO.orig_video_mode == 7) {
     
602.                 vidmem = (char *) 0xb0000;
     
603.                 vidport = 0x3b4;
     
604.         } else {
     
605.                 vidmem = (char *) 0xb8000;
     
606.                 vidport = 0x3d4;
     
607.         }
     
608. 
     
609.         lines = SCREEN_INFO.orig_video_lines;
     
610.         cols = SCREEN_INFO.orig_video_cols;
     
611. 
     
612.         if (free_mem_ptr < 0x100000) setup_normal_output_buffer();
     
613.         else setup_output_buffer_if_we_run_high(mv);
     
614. 
     
615.         makecrc();
     
616.         puts("Uncompressing Linux... ");
     
617.         gunzip();
     
618.         puts("Ok, booting the kernel.\n");
     
619.         if (high_loaded) close_output_buffer_if_we_run_high(mv);
     
620.         return high_loaded;
     
621. }
     
622. 
     

复制代码