Linux的初始内核自解压分析

Linux的初始内核自解压分析

　　概述

　　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的起始位置.
　　解压根内存盘映象文件的代码
　　--------------------------
　　； drivers/block/rd.c
　　#ifdef BUILD_CRAMDISK
　　
　　#define OF(args) args ； 用于函数原型声明的宏
　　#ifndef memzero
　　#define memzero(s， n) memset ((s)， 0， (n))
　　#endif
　　typedef unsigned char uch； 定义inflate.c所使用的3种数据类型
　　typedef unsigned short ush；
　　typedef unsigned long ulg；
　　#define INBUFSIZ 4096 用户输入缓冲区尺寸
　　#define WSIZE 0x8000
　　
　　static uch *inbuf； 用户输入缓冲区，与inflate.c无关
　　static uch *window； 解压窗口
　　static unsigned insize；
　　static unsigned inptr；
　　static unsigned outcnt；
　　static int exit_code；
　　static long bytes_out； 总解压输出长度，与inflate.c无关
　　static struct file *crd_infp， *crd_outfp；
　　#define get_byte() (inptr
　　 一些调试宏
　　#define Assert(cond，msg)
　　#define Trace(x)
　　#define Tracev(x)
　　#define Tracevv(x)
　　#define Tracec(c，x)
　　#define Tracecv(c，x)
　　#define STATIC static
　　static int fill_inbuf(void)；
　　static void flush_window(void)；
　　static void *malloc(int size)；
　　static void free(void *where)；
　　static void error(char *m)；
　　static void gzip_mark(void **)；
　　static void gzip_release(void **)；
　　#include "../../lib/inflate.c"
　　static void __init *malloc(int size)
　　{
　　return kmalloc(size， GFP_KERNEL)；
　　}
　　static void __init free(void *where)
　　{
　　kfree(where)；
　　}
　　static void __init gzip_mark(void **ptr)
　　{
　　； 读取用户一个标记
　　}
　　static void __init gzip_release(void **ptr)
　　{
　　； 归还用户标记
　　}
　　
　　static int __init fill_inbuf(void) 填充输入缓冲区
　　{
　　if (exit_code) return -1；
　　insize = crd_infp->f_op->read(crd_infp， inbuf， INBUFSIZ，
　　if (insize == 0) return -1；
　　inptr = 1；
　　return inbuf[0]；
　　}
　　
　　static void __init flush_window(void) 输出window缓冲区中outcnt个字节串
　　{
　　ulg c = crc；
　　unsigned n；
　　uch *in， ch；
　　crd_outfp->f_op->write(crd_outfp， window， outcnt，
　　in = window；
　　for (n = 0； n ch = *in++；
　　c = crc_32_tab[((int)c ^ ch) 0xff] ^ (c >> 8)； 计算输出串的CRC
　　}
　　crc = c；
　　bytes_out += (ulg)outcnt； 刷新总字节数
　　outcnt = 0；
　　}
　　static void __init error(char *x) 解压出错调用的函数
　　{
　　printk(KERN_ERR "%s"， x)；
　　exit_code = 1；
　　}
　　static int __init
　　crd_load(struct file * fp， struct file *outfp)
　　{
　　int result；
　　insize = 0；
　　inptr = 0；
　　outcnt = 0；
　　exit_code = 0；
　　bytes_out = 0；
　　crc = (ulg)0xffffffffL；
　　crd_infp = fp；
　　crd_outfp = outfp；
　　inbuf = kmalloc(INBUFSIZ， GFP_KERNEL)；
　　if (inbuf == 0) {
　　printk(KERN_ERR "RAMDISK: Couldn't allocate gzip buffer\n")；
　　return -1；
　　}
　　window = kmalloc(WSIZE， GFP_KERNEL)；
　　if (window == 0) {
　　printk(KERN_ERR "RAMDISK: Couldn't allocate gzip window\n")；
　　kfree(inbuf)；
　　return -1；
　　}
　　makecrc()；
　　result = gunzip()；
　　kfree(inbuf)；
　　kfree(window)；
　　return result；
　　}
　　#endif
　　32位内核自解压代码
　　------------------
　　； arch/i386/boot/compressed/head.S
　　.text
　　#include ·
　　#include
　　.globl startup_32 对于zImage该入口地址为0x1000； 对于bzImage为0x101000
　　startup_32:
　　cld
　　cli
　　movl $(__KERNEL_DS)，%eax
　　movl %eax，%ds
　　movl %eax，%es
　　movl %eax，%fs
　　movl %eax，%gs
　　lss SYMBOL_NAME(stack_start)，%esp # 自解压代码的堆栈为misc.c中定义的16K字节的数组
　　xorl %eax，%eax
　　1: incl %eax # check that A20 really IS enabled
　　movl %eax，0x000000 # loop forever if it isn't
　　cmpl %eax，0x100000
　　je 1b
　　
　　pushl $0
　　popfl
　　
　　xorl %eax，%eax
　　movl $ SYMBOL_NAME(_edata)，%edi
　　movl $ SYMBOL_NAME(_end)，%ecx
　　subl %edi，%ecx
　　cld
　　rep
　　stosb
　　
　　subl $16，%esp # place for structure on the stack
　　movl %esp，%eax
　　pushl %esi # real mode pointer as second arg
　　pushl %eax # address of structure as first arg
　　call SYMBOL_NAME(decompress_kernel)
　　orl %eax，%eax # 如果返回非零，则表示为内核解压为低端和高端的两个片断
　　jnz 3f
　　popl %esi # discard address
　　popl %esi # real mode pointer
　　xorl %ebx，%ebx
　　ljmp $(__KERNEL_CS)， $0x100000 # 运行start_kernel
　　
　　3:
　　movl $move_routine_start，%esi
　　movl $0x1000，%edi
　　movl $move_routine_end，%ecx
　　subl %esi，%ecx
　　addl $3，%ecx
　　shrl $2，%ecx # 按字取整
　　cld
　　rep
　　movsl # 将内核片断合并代码复制到0x1000区域， 内核的片段起始为0x2000
　　popl %esi # discard the address
　　popl %ebx # real mode pointer
　　popl %esi # low_buffer_start 内核低端片段的起始地址
　　popl %ecx # lcount 内核低端片段的字节数量
　　popl %edx # high_buffer_start 内核高端片段的起始地址
　　popl %eax # hcount 内核高端片段的字节数量
　　movl $0x100000，%edi 内核合并的起始地址
　　cli # make sure we don't get interrupted
　　ljmp $(__KERNEL_CS)， $0x1000 # and jump to the move routine
　　
　　move_routine_start:
　　movl %ecx，%ebp
　　shrl $2，%ecx
　　rep
　　movsl # 按字拷贝第1个片段
　　movl %ebp，%ecx
　　andl $3，%ecx
　　rep
　　movsb # 传送不完全字
　　movl %edx，%esi
　　movl %eax，%ecx # NOTE: rep movsb won't move if %ecx == 0
　　addl $3，%ecx
　　shrl $2，%ecx # 按字对齐
　　rep
　　movsl # 按字拷贝第2个片段
　　movl %ebx，%esi # Restore setup pointer
　　xorl %ebx，%ebx
　　ljmp $(__KERNEL_CS)， $0x100000 # 运行start_kernel
　　move_routine_end:
　　； arch/i386/boot/compressed/misc.c
　　
　　#define OF(args) args
　　#define STATIC static
　　#undef memset
　　#undef memcpy
　　#define memzero(s， n) memset ((s)， 0， (n))
　　ypedef unsigned char uch；
　　typedef unsigned short ush；
　　typedef unsigned long ulg；
　　#define WSIZE 0x8000
　　
　　static uch *inbuf；
　　static uch window[WSIZE]；
　　static unsigned insize = 0；
　　static unsigned inptr = 0；
　　static unsigned outcnt = 0；
　　
　　#define ASCII_FLAG 0x01
　　#define CONTINUATION 0x02
　　#define EXTRA_FIELD 0x04
　　#define ORIG_NAME 0x08
　　#define COMMENT 0x10
　　#define ENCRYPTED 0x20
　　#define RESERVED 0xC0
　　#define get_byte() (inptr
　　
　　#ifdef DEBUG
　　# define Assert(cond，msg) {if(!(cond)) error(msg)；}
　　# define Trace(x) fprintf x
　　# define Tracev(x) {if (verbose) fprintf x ；}
　　# define Tracevv(x) {if (verbose>1) fprintf x ；}
　　# define Tracec(c，x) {if (verbose (c)) fprintf x ；}
　　# define Tracecv(c，x) {if (verbose>1 (c)) fprintf x ；}
　　#else
　　# define Assert(cond，msg)
　　# define Trace(x)
　　# define Tracev(x)
　　# define Tracevv(x)
　　# define Tracec(c，x)
　　# define Tracecv(c，x)
　　#endif
　　static int fill_inbuf(void)；
　　static void flush_window(void)；
　　static void error(char *m)；
　　static void gzip_mark(void **)；
　　static void gzip_release(void **)；
　　
　　static unsigned char *real_mode；
　　#define EXT_MEM_K (*(unsigned short *)(real_mode + 0x2))
　　#ifndef STANDARD_MEMORY_BIOS_CALL
　　#define ALT_MEM_K (*(unsigned long *)(real_mode + 0x1e0))
　　#endif
　　#define SCREEN_INFO (*(struct screen_info *)(real_mode+0))
　　extern char input_data[]；
　　extern int input_len；
　　static long bytes_out = 0；
　　static uch *output_data；
　　static unsigned long output_ptr = 0；
　　static void *malloc(int size)；
　　static void free(void *where)；
　　static void error(char *m)；
　　static void gzip_mark(void **)；
　　static void gzip_release(void **)；
　　static void puts(const char *)；
　　extern int end；
　　static long free_mem_ptr = (long)
　　static long free_mem_end_ptr；
　　#define INPLACE_MOVE_ROUTINE 0x1000 内核片段合并代码的运行地址
　　#define LOW_BUFFER_START 0x2000 内核低端解压片段的起始地址
　　#define LOW_BUFFER_MAX 0x90000 内核低端解压片段的终止地址
　　#define HEAP_SIZE 0x3000 为解压低码保留的堆的尺寸，堆起始于BSS的结束
　　static unsigned int low_buffer_end， low_buffer_size；
　　static int high_loaded =0��
　　static uch *high_buffer_start ；
　　static char *vidmem = (char *)0xb8000；
　　static int vidport；
　　static int lines， cols；
　　#include "../../../../lib/inflate.c"
　　static void *malloc(int size)
　　{
　　void *p；
　　if (size if (free_mem_ptr
　　free_mem_ptr = (free_mem_ptr + 3) ~3；
　　p = (void *)free_mem_ptr；
　　free_mem_ptr += size；
　　if (free_mem_ptr >= free_mem_end_ptr)
　　error("\nOut of memory\n")；
　　return p；
　　}
　　static void free(void *where)
　　{
　　}
　　static void gzip_mark(void **ptr)
　　{
　　*ptr = (void *) free_mem_ptr；
　　}
　　static void gzip_release(void **ptr)
　　{
　　free_mem_ptr = (long) *ptr；
　　}
　　static void scroll(void)
　　{
　　int i；
　　memcpy ( vidmem， vidmem + cols * 2， ( lines - 1 ) * cols * 2 )；
　　for ( i = ( lines - 1 ) * cols * 2； i vidmem[ i ] = ' '；
　　}
　　static void puts(const char *s)
　　{
　　int x，y，pos；
　　char c；
　　x = SCREEN_INFO.orig_x；
　　y = SCREEN_INFO.orig_y；
　　while ( ( c = *s++ ) != '\0' ) {
　　if ( c == '\n' ) {
　　x = 0；
　　if ( ++y >= lines ) {
　　scroll()；
　　y--；
　　}
　　} else {
　　vidmem [ ( x + cols * y ) * 2 ] = c；
　　if ( ++x >= cols ) {
　　x = 0；
　　if ( ++y >= lines ) {
　　scroll()；
　　y--；
　　}
　　}
　　}
　　}
　　SCREEN_INFO.orig_x = x；
　　SCREEN_INFO.orig_y = y；
　　pos = (x + cols * y) * 2；
　　outb_p(14， vidport)；
　　outb_p(0xff (pos >> 9)， vidport+1)；
　　outb_p(15， vidport)；
　　outb_p(0xff (pos >> 1)， vidport+1)；
　　}
　　void* memset(void* s， int c， size_t n)
　　{
　　int i；
　　char *ss = (char*)s；
　　for (i=0；i return s；
　　}
　　void* memcpy(void* __dest， __const void* __src，
　　size_t __n)
　　{
　　int i；
　　char *d = (char *)__dest， *s = (char *)__src；
　　for (i=0；i return __dest；
　　}
　　
　　static int fill_inbuf(void)
　　{
　　if (insize != 0) {
　　error("ran out of input data\n")；
　　}
　　inbuf = input_data；
　　insize = input_len；
　　inptr = 1；
　　return inbuf[0]；
　　}
　　
　　static void flush_window_low(void)
　　{
　　ulg c = crc；
　　unsigned n；
　　uch *in， *out， ch；
　　in = window；
　　out =
　　for (n = 0； n ch = *out++ = *in++；
　　c = crc_32_tab[((int)c ^ ch) 0xff] ^ (c >> 8)；
　　}
　　crc = c；
　　bytes_out += (ulg)outcnt；
　　output_ptr += (ulg)outcnt；
　　outcnt = 0；
　　}
　　static void flush_window_high(void)
　　{
　　ulg c = crc；
　　unsigned n；
　　uch *in， ch；
　　in = window；
　　for (n = 0； n ch = *output_data++ = *in++；
　　if ((ulg)output_data == low_buffer_end) output_data=high_buffer_start；
　　c = crc_32_tab[((int)c ^ ch) 0xff] ^ (c >> 8)；
　　}
　　crc = c；
　　bytes_out += (ulg)outcnt；
　　outcnt = 0；
　　}
　　static void flush_window(void)
　　{
　　if (high_loaded) flush_window_high()；
　　else flush_window_low()；
　　}
　　static void error(char *x)
　　{
　　puts("\n\n")；
　　puts(x)；
　　puts("\n\n -- System halted")；
　　while(1)；
　　}
　　#define STACK_SIZE (4096)
　　long user_stack [STACK_SIZE]；
　　struct {
　　long * a；
　　short b；
　　} stack_start = { user_stack [STACK_SIZE] ， __KERNEL_DS }；
　　void setup_normal_output_buffer(void) 对于zImage， 直接解压到1M
　　{
　　#ifdef STANDARD_MEMORY_BIOS_CALL
　　if (EXT_MEM_K #else
　　if ((ALT_MEM_K > EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) #endif
　　output_data = (char *)0x100000；
　　free_mem_end_ptr = (long)real_mode；
　　}
　　struct moveparams {
　　uch *low_buffer_start； int lcount；
　　uch *high_buffer_start； int hcount；
　　}；
　　void setup_output_buffer_if_we_run_high(struct moveparams *mv)
　　{
　　high_buffer_start = (uch *)(((ulg) + HEAP_SIZE)；内核高端片段的最小起始地址
　　#ifdef STANDARD_MEMORY_BIOS_CALL
　　if (EXT_MEM_K #else
　　if ((ALT_MEM_K > EXT_MEM_K ? ALT_MEM_K : EXT_MEM_K) #endif
　　mv->low_buffer_start = output_data = (char *)LOW_BUFFER_START；
　　low_buffer_end = ((unsigned int)real_mode > LOW_BUFFER_MAX
　　? LOW_BUFFER_MAX : (unsigned int)real_mode) ~0xfff；
　　low_buffer_size = low_buffer_end - LOW_BUFFER_START；
　　high_loaded = 1；
　　free_mem_end_ptr = (long)high_buffer_start；
　　if ( (0x100000 + low_buffer_size) > ((ulg)high_buffer_start)) {
　　； 如果高端片段的最小起始地址小于它实际应加载的地址，则将它置为实际地址，
　　； 这样高端片段就无需再次移动了，否则它要向前移动
　　high_buffer_start = (uch *)(0x100000 + low_buffer_size)；
　　mv->hcount = 0；
　　}
　　else mv->hcount = -1； 待定
　　mv->high_buffer_start = high_buffer_start；
　　}
　　void close_output_buffer_if_we_run_high(struct moveparams *mv)
　　{
　　if (bytes_out > low_buffer_size) {
　　mv->lcount = low_buffer_size；
　　if (mv->hcount)
　　mv->hcount = bytes_out - low_buffer_size；求出高端片段的字节数
　　} else { 如果解压后内核只有低端的一个片段
　　mv->lcount = bytes_out；
　　mv->hcount = 0；
　　}
　　}
　　int decompress_kernel(struct moveparams *mv， void *rmode)
　　{
　　real_mode = rmode；
　　if (SCREEN_INFO.orig_video_mode == 7) {
　　vidmem = (char *) 0xb0000；
　　vidport = 0x3b4；
　　} else {
　　vidmem = (char *) 0xb8000；
　　vidport = 0x3d4；
　　}
　　lines = SCREEN_INFO.orig_video_lines；
　　cols = SCREEN_INFO.orig_video_cols；
　　if (free_mem_ptr else setup_output_buffer_if_we_run_high(mv)；
　　makecrc()；
　　puts("Uncompressing Linux... ")；
　　gunzip()；
　　puts("Ok， booting the kernel.\n")；
　　if (high_loaded) close_output_buffer_if_we_run_high(mv)；
　　return high_loaded；
　　}