嵌入式BootLoader技术内幕(二)

女爷i 2021-11-16 12:26 288阅读 0赞

三、Boot Loader 的主要任务与典型结构框架  
  
在继续本节的讨论之前，首先我们做一个假定，那就是：假定内核映像与根文件系统映像  
都被加载到 RAM 中运行。之所以提出这样一个假设前提是因为，在嵌入式系统中内核映像  
与根文件系统映像也可以直接在 ROM 或 Flash 这样的固态存储设备中直接运行。但这种  
做法无疑是以运行速度的牺牲为代价的。从操作系统的角度看，Boot Loader 的总目标就  
是正确地调用内核来执行。  
  
另外，由于 Boot Loader 的实现依赖于 CPU 的体系结构，因此大多数 Boot Loader 都分  
为 stage1 和 stage2 两大部分。依赖于 CPU 体系结构的代码，比如设备初始化代码等，  
通常都放在 stage1 中，而且通常都用汇编语言来实现，以达到短小精悍的目的。而 sta  
ge2 则通常用C语言来实现，这样可以实现给复杂的功能，而且代码会具有更好的可读性和  
可移植性。  
  
Boot Loader 的 stage1 通常包括以下步骤(以执行的先后顺序)：  
·硬件设备初始化。  
·为加载 Boot Loader 的 stage2 准备 RAM 空间。  
·拷贝 Boot Loader 的 stage2 到 RAM 空间中。  
·设置好堆栈。  
·跳转到 stage2 的 C 入口点。  
Boot Loader 的 stage2 通常包括以下步骤(以执行的先后顺序)：  
·初始化本阶段要使用到的硬件设备。  
·检测系统内存映射(memory map)。  
·将 kernel 映像和根文件系统映像从 flash 上读到 RAM 空间中。  
·为内核设置启动参数。  
·调用内核。  
  
3.1 Boot Loader 的 stage1  
  
3.1.1 基本的硬件初始化  
  
这是 Boot Loader 一开始就执行的操作，其目的是为 stage2 的执行以及随后的 kernel  
的执行准备好一些基本的硬件环境。它通常包括以下步骤（以执行的先后顺序）：  
  
1．屏蔽所有的中断。为中断提供服务通常是 OS 设备驱动程序的责任，因此在 Boot Loa  
der 的执行全过程中可以不必响应任何中断。中断屏蔽可以通过写 CPU 的中断屏蔽寄存器  
或状态寄存器（比如 ARM 的 CPSR 寄存器）来完成。  
  
2．设置 CPU 的速度和时钟频率。  
  
3．RAM 初始化。包括正确地设置系统的内存控制器的功能寄存器以及各内存库控制寄存器  
等。  
  
4．初始化 LED。典型地，通过 GPIO 来驱动 LED，其目的是表明系统的状态是 OK 还是  
Error。如果板子上没有 LED，那么也可以通过初始化 UART 向串口打印 Boot Loader 的  
Logo 字符信息来完成这一点。  
  
5． 关闭 CPU 内部指令／数据 cache。  
  
3.1.2 为加载 stage2 准备 RAM 空间  
  
为了获得更快的执行速度，通常把 stage2 加载到 RAM 空间中来执行，因此必须为加载  
Boot Loader 的 stage2 准备好一段可用的 RAM 空间范围。  
  
由于 stage2 通常是 C 语言执行代码，因此在考虑空间大小时，除了 stage2 可执行映象  
的大小外，还必须把堆栈空间也考虑进来。此外，空间大小最好是 memory page 大小(通  
常是 4KB)的倍数。一般而言，1M 的 RAM 空间已经足够了。具体的地址范围可以任意安排  
，比如 blob 就将它的 stage2 可执行映像安排到从系统 RAM 起始地址 0xc0200000 开始  
的 1M 空间内执行。但是，将 stage2 安排到整个 RAM 空间的最顶 1MB(也即(RamEnd-1M  
B) - RamEnd)是一种值得推荐的方法。  
  
为了后面的叙述方便，这里把所安排的 RAM 空间范围的大小记为：stage2\_size(字节)，  
把起始地址和终止地址分别记为：stage2\_start 和 stage2\_end(这两个地址均以 4 字节  
边界对齐)。因此：  
  
stage2\_end＝stage2\_start＋stage2\_size  
  
  
  
另外，还必须确保所安排的地址范围的的确确是可读写的 RAM 空间，因此，必须对你所安  
排的地址范围进行测试。具体的测试方法可以采用类似于 blob 的方法，也即：以 memor  
y page 为被测试单位，测试每个 memory page 开始的两个字是否是可读写的。为了后面  
叙述的方便，我们记这个检测算法为：test\_mempage，其具体步骤如下：  
  
1．先保存 memory page 一开始两个字的内容。  
  
2．向这两个字中写入任意的数字。比如：向第一个字写入 0x55，第 2 个字写入 0xaa。  
  
  
3．然后，立即将这两个字的内容读回。显然，我们读到的内容应该分别是 0x55 和 0xaa  
。如果不是，则说明这个 memory page 所占据的地址范围不是一段有效的 RAM 空间。  
  
  
4．再向这两个字中写入任意的数字。比如：向第一个字写入 0xaa，第 2 个字中写入 0x  
55。  
  
5．然后，立即将这两个字的内容立即读回。显然，我们读到的内容应该分别是 0xaa 和  
0x55。如果不是，则说明这个 memory page 所占据的地址范围不是一段有效的 RAM 空间  
。  
  
6．恢复这两个字的原始内容。测试完毕。  
  
为了得到一段干净的 RAM 空间范围，我们也可以将所安排的 RAM 空间范围进行清零操作  
。  
  
3.1.3 拷贝 stage2 到 RAM 中  
  
拷贝时要确定两点：(1) stage2 的可执行映象在固态存储设备的存放起始地址和终止地址  
；(2) RAM 空间的起始地址。  
  
3.1.4 设置堆栈指针 sp  
  
堆栈指针的设置是为了执行 C 语言代码作好准备。通常我们可以把 sp 的值设置为(stag  
e2\_end-4)，也即在 3.1.2 节所安排的那个 1MB 的 RAM 空间的最顶端(堆栈向下生长)。  
此外，在设置堆栈指针 sp 之前，也可以关闭 led 灯，以提示用户我们准备跳转到 stag  
e2。经过上述这些执行步骤后，系统的物理内存布局应该如下图2所示。  
  
3.1.5 跳转到 stage2 的 C 入口点  
  
在上述一切都就绪后，就可以跳转到 Boot Loader 的 stage2 去执行了。比如，在 ARM  
系统中，这可以通过修改 PC 寄存器为合适的地址来实现。  
  
  
[http://tech.ccidnet.com/pub/attachme.../12/268047.gif][http_tech.ccidnet.com_pub_attachme..._12_268047.gif]  
  
图2 bootloader 的 stage2 可执行映象刚被拷贝到 RAM 空间时的系统内存布局  
  
  
3.2 Boot Loader 的 stage2  
  
正如前面所说，stage2 的代码通常用 C 语言来实现，以便于实现更复杂的功能和取得更  
好的代码可读性和可移植性。但是与普通 C 语言应用程序不同的是，在编译和链接 boot  
loader 这样的程序时，我们不能使用 glibc 库中的任何支持函数。其原因是显而易见的  
。这就给我们带来一个问题，那就是从那里跳转进 main() 函数呢？直接把 main() 函数  
的起始地址作为整个 stage2 执行映像的入口点或许是最直接的想法。但是这样做有两个  
缺点：1)无法通过main() 函数传递函数参数；2)无法处理 main() 函数返回的情况。一种  
更为巧妙的方法是利用 trampoline(\*簧床)的概念。也即，用汇编语言写一段trampolin  
e 小程序，并将这段 trampoline 小程序来作为 stage2 可执行映象的执行入口点。然后  
我们可以在 trampoline 汇编小程序中用 CPU 跳转指令跳入 main() 函数中去执行；而当  
main() 函数返回时，CPU 执行路径显然再次回到我们的 trampoline 程序。简而言之，  
这种方法的思想就是：用这段 trampoline 小程序来作为 main() 函数的外部包裹(exter  
nal wrapper)。  
  
下面给出一个简单的 trampoline 程序示例(来自blob)：  
  
.text  
  
.globl \_trampoline  
\_trampoline:  
bl main  
/\* if main ever returns we just call it again \*/  
b \_trampoline  
  
  
  
可以看出，当 main() 函数返回后，我们又用一条跳转指令重新执行 trampoline 程序―  
―当然也就重新执行 main() 函数，这也就是 trampoline(\*簧床)一词的意思所在。  
  
  
3.2.1初始化本阶段要使用到的硬件设备  
  
这通常包括：（1）初始化至少一个串口，以便和终端用户进行 I/O 输出信息；（2）初始  
化计时器等。在初始化这些设备之前，也可以重新把 LED 灯点亮，以表明我们已经进入  
main() 函数执行。  
  
设备初始化完成后，可以输出一些打印信息，程序名字字符串、版本号等。  
  
3.2.2 检测系统的内存映射（memory map）  
  
所谓内存映射就是指在整个 4GB 物理地址空间中有哪些地址范围被分配用来寻址系统的  
RAM 单元。比如，在 SA-1100 CPU 中，从 0xC000,0000 开始的 512M 地址空间被用作系  
统的 RAM 地址空间，而在 Samsung S3C44B0X CPU 中，从 0x0c00,0000 到 0x1000,0000  
之间的 64M 地址空间被用作系统的 RAM 地址空间。虽然 CPU 通常预留出一大段足够的  
地址空间给系统 RAM，但是在搭建具体的嵌入式系统时却不一定会实现 CPU 预留的全部  
RAM 地址空间。也就是说，具体的嵌入式系统往往只把 CPU 预留的全部 RAM 地址空间中  
的一部分映射到 RAM 单元上，而让剩下的那部分预留 RAM 地址空间处于未使用状态。由  
于上述这个事实，因此 Boot Loader 的 stage2 必须在它想干点什么 (比如，将存储在  
flash 上的内核映像读到 RAM 空间中) 之前检测整个系统的内存映射情况，也即它必须知  
道 CPU 预留的全部 RAM 地址空间中的哪些被真正映射到 RAM 地址单元，哪些是处于 "u  
nused" 状态的。  
  
(1) 内存映射的描述  
  
可以用如下数据结构来描述 RAM 地址空间中的一段连续(continuous)的地址范围：  
  
typedef struct memory\_area\_struct \{  
u32 start; /\* the base address of the memory region \*/  
u32 size; /\* the byte number of the memory region \*/  
int used;  
\} memory\_area\_t;  
  
  
  
这段 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\[i\].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\[i\].used )  
i++;  
continue;  
\}  
  
/\*  
\* 当前页已经是一个被映射到 RAM 的有效地址范围  
\* 但是还要看看当前页是否只是 4GB 地址空间中某个地址页的别名？  
\*/  
if(\* (u32 \*)addr != 0) \{ /\* alias? \*/  
/\* 这个内存页是 4GB 地址空间中某个地址页的别名 \*/  
if ( memory\_map\[i\].used )  
i++;  
continue;  
\}  
  
/\*  
\* 当前页已经是一个被映射到 RAM 的有效地址范围  
\* 而且它也不是 4GB 地址空间中某个地址页的别名。  
\*/  
if (memory\_map\[i\].used == 0) \{  
memory\_map\[i\].start = addr;  
memory\_map\[i\].size = PAGE\_SIZE;  
memory\_map\[i\].used = 1;  
\} else \{  
memory\_map\[i\].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 是一个 str  
uct tag 类型的指针。宏 tag\_next() 将以指向当前标记的指针为参数，计算紧临当前标  
记的下一个标记的起始地址。注意，内核的根文件系统所在的设备ID就是在这里设置的。  
  
  
下面是设置内存映射情况的示例代码：  
  
for(i = 0; i < NUM\_MEM\_AREAS; i++) \{  
if(memory\_map\[i\].used) \{  
params->hdr.tag = ATAG\_MEM;  
params->hdr.size = tag\_size(tag\_mem32);  
  
params->u.mem.start = memory\_map\[i\].start;  
params->u.mem.size = memory\_map\[i\].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 中的什么地方可以找到 initr  
d 映象(压缩格式)以及它的大小：  
  
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 有多大（单位是K  
B）：  
  
params->hdr.tag = ATAG\_RAMDISK;  
params->hdr.size = tag\_size(tag\_ramdisk);  
  
params->u.ramdisk.start = 0;  
params->u.ramdisk.size = RAMDISK\_SIZE; /\* 请注意，单位是KB \*/  
params->u.ramdisk.flags = 1; /\* automatically load ramdisk \*/  
  
params = tag\_next(params);  
  
  
  
最后，设置 ATAG\_NONE 标记，结束整个启动参数列表：  
  
static void setup\_end\_tag(void)  
\{  
params->hdr.tag = ATAG\_NONE;  
params->hdr.size = 0;  
\}  
  
  
  
3.2.5 调用内核  
  
Boot Loader 调用 Linux 内核的方法是直接跳转到内核的第一条指令处，也即直接跳转到  
MEM\_START＋0x8000 地址处。在跳转时，下列条件要满足：  
  
1． CPU 寄存器的设置：  
·R0＝0；  
@R1＝机器类型 ID；关于 Machine Type Number，可以参见 linux/arch/arm/tools/mach  
\-types。  
@R2＝启动参数标记列表在 RAM 中起始基地址；  
  
2． CPU 模式：  
·必须禁止中断（IRQs和FIQs）；  
·CPU 必须 SVC 模式；  
  
3． Cache 和 MMU 的设置：  
·MMU 必须关闭；  
·指令 Cache 可以打开也可以关闭；  
·数据 Cache 必须关闭；  
  
如果用 C 语言，可以像下列示例代码这样来调用内核：  
  
void (\*theKernel)(int zero, int arch, u32 params\_addr)  
= (void (\*)(int, int, u32))KERNEL\_RAM\_BASE;  
……  
theKernel(0, ARCH\_NUMBER, (u32) kernel\_params\_start);  
  
  
  
注意，theKernel()函数调用应该永远不返回的。如果这个调用返回，则说明出错。

转载于:https://www.cnblogs.com/hnrainll/archive/2011/04/12/2013602.html

[http_tech.ccidnet.com_pub_attachme..._12_268047.gif]: http://tech.ccidnet.com/pub/attachment/2003/12/268047.gif