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 "）；
return -1；
}
window = kmalloc（WSIZE， GFP_KERNEL）；
if （window == 0） {
printk（KERN_ERR "RAMDISK: Couldn"t allocate gzip window "）；
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（" Out of memory "）；
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++ ）！= "" ） {
if （ c == " " ） {
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 "）；
}
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（" "）；
puts（x）；
puts（" -- 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. "）；
if （high_loaded） close_output_buffer_if_we_run_high（mv）；
return high_loaded；
}