嵌入式系统 boot loader 技术内幕 -- 詹荣开.rtf

bootloader内幕

这段 RAM 地址空间中的连续地址范围可以处于两种状态之一：(1)used=1，则说明这段连续的地址范围已被实现，也即真正地被映射到 RAM 单元上。(2)used=0，则说明这段连续的地址范围并未被系统所实现，而是处于未使用状态。 

基于上述 memory_area_t 数据结构，整个 CPU 预留的 RAM 地址空间可以用一个 memory_area_t 类型的数组来表示，如下所示： 


memory_area_t memory_map[NUM_MEM_AREAS] = {
        [0 ... (NUM_MEM_AREAS - 1)] = {
                .start = 0,
                .size = 0,
                .used = 0
        },
};



(2) 内存映射的检测 

下面我们给出一个可用来检测整个 RAM 地址空间内存映射情况的简单而有效的算法： 


/* 数组初始化 */
for(i = 0; i < NUM_MEM_AREAS; i++)
        memory_map.used = 0;

/* first write a 0 to all memory locations */
for(addr = MEM_START; addr < MEM_END; addr += PAGE_SIZE)
        * (u32 *)addr = 0;

for(i = 0, addr = MEM_START; addr < MEM_END; addr += PAGE_SIZE) {
     /*
      * 检测从基地址 MEM_START+i*PAGE_SIZE 开始,大小为
* PAGE_SIZE 的地址空间是否是有效的RAM地址空间。
      */
     调用3.1.2节中的算法test_mempage()；
     if ( current memory page isnot a valid ram page) {
                /* no RAM here */
                if(memory_map.used )
                        i++;
                continue;
        }
        
        /*
         * 当前页已经是一个被映射到 RAM 的有效地址范围
         * 但是还要看看当前页是否只是 4GB 地址空间中某个地址页的别名？
         */
        if(* (u32 *)addr != 0) { /* alias? */
                /* 这个内存页是 4GB 地址空间中某个地址页的别名 */
                if ( memory_map.used )
                        i++;
                continue;
        }
        
        /*
         * 当前页已经是一个被映射到 RAM 的有效地址范围
         * 而且它也不是 4GB 地址空间中某个地址页的别名。
         */
        if (memory_map.used == 0) {
                memory_map.start = addr;
                memory_map.size = PAGE_SIZE;
                memory_map.used = 1;
        } else {
                memory_map.size += PAGE_SIZE;
        }
} /* end of for (…) */



在用上述算法检测完系统的内存映射情况后，Boot Loader 也可以将内存映射的详细信息打印到串口。 

3.2.3 加载内核映像和根文件系统映像 

(1) 规划内存占用的布局 

这里包括两个方面：(1)内核映像所占用的内存范围；（2）根文件系统所占用的内存范围。在规划内存占用的布局时，主要考虑基地址和映像的大小两个方面。 

对于内核映像，一般将其拷贝到从(MEM_START＋0x8000) 这个基地址开始的大约1MB大小的内存范围内(嵌入式 Linux 的内核一般都不操过 1MB)。为什么要把从 MEM_START 到 MEM_START＋0x8000 这段 32KB 大小的内存空出来呢？这是因为 Linux 内核要在这段内存中放置一些全局数据结构，如：启动参数和内核页表等信息。 

而对于根文件系统映像，则一般将其拷贝到 MEM_START+0x0010,0000 开始的地方。如果用 Ramdisk 作为根文件系统映像，则其解压后的大小一般是1MB。 

（2）从 Flash 上拷贝 

由于像 ARM 这样的嵌入式 CPU 通常都是在统一的内存地址空间中寻址 Flash 等固态存储设备的，因此从 Flash 上读取数据与从 RAM 单元中读取数据并没有什么不同。用一个简单的循环就可以完成从 Flash 设备上拷贝映像的工作： 


while(count) {
        *dest++ = *src++; /* they are all aligned with word boundary */
        count -= 4; /* byte number */
};



3.2.4 设置内核的启动参数 

应该说，在将内核映像和根文件系统映像拷贝到 RAM 空间中后，就可以准备启动 Linux 内核了。但是在调用内核之前，应该作一步准备工作，即：设置 Linux 内核的启动参数。 

Linux 2.4.x 以后的内核都期望以标记列表(tagged list)的形式来传递启动参数。启动参数标记列表以标记 ATAG_CORE 开始，以标记 ATAG_NONE 结束。每个标记由标识被传递参数的 tag_header 结构以及随后的参数值数据结构来组成。数据结构 tag 和 tag_header 定义在 Linux 内核源码的include/asm/setup.h 头文件中： 


/* The list ends with an ATAG_NONE node. */
#define ATAG_NONE        0x00000000

struct tag_header {
        u32 size; /* 注意，这里size是字数为单位的 */
        u32 tag;
};
……
struct tag {
        struct tag_header hdr;
        union {
                struct tag_core                core;
                struct tag_mem32        mem;
                struct tag_videotext        videotext;
                struct tag_ramdisk        ramdisk;
                struct tag_initrd        initrd;
                struct tag_serialnr        serialnr;
                struct tag_revision        revision;
                struct tag_videolfb        videolfb;
                struct tag_cmdline        cmdline;

                /*
                 * Acorn specific
                 */
                struct tag_acorn        acorn;

                /*
                 * DC21285 specific
                 */
                struct tag_memclk        memclk;
        } u;
};



在嵌入式 Linux 系统中，通常需要由 Boot Loader 设置的常见启动参数有：ATAG_CORE、ATAG_MEM、ATAG_CMDLINE、ATAG_RAMDISK、ATAG_INITRD等。 

比如，设置 ATAG_CORE 的代码如下： 


params = (struct tag *)BOOT_PARAMS;

        params->hdr.tag = ATAG_CORE;
        params->hdr.size = tag_size(tag_core);

        params->u.core.flags = 0;
        params->u.core.pagesize = 0;
        params->u.core.rootdev = 0;

        params = tag_next(params);



其中，BOOT_PARAMS 表示内核启动参数在内存中的起始基地址，指针 params 是一个 struct tag 类型的指针。宏 tag_next() 将以指向当前标记的指针为参数，计算紧临当前标记的下一个标记的起始地址。注意，内核的根文件系统所在的设备ID就是在这里设置的。 

下面是设置内存映射情况的示例代码： 


for(i = 0; i < NUM_MEM_AREAS; i++) {
                if(memory_map.used) {
                        params->hdr.tag = ATAG_MEM;
                        params->hdr.size = tag_size(tag_mem32);

                        params->u.mem.start = memory_map.start;
                        params->u.mem.size = memory_map.size;
                        
                        params = tag_next(params);
                }
}



可以看出，在 memory_map［］数组中，每一个有效的内存段都对应一个 ATAG_MEM 参数标记。 

Linux 内核在启动时可以以命令行参数的形式来接收信息，利用这一点我们可以向内核提供那些内核不能自己检测的硬件参数信息，或者重载(override)内核自己检测到的信息。比如，我们用这样一个命令行参数字符串"console=ttyS0,115200n8"来通知内核以 ttyS0 作为控制台，且串口采用 "115200bps、无奇偶校验、8位数据位"这样的设置。下面是一段设置调用内核命令行参数字符串的示例代码： 


char *p;

        /* eat leading white space */
        for(p = commandline; *p == ' '; p++)
                ;

        /* skip non-existent command lines so the kernel will still
    * use its default command line.
         */
        if(*p == '\0')
                return;

        params->hdr.tag = ATAG_CMDLINE;
        params->hdr.size = (sizeof(struct tag_header) + strlen(p) + 1 + 4) >> 2;

        strcpy(params->u.cmdline.cmdline, p);

        params = tag_next(params);



请注意在上述代码中，设置 tag_header 的大小时，必须包括字符串的终止符'\0'，此外还要将字节数向上圆整4个字节，因为 tag_header 结构中的size 成员表示的是字数。 

下面是设置 ATAG_INITRD 的示例代码，它告诉内核在 RAM 中的什么地方可以找到 initrd 映象(压缩格式)以及它的大小： 


        params->hdr.tag = ATAG_INITRD2;
        params->hdr.size = tag_size(tag_initrd);
        
        params->u.initrd.start = RAMDISK_RAM_BASE;
        params->u.initrd.size = INITRD_LEN;
        
        params = tag_next(params);



下面是设置 ATAG_RAMDISK 的示例代码，它告诉内核解压后的 Ramdisk 有多大（单位是KB）： 


params->hdr.tag = ATAG_RAMDISK;
params->hdr.size = tag_size(tag_ramdisk);